@rikaidev/yomi 0.2.6

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

@@ -0,0 +1,77 @@
+/**
+ * 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;
+}
+/**
+ * Extract profile fields from one raw contact struct.
+ *
+ * @param contact - Raw contact thrift struct.
+ * @returns Normalized profile fields.
+ */
+function mapContactProfileFields(contact) {
+    return {
+        displayName: contact[22] || null,
+        phoneticName: contact[23] || null,
+        pictureStatus: contact[24] || null,
+        thumbnailUrl: contact[25] || null,
+        statusMessage: contact[26] || null,
+        displayNameOverridden: contact[27] || null,
+        picturePath: contact[37] || null,
+        statusMessageContentMetadata: contact[43] || {},
+        profileId: contact[49] || null,
+    };
+}
+/**
+ * Extract capability flags from one raw contact struct.
+ *
+ * @param contact - Raw contact thrift struct.
+ * @returns Capability flags.
+ */
+function mapContactCapabilityFields(contact) {
+    return {
+        capableVoiceCall: Boolean(contact[31]),
+        capableVideoCall: Boolean(contact[32]),
+    };
+}
+/**
+ * Map one raw contact thrift struct into the app shape.
+ *
+ * @param contact - Raw contact thrift struct.
+ * @returns Normalized contact or null.
+ */
+export function mapContactStruct(contact) {
+    if (!contact || typeof contact !== 'object') {
+        return null;
+    }
+    return {
+        mid: contact[1] || null,
+        createdTime: normalizeNumericValue(contact[2]),
+        type: contact[10] ?? null,
+        status: contact[11] ?? null,
+        relation: contact[21] ?? null,
+        favoriteTime: normalizeNumericValue(contact[28]),
+        ...mapContactCapabilityFields(contact),
+        ...mapContactProfileFields(contact),
+    };
+}
+/**
+ * Map a contact list, dropping invalid entries.
+ *
+ * @param contacts - Raw contact list.
+ * @returns Normalized contact list.
+ */
+export function mapContactList(contacts) {
+    return Array.isArray(contacts)
+        ? contacts
+            .map((contact) => mapContactStruct(contact))
+            .filter(Boolean)
+        : [];
+}

package/dist/line/client/talk-service/message-box-query.js

