@rikaidev/yomi 0.2.6

package/dist/line/client/sync-service/client.js

@@ -0,0 +1,317 @@
+/**
+ * LINE Client sync capability.
+ */
+import { createCliLogger } from '../../../util/log.js';
+import { LINE_APP_CONFIG } from '../../core/config.js';
+import { OP_TYPE } from '../../core/constants.js';
+import { encodeCallMessage } from '../../core/thrift/index.js';
+import { sendRequest } from '../transport.js';
+/**
+ * Check whether a logger exposes the CLI logger contract used by LINE sync.
+ *
+ * @param logger - Candidate logger.
+ * @returns True when the logger supports info/warn/error.
+ */
+function hasCliLogger(logger) {
+    return Boolean(logger?.info && logger?.warn && logger?.error);
+}
+/**
+ * Resolve the active logger for one LINE sync runtime.
+ *
+ * @param runtime - LINE client runtime.
+ * @returns Logger for sync diagnostics.
+ */
+function getLineLog(runtime) {
+    if (hasCliLogger(runtime?.startupFlowLogger)) {
+        return runtime.startupFlowLogger;
+    }
+    if (hasCliLogger(runtime?.logger)) {
+        return runtime.logger;
+    }
+    return createCliLogger('LINE');
+}
+/**
+ * Build the thrift payload for one sync request.
+ *
+ * @param runtime - LINE client runtime.
+ * @param count - Maximum operations requested.
+ * @returns Encoded sync request payload.
+ */
+function buildSyncPayload(runtime, count) {
+    const fields = [
+        [
+            12,
+            1,
+            [
+                [10, 1, Math.max(0, runtime.revision)],
+                [8, 2, count],
+                [10, 3, runtime.globalRevision ?? 0],
+                [10, 4, runtime.individualRevision ?? 0],
+            ],
+        ],
+    ];
+    return encodeCallMessage('sync', runtime.seq++, fields);
+}
+/**
+ * Parse raw LINE operations into normalized operation objects.
+ *
+ * @param runtime - LINE client runtime.
+ * @param ops - Raw operation array.
+ * @returns Parsed operations.
+ */
+function parseOperations(runtime, ops) {
+    return Array.isArray(ops)
+        ? ops.map((op) => runtime.parseOperation(op)).filter(Boolean)
+        : [];
+}
+/**
+ * Apply token rotation returned from a sync response.
+ *
+ * @param runtime - LINE client runtime.
+ * @param result - Decoded sync response.
+ */
+function applyTokenRotation(runtime, result) {
+    if (!result.nextToken) {
+        return;
+    }
+    runtime.authToken = result.nextToken;
+    runtime.emit('tokenRotated', result.nextToken);
+}
+/**
+ * Throw when the sync response contains a thrift exception payload.
+ *
+ * @param result - Decoded sync response.
+ * @param lineLog - Active LINE logger.
+ */
+function throwSyncException(result, lineLog) {
+    const exc = result.fields?.[1];
+    if (!exc || typeof exc !== 'object') {
+        return;
+    }
+    const excMsg = typeof exc[2] === 'string' ? exc[2] : JSON.stringify(exc);
+    lineLog.error('sync.exception', { error: excMsg });
+    throw new Error(`sync exception: ${excMsg}`);
+}
+/**
+ * Apply revision fields from one sync response and return raw operations.
+ *
+ * @param runtime - LINE client runtime.
+ * @param response - Top-level sync response payload.
+ * @returns Raw operations array.
+ */
+function updateSyncRevisions(runtime, response) {
+    const operationResponse = response?.[1];
+    const ops = operationResponse?.[1];
+    const nextRevision = response?.[2];
+    const lastGlobalRevision = operationResponse?.[2];
+    const lastIndividualRevision = operationResponse?.[3];
+    if (typeof nextRevision === 'number' || typeof nextRevision === 'bigint') {
+        runtime.revision =
+            typeof nextRevision === 'bigint' ? Number(nextRevision) : nextRevision;
+    }
+    if (typeof lastGlobalRevision === 'number' ||
+        typeof lastGlobalRevision === 'bigint') {
+        runtime.globalRevision =
+            typeof lastGlobalRevision === 'bigint'
+                ? Number(lastGlobalRevision)
+                : lastGlobalRevision;
+    }
+    if (typeof lastIndividualRevision === 'number' ||
+        typeof lastIndividualRevision === 'bigint') {
+        runtime.individualRevision =
+            typeof lastIndividualRevision === 'bigint'
+                ? Number(lastIndividualRevision)
+                : lastIndividualRevision;
+    }
+    return ops;
+}
+/**
+ * Emit one sync poll summary and maintain idle counters.
+ *
+ * @param lineLog - Active LINE logger.
+ * @param runtime - LINE client runtime.
+ * @param opCount - Number of operations returned.
+ * @param elapsedMs - Poll duration in milliseconds.
+ */
+function recordSyncPoll(lineLog, runtime, opCount, elapsedMs) {
+    if (opCount > 0) {
+        lineLog.info('sync.event', {
+            elapsed_ms: elapsedMs,
+            ops: opCount,
+            revision: runtime.revision,
+        });
+        runtime._syncEmptyLogCount = 0;
+        return;
+    }
+    runtime._syncEmptyLogCount = (runtime._syncEmptyLogCount || 0) + 1;
+    if (runtime._syncEmptyLogCount === 1 ||
+        runtime._syncEmptyLogCount % 10 === 0) {
+        lineLog.info('sync.idle', {
+            elapsed_ms: elapsedMs,
+            empty_polls: runtime._syncEmptyLogCount,
+            revision: runtime.revision,
+        });
+    }
+}
+/**
+ * Emit parsed operations to downstream listeners and advance revisions.
+ *
+ * @param runtime - LINE client runtime.
+ * @param ops - Parsed operations.
+ */
+function emitOperations(runtime, ops) {
+    for (const op of ops) {
+        runtime.emit('operation', op);
+        if (op.type === OP_TYPE.RECEIVE_MESSAGE && op.message) {
+            runtime.emit('message', op.message);
+        }
+        if (op.revision && op.revision > runtime.revision) {
+            runtime.revision = op.revision;
+        }
+    }
+}
+/**
+ * Compute the next poll delay from the current activity level.
+ *
+ * @param opCount - Number of operations returned.
+ * @param consecutiveEmptyPolls - Consecutive idle poll count.
+ * @returns Delay in milliseconds.
+ */
+function getNextPollDelay(opCount, consecutiveEmptyPolls) {
+    if (opCount > 0) {
+        return 250;
+    }
+    return Math.min(1000 * 2 ** Math.min(consecutiveEmptyPolls, 4), 15000);
+}
+/**
+ * Sleep helper used by the polling loop.
+ *
+ * @param ms - Delay in milliseconds.
+ * @returns Promise resolving after the delay.
+ */
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Run one long-poll iteration and emit any returned operations.
+ *
+ * @param runtime - LINE client runtime.
+ * @returns Parsed operations from this poll.
+ */
+async function pollOnce(runtime) {
+    const ops = await runtime.syncLongPoll(50, 60000);
+    emitOperations(runtime, ops);
+    return ops;
+}
+/**
+ * Create the sync capability bound to one LINE client runtime.
+ *
+ * @param runtime - Mutable LINE client runtime.
+ * @returns Sync and polling methods bound to the runtime.
+ */
+export function createSyncClient(runtime) {
+    return {
+        /**
+         * Sync operations since the current revision.
+         *
+         * @param count - Maximum number of operations to retrieve.
+         * @returns Parsed operations.
+         */
+        async sync(count = 50) {
+            const data = buildSyncPayload(runtime, count);
+            const result = await sendRequest(runtime.host, LINE_APP_CONFIG.syncPath, data, { 'X-Line-Access': runtime.authToken }, 10000);
+            if (result.error === 'timeout') {
+                return [];
+            }
+            const ops = result.fields?.[0]?.[1]?.[1];
+            return parseOperations(runtime, ops);
+        },
+        /**
+         * Long-poll sync until new operations arrive or the timeout elapses.
+         *
+         * @param count - Maximum number of operations to retrieve.
+         * @param timeoutMs - Long-poll timeout in milliseconds.
+         * @returns Parsed operations.
+         */
+        async syncLongPoll(count = 50, timeoutMs = 60000) {
+            const lineLog = getLineLog(runtime);
+            const startedAt = Date.now();
+            const data = buildSyncPayload(runtime, count);
+            const result = await sendRequest(runtime.host, LINE_APP_CONFIG.syncPath, data, { 'X-Line-Access': runtime.authToken }, timeoutMs + 5000);
+            if (result.error === 'timeout') {
+                return [];
+            }
+            applyTokenRotation(runtime, result);
+            throwSyncException(result, lineLog);
+            if (result.statusCode && result.statusCode !== 200) {
+                lineLog.warn('sync.http', { status_code: result.statusCode });
+            }
+            const response = result.fields?.[0];
+            const ops = updateSyncRevisions(runtime, response);
+            const opCount = Array.isArray(ops) ? ops.length : 0;
+            recordSyncPoll(lineLog, runtime, opCount, Date.now() - startedAt);
+            return parseOperations(runtime, ops);
+        },
+        /**
+         * Fetch the latest operation revision from the server.
+         *
+         * @returns The latest operation revision.
+         */
+        async getLastOpRevision() {
+            const lineLog = getLineLog(runtime);
+            const result = await runtime.sendTalk('getLastOpRevision', []);
+            if (result.fields?.[1]) {
+                const exc = result.fields[1];
+                lineLog.error('revision.fetch.failed', { error: JSON.stringify(exc) });
+                throw new Error(`getLastOpRevision: ${exc[2] || exc[1] || 'unknown'}`);
+            }
+            const rev = result.fields?.[0];
+            lineLog.info('revision.fetch', { type: typeof rev, value: rev });
+            return rev !== undefined
+                ? typeof rev === 'bigint'
+                    ? Number(rev)
+                    : rev
+                : 0;
+        },
+        /**
+         * Start continuous polling for new operations and messages.
+         *
+         * @returns Promise resolving when polling stops.
+         */
+        async startPolling() {
+            const lineLog = getLineLog(runtime);
+            if (runtime.polling) {
+                return;
+            }
+            runtime.polling = true;
+            runtime.aborted = false;
+            if (runtime.revision < 0) {
+                runtime.revision = await runtime.getLastOpRevision();
+                lineLog.info('polling.start', { revision: runtime.revision });
+            }
+            let consecutiveEmptyPolls = 0;
+            while (runtime.polling && !runtime.aborted) {
+                try {
+                    const ops = await pollOnce(runtime);
+                    consecutiveEmptyPolls =
+                        ops.length === 0 ? consecutiveEmptyPolls + 1 : 0;
+                    await sleep(getNextPollDelay(ops.length, consecutiveEmptyPolls));
+                }
+                catch (err) {
+                    runtime.emit('error', err);
+                    consecutiveEmptyPolls = 0;
+                    if (runtime.polling && !runtime.aborted) {
+                        await sleep(3000);
+                    }
+                }
+            }
+        },
+        /**
+         * Stop the polling loop.
+         */
+        stopPolling() {
+            runtime.polling = false;
+            runtime.aborted = true;
+        },
+    };
+}

