agent-messenger 2.36.1 → 2.37.1

package/dist/src/platforms/kakaotalk/client.js

@@ -5,20 +5,40 @@ import { Long } from 'bson';
 import { getConfigDir } from '../../shared/utils/config-dir.js';
 import { warn } from '../../shared/utils/stderr.js';
 import { planAttachments } from './attachment-router.js';
+import { isOpenKakaoChatType } from './chat-classifier.js';
 import { detectImageDimensions } from './image-meta.js';
 import { sha1Hex } from './media-upload.js';
 import { LANG, PC_OS_NAME, getLocoDeviceConfig } from './protocol/config.js';
+import { isSyntheticConnectionClose } from './protocol/login-response.js';
 import { uploadMediaToLoco, uploadMultiMediaEntry } from './protocol/media-uploader.js';
 import { LocoSession } from './protocol/session.js';
 import { KAKAO_MESSAGE_TYPE, } from './types.js';
 export class KakaoTalkError extends Error {
     code;
     serverStatus;
+    responseFailureKind;
+    responseStatusSource;
+    getChatFailureReason;
     constructor(message, code, options) {
         super(message, options);
         this.name = 'KakaoTalkError';
         this.code = code;
         this.serverStatus = options?.serverStatus;
+        this.responseFailureKind = options?.responseFailureKind;
+        this.responseStatusSource = options?.responseStatusSource;
+        this.getChatFailureReason = options?.getChatFailureReason;
+    }
+}
+class LocoResponseError extends Error {
+    serverStatus;
+    responseFailureKind;
+    responseStatusSource;
+    constructor(message, responseFailureKind, options) {
+        super(message);
+        this.name = 'LocoResponseError';
+        this.serverStatus = options?.serverStatus;
+        this.responseFailureKind = responseFailureKind;
+        this.responseStatusSource = options?.responseStatusSource;
     }
 }
 class MemberNameCache {
@@ -141,7 +161,7 @@ function formatChat(chat, title, nameCache) {
     const chatId = longToString(chat.c);
     return {
         chat_id: chatId,
-        type: chat.t,
+        type: requiredChatType(chat.t),
         display_name: displayName,
         title,
         active_members: chat.a,
@@ -166,6 +186,64 @@ function extractTitle(body) {
     const content = titleMeta?.content;
     return typeof content === 'string' && content.length > 0 ? content : null;
 }
+function extractChannelInfo(body, expectedChatId) {
+    const info = body.chatInfo;
+    if (!info || typeof info !== 'object') {
+        throw new Error('CHATINFO response missing chatInfo');
+    }
+    const responseChatId = longToString(info.chatId);
+    if (responseChatId !== expectedChatId) {
+        throw new Error('CHATINFO response chatId mismatch');
+    }
+    return info;
+}
+function requiredNonNegativeInteger(value, field) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`CHATINFO response invalid ${field}`);
+    }
+    return value;
+}
+function requiredChatType(value) {
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
+    }
+    return requiredNonNegativeInteger(value, 'type');
+}
+function channelInfoToChatData(body, expectedChatId) {
+    const info = extractChannelInfo(body, expectedChatId);
+    const type = requiredChatType(info.type);
+    const activeMembers = requiredNonNegativeInteger(info.activeMembersCount, 'activeMembersCount');
+    const unreadCount = info.invalidNewMessageCount === true ? 0 : requiredNonNegativeInteger(info.newMessageCount, 'newMessageCount');
+    const displayMembers = Array.isArray(info.displayMembers) ? info.displayMembers : [];
+    const memberIds = [];
+    const memberNames = [];
+    for (const member of displayMembers) {
+        if (!member || typeof member !== 'object')
+            continue;
+        if (member.userId === undefined || typeof member.nickName !== 'string')
+            continue;
+        memberIds.push(member.userId);
+        memberNames.push(member.nickName);
+    }
+    return {
+        c: info.chatId,
+        t: type,
+        a: activeMembers,
+        n: unreadCount,
+        l: info.lastChatLog ?? null,
+        ll: info.lastLogId,
+        i: memberIds,
+        k: memberNames,
+        li: info.li,
+    };
+}
+function extractChannelMaxLogId(body, expectedChatId) {
+    const info = extractChannelInfo(body, expectedChatId);
+    const maxLogId = bsonToLong(info.lastLogId);
+    if (!maxLogId)
+        throw new Error('CHATINFO response missing lastLogId');
+    return maxLogId;
+}
 function extractOpenLinkName(body) {
     const ols = body.ols;
     if (!Array.isArray(ols) || ols.length === 0)
@@ -173,9 +251,8 @@ function extractOpenLinkName(body) {
     const ln = ols[0]?.ln;
     return typeof ln === 'string' && ln.length > 0 ? ln : null;
 }
-const OPEN_CHAT_TYPES = new Set(['OM', 'OD']);
 function isOpenChat(chat) {
-    return typeof chat.t === 'string' && OPEN_CHAT_TYPES.has(chat.t);
+    return isOpenKakaoChatType(chat.t);
 }
 function getOpenLinkId(chat) {
     return bsonToLong(chat.li) ?? null;
@@ -209,11 +286,39 @@ function collectChats(chatDatas, into, seen) {
         }
     }
 }