@@ -0,0 +1,137 @@
+import { createCliLogger } from '../../../util/log.js';
+import { parseMessages } from '../parsers.js';
+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;
+}
+/**
+ * Map one last-delivered-message cursor into the normalized shape.
+ *
+ * @param cursor - Raw cursor payload.
+ * @returns Normalized cursor or null.
+ */
+function mapLastDeliveredMessageId(cursor) {
+    if (!cursor || typeof cursor !== 'object') {
+        return null;
+    }
+    return {
+        deliveredTime: normalizeNumericValue(cursor[1]),
+        messageId: cursor[2] != null ? String(cursor[2]) : null,
+    };
+}
+/**
+ * Build the request field array for getMessageBoxes.
+ *
+ * @param options - Listing options.
+ * @returns Thrift request field tuples.
+ */
+export function buildMessageBoxRequest(options = {}) {
+    const request = [];
+    if (options.minChatId) {
+        request.push([11, 1, options.minChatId]);
+    }
+    if (options.maxChatId) {
+        request.push([11, 2, options.maxChatId]);
+    }
+    if (options.activeOnly != null) {
+        request.push([2, 3, options.activeOnly]);
+    }
+    if (options.messageBoxCountLimit != null) {
+        request.push([8, 4, options.messageBoxCountLimit]);
+    }
+    if (options.withUnreadCount != null) {
+        request.push([2, 5, options.withUnreadCount]);
+    }
+    if (options.lastMessagesPerMessageBoxCount != null) {
+        request.push([8, 6, options.lastMessagesPerMessageBoxCount]);
+    }
+    if (options.unreadOnly != null) {
+        request.push([2, 7, options.unreadOnly]);
+    }
+    return request;
+}
+/**
+ * Build the end-message cursor field list for previous-message requests.
+ *
+ * @param request - Previous-message request.
+ * @returns Thrift field tuples.
+ */
+export function buildEndMessageIdFields(request) {
+    const endMessageIdFields = [];
+    if (request?.endMessageId?.deliveredTime != null) {
+        endMessageIdFields.push([10, 1, request.endMessageId.deliveredTime]);
+    }
+    if (request?.endMessageId?.messageId != null) {
+        endMessageIdFields.push([10, 2, request.endMessageId.messageId]);
+    }
+    return endMessageIdFields;
+}
+/**
+ * Map one raw message-box thrift struct into the app shape.
+ *
+ * @param box - Raw message-box thrift struct.
+ * @returns Normalized message-box or null.
+ */
+function mapMessageBoxStruct(box) {
+    if (!box || typeof box !== 'object') {
+        return null;
+    }
+    return {
+        id: box[1] || null,
+        midType: box[2] ?? null,
+        lastDeliveredMessageId: mapLastDeliveredMessageId(box[4]),
+        unreadCount: normalizeNumericValue(box[6]) || 0,
+        lastMessages: Array.isArray(box[7]) ? parseMessages(box[7]) : [],
+    };
+}
+/**
+ * Map a message-box list, dropping invalid entries.
+ *
+ * @param boxes - Raw message-box list.
+ * @returns Normalized message-box list.
+ */
+export function mapMessageBoxList(boxes) {
+    return Array.isArray(boxes)
+        ? boxes
+            .map((box) => mapMessageBoxStruct(box))
+            .filter(Boolean)
+        : [];
+}
+/**
+ * Emit one debug log for previous-message responses.
+ *
+ * @param request - Previous-message request.
+ * @param messages - Parsed messages.
+ */
+export function logPreviousMessagesResponse(request, messages) {
+    lineLog.debug('talk.get_previous_messages.response', {
+        box: request.messageBoxId,
+        count: request.messagesCount,
+        parsed: messages.length,
+    });
+}
+/**
+ * Emit one debug log for recent-message responses.
+ *
+ * @param chatId - Chat MID.
+ * @param count - Requested message count.
+ * @param raw - Raw response payload.
+ * @param messages - Parsed messages.
+ */
+export function logRecentMessagesResponse(chatId, count, raw, messages) {
+    lineLog.debug('talk.get_recent_messages.response', {
+        chat: chatId,
+        count,
+        parsed: messages.length,
+        raw_type: Array.isArray(raw) ? 'array' : typeof raw,
+    });
+}

package/dist/line/client/talk-service/message-id-query.js

