461 lines
12 KiB
JavaScript
461 lines
12 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 { emitLines, promisify } from "./util.js"
|
||
|
|
import {
|
||
|
|
AuthApiClient,
|
||
|
|
OAuthApiClient,
|
||
|
|
ServiceApiClient,
|
||
|
|
TalkClient,
|
||
|
|
KnownAuthStatusCode,
|
||
|
|
util,
|
||
|
|
} from "node-kakao"
|
||
|
|
/** @typedef {import("node-kakao").OAuthCredential} OAuthCredential */
|
||
|
|
/** @typedef {import("./clientmanager.js").default} ClientManager} */
|
||
|
|
|
||
|
|
|
||
|
|
class UserClient {
|
||
|
|
|
||
|
|
#talkClient = new TalkClient()
|
||
|
|
get talkClient() { return this.#talkClient }
|
||
|
|
|
||
|
|
/** @type {ServiceApiClient} */
|
||
|
|
#serviceClient = null
|
||
|
|
get serviceClient() { return this.#serviceClient }
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param {string} mxid The ID of the associated Matrix user
|
||
|
|
* @param {OAuthCredential} credential The tokens that API calls may use
|
||
|
|
*/
|
||
|
|
constructor(mxid, credential) {
|
||
|
|
this.mxid = mxid
|
||
|
|
this.credential = credential
|
||
|
|
}
|
||
|
|
|
||
|
|
static async create(mxid, credential) {
|
||
|
|
const userClient = new UserClient(mxid, credential)
|
||
|
|
userClient.#serviceClient = await ServiceApiClient.create(this.credential)
|
||
|
|
return userClient
|
||
|
|
}
|
||
|
|
|
||
|
|
close() {
|
||
|
|
this.#talkClient.close()
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* TODO Maybe use a "write" method instead
|
||
|
|
* @param {string} command
|
||
|
|
*/
|
||
|
|
getCmd(command) {
|
||
|
|
return `${command}:${this.mxid}`
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
export default class PeerClient {
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param {ClientManager} manager
|
||
|
|
* @param {import("net").Socket} socket
|
||
|
|
* @param {number} connID
|
||
|
|
* @param {Map<string, UserClient>} userClients
|
||
|
|
*/
|
||
|
|
constructor(manager, socket, connID) {
|
||
|
|
this.manager = manager
|
||
|
|
this.socket = socket
|
||
|
|
this.connID = connID
|
||
|
|
this.stopped = false
|
||
|
|
this.notificationID = 0
|
||
|
|
this.maxCommandID = 0
|
||
|
|
this.peerID = null
|
||
|
|
|
||
|
|
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
|
||
|
|
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 = async () => {
|
||
|
|
// TODO Persist clients across bridge disconnections.
|
||
|
|
// But then have to queue received events until bridge acks them!
|
||
|
|
this.log("Closing all API clients for", this.peerID)
|
||
|
|
for (const userClient of this.userClients.values()) {
|
||
|
|
userClient.close()
|
||
|
|
}
|
||
|
|
this.userClients.clear()
|
||
|
|
|
||
|
|
this.stopped = true
|
||
|
|
if (this.peerID && this.manager.clients.get(this.peerID) === this) {
|
||
|
|
this.manager.clients.delete(this.peerID)
|
||
|
|
}
|
||
|
|
this.log(`Connection closed (peer: ${this.peerID})`)
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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) + "\n", cb))
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param {Object} req
|
||
|
|
* @param {string} req.passcode
|
||
|
|
* @param {string} req.uuid
|
||
|
|
* @param {Object} req.form
|
||
|
|
*/
|
||
|
|
registerDevice = async (req) => {
|
||
|
|
const authClient = await this.#createAuthClient(req.uuid)
|
||
|
|
return await authClient.registerDevice(req.form, req.passcode, true)
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Log in. 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
|
||
|
|
* @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, true)
|
||
|
|
if (loginRes.status === KnownAuthStatusCode.DEVICE_NOT_REGISTERED) {
|
||
|
|
const passcodeRes = await authClient.requestPasscode(req.form)
|
||
|
|
if (!passcodeRes.success) {
|
||
|
|
loginRes.status = passcodeRes.status
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return loginRes
|
||
|
|
}
|
||
|
|
|
||
|
|
// TODO Wrapper for per-user commands
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checked lookup of a UserClient for a given mxid.
|
||
|
|
* @param {string} mxid
|
||
|
|
*/
|
||
|
|
#getUser(mxid) {
|
||
|
|
/** @type {UserClient} */
|
||
|
|
const userClient = this.userClients.get(mxid)
|
||
|
|
if (userClient === undefined) {
|
||
|
|
throw new Error(`Could not find user ${mxid}`)
|
||
|
|
}
|
||
|
|
return userClient
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param {Object} req
|
||
|
|
* @param {OAuthCredential} req.oauth_credential
|
||
|
|
*/
|
||
|
|
handleRenew = async (req) => {
|
||
|
|
const oAuthClient = await OAuthApiClient.create()
|
||
|
|
return await oAuthClient.renew(req.oauth_credential)
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* TODO Consider caching per-user
|
||
|
|
* @param {string} uuid
|
||
|
|
*/
|
||
|
|
async #createAuthClient(uuid) {
|
||
|
|
return await AuthApiClient.create("KakaoTalk Bridge", uuid)
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param {Object} req
|
||
|
|
* @param {string} req.mxid
|
||
|
|
* @param {OAuthCredential} req.oauth_credential
|
||
|
|
*/
|
||
|
|
handleStart = async (req) => {
|
||
|
|
// TODO Don't re-login if possible. But must still return a LoginResult!
|
||
|
|
{
|
||
|
|
const oldUserClient = this.userClients.get(req.mxid)
|
||
|
|
if (oldUserClient !== undefined) {
|
||
|
|
oldUserClient.close()
|
||
|
|
this.userClients.delete(req.mxid)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const userClient = await UserClient.create(req.mxid, req.oauth_credential)
|
||
|
|
const res = await userClient.talkClient.login(req.oauth_credential)
|
||
|
|
if (!res.success) return res
|
||
|
|
|
||
|
|
// Attach listeners in something like start_listen
|
||
|
|
/*
|
||
|
|
userClient.talkClient.on("chat", (data, channel) => {
|
||
|
|
this.log(`Found message in channel ${channel.channelId}`)
|
||
|
|
return this.#write({
|
||
|
|
id: --this.notificationID,
|
||
|
|
command: userClient.getCmd("chat"),
|
||
|
|
//is_sequential: true, // TODO make sequential per user!
|
||
|
|
chatlog: data.chat(),
|
||
|
|
channelId: channel.channelId,
|
||
|
|
})
|
||
|
|
})
|
||
|
|
|
||
|
|
/*
|
||
|
|
userClient.talkClient.on("chat_read", (chat, channel, reader) => {
|
||
|
|
this.log(`chat_read in channel ${channel.channelId}`)
|
||
|
|
//chat.logId
|
||
|
|
})
|
||
|
|
*/
|
||
|
|
|
||
|
|
this.userClients.set(req.mxid, userClient)
|
||
|
|
return res
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param {Object} req
|
||
|
|
* @param {string} req.mxid
|
||
|
|
* @param {OAuthCredential} req.oauth_credential
|
||
|
|
*/
|
||
|
|
getOwnProfile = async (req) => {
|
||
|
|
const serviceClient =
|
||
|
|
this.userClients.get(req.mxid)?.serviceClient ||
|
||
|
|
await ServiceApiClient.create(req.oauth_credential)
|
||
|
|
return await serviceClient.requestMyProfile()
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param {Object} req
|
||
|
|
* @param {string} req.mxid
|
||
|
|
* @param {OAuthCredential} req.oauth_credential
|
||
|
|
* @param {Long} req.user_id
|
||
|
|
*/
|
||
|
|
getProfile = async (req) => {
|
||
|
|
const serviceClient =
|
||
|
|
this.userClients.get(mxid)?.serviceClient ||
|
||
|
|
await ServiceApiClient.create(req.oauth_credential)
|
||
|
|
return await serviceClient.requestProfile(user_id)
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param {Object} req
|
||
|
|
* @param {string} req.mxid
|
||
|
|
* @param {Long} req.channel_id
|
||
|
|
*/
|
||
|
|
getPortalChannelInfo = (req) => {
|
||
|
|
const userClient = this.#getUser(req.mxid)
|
||
|
|
const talkChannel = userClient.talkClient.channelList.get(req.channel_id)
|
||
|
|
|
||
|
|
/* TODO Decide if this is needed. If it is, make function async!
|
||
|
|
const res = await talkChannel.updateAll()
|
||
|
|
if (!res.success) return res
|
||
|
|
*/
|
||
|
|
|
||
|
|
return this.#makeCommandResult({
|
||
|
|
name: talkChannel.getDisplayName(),
|
||
|
|
//participants: Array.from(talkChannel.getAllUserInfo()),
|
||
|
|
// TODO Image
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
#makeCommandResult(result) {
|
||
|
|
return {
|
||
|
|
success: true,
|
||
|
|
status: 0,
|
||
|
|
result: result
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param {Object} req
|
||
|
|
* @param {string} req.mxid
|
||
|
|
*/
|
||
|
|
handleStop = async (req) => {
|
||
|
|
this.#getUser(req.mxid).close()
|
||
|
|
}
|
||
|
|
|
||
|
|
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)
|
||
|
|
} 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
|
||
|
|
}
|
||
|
|
if (req.command != "is_connected") {
|
||
|
|
this.log("Received request", req.id, "with command", req.command)
|
||
|
|
}
|
||
|
|
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 Subclass / object for KakaoTalk-specific handlers?
|
||
|
|
start: this.handleStart,
|
||
|
|
stop: this.handleStop,
|
||
|
|
disconnect: () => this.stop(),
|
||
|
|
login: this.handleLogin,
|
||
|
|
renew: this.handleRenew,
|
||
|
|
generate_uuid: util.randomAndroidSubDeviceUUID,
|
||
|
|
register_device: this.registerDevice,
|
||
|
|
get_own_profile: this.getOwnProfile,
|
||
|
|
get_portal_channel_info: this.getPortalChannelInfo,
|
||
|
|
get_profile: this.getProfile,
|
||
|
|
/*
|
||
|
|
send: req => this.puppet.sendMessage(req.chat_id, req.text),
|
||
|
|
send_file: req => this.puppet.sendFile(req.chat_id, req.file_path),
|
||
|
|
set_last_message_ids: req => this.puppet.setLastMessageIDs(req.msg_ids, req.own_msg_ids, req.rct_ids),
|
||
|
|
forget_chat: req => this.puppet.forgetChat(req.chat_id),
|
||
|
|
pause: () => this.puppet.stopObserving(),
|
||
|
|
resume: () => this.puppet.startObserving(),
|
||
|
|
get_contacts: () => this.puppet.getContacts(),
|
||
|
|
get_chats: () => this.puppet.getRecentChats(),
|
||
|
|
get_chat: req => this.puppet.getChatInfo(req.chat_id, req.force_view),
|
||
|
|
get_messages: req => this.puppet.getMessages(req.chat_id),
|
||
|
|
read_image: req => this.puppet.readImage(req.image_url),
|
||
|
|
*/
|
||
|
|
//is_connected: async () => ({ is_connected: !await this.puppet.isDisconnected() }),
|
||
|
|
}[req.command] || this.handleUnknownCommand
|
||
|
|
}
|
||
|
|
const resp = { id: req.id }
|
||
|
|
delete req.id
|
||
|
|
delete req.command
|
||
|
|
req = typeify(req)
|
||
|
|
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()
|
||
|
|
this.log(`Error handling request ${resp.id} ${err}`)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
await this.#write(resp)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Recursively scan an object to check if any of its sub-objects
|
||
|
|
* should be converted into instances of a specified class.
|
||
|
|
* @param obj The object to be scanned & updated.
|
||
|
|
* @returns The converted object.
|
||
|
|
*/
|
||
|
|
function typeify(obj) {
|
||
|
|
if (!(obj instanceof Object)) {
|
||
|
|
return obj
|
||
|
|
}
|
||
|
|
const converterFunc = TYPE_MAP.get(obj.__type__)
|
||
|
|
if (converterFunc !== undefined) {
|
||
|
|
return converterFunc(obj)
|
||
|
|
}
|
||
|
|
for (const key in obj) {
|
||
|
|
obj[key] = typeify(obj[key])
|
||
|
|
}
|
||
|
|
return obj
|
||
|
|
}
|
||
|
|
|
||
|
|
// TODO Add more if needed
|
||
|
|
const TYPE_MAP = new Map([
|
||
|
|
["Long", (obj) => new Long(obj.low, obj.high, obj.unsigned)],
|
||
|
|
])
|