package/dist/line/client/talk-service/chat-query.js

@@ -0,0 +1,122 @@
+import { createCliLogger } from '../../../util/log.js';
+import { buildGetChatsRequest } from './requests.js';
+const GET_CHATS_BATCH_SIZE = 100;
+const lineLog = createCliLogger('LINE');
+/**
+ * Normalize bigint-like thrift scalars into numbers when possible.
+ *
+ * @param value - Raw thrift scalar.
+ * @returns Parsed number or original fallback.
+ */
+function normalizeNumericValue(value) {
+    if (typeof value === 'bigint') {
+        return Number(value);
+    }
+    return value || null;
+}
+/**
+ * Resolve the actual chat-array field from a getChats response.
+ *
+ * @param responseRoot - Root response payload.
+ * @returns Raw chat array or null.
+ */
+export function findChatArray(responseRoot) {
+    if (!responseRoot) {
+        return null;
+    }
+    const keys = Object.keys(responseRoot)
+        .map(Number)
+        .sort((a, b) => a - b);
+    lineLog.debug('talk.get_chats.response', { keys: keys.join(',') });
+    for (const key of keys) {
+        const candidate = responseRoot[key];
+        if (!Array.isArray(candidate)) {
+            continue;
+        }
+        if (candidate.length === 0 || typeof candidate[0] !== 'object') {
+            continue;
+        }
+        if (key !== 1) {
+            lineLog.warn('talk.get_chats.field_mismatch', {
+                actual_field: key,
+                expected_field: 1,
+            });
+        }
+        return candidate;
+    }
+    return null;
+}
+/**
+ * Map one raw chat thrift struct into the app shape.
+ *
+ * @param chat - Raw chat thrift struct.
+ * @returns Normalized chat or null.
+ */
+export function mapChatStruct(chat) {
+    if (!chat || typeof chat !== 'object') {
+        return null;
+    }
+    return {
+        type: chat[1] ?? null,
+        chatMid: chat[2] || null,
+        createdTime: normalizeNumericValue(chat[3]),
+        notificationDisabled: Boolean(chat[4]),
+        favoriteTimestamp: normalizeNumericValue(chat[5]),
+        chatName: chat[6] || null,
+        picturePath: chat[7] || null,
+        extra: chat[8] || null,
+    };
+}
+/**
+ * Map a chat list, dropping invalid entries.
+ *
+ * @param chats - Raw chat list.
+ * @returns Normalized chat list.
+ */
+export function mapChatList(chats) {
+    return Array.isArray(chats)
+        ? chats
+            .map((chat) => mapChatStruct(chat))
+            .filter(Boolean)
+        : [];
+}
+/**
+ * Fetch and normalize chats from TalkService.
+ *
+ * @param runtime - LINE client runtime.
+ * @param syncReason - Talk sync reason constant.
+ * @param chatMids - Requested chat MIDs.
+ * @param withMembers - Whether to include members.
+ * @returns Normalized chat list.
+ */
+export async function fetchChats(runtime, syncReason, chatMids, withMembers = true) {
+    if (!Array.isArray(chatMids) || chatMids.length === 0) {
+        return [];
+    }
+    if (chatMids.length > GET_CHATS_BATCH_SIZE) {
+        const allChats = [];
+        for (let index = 0; index < chatMids.length; index += GET_CHATS_BATCH_SIZE) {
+            const batch = chatMids.slice(index, index + GET_CHATS_BATCH_SIZE);
+            const chats = await fetchChats(runtime, syncReason, batch, withMembers);
+            allChats.push(...chats);
+        }
+        return allChats;
+    }
+    let result;
+    try {
+        result = await runtime.sendTalk('getChats', buildGetChatsRequest(chatMids, withMembers, syncReason));
+    }
+    catch (error) {
+        lineLog.error('talk.get_chats.failed', { error: error?.message || error });
+        throw error;
+    }
+    const response = result.fields?.[0];
+    const chatStructs = findChatArray(response);
+    if (chatStructs) {
+        return mapChatList(chatStructs);
+    }
+    lineLog.warn('talk.get_chats.empty', {
+        keys: response ? Object.keys(response).join(',') : 'null',
+    });
+    return [];
+}

