@rikaidev/yomi 0.2.6

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

@@ -0,0 +1,383 @@
+import { CONTENT_TYPE } from '../../core/constants.js';
+import { boolField, byteField, i32Field, i64Field, listField, mapField, setField, stringField, structField, } from '../../core/thrift/index.js';
+/**
+ * Normalize sendMessage inputs into one consistent options object.
+ *
+ * @param to - Recipient chat id or options object.
+ * @param text - Legacy text argument.
+ * @returns Normalized message options.
+ */
+export function normalizeSendMessageOptions(to, text) {
+    if (typeof to === 'object' && to !== null) {
+        return {
+            to: to.to,
+            text: to.text,
+            contentType: to.contentType ?? CONTENT_TYPE.NONE,
+            contentMetadata: to.contentMetadata ?? {},
+            chunks: to.chunks ?? null,
+            relatedMessageId: to.relatedMessageId ?? null,
+            messageRelationType: to.messageRelationType ?? null,
+            relatedMessageServiceCode: to.relatedMessageServiceCode ?? null,
+            location: to.location ?? null,
+        };
+    }
+    return {
+        to,
+        text,
+        contentType: CONTENT_TYPE.NONE,
+        contentMetadata: {},
+        chunks: null,
+        relatedMessageId: null,
+        messageRelationType: null,
+        relatedMessageServiceCode: null,
+        location: null,
+    };
+}
+/**
+ * Build the sendMessage nested payload fields.
+ *
+ * @param options - Normalized send-message options.
+ * @returns Thrift struct fields.
+ */
+export function buildSendMessagePayload(options) {
+    const fields = [stringField(2, options.to), i32Field(15, options.contentType)];
+    if (options.text != null) {
+        fields.push(stringField(10, options.text));
+    }
+    if (options.contentMetadata &&
+        Object.keys(options.contentMetadata).length > 0) {
+        fields.push(mapField(18, 11, 11, options.contentMetadata));
+    }
+    if (Array.isArray(options.chunks)) {
+        fields.push(listField(20, 11, options.chunks));
+    }
+    if (options.relatedMessageId) {
+        fields.push(stringField(21, options.relatedMessageId));
+        // A reply needs messageRelationType (field 22, MessageRelationType enum,
+        // REPLY=3) AND relatedMessageServiceCode (field 24, ServiceCode enum,
+        // TALK=1) alongside the related id — both are i32 enums, not strings, and
+        // relatedMessageId alone is not rendered as a quoted reply.
+        if (options.messageRelationType != null) {
+            fields.push(i32Field(22, options.messageRelationType));
+        }
+        if (options.relatedMessageServiceCode != null) {
+            fields.push(i32Field(24, options.relatedMessageServiceCode));
+        }
+    }
+    if (options.location) {
+        fields.push(structField(11, options.location));
+    }
+    return fields;
+}
+/**
+ * Build the sendMessage request fields.
+ *
+ * @param options - Normalized send-message options.
+ * @returns Thrift request fields.
+ */
+export function buildSendMessageRequest(options) {
+    return [i32Field(1, 0), structField(2, buildSendMessagePayload(options))];
+}
+/**
+ * Build the getAllChatMids request fields.
+ *
+ * @param syncReason - Talk sync reason constant.
+ * @returns Thrift request fields.
+ */
+export function buildGetAllChatMidsRequest(syncReason) {
+    return [
+        structField(1, [boolField(1, true), boolField(2, true)]),
+        i32Field(2, syncReason),
+    ];
+}
+/**
+ * Build the getChats request fields.
+ *
+ * @param chatMids - Requested chat MIDs.
+ * @param withMembers - Whether to include members.
+ * @param syncReason - Talk sync reason constant.
+ * @returns Thrift request fields.
+ */
+export function buildGetChatsRequest(chatMids, withMembers, syncReason) {
+    return [
+        structField(1, [
+            listField(1, 11, chatMids),
+            boolField(2, withMembers),
+            boolField(3, true),
+        ]),
+        i32Field(2, syncReason),
+    ];
+}
+/**
+ * Build the getMessageBoxes request fields.
+ *
+ * @param request - Message-box request payload.
+ * @param syncReason - Talk sync reason constant.
+ * @returns Thrift request fields.
+ */
+export function buildGetMessageBoxesRequest(request, syncReason) {
+    return [structField(2, request), i32Field(3, syncReason)];
+}
+/**
+ * Build the getPreviousMessagesV2WithRequest request fields.
+ *
+ * @param request - Previous-message request payload.
+ * @param endMessageIdFields - Cursor struct fields.
+ * @param syncReason - Talk sync reason constant.
+ * @returns Thrift request fields.
+ */
+export function buildPreviousMessagesRequest(request, endMessageIdFields, syncReason) {
+    return [
+        structField(2, [
+            stringField(1, request.messageBoxId),
+            structField(2, endMessageIdFields),
+            i32Field(3, request.messagesCount),
+            boolField(4, Boolean(request.withReadCount)),
+            boolField(5, Boolean(request.receivedOnly)),
+        ]),
+        i32Field(3, syncReason),
+    ];
+}
+/**
+ * Build the getRecentMessagesV2 request fields.
+ *
+ * @param chatId - Target chat MID.
+ * @param count - Maximum number of messages.
+ * @returns Thrift request fields.
+ */
+export function buildRecentMessagesRequest(chatId, count) {
+    return [stringField(2, chatId), i32Field(3, count)];
+}
+/**
+ * Build a message-content download request.
+ *
+ * @param requestId - Client request identifier.
+ * @param messageId - LINE message identifier.
+ * @returns Thrift request fields.
+ */
+export function buildDownloadMessageContentRequest(requestId, messageId) {
+    return [stringField(1, requestId), stringField(2, messageId)];
+}
+/**
+ * Build a single-MID lookup request.
+ *
+ * @param mid - Target MID.
+ * @returns Thrift request fields.
+ */
+export function buildMidLookupRequest(mid) {
+    return [stringField(2, mid)];
+}
+/**
+ * Build a multi-MID lookup request.
+ *
+ * @param mids - Target MIDs.
+ * @returns Thrift request fields.
+ */
+export function buildMidListRequest(mids) {
+    return [listField(2, 11, mids)];
+}
+/**
+ * Build the getAllContactIds request fields.
+ *
+ * @returns Thrift request fields.
+ */
+export function buildGetAllContactIdsRequest() {
+    return [i32Field(1, 0)];
+}
+/**
+ * Build the sendChatChecked request fields.
+ *
+ * @param chatMid - Chat MID to mark read.
+ * @param lastMessageId - Message id to mark read up to.
+ * @param sessionId - Client session id (default 0).
+ * @returns Thrift request fields.
+ */
+export function buildSendChatCheckedRequest(chatMid, lastMessageId, sessionId = 0) {
+    return [
+        i32Field(1, 0),
+        stringField(2, chatMid),
+        stringField(3, lastMessageId),
+        byteField(4, sessionId),
+    ];
+}
+/**
+ * Build the updateChat request fields to rename a group/chat.
+ *
+ * LINE's modern unified chat API updates a Chat struct and names which
+ * attribute changed via `updatedAttribute` (NAME=1). The whole request is a
+ * single struct arg at field 1: `{ seq, chat{ type, chatMid, name }, attr }`.
+ *
+ * @param chatMid - Chat/group MID to rename.
+ * @param name - New chat name.
+ * @returns Thrift request fields.
+ */
+export function buildUpdateChatNameRequest(chatMid, name) {
+    return [
+        structField(1, [
+            i32Field(1, 0),
+            structField(2, [
+                i32Field(1, 1),
+                stringField(2, chatMid),
+                stringField(6, name),
+            ]),
+            i32Field(3, 1),
+        ]),
+    ];
+}
+/**
+ * Build the inviteIntoChat request fields.
+ *
+ * Single struct arg at field 1: `{ seq, to, targetMids }`.
+ *
+ * @param chatMid - Chat/group MID to invite into.
+ * @param mids - MIDs to invite.
+ * @returns Thrift request fields.
+ */
+export function buildInviteIntoChatRequest(chatMid, mids) {
+    return [
+        structField(1, [
+            i32Field(1, 0),
+            stringField(2, chatMid),
+            setField(3, 11, mids),
+        ]),
+    ];
+}
+/**
+ * Build the deleteOtherFromChat request fields (kick members).
+ *
+ * Single struct arg at field 1: `{ seq, to, targetMids }`.
+ *
+ * @param chatMid - Chat/group MID to remove members from.
+ * @param mids - MIDs to remove.
+ * @returns Thrift request fields.
+ */
+export function buildDeleteOtherFromChatRequest(chatMid, mids) {
+    return [
+        structField(1, [
+            i32Field(1, 0),
+            stringField(2, chatMid),
+            setField(3, 11, mids),
+        ]),
+    ];
+}
+/**
+ * Build the deleteSelfFromChat request fields (leave a chat/group).
+ *
+ * Single struct arg at field 1: `{ seq, to }`.
+ *
+ * @param chatMid - Chat/group MID to leave.
+ * @returns Thrift request fields.
+ */
+export function buildDeleteSelfFromChatRequest(chatMid) {
+    return [structField(1, [i32Field(1, 0), stringField(2, chatMid)])];
+}
+/**
+ * Build the createChat request fields (create a new group/room).
+ *
+ * Single struct arg at field 1: CreateChatRequest
+ * `{ reqSeq, type, name, targetUserMids }`. `type` is the LINE chat type —
+ * 0 = GROUP (invitees must accept before joining), 1 = ROOM (members are added
+ * directly). targetUserMids is a set on the wire; a list encodes identically.
+ *
+ * @param name - Chat name.
+ * @param mids - Initial member MIDs.
+ * @param chatType - LINE chat type (0 = group, 1 = room).
+ * @returns Thrift request fields.
+ */
+export function buildCreateChatRequest(name, mids, chatType = 1) {
+    return [
+        structField(1, [
+            i32Field(1, 0),
+            i32Field(2, chatType),
+            stringField(3, name),
+            setField(4, 11, mids),
+        ]),
+    ];
+}
+/**
+ * Build the react request fields (add a predefined reaction to a message).
+ *
+ * Single struct arg at field 1: `{ reqSeq, messageId, reactionType{ predefined } }`.
+ * The messageId is a thrift i64 (LINE message ids are 64-bit), so it is passed
+ * as a BigInt. `reactionType` is LINE's predefinedReactionType enum:
+ * 2 = LIKE 👍, 3 = LOVE ❤️, 4 = LAUGH 😆, 5 = SURPRISE 😮, 6 = SAD 😢, 7 = ANGRY 😡.
+ *
+ * @param messageId - Target message id (numeric string).
+ * @param reactionType - Predefined reaction type (default 2 = LIKE).
+ * @returns Thrift request fields.
+ */
+export function buildReactRequest(messageId, reactionType = 2) {
+    return [
+        structField(1, [
+            i32Field(1, 0),
+            i64Field(2, BigInt(messageId)),
+            structField(3, [i32Field(1, reactionType)]),
+        ]),
+    ];
+}
+/**
+ * Build the cancelReaction request fields (remove this account's reaction).
+ *
+ * Single struct arg at field 1: `{ reqSeq, messageId }`. The messageId is a
+ * thrift i64, passed as a BigInt.
+ *
+ * @param messageId - Target message id (numeric string).
+ * @returns Thrift request fields.
+ */
+export function buildCancelReactionRequest(messageId) {
+    return [structField(1, [i32Field(1, 0), i64Field(2, BigInt(messageId))])];
+}
+/**
+ * Build the unsendMessage request fields (retract one of this account's own
+ * messages for everyone).
+ *
+ * Top-level fields (NOT wrapped in a request struct): `{ seq, messageId }`.
+ * Unlike react, unsendMessage takes the messageId as a plain string, not an
+ * i64.
+ *
+ * @param messageId - Message id to unsend (numeric string).
+ * @returns Thrift request fields.
+ */
+export function buildUnsendMessageRequest(messageId) {
+    return [i32Field(1, 0), stringField(2, messageId)];
+}
+/**
+ * Build the findAndAddContactsByMid request fields (add a friend by MID).
+ *
+ * Top-level fields: `{ reqSeq, mid, type, reference }`. `type` is 0; `reference`
+ * is a JSON breadcrumb LINE records for where the add came from.
+ *
+ * @param mid - MID of the person to add.
+ * @param reference - JSON reference breadcrumb.
+ * @returns Thrift request fields.
+ */
+export function buildFindAndAddContactsByMidRequest(mid, reference = '{"screen":"chat","spec":"native"}') {
+    return [
+        i32Field(1, 0),
+        stringField(2, mid),
+        i32Field(3, 0),
+        stringField(4, reference),
+    ];
+}
+/**
+ * Build a `{ reqSeq, mid }` contact-action request — shared by blockContact and
+ * unblockContact, which have identical wire shapes (only the method differs).
+ *
+ * @param mid - Target contact MID.
+ * @returns Thrift request fields.
+ */
+export function buildContactMidActionRequest(mid) {
+    return [i32Field(1, 0), stringField(2, mid)];
+}
+/**
+ * Build the acceptChatInvitation request fields (join a group you were invited
+ * to).
+ *
+ * Single struct arg at field 1: `{ reqSeq, to }`.
+ *
+ * @param chatMid - Group/chat MID to accept the invitation for.
+ * @returns Thrift request fields.
+ */
+export function buildAcceptChatInvitationRequest(chatMid) {
+    return [structField(1, [i32Field(1, 0), stringField(2, chatMid)])];
+}