-function wrapError(error, code) {
-    if (error instanceof KakaoTalkError)
-        return error;
+function wrapError(error, code, options) {
+    if (error instanceof KakaoTalkError) {
+        const responseFailureKind = error.responseFailureKind ?? (options?.classifyResponseFailure ? 'transient_or_unknown' : undefined);
+        const getChatFailureReason = error.getChatFailureReason ?? (options?.classifyGetChatFailure ? 'transport_or_unknown' : undefined);
+        if (responseFailureKind === error.responseFailureKind && getChatFailureReason === error.getChatFailureReason) {
+            return error;
+        }
+        return new KakaoTalkError(error.message, error.code, {
+            cause: error.cause ?? error,
+            serverStatus: error.serverStatus,
+            responseFailureKind,
+            responseStatusSource: error.responseStatusSource,
+            getChatFailureReason,
+        });
+    }
     const message = error instanceof Error ? error.message : String(error);
-    return new KakaoTalkError(message, code, { cause: error });
+    return new KakaoTalkError(message, code, {
+        cause: error,
+        serverStatus: error instanceof LocoResponseError ? error.serverStatus : undefined,
+        responseStatusSource: error instanceof LocoResponseError ? error.responseStatusSource : undefined,
+        responseFailureKind: error instanceof LocoResponseError
+            ? error.responseFailureKind
+            : options?.classifyResponseFailure
+                ? 'transient_or_unknown'
+                : undefined,
+        getChatFailureReason: options?.classifyGetChatFailure
+            ? error instanceof LocoResponseError && error.responseFailureKind === 'provider_rejection'
+                ? 'provider_rejection'
+                : error instanceof LocoResponseError && error.responseStatusSource === 'packet' && error.serverStatus === -1
+                    ? 'synthetic_connection_close'
+                    : 'transport_or_unknown'
+            : undefined,
+    });
 }
 function isLoginResponseError(error) {
     if (!(error instanceof Error))
@@ -335,12 +440,27 @@ function isNonZeroLong(v) {
 // caller-visible error channel (e.g. GETMEM/MEMBER return `[]` for both empty rooms and dead
 // sockets). Throwing here lets executeWithReconnect detect session death and reconnect.
 function assertLocoOk(response, command) {
+    if (typeof response.statusCode !== 'number' || !Number.isFinite(response.statusCode)) {
+        throw new LocoResponseError(`${command} failed: response status unavailable`, 'transient_or_unknown');
+    }
+    if (isSyntheticConnectionClose(response)) {
+        throw new LocoResponseError(`${command} failed: connection closed`, 'transient_or_unknown', {
+            serverStatus: response.statusCode,
+            responseStatusSource: 'packet',
+        });
+    }
     if (response.statusCode !== 0) {
-        throw new Error(`${command} failed: statusCode=${response.statusCode}`);
+        throw new LocoResponseError(`${command} failed: statusCode=${response.statusCode}`, 'provider_rejection', {
+            serverStatus: response.statusCode,
+            responseStatusSource: 'packet',
+        });
     }
     const bodyStatus = response.body.status;
     if (typeof bodyStatus === 'number' && bodyStatus !== 0) {
-        throw new Error(`${command} failed: body.status=${bodyStatus}`);
+        throw new LocoResponseError(`${command} failed: body.status=${bodyStatus}`, 'provider_rejection', {
+            serverStatus: bodyStatus,
+            responseStatusSource: 'body',
+        });
     }
 }
 function formatMember(member) {
@@ -359,10 +479,24 @@ function formatMember(member) {
     };
 }
 function memberIdKey(member) {
-    if (member.userId === undefined || member.userId === null)
+    const value = member.userId;
+    if (typeof value === 'number') {
+        return Number.isSafeInteger(value) && value > 0 ? String(value) : null;
+    }
+    if (!value || typeof value !== 'object' || !('low' in value) || !('high' in value)) {
+        return null;
+    }
+    const { low, high } = value;
+    if (!Number.isInteger(low) ||
+        !Number.isInteger(high) ||
+        low < -0x80000000 ||
+        low > 0xffffffff ||
+        high < -0x80000000 ||
+        high > 0xffffffff) {
         return null;
-    const key = longToString(member.userId);
-    return key === '0' ? null : key;
+    }
+    const numeric = (BigInt(high >>> 0) << 32n) | BigInt(low >>> 0);
+    return numeric > 0n && numeric <= BigInt(Number.MAX_SAFE_INTEGER) ? numeric.toString() : null;
 }
 function mergeMemberRecords(primaryMembers, fallbackMembers) {
     const merged = [];
@@ -385,18 +519,43 @@ function mergeMemberRecords(primaryMembers, fallbackMembers) {
         upsert(member);
     return merged;
 }
-function extractChatInfoMembers(body) {
-    if (!body || typeof body !== 'object')
-        return [];
-    const record = body;
-    if (Array.isArray(record.m)) {
-        return record.m;
-    }
-    const chatInfo = record.chatInfo;
-    if (!chatInfo || typeof chatInfo !== 'object')
-        return [];
-    const displayMembers = chatInfo.displayMembers;
-    return Array.isArray(displayMembers) ? displayMembers : [];
+function exactMemberRecords(value, source) {
+    if (!Array.isArray(value)) {
+        throw new Error(`${source} member snapshot missing`);
+    }
+    const records = [];
+    const ids = new Set();
+    for (const raw of value) {
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+            throw new Error(`${source} member snapshot invalid`);
+        }
+        const record = raw;
+        const id = memberIdKey(record);
+        if (!id || ids.has(id)) {
+            throw new Error(`${source} member snapshot invalid`);
+        }
+        ids.add(id);
+        records.push(record);
+    }
+    return { records, ids };
+}
+function sameIds(left, right) {
+    return left.size === right.size && [...left].every((id) => right.has(id));
+}
+function subsetIds(subset, superset) {
+    return [...subset].every((id) => superset.has(id));
+}
+function channelMemberView(body, expectedChatId) {
+    const info = extractChannelInfo(body, expectedChatId);
+    const activeMembers = requiredNonNegativeInteger(info.activeMembersCount, 'activeMembersCount');
+    const displayMembers = exactMemberRecords(info.displayMembers ?? [], 'CHATINFO');
+    if (displayMembers.records.length > activeMembers) {
+        throw new Error('CHATINFO member snapshot invalid');
+    }
+    return {
+        activeMembers,
+        ...displayMembers,
+    };
 }
 function formatMessages(logs, count, chatId, nameCache) {
     logs.sort((a, b) => a.sendAt - b.sendAt);
@@ -410,6 +569,40 @@ function formatMessages(logs, count, chatId, nameCache) {
         sent_at: log.sendAt,
     }));
 }
+function formatForwardMessage(log, chatId, nameCache) {
+    return {
+        log_id: longToString(log.logId),
+        type: log.type,
+        author_id: log.authorId,
+        author_name: nameCache.lookup(chatId, log.authorId),
+        message: log.message,
+        attachment: parseAttachmentJson(log.attachment),
+        sent_at: log.sendAt,
+    };
+}
+function buildMessagePage(logs, count, cursor, protocolComplete, chatId, nameCache) {
+    const cursorValue = BigInt(cursor.toString());
+    const unique = new Map();
+    for (const log of logs) {
+        const logId = longToString(log.logId);
+        if (BigInt(logId) <= cursorValue)
+            continue;
+        if (!unique.has(logId))
+            unique.set(logId, log);
+    }
+    const ordered = [...unique.entries()].sort(([left], [right]) => {
+        const a = BigInt(left);
+        const b = BigInt(right);
+        return a < b ? -1 : a > b ? 1 : 0;
+    });
+    const selected = ordered.slice(0, count);
+    const nextCursor = selected.at(-1)?.[0] ?? null;
+    return {
+        messages: selected.map(([, log]) => formatForwardMessage(log, chatId, nameCache)),
+        next_cursor: nextCursor,
+        complete: protocolComplete && ordered.length <= count,
+    };
+}
 function buildReplyExtra(target) {
     return {
         attach_only: false,
@@ -636,6 +829,7 @@ export class KakaoTalkClient {
                 if (options?.all || options?.search || snapshotEmpty) {
                     let cursor = loginResult;
                     let pages = 0;
+                    const requireCompleteList = options?.all === true;
                     while (pages < MAX_PAGES) {
                         // Trust eof only when the snapshot had data. When the snapshot was empty
                         // (new device), ignore eof for the first iteration so we always attempt
@@ -647,14 +841,26 @@ export class KakaoTalkClient {
                         const lastTokenId = bsonToLong(cursor.lastTokenId);
                         const lastChatId = bsonToLong(cursor.lastChatId);
                         const response = await session.getChatList(lastTokenId, lastChatId);
+                        if (requireCompleteList)
+                            assertLocoOk(response, 'LCHATLIST');
                         const body = response.body;
+                        if (requireCompleteList && !Array.isArray(body.chatDatas)) {
+                            throw new Error('LCHATLIST pagination incomplete: chatDatas unavailable');
+                        }
                         const chatDatas = (body.chatDatas ?? []);
-                        if (chatDatas.length === 0)
+                        cursor = body;
+                        pages++;
+                        if (chatDatas.length === 0) {
+                            if (requireCompleteList && body.eof !== true) {
+                                throw new Error('LCHATLIST pagination incomplete: empty non-EOF page');
+                            }
                             break;
+                        }
                         collectChats(chatDatas, allChats, seenChatIds);
                         this.nameCache.ingest(chatDatas);
-                        cursor = body;
-                        pages++;
+                    }
+                    if (requireCompleteList && cursor.eof !== true) {
+                        throw new Error(`LCHATLIST pagination incomplete after ${pages} pages`);
                     }
                 }
                 allChats.sort((a, b) => (b.o ?? 0) - (a.o ?? 0));
@@ -672,6 +878,63 @@ export class KakaoTalkClient {
             }
         });
     }
+    /**
+     * Fetch one chat directly by id via read-only CHATINFO.
+     *
+     * Unlike `getChats()`, this does not depend on the login-time snapshot or
+     * LCHATLIST pagination, so a room first observed from a live push can be
+     * resolved without interpreting protocol fields outside this SDK.
+     * The returned chat type preserves numeric values and non-empty protocol
+     * strings, including DirectChat, MultiChat, PlusChat, MemoChat, OM, and OD;
+     * unknown non-empty strings are preserved for forward compatibility.
+     */
+    async getChat(chatId) {
+        const parsedChatId = parseChatId(chatId);
+        const normalizedChatId = longToString(parsedChatId);
+        return this.executeWithReconnect(async ({ session }) => {
+            try {
+                const response = await session.getChannelInfo(parsedChatId);
+                assertLocoOk(response, 'CHATINFO');
+                const body = response.body;
+                const chatInfo = body.chatInfo;
+                const isLeftChatInfo = chatInfo !== null &&
+                    typeof chatInfo === 'object' &&
+                    !Array.isArray(chatInfo) &&
+                    chatInfo.left === true;
+                if (isLeftChatInfo) {
+                    extractChannelInfo(body, normalizedChatId);
+                }
+                if (chatInfo === undefined || chatInfo === null || isLeftChatInfo) {
+                    throw new KakaoTalkError('CHATINFO response missing chatInfo', 'get_chat_failed', {
+                        responseFailureKind: 'transient_or_unknown',
+                        getChatFailureReason: 'chat_info_absent',
+                    });
+                }
+                const chat = channelInfoToChatData(body, normalizedChatId);
+                this.nameCache.ingest([chat]);
+                let title = extractTitle(body);
+                if (!title && isOpenChat(chat)) {
+                    const linkId = getOpenLinkId(chat);
+                    if (linkId) {
+                        try {
+                            const openLinkResponse = await session.getOpenLinkInfo([linkId]);
+                            title = extractOpenLinkName(openLinkResponse.body);
+                        }
+                        catch {
+                            title = null;
+                        }
+                    }
+                }
+                return formatChat(chat, title, this.nameCache);
+            }
+            catch (error) {
+                throw wrapError(error, 'get_chat_failed', {
+                    classifyResponseFailure: true,
+                    classifyGetChatFailure: true,
+                });
+            }
+        });
+    }
     /**
      * Resolve the user-set room title via CHATINFO. Returns null on any error
      * (network, malformed response, or no TITLE meta present). Designed to be
@@ -714,6 +977,50 @@ export class KakaoTalkClient {
             return null;
         }
     }
+    /**
+     * Fetch one forward-only, lossless history page after `from`.
+     *
+     * The page never keeps only the newest `count` entries. If the protocol
+     * returns more entries than requested, the oldest entries are returned and
+     * `complete` remains false so callers can continue from `next_cursor`.
+     */
+    async getMessagePage(chatId, options) {
+        const count = options?.count ?? 100;
+        if (!Number.isInteger(count) || count < 1 || count > 100) {
+            throw new KakaoTalkError('Message page count must be an integer between 1 and 100', 'invalid_message_page_count');
+        }
+        const parsedChatId = parseChatId(chatId);
+        const normalizedChatId = longToString(parsedChatId);
+        const cursor = options?.from ? parseLogId(options.from) : Long.fromNumber(0);
+        return this.executeWithReconnect(async ({ session }) => {
+            try {
+                const response = await session.getChatLogs([parsedChatId], [cursor]);
+                assertLocoOk(response, 'MCHATLOGS');
+                const batch = (response.body.chatLogs ?? []).filter((log) => longToString(log.chatId) === normalizedChatId);
+                if (batch.length > 0) {
+                    return buildMessagePage(batch, count, cursor, response.body.eof === true, normalizedChatId, this.nameCache);
+                }
+                // CHATINFO is read-only and supplies a fresh lastLogId even for rooms
+                // absent from the login snapshot. This avoids CHATONROOM, which can
+                // advance server-side unread state.
+                const chatInfoResponse = await session.getChannelInfo(parsedChatId);
+                assertLocoOk(chatInfoResponse, 'CHATINFO');
+                const maxLogId = extractChannelMaxLogId(chatInfoResponse.body, normalizedChatId);
+                if (maxLogId.lessThanOrEqual(cursor)) {
+                    return { messages: [], next_cursor: null, complete: true };
+                }
+                const syncResponse = await session.syncMessages(parsedChatId, Math.min(count, 80), cursor, maxLogId);
+                assertLocoOk(syncResponse, 'SYNCMSG');
+                const syncBatch = (syncResponse.body.chatLogs ?? []).filter((log) => longToString(log.chatId) === normalizedChatId);
+                const maxReturned = findMaxLogId(syncBatch, 'logId');
+                const protocolComplete = syncResponse.body.isOK === true || (maxReturned !== null && maxReturned.greaterThanOrEqual(maxLogId));
+                return buildMessagePage(syncBatch, count, cursor, protocolComplete, normalizedChatId, this.nameCache);
+            }
+            catch (error) {
+                throw wrapError(error, 'get_message_page_failed');
+            }
+        });
+    }
     async getMessages(chatId, options) {
         return this.executeWithReconnect(async ({ session, loginResult }) => {
             try {
@@ -798,30 +1105,58 @@ export class KakaoTalkClient {
             }
         });
     }
-    async getMembers(chatId) {
+    async getMemberSnapshot(chatId) {
         const parsedChatId = parseChatId(chatId);
+        const normalizedChatId = longToString(parsedChatId);
         return this.executeWithReconnect(async ({ session }) => {
             try {
-                const response = await session.getAllMembers(parsedChatId);
-                assertLocoOk(response, 'GETMEM');
-                const members = (response.body.members ?? []);
-                let fallbackMembers = [];
-                try {
-                    // Some KakaoTalk rooms return only a subset from GETMEM even though
-                    // CHATONROOM carries the full active member list in `m`.
-                    const chatInfo = await session.getChatInfo(parsedChatId);
-                    fallbackMembers = extractChatInfoMembers(chatInfo.body);
+                const firstChatResponse = await session.getChannelInfo(parsedChatId);
+                assertLocoOk(firstChatResponse, 'CHATINFO');
+                const firstChat = channelMemberView(firstChatResponse.body, normalizedChatId);
+                const firstMemberResponse = await session.getAllMembers(parsedChatId);
+                assertLocoOk(firstMemberResponse, 'GETMEM');
+                const firstMembers = exactMemberRecords(firstMemberResponse.body.members ?? [], 'GETMEM');
+                const secondChatResponse = await session.getChannelInfo(parsedChatId);
+                assertLocoOk(secondChatResponse, 'CHATINFO');
+                const secondChat = channelMemberView(secondChatResponse.body, normalizedChatId);
+                const secondMemberResponse = await session.getAllMembers(parsedChatId);
+                assertLocoOk(secondMemberResponse, 'GETMEM');
+                const secondMembers = exactMemberRecords(secondMemberResponse.body.members ?? [], 'GETMEM');
+                if (firstChat.activeMembers !== secondChat.activeMembers ||
+                    firstMembers.records.length !== firstChat.activeMembers ||
+                    secondMembers.records.length !== secondChat.activeMembers ||
+                    !sameIds(firstChat.ids, secondChat.ids) ||
+                    !sameIds(firstMembers.ids, secondMembers.ids) ||
+                    !subsetIds(secondChat.ids, secondMembers.ids)) {
+                    throw new Error('member_snapshot_changed_or_incomplete');
                 }
-                catch {
-                    fallbackMembers = [];
-                }
-                return mergeMemberRecords(members, fallbackMembers).map(formatMember);
+                return {
+                    chat_id: normalizedChatId,
+                    active_members: secondChat.activeMembers,
+                    members: mergeMemberRecords(secondMembers.records, secondChat.records).map(formatMember),
+                    complete: true,
+                    consistency_basis: 'stable_double_read_chatinfo_getmem',
+                };
             }
             catch (error) {
-                throw wrapError(error, 'get_members_failed');
+                throw wrapError(error, 'get_member_snapshot_failed');
             }
         });
     }
+    async getMembers(chatId) {
+        try {
+            return (await this.getMemberSnapshot(chatId)).members;
+        }
+        catch (error) {
+            if (error instanceof KakaoTalkError && error.code === 'get_member_snapshot_failed') {
+                throw new KakaoTalkError(error.message, 'get_members_failed', {
+                    cause: error,
+                    serverStatus: error.serverStatus,
+                });
+            }
+            throw error;
+        }
+    }
     async getMembersByIds(chatId, userIds) {
         if (userIds.length === 0)
             return [];