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

742 lines
19 KiB
JavaScript
Raw Normal View History

2022-02-25 02:22:50 -05:00
// 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"
2022-02-25 02:22:50 -05:00
import {
AuthApiClient,
OAuthApiClient,
ServiceApiClient,
TalkClient,
KnownAuthStatusCode,
util,
} from "node-kakao"
/** @typedef {import("node-kakao").OAuthCredential} OAuthCredential */
/** @typedef {import("node-kakao").ChannelType} ChannelType */
2022-04-05 15:44:02 -04:00
/** @typedef {import("node-kakao").ReplyAttachment} ReplyAttachment */
2022-04-06 12:49:23 -04:00
/** @typedef {import("node-kakao").MentionStruct} MentionStruct */
2022-04-05 15:44:02 -04:00
/** @typedef {import("node-kakao/dist/talk").TalkChannelList} TalkChannelList */
2022-03-09 20:26:39 -05:00
import chat from "node-kakao/chat"
const { KnownChatType } = chat
2022-02-25 02:22:50 -05:00
2022-03-18 03:52:55 -04:00
import { emitLines, promisify } from "./util.js"
2022-04-08 19:01:32 -04:00
/**
* @typedef {Object} ChannelProps
* @property {Long} id
* @property {ChannelType} type
*/
2022-02-25 02:22:50 -05:00
2022-03-23 03:09:30 -04:00
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,
};
}
2022-02-25 02:22:50 -05:00
class UserClient {
static #initializing = false
2022-02-25 02:22:50 -05:00
#talkClient = new TalkClient()
get talkClient() { return this.#talkClient }
/** @type {ServiceApiClient} */
2022-03-18 03:52:55 -04:00
#serviceClient
2022-02-25 02:22:50 -05:00
get serviceClient() { return this.#serviceClient }
/**
* 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
2022-02-25 02:22:50 -05:00
*/
constructor(mxid, peerClient) {
if (!UserClient.#initializing) {
throw new Error("Private constructor")
}
UserClient.#initializing = false
2022-02-25 02:22:50 -05:00
this.mxid = mxid
this.peerClient = peerClient
this.#talkClient.on("chat", (data, channel) => {
this.log(`${data.chat.logId} received in channel ${channel.channelId}`)
return 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(`${feed.logId} deleted in channel ${channel.channelId} by user ${feedChatlog.sender.userId}`);
return 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 ${hideLog.logId} hid from channel ${channel.channelId} by user ${hideLog.sender.userId}`);
return this.write("chat_deleted", {
chatId: feed.logId,
senderId: hideLog.sender.userId,
timestamp: hideLog.sendAt,
channelId: channel.channelId,
channelType: channel.info.type,
})
})
/* TODO Many more listeners
this.#talkClient.on("chat_read", (chat, channel, reader) => {
this.log(`chat_read in channel ${channel.channelId}`)
//chat.logId
})
*/
this.#talkClient.on("disconnected", (reason) => {
this.log(`Disconnected (reason=${reason})`)
this.disconnect()
return this.write("disconnected", {
reason: reason,
})
})
this.#talkClient.on("switch_server", () => {
this.log(`Server switch requested`)
return this.write("switch_server", {
is_sequential: true,
})
})
2022-04-10 02:18:53 -04:00
this.#talkClient.on("error", (err) => {
this.log(`Client error: ${err}`)
return this.write("error", {
error: err,
})
})
2022-02-25 02:22:50 -05:00
}
/**
* @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)
2022-03-11 20:38:55 -05:00
userClient.#serviceClient = await ServiceApiClient.create(credential)
2022-02-25 02:22:50 -05:00
return userClient
}
log(...text) {
console.log(`[API/${this.mxid}]`, ...text)
}
error(...text) {
console.error(`[API/${this.mxid}]`, ...text)
}
/**
2022-04-08 19:01:32 -04:00
* @param {ChannelProps} channelProps
*/
2022-04-08 19:01:32 -04:00
async getChannel(channelProps) {
let channel = this.#talkClient.channelList.get(channelProps.id)
if (channel) {
return channel
} else {
const channelList = getChannelListForType(
this.#talkClient.channelList,
2022-04-08 19:01:32 -04:00
channelProps.type
)
const res = await channelList.addChannel({
2022-04-08 19:01:32 -04:00
channelId: channelProps.id,
})
if (!res.success) {
2022-04-08 19:01:32 -04:00
throw new Error(`Unable to add ${channelProps.type} channel ${channelProps.id}`)
}
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()
return await this.#talkClient.login(credential)
}
disconnect() {
if (this.#talkClient.logon) {
this.#talkClient.close()
}
2022-02-25 02:22:50 -05:00
}
/**
* 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.
2022-02-25 02:22:50 -05:00
*/
write(command, data) {
return this.peerClient.write({
id: --this.peerClient.notificationID,
command: `${command}:${this.mxid}`,
...data
})
2022-02-25 02:22:50 -05:00
}
}
export default class PeerClient {
/**
* @param {import("./clientmanager.js").default} manager
2022-02-25 02:22:50 -05:00
* @param {import("net").Socket} socket
* @param {number} connID
*/
constructor(manager, socket, connID) {
this.manager = manager
this.socket = socket
this.connID = connID
2022-02-25 02:22:50 -05:00
this.stopped = false
this.notificationID = 0
this.maxCommandID = 0
this.peerID = null
/** @type {Map<string, UserClient>} */
2022-02-25 02:22:50 -05:00
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 3 seconds, terminating")
this.stop("Register request timeout")
}
}, 3000)
}
async stop(error = null) {
if (this.stopped) {
return
}
this.stopped = true
2022-03-18 03:52:55 -04:00
this.#closeUsers()
2022-02-25 02:22:50 -05:00
try {
await this.write({ id: --this.notificationID, command: "quit", error })
2022-02-25 02:22:50 -05:00
await promisify(cb => this.socket.end(cb))
} catch (err) {
this.error("Failed to end connection:", err)
this.socket.destroy(err)
}
}
2022-03-18 03:52:55 -04:00
handleEnd = () => {
2022-02-25 02:22:50 -05:00
this.stopped = true
2022-03-18 03:52:55 -04:00
this.#closeUsers()
2022-02-25 02:22:50 -05:00
if (this.peerID && this.manager.clients.get(this.peerID) === this) {
this.manager.clients.delete(this.peerID)
}
this.log(`Connection closed (peer: ${this.peerID})`)
}
2022-03-18 03:52:55 -04:00
#closeUsers() {
this.log("Closing all API clients for", this.peerID)
for (const userClient of this.userClients.values()) {
userClient.disconnect()
2022-03-18 03:52:55 -04:00
}
this.userClients.clear()
}
2022-02-25 02:22:50 -05:00
/**
* 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))
2022-02-25 02:22:50 -05:00
}
/**
* @param {Object} req
* @param {string} req.passcode
* @param {string} req.uuid
* @param {Object} req.form
*/
registerDevice = async (req) => {
2022-03-18 03:52:55 -04:00
// TODO Look for a deregister API call
2022-02-25 02:22:50 -05:00
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.
2022-02-25 02:22:50 -05:00
* @param {Object} req
* @param {string} req.uuid
* @param {Object} req.form
* @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) => {
2022-03-18 03:52:55 -04:00
// TODO Look for a logout API call
2022-02-25 02:22:50 -05:00
const authClient = await this.#createAuthClient(req.uuid)
const loginRes = await authClient.login(req.form, true)
if (loginRes.status === KnownAuthStatusCode.DEVICE_NOT_REGISTERED) {
const passcodeRes = await authClient.requestPasscode(req.form)
if (!passcodeRes.success) {
loginRes.status = passcodeRes.status
}
}
return loginRes
}
2022-03-09 02:25:28 -05:00
/**
* TODO Consider caching per-user
* @param {string} uuid
*/
async #createAuthClient(uuid) {
return await AuthApiClient.create("KakaoTalk Bridge", uuid)
}
2022-02-25 02:22:50 -05:00
// TODO Wrapper for per-user commands
/**
* Checked lookup of a UserClient for a given mxid.
* @param {string} mxid
* @returns {UserClient}
2022-02-25 02:22:50 -05:00
*/
#getUser(mxid) {
const userClient = this.userClients.get(mxid)
if (userClient === undefined) {
throw new Error(`Could not find user ${mxid}`)
}
return userClient
}
2022-03-18 03:52:55 -04:00
/**
* Unchecked lookup of a UserClient for a given mxid.
* @param {string} mxid
* @returns {UserClient | undefined}
*/
#tryGetUser(mxid) {
return this.userClients.get(mxid)
}
2022-04-05 00:59:22 -04:00
/**
* @param {string} mxid
2022-04-08 19:01:32 -04:00
* @param {ChannelProps} channelProps
2022-04-05 00:59:22 -04:00
*/
2022-04-08 19:01:32 -04:00
async #getUserChannel(mxid, channelProps) {
return await this.#getUser(mxid).getChannel(channelProps)
2022-04-05 00:59:22 -04:00
}
2022-02-25 02:22:50 -05:00
/**
* @param {Object} req
* @param {OAuthCredential} req.oauth_credential
*/
handleRenew = async (req) => {
// TODO Cache per user? Reset API client objects?
2022-02-25 02:22:50 -05:00
const oAuthClient = await OAuthApiClient.create()
return await oAuthClient.renew(req.oauth_credential)
}
/**
* @param {Object} req
* @param {string} req.mxid
* @param {OAuthCredential} req.oauth_credential
*/
userStart = async (req) => {
const userClient = this.#tryGetUser(req.mxid) || await UserClient.create(req.mxid, req.oauth_credential, this)
// TODO Should call requestMore/LessSettings instead
const res = await userClient.serviceClient.requestMyProfile()
if (res.success) {
this.userClients.set(req.mxid, userClient)
}
return res
}
2022-02-25 02:22:50 -05:00
/**
* @param {Object} req
* @param {string} req.mxid
*/
userStop = async (req) => {
this.handleDisconnect(req)
this.userClients.delete(req.mxid)
}
2022-02-25 02:22:50 -05:00
/**
* @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)
2022-03-18 03:52:55 -04:00
}
/**
* @param {Object} req
* @param {string} req.mxid
*/
handleDisconnect = (req) => {
this.#tryGetUser(req.mxid)?.disconnect()
2022-02-25 02:22:50 -05:00
}
/**
* @param {Object} req
2022-03-23 03:09:30 -04:00
* @param {?string} req.mxid
2022-02-25 02:22:50 -05:00
*/
getOwnProfile = async (req) => {
return await this.#getUser(req.mxid).serviceClient.requestMyProfile()
2022-02-25 02:22:50 -05:00
}
/**
* @param {Object} req
2022-03-23 03:09:30 -04:00
* @param {?string} req.mxid
2022-02-25 02:22:50 -05:00
* @param {Long} req.user_id
*/
getProfile = async (req) => {
return await this.#getUser(req.mxid).serviceClient.requestProfile(req.user_id)
2022-02-25 02:22:50 -05:00
}
/**
* @param {Object} req
* @param {string} req.mxid
2022-04-08 19:01:32 -04:00
* @param {ChannelProps} req.channel_props
2022-02-25 02:22:50 -05:00
*/
2022-03-09 02:25:28 -05:00
getPortalChannelInfo = async (req) => {
2022-04-05 00:59:22 -04:00
const talkChannel = await this.#getUserChannel(req.mxid, req.channel_props)
2022-02-25 02:22:50 -05:00
const res = await talkChannel.updateAll()
if (!res.success) return res
return this.#makeCommandResult({
name: talkChannel.getDisplayName(),
2022-03-09 02:25:28 -05:00
participants: Array.from(talkChannel.getAllUserInfo()),
2022-02-25 02:22:50 -05:00
// TODO Image
})
}
/**
* @param {Object} req
* @param {string} req.mxid
2022-04-08 19:01:32 -04:00
* @param {ChannelProps} req.channel_props
*/
getParticipants = async (req) => {
2022-04-05 00:59:22 -04:00
const talkChannel = await this.#getUserChannel(req.mxid, req.channel_props)
return await talkChannel.getAllLatestUserInfo()
}
2022-03-09 02:25:28 -05:00
/**
* @param {Object} req
* @param {string} req.mxid
2022-04-08 19:01:32 -04:00
* @param {ChannelProps} req.channel_props
2022-03-23 03:09:30 -04:00
* @param {?Long} req.sync_from
* @param {?Number} req.limit
2022-03-09 02:25:28 -05:00
*/
getChats = async (req) => {
2022-04-05 00:59:22 -04:00
const talkChannel = await this.#getUserChannel(req.mxid, req.channel_props)
2022-03-09 02:25:28 -05:00
const res = await talkChannel.getChatListFrom(req.sync_from)
if (res.success && 0 < req.limit && req.limit < res.result.length) {
res.result.splice(0, res.result.length - req.limit)
}
return res
2022-03-09 02:25:28 -05:00
}
2022-03-23 03:09:30 -04:00
/**
* @param {Object} req
* @param {string} req.mxid
2022-03-23 03:09:30 -04:00
*/
listFriends = async (req) => {
return await this.#getUser(req.mxid).serviceClient.requestFriendList()
2022-03-23 03:09:30 -04:00
}
/**
* @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 this.#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
for (const channel of channelList.all()) {
if (channel.info.type == "MemoChat") {
channelIds.push(channel.channelId)
}
}
return channelIds
}
2022-03-09 20:26:39 -05:00
/**
* @param {Object} req
* @param {string} req.mxid
2022-04-08 19:01:32 -04:00
* @param {ChannelProps} req.channel_props
2022-03-09 20:26:39 -05:00
* @param {string} req.text
2022-04-05 15:44:02 -04:00
* @param {?ReplyAttachment} req.reply_to
2022-04-06 12:49:23 -04:00
* @param {?MentionStruct[]} req.mentions
2022-03-09 20:26:39 -05:00
*/
2022-04-05 00:59:22 -04:00
sendChat = async (req) => {
const talkChannel = await this.#getUserChannel(req.mxid, req.channel_props)
2022-03-09 20:26:39 -05:00
return await talkChannel.sendChat({
text: req.text,
2022-04-05 15:44:02 -04:00
type: !!req.reply_to ? KnownChatType.REPLY : KnownChatType.TEXT,
2022-04-06 12:49:23 -04:00
attachment: !req.mentions ? req.reply_to : {...req.reply_to, mentions: req.mentions},
2022-03-09 20:26:39 -05:00
})
}
2022-03-26 03:37:53 -04:00
/**
* @param {Object} req
* @param {string} req.mxid
2022-04-08 19:01:32 -04:00
* @param {ChannelProps} req.channel_props
2022-03-26 03:37:53 -04:00
* @param {int} req.type
2022-04-06 12:49:23 -04:00
* @param {number[]} req.data
2022-03-26 03:37:53 -04:00
* @param {string} req.name
* @param {?int} req.width
* @param {?int} req.height
* @param {?string} req.ext
*/
sendMedia = async (req) => {
2022-04-05 00:59:22 -04:00
const talkChannel = await this.#getUserChannel(req.mxid, req.channel_props)
2022-03-26 03:37:53 -04:00
return await talkChannel.sendMedia(req.type, {
data: Uint8Array.from(req.data),
name: req.name,
width: req.width,
height: req.height,
ext: req.ext,
})
}
2022-04-09 04:02:51 -04:00
/**
* @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,
})
}
2022-02-25 02:22:50 -05:00
#makeCommandResult(result) {
return {
success: true,
status: 0,
result: result
}
}
handleUnknownCommand = () => {
throw new Error("Unknown command")
}
/**
* @param {Object} req
* @param {string} req.peer_id
*/
handleRegister = async (req) => {
this.peerID = req.peer_id
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)
2022-02-25 02:22:50 -05:00
} 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("Received request", req.id, "with command", req.command)
2022-02-25 02:22:50 -05:00
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 = {
2022-03-18 03:52:55 -04:00
// TODO Wrapper for per-user commands
2022-02-25 02:22:50 -05:00
generate_uuid: util.randomAndroidSubDeviceUUID,
register_device: this.registerDevice,
2022-03-18 03:52:55 -04:00
login: this.handleLogin,
renew: this.handleRenew,
start: this.userStart,
stop: this.userStop,
2022-03-18 03:52:55 -04:00
connect: this.handleConnect,
disconnect: this.handleDisconnect,
2022-02-25 02:22:50 -05:00
get_own_profile: this.getOwnProfile,
2022-03-18 03:52:55 -04:00
get_profile: this.getProfile,
2022-02-25 02:22:50 -05:00
get_portal_channel_info: this.getPortalChannelInfo,
get_participants: this.getParticipants,
2022-03-09 02:25:28 -05:00
get_chats: this.getChats,
2022-03-23 03:09:30 -04:00
list_friends: this.listFriends,
get_friend_dm_id: req => this.getFriendProperty(req, "directChatId"),
get_memo_ids: this.getMemoIds,
2022-04-05 00:59:22 -04:00
send_chat: this.sendChat,
2022-03-26 03:37:53 -04:00
send_media: this.sendMedia,
2022-04-09 04:02:51 -04:00
delete_chat: this.deleteChat,
2022-02-25 02:22:50 -05:00
}[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 {
resp.command = "error"
resp.error = err.toString()
2022-03-11 20:38:55 -05:00
this.log(`Error handling request ${resp.id} ${err.stack}`)
2022-03-18 03:52:55 -04:00
// TODO Check if session is broken. If it is, close the PeerClient
2022-02-25 02:22:50 -05:00
}
}
await this.write(resp)
2022-02-25 02:22:50 -05:00
}
#writeReplacer = function(key, value) {
if (value instanceof Long) {
return value.toString()
} else {
return value
}
2022-02-25 02:22:50 -05:00
}
#readReviver = function(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
2022-02-25 02:22:50 -05:00
}
}
/**
* @param {TalkChannelList} channelList
* @param {ChannelType} channelType
*/
function getChannelListForType(channelList, channelType) {
2022-04-08 19:01:32 -04:00
return isChannelTypeOpen(channelType) ? channelList.open : channelList.normal
}
/**
* @param {ChannelType} channelType
*/
function isChannelTypeOpen(channelType) {
switch (channelType) {
case "OM":
case "OD":
2022-04-08 19:01:32 -04:00
return true
default:
2022-04-08 19:01:32 -04:00
return false
}
}