package/dist/line/client/transport.js

@@ -0,0 +1,138 @@
+/**
+ * Shared HTTP transport for LINE TCompact protocol.
+ * Used by both LinePwlessLogin and LineClient.
+ */
+import { Buffer } from 'node:buffer';
+import https from 'node:https';
+import { createCliLogger } from '../../util/log.js';
+import { LINE_APP_CONFIG } from '../core/config.js';
+import { decodeResponseMessage } from '../core/thrift/index.js';
+const log = createCliLogger('LINE');
+/**
+ * Resolve the transport logger for the current LINE runtime.
+ *
+ * @param options - Optional transport options.
+ * @returns Logger used for transport diagnostics.
+ */
+function getTransportLog(options = {}) {
+    return options.logger || log;
+}
+/**
+ * Determine whether one HTTP status is expected during long-poll style LINE auth flows.
+ *
+ * @param path - Request path.
+ * @param statusCode - HTTP status code.
+ * @param bodyLength - Response body length.
+ * @returns True when the transport event should be downgraded from warning noise.
+ */
+function isExpectedHttpStatus(path, statusCode, bodyLength) {
+    return (statusCode === 410 &&
+        bodyLength === 0 &&
+        (path === LINE_APP_CONFIG.qrLongPollPath ||
+            path === LINE_APP_CONFIG.pwlessLongPollPath));
+}
+/**
+ * Send a TCompact request to LINE server.
+ *
+ * @param host - The LINE server hostname
+ * @param path - The API endpoint path
+ * @param data - TCompact-encoded body
+ * @param extraHeaders - Additional HTTP headers
+ * @param timeout - Request timeout in milliseconds
+ * @param options - Optional transport logging options
+ * @returns Promise resolving to decoded response with optional nextToken
+ */
+export function sendRequest(host, path, data, extraHeaders = {}, timeout = 30000, options = {}) {
+    return new Promise((resolve, reject) => {
+        const transportLog = getTransportLog(options);
+        const headers = {
+            'Content-Type': 'application/x-thrift',
+            Accept: 'application/x-thrift',
+            'X-Line-Application': LINE_APP_CONFIG.lineApp,
+            'User-Agent': LINE_APP_CONFIG.userAgent,
+            'x-lal': 'ja_JP',
+            'x-lpv': '1',
+            ...extraHeaders,
+            'Content-Length': data.length,
+        };
+        const req = https.request({
+            hostname: host,
+            port: 443,
+            path,
+            method: 'POST',
+            headers,
+            timeout,
+        }, (res) => {
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => {
+                const body = Buffer.concat(chunks);
+                const nextToken = extractNextToken(res.headers);
+                if (nextToken) {
+                    transportLog.debug?.('transport.token_rotated', { path });
+                }
+                if (res.statusCode && res.statusCode >= 400) {
+                    const eventName = isExpectedHttpStatus(path, res.statusCode, body.length)
+                        ? 'transport.http_expected'
+                        : 'transport.http_error';
+                    const logMethod = isExpectedHttpStatus(path, res.statusCode, body.length)
+                        ? transportLog.debug
+                        : transportLog.warn;
+                    logMethod?.(eventName, {
+                        path,
+                        status: res.statusCode,
+                        bytes: body.length,
+                    });
+                }
+                if (body.length > 0) {
+                    try {
+                        const decoded = decodeResponseMessage(body);
+                        resolve({ ...decoded, statusCode: res.statusCode, nextToken });
+                    }
+                    catch (error) {
+                        console.error(`[LINE] Decode failed on ${path}: ${error?.message || error} [${body.length}B]`);
+                        console.error(`[LINE] Decode first 64B on ${path}: ${body.subarray(0, 64).toString('hex')}`);
+                        console.error(`[LINE] Decode last 64B on ${path}: ${body.subarray(Math.max(0, body.length - 64)).toString('hex')}`);
+                        reject(error);
+                    }
+                }
+                else {
+                    resolve({
+                        error: 'empty_response',
+                        statusCode: res.statusCode,
+                        nextToken,
+                    });
+                }
+            });
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            resolve({ error: 'timeout' });
+        });
+        req.on('error', (err) => {
+            const errorCode = err.code;
+            if (errorCode === 'ECONNRESET' ||
+                errorCode === 'ETIMEDOUT' ||
+                err.message.includes('socket hang up') ||
+                err.message.includes('ETIMEDOUT')) {
+                resolve({ error: 'timeout' });
+            }
+            else {
+                reject(err);
+            }
+        });
+        req.write(data);
+        req.end();
+    });
+}
+/**
+ * Extract new access token from LINE response headers.
+ * LINE rotates tokens by sending x-line-next-access in any response.
+ *
+ * @param headers - HTTP response headers
+ * @returns New token string or undefined
+ */
+function extractNextToken(headers) {
+    const next = headers['x-line-next-access'];
+    return typeof next === 'string' && next.length > 0 ? next : undefined;
+}