@@ -0,0 +1,241 @@
+import { Buffer } from 'node:buffer';
+import https from 'node:https';
+import { LINE_APP_CONFIG } from '../../core/config.js';
+import { parseMessages } from '../parsers.js';
+const writeI32 = (value) => {
+    const buffer = Buffer.alloc(4);
+    buffer.writeUInt32BE(value >>> 0);
+    return buffer;
+};
+const writeI16 = (value) => {
+    const buffer = Buffer.alloc(2);
+    buffer.writeInt16BE(value);
+    return buffer;
+};
+const writeI64 = (value) => {
+    const buffer = Buffer.alloc(8);
+    buffer.writeBigInt64BE(BigInt(value));
+    return buffer;
+};
+const writeString = (value) => {
+    const body = Buffer.from(value, 'utf8');
+    return Buffer.concat([writeI32(body.length), body]);
+};
+const writeFieldHeader = (type, id) => {
+    return Buffer.concat([Buffer.from([type]), writeI16(id)]);
+};
+let writeValue;
+const writeStruct = (fields) => {
+    return Buffer.concat([
+        ...fields.map(([type, id, value]) => Buffer.concat([writeFieldHeader(type, id), writeValue(type, value)])),
+        Buffer.from([0]),
+    ]);
+};
+writeValue = (type, value) => {
+    if (type === 10) {
+        return writeI64(value);
+    }
+    if (type === 11) {
+        return writeString(String(value));
+    }
+    if (type === 12) {
+        return writeStruct(value);
+    }
+    if (type === 15) {
+        const [elementType, items] = value;
+        return Buffer.concat([
+            Buffer.from([elementType]),
+            writeI32(items.length),
+            ...items.map((item) => writeValue(elementType, item)),
+        ]);
+    }
+    throw new Error(`Unsupported TBinary write type: ${type}`);
+};
+const encodeBinaryCallMessage = (method, seqId, fields) => {
+    return Buffer.concat([
+        writeI32(0x80010001),
+        writeString(method),
+        writeI32(seqId),
+        writeStruct(fields),
+    ]);
+};
+const readI32 = (buffer, state) => {
+    const value = buffer.readInt32BE(state.position);
+    state.position += 4;
+    return value;
+};
+const readU32 = (buffer, state) => {
+    const value = buffer.readUInt32BE(state.position);
+    state.position += 4;
+    return value;
+};
+const readI16 = (buffer, state) => {
+    const value = buffer.readInt16BE(state.position);
+    state.position += 2;
+    return value;
+};
+const readI64 = (buffer, state) => {
+    const value = buffer.readBigInt64BE(state.position);
+    state.position += 8;
+    return value.toString();
+};
+const readString = (buffer, state) => {
+    const length = readI32(buffer, state);
+    const value = buffer
+        .subarray(state.position, state.position + length)
+        .toString('utf8');
+    state.position += length;
+    return value;
+};
+let readValue;
+const readStruct = (buffer, state) => {
+    const fields = {};
+    while (state.position < buffer.length) {
+        const type = buffer[state.position];
+        state.position += 1;
+        if (type === 0) {
+            break;
+        }
+        const id = readI16(buffer, state);
+        fields[id] = readValue(buffer, state, type);
+    }
+    return fields;
+};
+readValue = (buffer, state, type) => {
+    if (type === 2) {
+        const value = Boolean(buffer[state.position]);
+        state.position += 1;
+        return value;
+    }
+    if (type === 3) {
+        const value = buffer[state.position];
+        state.position += 1;
+        return value;
+    }
+    if (type === 8) {
+        return readI32(buffer, state);
+    }
+    if (type === 10) {
+        return readI64(buffer, state);
+    }
+    if (type === 11) {
+        return readString(buffer, state);
+    }
+    if (type === 12) {
+        return readStruct(buffer, state);
+    }
+    if (type === 13) {
+        const keyType = buffer[state.position];
+        const valueType = buffer[state.position + 1];
+        state.position += 2;
+        const length = readI32(buffer, state);
+        const entries = {};
+        for (let index = 0; index < length; index += 1) {
+            entries[String(readValue(buffer, state, keyType))] = readValue(buffer, state, valueType);
+        }
+        return entries;
+    }
+    if (type === 15) {
+        const elementType = buffer[state.position];
+        state.position += 1;
+        const length = readI32(buffer, state);
+        const items = [];
+        for (let index = 0; index < length; index += 1) {
+            items.push(readValue(buffer, state, elementType));
+        }
+        return items;
+    }
+    throw new Error(`Unsupported TBinary read type: ${type}`);
+};
+const decodeBinaryResponseMessage = (buffer) => {
+    const state = { position: 0 };
+    readU32(buffer, state);
+    const method = readString(buffer, state);
+    const seqId = readI32(buffer, state);
+    const fields = readStruct(buffer, state);
+    return { fields, method, seqId };
+};
+const postBinary = (host, path, body, token) => {
+    return new Promise((resolve, reject) => {
+        const request = https.request({
+            headers: {
+                accept: 'application/x-thrift',
+                'Content-Length': body.length,
+                'Content-Type': 'application/x-thrift',
+                'User-Agent': LINE_APP_CONFIG.userAgent,
+                'X-Line-Access': token,
+                'X-Line-Application': LINE_APP_CONFIG.lineApp,
+                'x-lal': 'ja_JP',
+                'x-lpv': '1',
+            },
+            hostname: host,
+            method: 'POST',
+            path,
+            port: 443,
+            timeout: 30000,
+        }, (response) => {
+            const chunks = [];
+            response.on('data', (chunk) => chunks.push(chunk));
+            response.on('end', () => {
+                const nextToken = response.headers['x-line-next-access'];
+                resolve({
+                    body: Buffer.concat(chunks),
+                    nextToken: typeof nextToken === 'string' ? nextToken : undefined,
+                    statusCode: response.statusCode,
+                });
+            });
+        });
+        request.on('error', reject);
+        request.on('timeout', () => {
+            request.destroy(new Error('timeout'));
+        });
+        request.write(body);
+        request.end();
+    });
+};
+const buildMessageIdStruct = (messageId) => {
+    return [
+        [10, 1, messageId.deliveredTime],
+        [10, 2, messageId.messageId],
+    ];
+};
+/**
+ * Fetch message payloads by MessageBoxV2 ids through the legacy /S3 endpoint.
+ *
+ * LINE only accepts one messagesByIds request part per call on this route.
+ *
+ * @param runtime - Active LINE client runtime.
+ * @param messageBoxId - Conversation id.
+ * @param messageIds - MessageBoxV2 ids to resolve.
+ * @returns Parsed LINE messages.
+ */
+export async function fetchMessagesByIds(runtime, messageBoxId, messageIds) {
+    const messages = [];
+    for (const messageId of messageIds) {
+        const requestPart = [
+            [11, 1, messageBoxId],
+            [15, 2, [12, [buildMessageIdStruct(messageId)]]],
+        ];
+        const body = encodeBinaryCallMessage('getMessagesByIds', runtime.seq++, [
+            [15, 2, [12, [requestPart]]],
+        ]);
+        const response = await postBinary(runtime.host, '/S3', body, runtime.authToken);
+        if (response.nextToken) {
+            runtime.authToken = response.nextToken;
+            runtime.emit?.('tokenRotated', response.nextToken);
+        }
+        if (!response.body.length) {
+            continue;
+        }
+        const decoded = decodeBinaryResponseMessage(response.body);
+        const exception = decoded.fields?.[1];
+        if (exception) {
+            throw new Error(`getMessagesByIds failed: ${exception[2] || JSON.stringify(exception)}`);
+        }
+        const rawMessages = decoded.fields?.[0];
+        if (Array.isArray(rawMessages)) {
+            messages.push(...parseMessages(rawMessages));
+        }
+    }
+    return messages;
+}

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

