matrix-appservice-kakaotalk/node/src/client.js

1497 lines
41 KiB
JavaScript

// matrix-appservice-kakaotalk - A Matrix-KakaoTalk puppeting bridge.
// Copyright (C) 2022 Tulir Asokan, Andrew Ferrazzutti
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
import { Long } from "bson"
import {
AuthApiClient,
OAuthApiClient,
ServiceApiClient,
TalkClient,
KnownAuthStatusCode,
util,
} from "node-kakao"
import { ReadStreamUtil } from "node-kakao/stream"
/** @typedef {import("node-kakao").OAuthCredential} OAuthCredential */
/** @typedef {import("node-kakao").ChannelType} ChannelType */
/** @typedef {import("node-kakao").ReplyAttachment} ReplyAttachment */
/** @typedef {import("node-kakao").MentionStruct} MentionStruct */
/** @typedef {import("node-kakao").TalkNormalChannel} TalkNormalChannel */
/** @typedef {import("node-kakao").TalkOpenChannel} TalkOpenChannel */
/** @typedef {import("node-kakao/dist/talk").TalkChannelList} TalkChannelList */
// TODO Remove once/if some helper type hints are upstreamed
/** @typedef {import("node-kakao").OpenChannelUserInfo} OpenChannelUserInfo */
import openlink from "node-kakao/openlink"
const { OpenChannelUserPerm } = openlink
import chat from "node-kakao/chat"
const { KnownChatType } = chat
import * as modutil from "./modutil.js"
import { emitLines, promisify } from "./util.js"
/**
* @typedef {object} ChannelProps
* @property {Long} id
* @property {ChannelType} type
*/
ServiceApiClient.prototype.requestFriendList = async function() {
const res = await this._client.requestData(
"POST",
`${this.getFriendsApiPath("update.json")}`,
{
phone_number_type: 1,
}
)
return {
status: res.status,
success: res.status === 0,
result: res,
}
}
class ProtocolError extends Error {}
class PermError extends ProtocolError {
/** @type {Map<OpenChannelUserPerm, string> */
static #PERM_NAMES = new Map([
[OpenChannelUserPerm.OWNER, "the channel owner"],
[OpenChannelUserPerm.MANAGER, "channel admininstrators"],
[OpenChannelUserPerm.BOT, "bots"],
[OpenChannelUserPerm.NONE, "registered KakaoTalk users"],
])
/**
* @param {?OpenChannelUserPerm[]} permNeeded
* @param {?OpenChannelUserPerm} permActual
* @param {string} action
*/
constructor(permNeeded, permActual, action) {
const who =
!permActual
? "In this channel, no one"
: "Only " + permNeeded
.map(v => PermError.#PERM_NAMES.get(v))
.reduce((prev, curr) => prev += ` and ${curr}`)
super(`${who} can ${action}`)
this.name = this.constructor.name
}
}
class UserClient {
static #initializing = false
#connected = false
#talkClient = new TalkClient()
get talkClient() { return this.#talkClient }
/** @type {ServiceApiClient} */
#serviceClient
get serviceClient() { return this.#serviceClient }
/** @type {OAuthCredential} */
#credential
get userId() { return this.#credential.userId }
/**
* DO NOT CONSTRUCT DIRECTLY. Callers should use {@link UserClient#create} instead.
* @param {string} mxid
* @param {PeerClient} peerClient TODO Make RPC user-specific instead of needing this
*/
constructor(mxid, peerClient) {
if (!UserClient.#initializing) {
throw new Error("Private constructor")
}
UserClient.#initializing = false
this.mxid = mxid
this.peerClient = peerClient
this.#talkClient.on("chat", (data, channel) => {
this.log(`Chat ${data.chat.logId} received in channel ${channel.channelId}`)
this.write("chat", {
//is_sequential: true, // TODO Make sequential per user & channel (if it isn't already)
chatlog: data.chat,
channelId: channel.channelId,
channelType: channel.info.type,
})
})
this.#talkClient.on("chat_deleted", (feedChatlog, channel, feed) => {
this.log(`Chat ${feed.logId} deleted in channel ${channel.channelId} by user ${feedChatlog.sender.userId}`)
this.write("chat_deleted", {
chatId: feed.logId,
senderId: feedChatlog.sender.userId,
timestamp: feedChatlog.sendAt,
channelId: channel.channelId,
channelType: channel.info.type,
})
})
this.#talkClient.on("message_hidden", (hideLog, channel, feed) => {
this.log(`Message ${feed.logId} hid from channel ${channel.channelId} by user ${hideLog.sender.userId}`)
this.write("chat_deleted", {
chatId: feed.logId,
senderId: hideLog.sender.userId,
timestamp: hideLog.sendAt,
channelId: channel.channelId,
channelType: channel.info.type,
})
})
this.#talkClient.on("chat_read", (chat, channel, reader) => {
let senderId
if (reader) {
senderId = reader.userId
} else if (channel.info.type == "MemoChat") {
senderId = channel.clientUser.userId
} else {
this.error(`Chat ${chat.logId} read in channel ${channel.channelId} by unknown reader (channel type: ${channel.info.type || "none"})`)
return
}
this.log(`Chat ${chat.logId} read in channel ${channel.channelId} by ${senderId}`)
this.write("chat_read", {
chatId: chat.logId,
senderId: senderId,
channelId: channel.channelId,
channelType: channel.info.type,
})
})
this.#talkClient.on("chat_event", (channel, author, type, count, chat) => {
// TODO Figure out if this is can ever be for anything other than hearts on Shouts
this.log(`Event ${type} (count = ${count}) on chat ${chat.logId} in channel ${channel.channelId} sent by user ${author.userId}`)
})
this.#talkClient.on("profile_changed", (channel, lastInfo, user) => {
this.log(`Profile of ${user.userId} changed (in channel ${channel ? channel.channelId : "None"})`)
this.write("profile_changed", {
info: user,
/* TODO Is this ever a per-channel profile change?
channelId: channel.channelId,
channelType: channel.info.type,
*/
})
})
this.#talkClient.on("perm_changed",
/**
* TODO Upstream these type hints
* @param {TalkOpenChannel} channel
* @param {OpenChannelUserInfo} lastInfo
* @param {OpenChannelUserInfo} user
*/
(channel, lastInfo, user) => {
this.log(`Perms of user ${user.userId} in channel ${channel.channelId} changed from ${lastInfo.perm} to ${user.perm}`)
this.write("perm_changed", {
is_sequential: true,
userId: user.userId,
perm: user.perm,
senderId: getChannelOwner().userId,
channelId: channel.channelId,
channelType: channel.info.type,
})
})
this.#talkClient.on("host_handover", (channel, lastLink, link) => {
// TODO Find how or if this relates to permissions
this.log(`Host of channel ${channel.channelId} changed from ${lastLink.linkOwner.nickname} to ${link.linkOwner.nickname}`)
})
this.#talkClient.on("channel_added", channel => {
this.log(`Added channel ${channel.channelId}`)
this.write("channel_added", {
channelInfo: channel.info,
})
})
this.#talkClient.on("channel_join", channel => {
this.log(`Joined channel ${channel.channelId}`)
this.write("channel_join", {
channelInfo: channel.info,
})
})
this.#talkClient.on("channel_left", channel => {
this.log(`Left channel ${channel.channelId}`)
this.write("channel_left", {
channelId: channel.channelId,
channelType: channel.info.type,
})
})
this.#talkClient.on("channel_kicked", (kickedLog, channel, feed) => {
// TODO Confirm whether this can refer to any user that was kicked, or only to the current user
this.log(`Kicked from channel ${channel.channelId}`)
this.write("channel_kicked", {
userId: feed.member.userId,
senderId: kickedLog.sender.userId,
channelId: channel.channelId,
channelType: channel.info.type,
})
})
this.#talkClient.on("channel_link_deleted", (feedChatLog, channel, feed) => {
// TODO Figure out what this means
this.log(`Channel link deleted in channel ${channel.channelId}: feed=${JSON.stringify(feed)}, feedChatLog=${JSON.stringify(feedChatLog)}`)
})
this.#talkClient.on("link_created", link => {
// TODO Figure out what this means
this.log(`Link created: ${JSON.stringify(link)}`)
})
this.#talkClient.on("link_deleted", link => {
// TODO Figure out what this means
this.log(`Link deleted: ${JSON.stringify(link)}`)
})
this.#talkClient.on("user_join", (joinLog, channel, user, feed) => {
this.log(`User ${user.userId} joined channel ${channel.channelId}`)
this.write("user_join", {
userId: user.userId,
channelId: channel.channelId,
channelType: channel.info.type,
})
})
this.#talkClient.on("user_left", (leftLog, channel, user, feed) => {
this.log(`User ${user.userId} left channel ${channel.channelId}`)
this.write("user_left", {
userId: user.userId,
channelId: channel.channelId,
channelType: channel.info.type,
})
})
this.#talkClient.on("meta_change", (channel, type, newMeta) => {
// TODO Handle announcements as pinned messages
this.log(`Channel ${channel.channelId} metadata changed`)
})
this.#talkClient.on("push_packet", (method, data) => {
// TODO Find a better way to do this...but data doesn't have much.
if (method == "SYNCLINKUP") {
if (!data?.ol) return
const linkURL = data.ol?.lu
if (!linkURL) return
for (const channel of this.#talkClient.channelList.open.all()) {
if (channel.info.openLink?.linkURL == linkURL) {
this.write("channel_meta_change", {
info: {
name: data.ol?.ln,
description: data.ol?.desc || null,
photoURL: data.ol?.liu || null,
},
channelId: channel.channelId,
channelType: channel.info.type,
})
break
}
}
}
})
this.#talkClient.on("disconnected", reason => {
this.log(`Disconnected (reason=${reason})`)
this.disconnect()
this.write("disconnected", {
reason: reason,
})
})
this.#talkClient.on("switch_server", () => {
this.log(`Server switch requested`)
this.write("switch_server", {
is_sequential: true,
})
})
this.#talkClient.on("error", err => {
this.log(`Client error: ${err}`)
this.write("error", {
error: err,
})
})
}
/**
* @param {string} mxid The ID of the associated Matrix user
* @param {OAuthCredential} credential The token to log in with, obtained from prior login
* @param {PeerClient} peerClient What handles RPC
*/
static async create(mxid, credential, peerClient) {
this.#initializing = true
const userClient = new UserClient(mxid, peerClient)
await userClient.setCredential(credential)
return userClient
}
log(...text) {
console.log(`[API/${this.mxid}]`, ...text)
}
error(...text) {
console.error(`[API/${this.mxid}]`, ...text)
}
/**
* @param {OAuthCredential} credential
*/
async setCredential(credential) {
this.#serviceClient = await ServiceApiClient.create(credential)
this.#credential = credential
}
/**
* @param {ChannelProps} channelProps
*/
async getChannel(channelProps) {
const talkChannel = this.#talkClient.channelList.get(channelProps.id)
if (talkChannel) {
return talkChannel
}
const channelList = getChannelListForType(
this.#talkClient.channelList,
channelProps.type
)
const res = await channelList.addChannel({ channelId: channelProps.id })
if (!res.success) {
this.error(`Unable to add ${channelProps.type} channel ${channelProps.id}`)
throw res
}
return res.result
}
/**
* @param {Long} channelId
*/
async getNormalChannel(channelId) {
const channelList = this.#talkClient.channelList.normal
const talkChannel = channelList.get(channelId)
if (talkChannel) {
return talkChannel
}
const res = await channelList.addChannel({ channelId: channelId })
if (!res.success) {
this.error(`Unable to add normal channel ${channelProps.id}`)
throw res
}
return res.result
}
/**
* @param {?OAuthCredential} credential The token to log in with, obtained from prior login
*/
async connect(credential) {
// TODO Don't re-login if possible. But must still return a LoginResult!
this.disconnect()
if (credential && this.#credential != credential) {
await this.setCredential(credential)
}
const res = await this.#talkClient.login(this.#credential)
this.#connected = res.success
return res
}
disconnect() {
if (this.isConnected()) {
this.#talkClient.close()
}
this.#connected = false
}
isConnected() {
return this.#talkClient?.logon || false
}
isUnexpectedlyDisconnected() {
return this.#connected && !this.isConnected()
}
/**
* Send a user-specific command with (optional) data to the socket.
*
* @param {string} command - The data to write.
* @param {?object} data - The data to write.
*/
write(command, data) {
return this.peerClient.write({
id: --this.peerClient.notificationID,
command: `${command}:${this.mxid}`,
...data
})
}
}
export default class PeerClient {
/**
* @param {import("./clientmanager.js").default} manager
* @param {import("net").Socket} socket
* @param {number} connID
*/
constructor(manager, socket, connID) {
this.manager = manager
this.registerTimeout = manager.registerTimeout
this.loggingKeys = manager.loggingKeys
this.socket = socket
this.connID = connID
this.stopped = false
this.notificationID = 0
this.maxCommandID = 0
this.peerID = ""
this.deviceName = "KakaoTalk Bridge"
/** @type {Map<string, UserClient>} */
this.userClients = new Map()
}
log(...text) {
if (this.peerID) {
console.log(`[API/${this.peerID}/${this.connID}]`, ...text)
} else {
console.log(`[API/${this.connID}]`, ...text)
}
}
error(...text) {
if (this.peerID) {
console.error(`[API/${this.peerID}/${this.connID}]`, ...text)
} else {
console.error(`[API/${this.connID}]`, ...text)
}
}
start() {
this.log("Received connection", this.connID)
emitLines(this.socket)
this.socket.on("line", line => this.handleLine(line)
.catch(err => this.log("Error handling line:", err)))
this.socket.on("end", this.handleEnd)
setTimeout(() => {
if (!this.peerID && !this.stopped) {
this.log(`Didn't receive register request within ${this.registerTimeout/1000} seconds, terminating`)
this.stop("Register request timeout")
}
}, this.registerTimeout)
}
async stop(error = null) {
if (this.stopped) {
return
}
this.stopped = true
this.#closeUsers()
try {
await this.write({ id: --this.notificationID, command: "quit", error })
await promisify(cb => this.socket.end(cb))
} catch (err) {
this.error("Failed to end connection:", err)
this.socket.destroy(err)
}
}
handleEnd = () => {
this.stopped = true
this.#closeUsers()
if (this.peerID && this.manager.clients.get(this.peerID) === this) {
this.manager.clients.delete(this.peerID)
}
this.log(`Connection closed (peer: ${this.peerID || "unknown peer"})`)
}
#closeUsers() {
this.log(`Closing all API clients for ${this.peerID || "unknown peer"}`)
for (const userClient of this.userClients.values()) {
userClient.disconnect()
}
this.userClients.clear()
}
/**
* Write JSON data to the socket.
*
* @param {object} data - The data to write.
* @returns {Promise<void>}
*/
write(data) {
return promisify(cb => this.socket.write(JSON.stringify(data, this.#writeReplacer) + "\n", cb))
}
/**
* @param {object} req
* @param {string} req.passcode
* @param {string} req.uuid
* @param {object} req.form
*/
registerDevice = async (req) => {
// TODO Look for a deregister API call
const authClient = await this.#createAuthClient(req.uuid)
return await authClient.registerDevice(req.form, req.passcode, true)
}
/**
* Obtain login tokens. If this fails due to not having a device, also request a device passcode.
* @param {object} req
* @param {string} req.uuid
* @param {object} req.form
* @param {boolean} req.forced
* @returns The response of the login attempt, including obtained
* credentials for subsequent token-based login. If a required device passcode
* request failed, its status is stored here.
*/
handleLogin = async (req) => {
const authClient = await this.#createAuthClient(req.uuid)
const loginRes = await authClient.login(req.form, req.forced)
if (loginRes.status === KnownAuthStatusCode.DEVICE_NOT_REGISTERED) {
const passcodeRes = await authClient.requestPasscode(req.form)
if (!passcodeRes.success) {
loginRes.status = passcodeRes.status
}
}
return loginRes
}
/**
* TODO Consider caching per-user
* @param {string} uuid
*/
async #createAuthClient(uuid) {
return await AuthApiClient.create(this.deviceName, uuid, {}, modutil.ModXVCProvider)
}
// TODO Wrapper for per-user commands
/**
* Checked lookup of a UserClient for a given mxid.
* @param {string} mxid
* @returns {UserClient}
*/
#getUser(mxid) {
const userClient = this.userClients.get(mxid)
if (userClient === undefined) {
throw new Error(`Could not find user ${mxid}`)
}
return userClient
}
/**
* Unchecked lookup of a UserClient for a given mxid.
* @param {string} mxid
* @returns {UserClient | undefined}
*/
#tryGetUser(mxid) {
return this.userClients.get(mxid)
}
/**
* @param {string} mxid
* @param {ChannelProps} channelProps
* @param {?OpenChannelUserPerm[]} permNeeded If set, throw if the user's permission level matches none of the values in this list.
* @param {?string} action The action requiring permission, to be used in an error message if throwing.
* @throws {PermError} if the user does not have the specified permission level.
*/
async #getUserChannel(mxid, channelProps, permNeeded, action) {
const userClient = this.#getUser(mxid)
const talkChannel = await userClient.getChannel(channelProps)
if (permNeeded) {
await this.#requireChannelPerm(talkChannel, permNeeded, action)
}
return talkChannel
}
/**
* @param {TalkOpenChannel} talkChannel
* @param {OpenChannelUserPerm[]} permNeeded Throw if the user's permission level matches none of the values in this list.
* @param {string} action The action requiring permission
* @throws {PermError} if the user does not have the specified permission level.
*/
async #requireChannelPerm(talkChannel, permNeeded, action) {
const permActual = talkChannel.getUserInfo({ userId: talkChannel.clientUser.userId }).perm
if (permNeeded.indexOf(permActual) == -1) {
throw new PermError(permNeeded, permActual, action)
}
}
/**
* @param {string} mxid
* @param {Long} channelId
*/
async #getUserNormalChannel(mxid, channelId) {
return await this.#getUser(mxid).getNormalChannel(channelId)
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {OAuthCredential} req.oauth_credential
*/
handleRenew = async (req) => {
const userClient = this.#tryGetUser(req.mxid)
const oAuthClient = await OAuthApiClient.create()
const res = await oAuthClient.renew(req.oauth_credential)
if (res.success && userClient) {
await userClient.setCredential(res.result.credential)
}
return res
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {OAuthCredential} req.oauth_credential
*/
userStart = async (req) => {
let userClient = this.#tryGetUser(req.mxid)
if (!userClient) {
userClient = await UserClient.create(req.mxid, req.oauth_credential, this)
} else {
await userClient.setCredential(req.oauth_credential)
}
const res = await this.#getSettings(userClient.serviceClient)
if (res.success) {
this.userClients.set(req.mxid, userClient)
}
return res
}
/**
* @param {object} req
* @param {string} req.mxid
*/
userStop = async (req) => {
this.handleDisconnect(req)
this.userClients.delete(req.mxid)
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {?OAuthCredential} req.oauth_credential
*/
handleConnect = async (req) => {
return await this.#getUser(req.mxid).connect(req.oauth_credential)
}
/**
* @param {object} req
* @param {string} req.mxid
*/
handleDisconnect = (req) => {
this.#tryGetUser(req.mxid)?.disconnect()
}
/**
* @param {object} req
* @param {string} req.mxid
*/
isConnected = (req) => {
return this.#tryGetUser(req.mxid)?.isConnected()
}
/**
* @param {object} req
* @param {string} req.mxid
*/
getSettings = async (req) => {
return await this.#getSettings(this.#getUser(req.mxid).serviceClient)
}
/**
* @param {ServiceApiClient} serviceClient
*/
#getSettings = async (serviceClient) => {
const moreRes = await serviceClient.requestMoreSettings()
if (!moreRes.success) return moreRes
const lessRes = await serviceClient.requestLessSettings()
if (!lessRes.success) return lessRes
return makeCommandResult({
more: moreRes.result,
less: lessRes.result,
})
}
/**
* @param {object} req
* @param {string} req.mxid
*/
getOwnProfile = async (req) => {
return await this.#getUser(req.mxid).serviceClient.requestMyProfile()
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {Long} req.user_id
*/
getProfile = async (req) => {
return await this.#getUser(req.mxid).serviceClient.requestProfile(req.user_id)
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {ChannelProps} req.channel_props
*/
getPortalChannelInfo = async (req) => {
const talkChannel = await this.#getUserChannel(req.mxid, req.channel_props)
const res = await talkChannel.updateAll()
if (!res.success) return res
return makeCommandResult({
name: talkChannel.getDisplayName(),
description: talkChannel.info.openLink?.description,
// TODO Find out why linkCoverURL is blank, despite having updated the channel!
photoURL: talkChannel.info.openLink?.linkCoverURL || null,
participantInfo: {
// TODO Get members from chatON?
participants: Array.from(talkChannel.getAllUserInfo()),
kickedUserIds: await this.#getKickedUserIds(talkChannel),
},
})
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {ChannelProps} req.channel_props
*/
getPortalChannelParticipantInfo = async (req) => {
const talkChannel = await this.#getUserChannel(req.mxid, req.channel_props)
// TODO Get members from chatON?
const participantRes = await talkChannel.getAllLatestUserInfo()
if (!participantRes.success) return participantRes
return {
participants: participantRes.result,
kickedUserIds: await this.#getKickedUserIds(talkChannel),
}
}
/**
* @param {TalkNormalChannel | TalkOpenChannel} talkChannel
*/
async #getKickedUserIds(talkChannel) {
if (!isChannelTypeOpen(talkChannel.info.type)) {
return []
} else {
const kickListRes = await talkChannel.getKickList()
if (!kickListRes.success) {
return []
} else {
return kickListRes.result.map(kickUser => kickUser.userId)
}
}
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {ChannelProps} req.channel_props
*/
getParticipants = async (req) => {
const talkChannel = await this.#getUserChannel(req.mxid, req.channel_props)
return await talkChannel.getAllLatestUserInfo()
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {ChannelProps} req.channel_props
* @param {?Long} req.sync_from
* @param {?number} req.limit
*/
getChats = async (req) => {
const talkChannel = await this.#getUserChannel(req.mxid, req.channel_props)
const res = await talkChannel.getChatListFrom(req.sync_from)
if (!res.success || !res.length) return res
while (true) {
const nextRes = await talkChannel.getChatListFrom(
res.result[res.result.length - 1].logId
)
if (!nextRes.success) return nextRes
if (!nextRes.result.length) break
res.result.push(...nextRes.result)
}
if (0 < req.limit && req.limit < res.result.length) {
res.result.splice(0, res.result.length - req.limit)
}
return res
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {ChannelProps} req.channel_props
* @param {[Long]} req.unread_chat_ids Must be in DECREASING order
*/
getReadReceipts = async (req) => {
const talkChannel = await this.#getUserChannel(req.mxid, req.channel_props)
// TODO Is any pre-syncing needed?
const userCount = talkChannel.userCount
if (userCount == 1) return makeCommandResult([])
/** @type {Map<Long, Long> */
const latestReceiptByUser = new Map()
let fullyRead = false
for (const chatId of req.unread_chat_ids) {
const chatReaders = talkChannel.getReaders({ logId: chatId })
for (const chatReader of chatReaders) {
if (!latestReceiptByUser.has(chatReader.userId)) {
latestReceiptByUser.set(chatReader.userId, chatId)
if (latestReceiptByUser.size == userCount) {
fullyRead = true
break
}
}
}
if (fullyRead) {
break
}
}
/**
* @typedef {object} Receipt
* @property {Long} userId
* @property {Long} chatId
*/
/** @type {[Receipt]} */
const receipts = []
latestReceiptByUser.forEach((value, key) => receipts.push({ "userId": key, "chatId": value }))
return makeCommandResult(receipts)
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {string} req.uuid
*/
canChangeUUID = async (req) => {
return await this.#getUser(req.mxid).serviceClient.canChangeUUID(req.uuid)
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {string} req.uuid
*/
changeUUID = async (req) => {
const serviceClient = this.#getUser(req.mxid).serviceClient
const checkRes = await serviceClient.canChangeUUID(req.uuid)
if (!checkRes.success) return checkRes
return await serviceClient.changeUUID(req.uuid)
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {boolean} req.searchable
*/
setUUIDSearchable = async (req) => {
const serviceClient = this.#getUser(req.mxid).serviceClient
const moreRes = await serviceClient.requestMoreSettings()
if (!moreRes.success) {
throw new ProtocolError("Error checking status of KakaoTalk ID")
}
if (!moreRes.result.uuid) {
throw new ProtocolError("You do not yet have a KakaoTalk ID")
}
if (req.searchable == moreRes.result.uuidSearchable) {
throw new ProtocolError(`Your KakaoTalk ID is already ${req.searchable ? "searchable" : "hidden"}`)
}
return await serviceClient.updateSettings({
uuid_searchable: req.searchable,
})
}
/**
* @param {object} req
* @param {string} req.mxid
*/
listFriends = async (req) => {
return await this.#getUser(req.mxid).serviceClient.requestFriendList()
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {Long} req.user_id
* @param {boolean} req.add
*/
editFriend = async (req) => {
return await this.#editFriend(
this.#getUser(req.mxid).serviceClient,
req.user_id,
req.add
)
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {string} req.uuid
* @param {boolean} req.add
*/
editFriendByUUID = async (req) => {
const serviceClient = this.#getUser(req.mxid).serviceClient
const res = await serviceClient.findFriendByUUID(req.uuid)
if (!res.success) return res
return await this.#editFriend(
serviceClient,
res.result.member.userId instanceof Long
? res.result.member.userId
: Long.fromNumber(res.result.member.userId),
req.add
)
}
/**
* @param {ServiceApiClient} serviceClient
* @param {Long} id
* @param {boolean} add
*/
async #editFriend(serviceClient, id, add) {
const listRes = await serviceClient.requestFriendList()
if (listRes.success) {
const isFriend = -1 != listRes.result.friends.findIndex(friend => id.equals(friend.userId))
if (isFriend == add) {
throw new ProtocolError(`User is already ${add ? "in" : "absent from"} friends list`)
}
}
return add ? await serviceClient.addFriend(id) : await serviceClient.removeFriend(id)
}
/**
* @param {object} req
* @param {string} req.mxid The user whose friend is being looked up.
* @param {string} req.friend_id The friend to search for.
* @param {string} propertyName The property to retrieve from the specified friend.
*/
getFriendProperty = async (req, propertyName) => {
const res = await this.#getUser(req.mxid).serviceClient.findFriendById(req.friend_id)
if (!res.success) return res
return makeCommandResult(res.result.friend[propertyName])
}
/**
* @param {object} req
* @param {string} req.mxid
*/
getMemoIds = (req) => {
/** @type Long[] */
const channelIds = []
const channelList = this.#getUser(req.mxid).talkClient.channelList
// TODO channelList.all() doesn't really return *all* channels...
for (const channel of channelList.all()) {
if (channel.info.type == "MemoChat") {
channelIds.push(channel.channelId)
}
}
return channelIds
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {ChannelProps} req.channel_props
* @param {string} req.key
*/
downloadFile = async (req) => {
const talkChannel = await this.#getUserChannel(req.mxid, req.channel_props)
const res = await talkChannel.downloadMedia({ key: req.key }, KnownChatType.FILE)
if (!res.success) return res
const data = await ReadStreamUtil.all(res.result)
return makeCommandResult(Array.from(data))
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {ChannelProps} req.channel_props
* @param {string} req.text
* @param {?ReplyAttachment} req.reply_to
* @param {?MentionStruct[]} req.mentions
*/
sendChat = async (req) => {
const talkChannel = await this.#getUserChannel(req.mxid, req.channel_props)
const res = await talkChannel.sendChat({
text: req.text,
type: !!req.reply_to ? KnownChatType.REPLY : KnownChatType.TEXT,
attachment: !req.mentions ? req.reply_to : {...req.reply_to, mentions: req.mentions},
})
if (res.success) res.result = res.result.logId
return res
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {ChannelProps} req.channel_props
* @param {int} req.type
* @param {number[]} req.data
* @param {string} req.name
* @param {?int} req.width
* @param {?int} req.height
* @param {?string} req.ext
*/
sendMedia = async (req) => {
const talkChannel = await this.#getUserChannel(req.mxid, req.channel_props)
const res = await talkChannel.sendMedia(req.type, {
data: Uint8Array.from(req.data),
name: req.name,
width: req.width,
height: req.height,
ext: req.ext,
})
if (res.success) res.result = res.result.logId
return res
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {ChannelProps} req.channel_props
* @param {Long} req.chat_id
*/
deleteChat = async (req) => {
const talkChannel = await this.#getUserChannel(req.mxid, req.channel_props)
return await talkChannel.deleteChat({
logId: req.chat_id,
})
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {ChannelProps} req.channel_props
* @param {Long} req.read_until_chat_id
*/
markRead = async (req) => {
const talkChannel = await this.#getUserChannel(req.mxid, req.channel_props)
return await talkChannel.markRead({
logId: req.read_until_chat_id,
})
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {ChannelProps} req.channel_props
* @param {Long} req.user_id
* @param {OpenChannelUserPerm} req.perm
*/
sendPerm = async (req) => {
const talkChannel = await this.#getUserChannel(
req.mxid,
req.channel_props,
[OpenChannelUserPerm.OWNER],
"change user permissions"
)
const user = { userId: req.user_id }
if (!talkChannel.getUserInfo(user)) {
throw new ProtocolError("Cannot set permission level of a user that is not a channel participant")
}
if (req.user_id.equals(talkChannel.clientUser.userId)) {
throw new ProtocolError("Cannot change own permission level")
}
return await talkChannel.setUserPerm(user, req.perm)
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {ChannelProps} req.channel_props
* @param {string} req.name
*/
setChannelName = async (req) => {
if (!isChannelTypeOpen(req.channel_props.type)) {
const talkChannel = await this.#getUserNormalChannel(req.mxid, req.channel_props.id)
return await talkChannel.setTitleMeta(req.name)
} else {
return await this.#setOpenChannelProperty(req.mxid, req.channel_props, "linkName", req.name)
}
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {ChannelProps} req.channel_props
* @param {string} req.description
*/
setChannelDescription = async (req) => {
return await this.#setOpenChannelProperty(req.mxid, req.channel_props, "description", req.description)
}
/**
* @param {string} mxid
* @param {ChannelProps} channelProps
* @param {string} propertyName
* @param {any} propertyValue
*/
async #setOpenChannelProperty(mxid, channelProps, propertyName, propertyValue) {
if (isChannelTypeOpen(channelProps)) {
throw ProtocolError(`Cannot set ${propertyName} of non-open channel ${channelProps.id} (type = ${channelProps.type})`)
}
const userClient = this.#getUser(mxid)
/** @type {TalkOpenChannel} */
const talkChannel = await userClient.getChannel(channelProps)
this.#requireChannelPerm(talkChannel, [OpenChannelUserPerm.OWNER], `change channel ${propertyName}`)
const linkRes = await talkChannel.getLatestOpenLink()
if (!linkRes.success) throw linkRes
const link = linkRes.result
link[propertyName] = propertyValue
return await userClient.talkClient.channelList.open.updateOpenLink(
{ linkId: link.linkId }, link
)
}
/*
* TODO
* @param {object} req
* @param {string} req.mxid
* @param {ChannelProps} req.channel_props
* @param {string} req.photo_url
setChannelPhoto = async (req) => {
const talkChannel = await this.#getUserChannel(
req.mxid,
req.channel_props,
[OpenChannelUserPerm.OWNER],
"change channel photo"
)
return await talkChannel.setProfileMeta({
imageUrl: req.photo_url,
fullImageUrl: req.photo_url,
})
}
*/
/**
* @param {object} req
* @param {string} req.mxid
* @param {Long} req.user_id
*/
createDirectChat = async (req) => {
const userClient = this.#getUser(req.mxid)
await this.#requireInFriendsList(userClient.serviceClient, req.user_id)
const channelList = userClient.talkClient.channelList.normal
const createChannel =
!req.user_id.equals(userClient.userId)
? channelList.createChannel.bind(channelList, {
userList: [{ userId: req.user_id }],
})
: channelList.createMemoChannel.bind(channelList)
const retry_delay = 2000
let retries_left = 1
let res
do {
res = await createChannel()
if (res.success) {
return makeCommandResult(res.result.channelId)
}
this.error(`Failed to create direct chat, try again in ${retry_delay} ms (${retries_left - 1} tries remaining)`)
await new Promise(resolve => setTimeout(resolve, retry_delay))
} while (retries_left--)
this.error(`Failed to create direct chat, not retrying`)
return res
}
/**
* @param {ServiceApiClient} serviceClient
* @param {Long} id
*/
async #requireInFriendsList(serviceClient, id) {
let listRes = await serviceClient.requestFriendList()
if (!listRes.success) {
this.error("Failed to check friends list")
throw listRes
}
const isFriend = -1 != listRes.result.friends.findIndex(friend => id.equals(friend.userId))
if (!isFriend) {
throw new ProtocolError("This user is not in your friends list")
}
}
/**
* @param {object} req
* @param {string} req.mxid
* @param {ChannelProps} req.channel_props
*/
leaveChannel = async (req) => {
const userClient = this.#getUser(req.mxid)
const channelList = getChannelListForType(
userClient.talkClient.channelList,
req.channel_props.type
)
return await channelList.leaveChannel({ channelId: req.channel_props.id })
}
handleUnknownCommand = () => {
throw new Error("Unknown command")
}
/**
* @param {object} req
* @param {string} req.peer_id
* @param {object} req.register_config
* @param {string} req.register_config.device_name
*/
handleRegister = async (req) => {
this.peerID = req.peer_id
this.deviceName = req.register_config.device_name || this.deviceName
this.log(`Registered socket ${this.connID} -> ${this.peerID}`)
if (this.manager.clients.has(this.peerID)) {
const oldClient = this.manager.clients.get(this.peerID)
this.log(`Terminating previous socket ${oldClient.connID} for ${this.peerID}`)
await oldClient.stop("Socket replaced by new connection")
}
this.manager.clients.set(this.peerID, this)
return { client_exists: this.authClient !== null }
}
async handleLine(line) {
if (this.stopped) {
this.log("Ignoring line, client is stopped")
return
}
let req
try {
req = JSON.parse(line, this.#readReviver)
} catch (err) {
this.log("Non-JSON request:", line)
return
}
if (!req.command || !req.id) {
this.log("Invalid request:", line)
return
}
if (req.id <= this.maxCommandID) {
this.log("Ignoring old request", req.id)
return
}
this.log(`Request ${req.id}:`, this.#logObj(req, req.command, this.loggingKeys.request))
this.maxCommandID = req.id
let handler
if (!this.peerID) {
if (req.command !== "register") {
this.log("First request wasn't a register request, terminating")
await this.stop("Invalid first request")
return
} else if (!req.peer_id) {
this.log("Register request didn't contain ID, terminating")
await this.stop("Invalid register request")
return
}
handler = this.handleRegister
} else {
handler = {
// TODO Wrapper for per-user commands
generate_uuid: util.randomAndroidSubDeviceUUID,
register_device: this.registerDevice,
login: this.handleLogin,
renew: this.handleRenew,
start: this.userStart,
stop: this.userStop,
connect: this.handleConnect,
disconnect: this.handleDisconnect,
is_connected: this.isConnected,
get_settings: this.getSettings,
get_own_profile: this.getOwnProfile,
get_profile: this.getProfile,
get_portal_channel_info: this.getPortalChannelInfo,
get_portal_channel_participant_info: this.getPortalChannelParticipantInfo,
get_participants: this.getParticipants,
get_chats: this.getChats,
get_read_receipts: this.getReadReceipts,
can_change_uuid: this.canChangeUUID,
change_uuid: this.changeUUID,
set_uuid_searchable: this.setUUIDSearchable,
list_friends: this.listFriends,
edit_friend: this.editFriend,
edit_friend_by_uuid: this.editFriendByUUID,
get_friend_dm_id: req => this.getFriendProperty(req, "directChatId"),
get_memo_ids: this.getMemoIds,
download_file: this.downloadFile,
send_chat: this.sendChat,
send_media: this.sendMedia,
delete_chat: this.deleteChat,
mark_read: this.markRead,
send_perm: this.sendPerm,
set_channel_name: this.setChannelName,
set_channel_description: this.setChannelDescription,
//set_channel_photo: this.setChannelPhoto,
create_direct_chat: this.createDirectChat,
leave_channel: this.leaveChannel,
}[req.command] || this.handleUnknownCommand
}
const resp = { id: req.id }
delete req.id
delete req.command
resp.command = "response"
try {
resp.response = await handler(req)
} catch (err) {
if (err.isAxiosError) {
resp.response = {
success: false,
status: err.response.status,
}
} else if ("status" in err) {
resp.response = err
} else {
resp.command = "error"
let errorDetails
if (err instanceof ProtocolError) {
resp.error = err.message
errorDetails = err.message
} else if (err instanceof Error) {
resp.error = err.toString()
errorDetails = err.stack
} else {
resp.error = JSON.stringify(err)
errorDetails = `throwed ${resp.error}`
}
this.error(`Response ${resp.id}: ${errorDetails}`)
}
}
if (resp.response) {
const success = resp.response.success !== false
const logger = (success ? this.log : this.error).bind(this)
logger(
`Response ${resp.id}:`,
this.#logObj(
resp.response instanceof Object ? resp.response : {value: resp.response},
success ? "success" : "failure",
this.loggingKeys.response
)
)
}
await this.write(resp)
if ("mxid" in req) {
const userClient = this.#tryGetUser(req.mxid)
if (userClient && userClient.isUnexpectedlyDisconnected()) {
this.error("Unexpected disconnect for user", req.mxid)
this.userClients.delete(req.mxid)
await userClient.write("unexpected_disconnect")
}
}
}
/**
* @param {object} obj
* @param {string} desc
* @param {[string]} keys
*/
#logObj(obj, desc, keys) {
return [desc].concat(
keys.filter(key => key in obj).map(key => `${key}: ${JSON.stringify(obj[key], this.#writeReplacer)}`)
).join(', ')
}
#writeReplacer(key, value) {
if (value instanceof Long) {
return value.toString()
} else {
return value
}
}
#readReviver(key, value) {
if (value instanceof Object) {
// TODO Use a type map if there will be many possible types
if (value.__type__ == "Long") {
return Long.fromString(value.str)
}
}
return value
}
}
/**
* @param {object} result
*/
function makeCommandResult(result) {
return {
success: true,
status: 0,
result: result
}
}
/**
* @param {TalkChannelList} channelList
* @param {ChannelType} channelType
*/
function getChannelListForType(channelList, channelType) {
return isChannelTypeOpen(channelType) ? channelList.open : channelList.normal
}
/**
* @param {ChannelType} channelType
*/
function isChannelTypeOpen(channelType) {
switch (channelType) {
case "OM":
case "OD":
return true
default:
return false
}
}
/**
* @param {TalkOpenChannel} channel
*/
function getChannelOwner(channel) {
for (const userInfo of channel.getAllUserInfo()) {
if (userInfo.perm == OpenChannelUserPerm.OWNER) {
return userInfo
}
}
return null
}