package/dist/line/core/auth-session-logout.js

@@ -0,0 +1,55 @@
+/**
+ * LINE auth/session logout runtime.
+ */
+/**
+ * Clear stored credentials while preserving the phone number and region, so
+ * a later re-login can prefill both (and, on a client without MCP
+ * elicitation, run fully argument-free via `login`). Neither is auth
+ * material; this matches invalidateSession, which already keeps them.
+ *
+ * @param service - LineProtocolService instance
+ */
+async function clearCredentialsKeepingPhone(service) {
+    const savedPhone = await service.credentialStore?.get?.('line_phone');
+    const savedRegion = await service.credentialStore?.get?.('line_region');
+    await service.credentialStore.clearAll();
+    if (savedPhone) {
+        await service.credentialStore?.set?.('line_phone', savedPhone);
+    }
+    if (savedRegion) {
+        await service.credentialStore?.set?.('line_region', savedRegion);
+    }
+}
+/**
+ * Log out from LINE by attempting a server-side logout first, then clearing the
+ * local session snapshot regardless of server acknowledgement.
+ *
+ * @param service - LineProtocolService instance
+ * @param disconnectedState - DISCONNECTED state constant from service
+ */
+export async function performLogout(service, disconnectedState) {
+    try {
+        service.client?.stopPolling?.();
+    }
+    catch {
+        // Polling may already be stopped
+    }
+    try {
+        await service.client?.logoutZ?.();
+    }
+    catch (error) {
+        service.logger?.warn?.('line.logout.remote_failed', {
+            error: error?.message || String(error),
+        });
+    }
+    await clearCredentialsKeepingPhone(service);
+    service.client = null;
+    service.profile = null;
+    service.e2eeWarning = false;
+    service.loginRequired = false;
+    service.loginReason = null;
+    service.nameCache.clear();
+    service.chatCache.clear();
+    service.setState(disconnectedState);
+    service.emit('line:loginRequired');
+}