package/dist/line/client/talk-service/command-client.js

@@ -0,0 +1,242 @@
+/**
+ * LINE TalkService command capability.
+ *
+ * Send messages and other TalkService write operations with side effects.
+ */
+import { Buffer } from 'node:buffer';
+import { parseMessage } from '../parsers.js';
+import { buildAcceptChatInvitationRequest, buildCancelReactionRequest, buildContactMidActionRequest, buildCreateChatRequest, buildDeleteOtherFromChatRequest, buildDeleteSelfFromChatRequest, buildFindAndAddContactsByMidRequest, buildInviteIntoChatRequest, buildReactRequest, buildSendChatCheckedRequest, buildSendMessageRequest, buildUnsendMessageRequest, buildUpdateChatNameRequest, normalizeSendMessageOptions, } from './requests.js';
+/**
+ * Create the TalkService command capability bound to one LINE client runtime.
+ *
+ * @param runtime - Mutable LINE client runtime.
+ * @returns Talk command methods bound to the runtime.
+ */
+export function createTalkCommandClient(runtime) {
+    return {
+        /**
+         * Send a LINE message via TalkService.
+         *
+         * This method keeps backward compatibility with the existing
+         * `sendMessage(to, text)` signature while also accepting a richer options
+         * object closer to linejs TalkService.sendMessage(). The extended form is
+         * required for E2EE outbound payloads because LINE expects caller-supplied
+         * `chunks` and matching `contentMetadata`.
+         *
+         * @param to - The recipient chat ID, or a full message options object.
+         * @param text - The message text when using the legacy two-argument signature.
+         * @returns The sent message object or null on error.
+         */
+        async sendMessage(to, text) {
+            const options = normalizeSendMessageOptions(to, text);
+            if (Array.isArray(options.chunks)) {
+                options.chunks = options.chunks.map((chunk) => Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            const result = await runtime.sendTalk('sendMessage', buildSendMessageRequest(options));
+            if (result.error) {
+                throw new Error(`sendMessage failed: ${result.error}`);
+            }
+            // fields[0] is the raw Thrift Message struct; normalize it so callers
+            // get { id, from, ... } consistent with the read path (raw struct
+            // carries the id at index [4], not `.id`).
+            const sent = result.fields?.[0];
+            return sent ? parseMessage(sent) : null;
+        },
+        /**
+         * Mark a LINE conversation read up to a given message via TalkService
+         * sendChatChecked. This has a side effect visible to the other party (a
+         * read receipt); it is only ever called from explicit user-intent paths,
+         * never from background sync. Returns true on success; throws on LINE error.
+         *
+         * @param chatMid - Chat MID to mark read.
+         * @param lastMessageId - Message id to mark read up to.
+         * @param sessionId - Client session id (default 0).
+         * @returns True when the read receipt was accepted.
+         */
+        async sendChatChecked(chatMid, lastMessageId, sessionId = 0) {
+            const result = await runtime.sendTalk('sendChatChecked', buildSendChatCheckedRequest(chatMid, lastMessageId, sessionId));
+            if (result.error) {
+                throw new Error(`sendChatChecked failed: ${result.error}`);
+            }
+            return true;
+        },
+        /**
+         * Rename a group/chat via TalkService updateChat. Side effect visible to
+         * every member. Throws on LINE error.
+         *
+         * @param chatMid - Group/chat MID to rename.
+         * @param name - New name.
+         * @returns True when the rename was accepted.
+         */
+        async updateChatName(chatMid, name) {
+            const result = await runtime.sendTalk('updateChat', buildUpdateChatNameRequest(chatMid, name));
+            if (result.error) {
+                throw new Error(`updateChat failed: ${result.error}`);
+            }
+            return true;
+        },
+        /**
+         * Invite members into a group/chat via TalkService inviteIntoChat. The
+         * invitees must accept before joining a group. Throws on LINE error.
+         *
+         * @param chatMid - Group/chat MID to invite into.
+         * @param mids - MIDs to invite.
+         * @returns True when the invitation was accepted.
+         */
+        async inviteIntoChat(chatMid, mids) {
+            const result = await runtime.sendTalk('inviteIntoChat', buildInviteIntoChatRequest(chatMid, mids));
+            if (result.error) {
+                throw new Error(`inviteIntoChat failed: ${result.error}`);
+            }
+            return true;
+        },
+        /**
+         * Remove (kick) members from a group/chat via TalkService
+         * deleteOtherFromChat. Side effect visible to every member; the removed
+         * member loses access. Throws on LINE error.
+         *
+         * @param chatMid - Group/chat MID to remove members from.
+         * @param mids - MIDs to remove.
+         * @returns True when the removal was accepted.
+         */
+        async deleteOtherFromChat(chatMid, mids) {
+            const result = await runtime.sendTalk('deleteOtherFromChat', buildDeleteOtherFromChatRequest(chatMid, mids));
+            if (result.error) {
+                throw new Error(`deleteOtherFromChat failed: ${result.error}`);
+            }
+            return true;
+        },
+        /**
+         * Leave a group/chat via TalkService deleteSelfFromChat — the authenticated
+         * account itself exits. Throws on LINE error.
+         *
+         * @param chatMid - Group/chat MID to leave.
+         * @returns True when the departure was accepted.
+         */
+        async deleteSelfFromChat(chatMid) {
+            const result = await runtime.sendTalk('deleteSelfFromChat', buildDeleteSelfFromChatRequest(chatMid));
+            if (result.error) {
+                throw new Error(`deleteSelfFromChat failed: ${result.error}`);
+            }
+            return true;
+        },
+        /**
+         * Create a new group/room via TalkService createChat with an initial member
+         * set. Does NOT mint or register any E2EE group key (key material is
+         * established lazily on first E2EE send/receive) — see the never-mint fix.
+         * Throws on LINE error.
+         *
+         * @param name - New chat name.
+         * @param mids - Initial member MIDs.
+         * @param chatType - LINE chat type (0 = group, 1 = room). Default 1.
+         * @returns The created Chat struct.
+         */
+        async createChat(name, mids, chatType = 1) {
+            const result = await runtime.sendTalk('createChat', buildCreateChatRequest(name, mids, chatType));
+            if (result.error) {
+                throw new Error(`createChat failed: ${result.error}`);
+            }
+            return result.fields?.[0] ?? null;
+        },
+        /**
+         * Add a predefined reaction to a message via TalkService react. Visible to
+         * the conversation. Throws on LINE error.
+         *
+         * @param messageId - Target message id (numeric string).
+         * @param reactionType - Predefined reaction type (2=LIKE, 3=LOVE, 4=LAUGH,
+         * 5=SURPRISE, 6=SAD, 7=ANGRY). Default 2.
+         * @returns True when the reaction was accepted.
+         */
+        async react(messageId, reactionType = 2) {
+            const result = await runtime.sendTalk('react', buildReactRequest(messageId, reactionType));
+            if (result.error) {
+                throw new Error(`react failed: ${result.error}`);
+            }
+            return true;
+        },
+        /**
+         * Remove this account's reaction from a message via TalkService
+         * cancelReaction. Throws on LINE error.
+         *
+         * @param messageId - Target message id (numeric string).
+         * @returns True when the cancellation was accepted.
+         */
+        async cancelReaction(messageId) {
+            const result = await runtime.sendTalk('cancelReaction', buildCancelReactionRequest(messageId));
+            if (result.error) {
+                throw new Error(`cancelReaction failed: ${result.error}`);
+            }
+            return true;
+        },
+        /**
+         * Unsend (retract) one of this account's own messages via TalkService
+         * unsendMessage — it is removed for everyone in the conversation. LINE only
+         * permits unsending the caller's own messages. Throws on LINE error.
+         *
+         * @param messageId - Message id to unsend (numeric string).
+         * @returns True when the unsend was accepted.
+         */
+        async unsendMessage(messageId) {
+            const result = await runtime.sendTalk('unsendMessage', buildUnsendMessageRequest(messageId));
+            if (result.error) {
+                throw new Error(`unsendMessage failed: ${result.error}`);
+            }
+            return true;
+        },
+        /**
+         * Add a friend by MID via TalkService findAndAddContactsByMid. Throws on
+         * LINE error.
+         *
+         * @param mid - MID of the person to add.
+         * @param reference - JSON reference breadcrumb (optional).
+         * @returns The added contact result (raw response fields).
+         */
+        async findAndAddContactByMid(mid, reference) {
+            const result = await runtime.sendTalk('findAndAddContactsByMid', buildFindAndAddContactsByMidRequest(mid, reference));
+            if (result.error) {
+                throw new Error(`findAndAddContactsByMid failed: ${result.error}`);
+            }
+            return result.fields?.[0] ?? null;
+        },
+        /**
+         * Block a contact via TalkService blockContact. Throws on LINE error.
+         *
+         * @param mid - Contact MID to block.
+         * @returns True when the block was accepted.
+         */
+        async blockContact(mid) {
+            const result = await runtime.sendTalk('blockContact', buildContactMidActionRequest(mid));
+            if (result.error) {
+                throw new Error(`blockContact failed: ${result.error}`);
+            }
+            return true;
+        },
+        /**
+         * Unblock a contact via TalkService unblockContact. Throws on LINE error.
+         *
+         * @param mid - Contact MID to unblock.
+         * @returns True when the unblock was accepted.
+         */
+        async unblockContact(mid) {
+            const result = await runtime.sendTalk('unblockContact', buildContactMidActionRequest(mid));
+            if (result.error) {
+                throw new Error(`unblockContact failed: ${result.error}`);
+            }
+            return true;
+        },
+        /**
+         * Accept a group/chat invitation via TalkService acceptChatInvitation —
+         * this account joins the chat. Throws on LINE error.
+         *
+         * @param chatMid - Group/chat MID to accept the invitation for.
+         * @returns True when the acceptance was accepted.
+         */
+        async acceptChatInvitation(chatMid) {
+            const result = await runtime.sendTalk('acceptChatInvitation', buildAcceptChatInvitationRequest(chatMid));
+            if (result.error) {
+                throw new Error(`acceptChatInvitation failed: ${result.error}`);
+            }
+            return true;
+        },
+    };
+}