@@ -0,0 +1,219 @@
+/**
+ * LINE TalkService query capability.
+ *
+ * Profile, contacts, chats, and message-box retrieval.
+ */
+import { parseMessages } from '../parsers.js';
+import { fetchChats } from './chat-query.js';
+import { mapContactList } from './contact-query.js';
+import { buildEndMessageIdFields, buildMessageBoxRequest, logPreviousMessagesResponse, logRecentMessagesResponse, mapMessageBoxList, } from './message-box-query.js';
+import { fetchMessagesByIds } from './message-id-query.js';
+import { buildDownloadMessageContentRequest, buildGetAllChatMidsRequest, buildGetAllContactIdsRequest, buildGetMessageBoxesRequest, buildMidListRequest, buildMidLookupRequest, buildPreviousMessagesRequest, buildRecentMessagesRequest, } from './requests.js';
+/** Sync reason constant matching CHRLINE reference. */
+const SYNC_REASON = 7;
+/** Sync reason used by getPreviousMessagesV2WithRequest for secondary-device history sync. */
+const PREVIOUS_MESSAGES_SYNC_REASON = 4;
+/**
+ * Create the TalkService query capability bound to one LINE client runtime.
+ *
+ * @param runtime - Mutable LINE client runtime.
+ * @returns Talk query methods bound to the runtime.
+ */
+export function createTalkQueryClient(runtime) {
+    return {
+        /**
+         * Retrieve the authenticated user's profile.
+         *
+         * @returns The user's profile object.
+         */
+        async getProfile() {
+            const result = await runtime.sendTalk('getProfile', []);
+            if (result.fields?.[1]) {
+                const err = result.fields[1];
+                throw new Error(`getProfile failed: code=${err[1]} ${err[2] || 'Unknown error'}`);
+            }
+            const profile = result.fields?.[0];
+            if (!profile || typeof profile !== 'object') {
+                throw new Error('getProfile: no profile data in response');
+            }
+            runtime.profile = {
+                mid: profile[1] || null,
+                displayName: profile[20] || null,
+                picturePath: profile[22] || null,
+                statusMessage: profile[24] || null,
+            };
+            return runtime.profile;
+        },
+        /**
+         * Retrieve all contact IDs from the server.
+         *
+         * @returns An array of contact IDs.
+         */
+        async getAllContactIds() {
+            const result = await runtime.sendTalk('getAllContactIds', buildGetAllContactIdsRequest());
+            const ids = result.fields?.[0];
+            return Array.isArray(ids) ? ids : [];
+        },
+        /**
+         * Retrieve one raw contact by MID.
+         *
+         * @param mid - Contact MID.
+         * @returns Contact object or null.
+         */
+        async getContact(mid) {
+            const result = await runtime.sendTalk('getContact', buildMidLookupRequest(mid));
+            return result.fields?.[0] || null;
+        },
+        /**
+         * Retrieve and normalize multiple contacts.
+         *
+         * @param mids - Contact MIDs.
+         * @returns Normalized contact objects.
+         */
+        async getContacts(mids) {
+            const result = await runtime.sendTalk('getContacts', buildMidListRequest(mids));
+            return mapContactList(result.fields?.[0]);
+        },
+        /**
+         * Retrieve all member and invited chat MIDs.
+         *
+         * @returns Member/invited chat MID groups.
+         */
+        async getAllChatMids() {
+            const result = await runtime.sendTalk('getAllChatMids', buildGetAllChatMidsRequest(SYNC_REASON));
+            const response = result.fields?.[0];
+            return {
+                memberChats: response?.[1] || [],
+                invitedChats: response?.[2] || [],
+            };
+        },
+        /**
+         * Retrieve and normalize chats.
+         *
+         * @param chatMids - Chat MIDs.
+         * @param withMembers - Whether to include members.
+         * @returns Normalized chat objects.
+         */
+        async getChats(chatMids, withMembers = true) {
+            return fetchChats(runtime, SYNC_REASON, chatMids, withMembers);
+        },
+        /**
+         * Retrieve one group profile.
+         *
+         * @param groupId - Group MID.
+         * @returns Group object or null.
+         */
+        async getGroup(groupId) {
+            const result = await runtime.sendTalk('getGroup', buildMidLookupRequest(groupId));
+            return result.fields?.[0] || null;
+        },
+        /**
+         * Retrieve message-box metadata.
+         *
+         * @param options - Message-box listing options.
+         * @returns Normalized message-box result.
+         */
+        async getMessageBoxes(options = {}) {
+            const request = buildMessageBoxRequest(options);
+            const result = await runtime.sendTalk('getMessageBoxes', buildGetMessageBoxesRequest(request, SYNC_REASON));
+            const root = result.fields?.[0];
+            return {
+                messageBoxes: mapMessageBoxList(root?.[1]),
+                hasNext: Boolean(root?.[2]),
+            };
+        },
+        /**
+         * Retrieve previous messages through one message-box cursor.
+         *
+         * @param request - Previous-message request payload.
+         * @returns Parsed previous messages.
+         */
+        async getPreviousMessagesV2WithRequest(request) {
+            const endMessageIdFields = buildEndMessageIdFields(request);
+            const result = await runtime.sendTalk('getPreviousMessagesV2WithRequest', buildPreviousMessagesRequest(request, endMessageIdFields, PREVIOUS_MESSAGES_SYNC_REASON));
+            const raw = result.fields?.[0];
+            const messages = Array.isArray(raw) ? parseMessages(raw) : [];
+            logPreviousMessagesResponse(request, messages);
+            return messages;
+        },
+        /**
+         * Retrieve previous MessageBoxV2 ids for one conversation.
+         *
+         * @param request - Previous-message request payload.
+         * @returns Message id cursors and the server pagination flag.
+         */
+        async getPreviousMessageIds(request) {
+            const fields = [[11, 1, request.messageBoxId]];
+            const endMessageIdFields = buildEndMessageIdFields(request);
+            if (endMessageIdFields.length > 0) {
+                fields.push([12, 2, endMessageIdFields]);
+            }
+            fields.push([8, 4, request.messagesCount]);
+            const result = await runtime.sendTalk('getPreviousMessageIds', [
+                [12, 2, fields],
+                [8, 3, PREVIOUS_MESSAGES_SYNC_REASON],
+            ]);
+            const response = result.fields?.[0];
+            const ids = Array.isArray(response?.[1])
+                ? response[1]
+                    .map((item) => ({
+                    deliveredTime: Number(item?.[1] || 0),
+                    messageId: String(item?.[2] || ''),
+                }))
+                    .filter((item) => item.deliveredTime && item.messageId)
+                : [];
+            return {
+                ids,
+                hasPrevious: Boolean(response?.[2]),
+            };
+        },
+        /**
+         * Retrieve messages by MessageBoxV2 ids.
+         *
+         * @param messageBoxId - Conversation id.
+         * @param messageIds - MessageBoxV2 ids to resolve.
+         * @returns Parsed messages.
+         */
+        async getMessagesByIds(messageBoxId, messageIds) {
+            return fetchMessagesByIds(runtime, messageBoxId, messageIds);
+        },
+        /**
+         * Retrieve recent messages from one chat.
+         *
+         * @param chatId - Chat MID.
+         * @param count - Maximum number of messages.
+         * @returns Parsed message list.
+         */
+        async getRecentMessages(chatId, count = 50) {
+            const result = await runtime.sendTalk('getRecentMessagesV2', buildRecentMessagesRequest(chatId, count));
+            const raw = result.fields?.[0];
+            const messages = raw ? parseMessages(raw) : [];
+            logRecentMessagesResponse(chatId, count, raw, messages);
+            return messages;
+        },
+        /**
+         * Retrieve binary media content for one LINE message.
+         *
+         * @param messageId - LINE message identifier.
+         * @param requestId - Client request identifier.
+         * @returns Message content bytes.
+         */
+        async downloadMessageContent(messageId, requestId = `yomi-${Date.now()}`) {
+            const result = await runtime.sendTalk('downloadMessageContent', buildDownloadMessageContentRequest(requestId, messageId));
+            const content = result.fields?.[0];
+            return Buffer.isBuffer(content) ? content : Buffer.from(content || '');
+        },
+        /**
+         * Retrieve binary preview media content for one LINE message.
+         *
+         * @param messageId - LINE message identifier.
+         * @param requestId - Client request identifier.
+         * @returns Message preview bytes.
+         */
+        async downloadMessageContentPreview(messageId, requestId = `yomi-${Date.now()}`) {
+            const result = await runtime.sendTalk('downloadMessageContentPreview', buildDownloadMessageContentRequest(requestId, messageId));
+            const content = result.fields?.[0];
+            return Buffer.isBuffer(content) ? content : Buffer.from(content || '');
+        },
+    };
+}