agent-messenger 2.12.1 → 2.13.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-messenger",
-  "version": "2.12.1",
+  "version": "2.13.0",
   "description": "Messaging platform interaction skills for AI agents. Interact with Slack, Discord, Microsoft Teams, Webex, Telegram, Telegram Bot, WhatsApp, LINE, Instagram, KakaoTalk, and Channel Talk - send messages, read channels, manage reactions, upload files, and more through simple CLI interfaces.",
   "author": {
     "name": "agent-messenger",

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "agent-messenger",
-    "version": "2.12.1",
+    "version": "2.13.0",
     "description": "Multi-platform messaging CLI for AI agents (Slack, Discord, Teams, Webex, Telegram, Telegram Bot, WhatsApp, LINE, Instagram, KakaoTalk, Channel Talk)",
     "repository": {
         "type": "git",

package/dist/src/platforms/kakaotalk/chat-classifier.d.ts

@@ -0,0 +1,18 @@
+import type { KakaoChat } from './types.js';
+export type KakaoChatKind = 'dm' | 'group' | 'open' | 'unknown';
+/**
+ * Classify a KakaoTalk chat as `'dm'`, `'group'`, `'open'`, or `'unknown'`.
+ *
+ * REGRESSION GUARD: An earlier implementation hard-coded `0=dm`, `1=group`,
+ * `2=open` on the raw `type` number. Modern KakaoTalk uses codes like `11`
+ * for normal DMs and `10` for normal groups, so the old mapping silently
+ * classified every real DM as `'unknown'` and bucketed it as a group. Do
+ * NOT "simplify" this back to a pure type-code mapping without verifying
+ * against a real KakaoTalk session.
+ *
+ * `'unknown'` is reserved for future protocol drift; the current heuristic
+ * never returns it, but it is part of the union so consumers can handle
+ * the case defensively.
+ */
+export declare function classifyKakaoChat(chat: Pick<KakaoChat, 'type' | 'active_members'>): KakaoChatKind;
+//# sourceMappingURL=chat-classifier.d.ts.map

package/dist/src/platforms/kakaotalk/chat-classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-classifier.d.ts","sourceRoot":"","sources":["../../../../src/platforms/kakaotalk/chat-classifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC,MAAM,MAAM,aAAa,GAAG,IAAI,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAA;AAQ/D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAAC,GAAG,aAAa,CAMjG"}

package/dist/src/platforms/kakaotalk/chat-classifier.js

@@ -0,0 +1,29 @@
+// OpenChat-family `type` codes observed on the wire. KakaoTalk's LOCO
+// protocol exposes a numeric `type` field with no documented mapping; these
+// five codes consistently identify OpenChat rooms across normal OpenChat,
+// OpenChat DMs, and the various OpenChat sub-types seen in production.
+const OPEN_CHAT_TYPE_CODES = new Set([2, 13, 14, 15, 16]);
+/**
+ * Classify a KakaoTalk chat as `'dm'`, `'group'`, `'open'`, or `'unknown'`.
+ *
+ * REGRESSION GUARD: An earlier implementation hard-coded `0=dm`, `1=group`,
+ * `2=open` on the raw `type` number. Modern KakaoTalk uses codes like `11`
+ * for normal DMs and `10` for normal groups, so the old mapping silently
+ * classified every real DM as `'unknown'` and bucketed it as a group. Do
+ * NOT "simplify" this back to a pure type-code mapping without verifying
+ * against a real KakaoTalk session.
+ *
+ * `'unknown'` is reserved for future protocol drift; the current heuristic
+ * never returns it, but it is part of the union so consumers can handle
+ * the case defensively.
+ */
+export function classifyKakaoChat(chat) {
+    if (OPEN_CHAT_TYPE_CODES.has(chat.type))
+        return 'open';
+    // active_members counts the logged-in user, so a 1:1 DM is exactly 2
+    // (self + one other) and a "lone" room with only self is 1.
+    if (chat.active_members <= 2)
+        return 'dm';
+    return 'group';
+}
+//# sourceMappingURL=chat-classifier.js.map

package/dist/src/platforms/kakaotalk/chat-classifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-classifier.js","sourceRoot":"","sources":["../../../../src/platforms/kakaotalk/chat-classifier.ts"],"names":[],"mappings":"AAIA,sEAAsE;AACtE,4EAA4E;AAC5E,0EAA0E;AAC1E,uEAAuE;AACvE,MAAM,oBAAoB,GAAwB,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;AAE9E;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAgD;IAChF,IAAI,oBAAoB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,MAAM,CAAA;IACtD,qEAAqE;IACrE,4DAA4D;IAC5D,IAAI,IAAI,CAAC,cAAc,IAAI,CAAC;QAAE,OAAO,IAAI,CAAA;IACzC,OAAO,OAAO,CAAA;AAChB,CAAC"}

package/dist/src/platforms/kakaotalk/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../../src/platforms/kakaotalk/cli.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,WAAW,CAAA;AAgBvD,QAAA,MAAM,OAAO,aAAgB,CAAA;AAmB7B,eAAe,OAAO,CAAA"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../../src/platforms/kakaotalk/cli.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,WAAW,CAAA;AAgBvD,QAAA,MAAM,OAAO,aAAgB,CAAA;AAoB7B,eAAe,OAAO,CAAA"}

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { Command } from 'commander';
 import pkg from '../../../package.json' with { type: 'json' };
-import { authCommand, chatCommand, messageCommand, whoamiCommand } from './commands/index.js';
+import { authCommand, chatCommand, memberCommand, messageCommand, whoamiCommand } from './commands/index.js';
 import { ensureKakaoAuth } from './ensure-auth.js';
 function isAuthCommand(command) {
     let cmd = command;
@@ -24,6 +24,7 @@ program.hook('preAction', async (_thisCommand, actionCommand) => {
 });
 program.addCommand(authCommand);
 program.addCommand(chatCommand);
+program.addCommand(memberCommand);
 program.addCommand(messageCommand);
 program.addCommand(whoamiCommand);
 program.parse(process.argv);

package/dist/src/platforms/kakaotalk/cli.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../../../src/platforms/kakaotalk/cli.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAEnC,OAAO,GAAG,MAAM,uBAAuB,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAA;AAC7D,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAC1F,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAE/C,SAAS,aAAa,CAAC,OAAoB;IACzC,IAAI,GAAG,GAAuB,OAAO,CAAA;IACrC,OAAO,GAAG,EAAE,CAAC;QACX,IAAI,GAAG,CAAC,IAAI,EAAE,KAAK,MAAM;YAAE,OAAO,IAAI,CAAA;QACtC,GAAG,GAAG,GAAG,CAAC,MAAM,CAAA;IAClB,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAA;AAE7B,OAAO;KACJ,IAAI,CAAC,iBAAiB,CAAC;KACvB,WAAW,CAAC,8EAA8E,CAAC;KAC3F,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;AAEvB,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,EAAE;IAC9D,IAAI,aAAa,CAAC,aAAa,CAAC;QAAE,OAAM;IACxC,MAAM,eAAe,EAAE,CAAA;AACzB,CAAC,CAAC,CAAA;AAEF,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAA;AAC/B,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAA;AAC/B,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,CAAA;AAClC,OAAO,CAAC,UAAU,CAAC,aAAa,CAAC,CAAA;AAEjC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;AAE3B,eAAe,OAAO,CAAA"}
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../../../src/platforms/kakaotalk/cli.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAEnC,OAAO,GAAG,MAAM,uBAAuB,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAA;AAC7D,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACzG,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAE/C,SAAS,aAAa,CAAC,OAAoB;IACzC,IAAI,GAAG,GAAuB,OAAO,CAAA;IACrC,OAAO,GAAG,EAAE,CAAC;QACX,IAAI,GAAG,CAAC,IAAI,EAAE,KAAK,MAAM;YAAE,OAAO,IAAI,CAAA;QACtC,GAAG,GAAG,GAAG,CAAC,MAAM,CAAA;IAClB,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAA;AAE7B,OAAO;KACJ,IAAI,CAAC,iBAAiB,CAAC;KACvB,WAAW,CAAC,8EAA8E,CAAC;KAC3F,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;AAEvB,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,EAAE;IAC9D,IAAI,aAAa,CAAC,aAAa,CAAC;QAAE,OAAM;IACxC,MAAM,eAAe,EAAE,CAAA;AACzB,CAAC,CAAC,CAAA;AAEF,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAA;AAC/B,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAA;AAC/B,OAAO,CAAC,UAAU,CAAC,aAAa,CAAC,CAAA;AACjC,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,CAAA;AAClC,OAAO,CAAC,UAAU,CAAC,aAAa,CAAC,CAAA;AAEjC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;AAE3B,eAAe,OAAO,CAAA"}

package/dist/src/platforms/kakaotalk/client.d.ts

@@ -1,4 +1,17 @@
-import type { KakaoChat, KakaoDeviceType, KakaoMessage, KakaoProfile, KakaoSendResult } from './types.js';
+import { LocoSession } from './protocol/session.js';
+import type { LocoPacket } from './protocol/types.js';
+import type { KakaoChat, KakaoDeviceType, KakaoMember, KakaoMessage, KakaoProfile, KakaoSendResult } from './types.js';
+export type KakaoSessionEvent = {
+    type: 'connected';
+    userId: string;
+} | {
+    type: 'disconnected';
+} | {
+    type: 'kicked';
+    reason: string;
+};
+export type KakaoPushHandler = (packet: LocoPacket) => void;
+export type KakaoSessionEventHandler = (event: KakaoSessionEvent) => void;
 export declare class KakaoTalkError extends Error {
     code: string;
     constructor(message: string, code: string, options?: {
@@ -13,6 +26,9 @@ export declare class KakaoTalkClient {
     private state;
     private initPromise;
     private closed;
+    private pushHandlers;
+    private sessionEventHandlers;
+    private nameCache;
     login(credentials?: {
         oauthToken: string;
         userId: string;
@@ -27,18 +43,36 @@ export declare class KakaoTalkClient {
     };
     private ensureAuth;
     private ensureSession;
+    acquireSession(): Promise<LocoSession>;
+    onPush(handler: KakaoPushHandler): () => void;
+    onSessionEvent(handler: KakaoSessionEventHandler): () => void;
+    isConnected(): boolean;
     private executeWithReconnect;
     private connect;
+    private dispatchPush;
+    private invalidateSession;
+    private emitSessionEvent;
     getChats(options?: {
         all?: boolean;
         search?: string;
+        resolveTitles?: boolean;
     }): Promise<KakaoChat[]>;
+    /**
+     * Resolve the user-set room title via CHATINFO. Returns null on any error
+     * (network, malformed response, or no TITLE meta present). Designed to be
+     * fire-and-forget per chat — failures don't poison the whole `getChats` call.
+     */
+    getChatTitle(chatId: string): Promise<string | null>;
+    private fetchChatTitle;
     getMessages(chatId: string, options?: {
         count?: number;
         from?: string;
     }): Promise<KakaoMessage[]>;
+    getMembers(chatId: string): Promise<KakaoMember[]>;
+    getMembersByIds(chatId: string, userIds: string[]): Promise<KakaoMember[]>;
     sendMessage(chatId: string, text: string): Promise<KakaoSendResult>;
     getProfile(): Promise<KakaoProfile>;
     close(): void;
+    lookupAuthorName(chatId: string, authorId: number): string | null;
 }
 //# sourceMappingURL=client.d.ts.map

package/dist/src/platforms/kakaotalk/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/platforms/kakaotalk/client.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAEtG,qBAAa,cAAe,SAAQ,KAAK;IACvC,IAAI,EAAE,MAAM,CAAA;gBAEA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAKzE;AA8MD,qBAAa,eAAe;IAC1B,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,UAAU,CAA4B;IAC9C,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,WAAW,CAAqC;IACxD,OAAO,CAAC,MAAM,CAAQ;IAEhB,KAAK,CACT,WAAW,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,eAAe,CAAA;KAAE,EACvG,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC;IAoBhB,cAAc,IAAI;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,eAAe,CAAA;KAAE;IAUzG,OAAO,CAAC,UAAU;YAMJ,aAAa;YA2Bb,oBAAoB;YAmBpB,OAAO;IA6Bf,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAqD5E,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IA8FjG,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAkBnE,UAAU,IAAI,OAAO,CAAC,YAAY,CAAC;IA6DzC,KAAK,IAAI,IAAI;CAUd"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/platforms/kakaotalk/client.ts"],"names":[],"mappings":"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"}

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

@@ -14,6 +14,53 @@ export class KakaoTalkError extends Error {
         this.code = code;
     }
 }
+class MemberNameCache {
+    byChatId = new Map();
+    ingest(chatDatas) {
+        for (const chat of chatDatas) {
+            const ids = chat.i;
+            const names = chat.k;
+            if (!Array.isArray(ids) || !Array.isArray(names))
+                continue;
+            const chatId = String(chat.c);
+            let map = this.byChatId.get(chatId);
+            if (!map) {
+                map = new Map();
+                this.byChatId.set(chatId, map);
+            }
+            const len = Math.min(ids.length, names.length);
+            for (let i = 0; i < len; i++) {
+                const numericId = toNumericUserId(ids[i]);
+                if (numericId === null)
+                    continue;
+                const name = names[i];
+                if (typeof name === 'string' && name.length > 0) {
+                    map.set(numericId, name);
+                }
+            }
+        }
+    }
+    lookup(chatId, userId) {
+        return this.byChatId.get(chatId)?.get(userId) ?? null;
+    }
+    forget(chatId) {
+        this.byChatId.delete(chatId);
+    }
+    clear() {
+        this.byChatId.clear();
+    }
+}
+function toNumericUserId(v) {
+    if (typeof v === 'number')
+        return Number.isFinite(v) ? v : null;
+    if (v && typeof v === 'object' && 'low' in v && 'high' in v) {
+        const { low, high } = v;
+        // chatDatas[].i entries are member user IDs. KakaoTalk user IDs fit in
+        // 53 bits — safe to flatten the BSON Long pair to a JS number for keying.
+        return (high >>> 0) * 0x100000000 + (low >>> 0);
+    }
+    return null;
+}
 function bsonToLong(v) {
     if (v && typeof v === 'object' && 'high' in v && 'low' in v) {
         const { high, low } = v;
@@ -34,25 +81,68 @@ function parseLong(s) {
     const high = Number((big >> 32n) & 0xffffffffn);
     return new Long(low, high);
 }
-function formatChat(chat) {
+function parseChatId(chatId) {
+    try {
+        return parseLong(chatId);
+    }
+    catch (cause) {
+        throw new KakaoTalkError(`Invalid chatId: ${chatId}`, 'invalid_chat_id', { cause });
+    }
+}
+function parseUserId(userId) {
+    try {
+        return parseLong(userId);
+    }
+    catch (cause) {
+        throw new KakaoTalkError(`Invalid userId: ${userId}`, 'invalid_user_id', { cause });
+    }
+}
+function formatChat(chat, title, nameCache) {
     const memberNames = (chat.k ?? []);
     const lastLog = chat.l;
     const displayName = memberNames.join(', ') || null;
+    const chatId = String(chat.c);
     return {
-        chat_id: String(chat.c),
+        chat_id: chatId,
         type: chat.t,
         display_name: displayName,
+        title,
         active_members: chat.a,
         unread_count: chat.n,
         last_message: lastLog
             ? {
                 author_id: lastLog.authorId,
+                author_name: nameCache.lookup(chatId, lastLog.authorId),
                 message: lastLog.message,
                 sent_at: lastLog.sendAt,
             }
             : null,
     };
 }
+const META_TYPE_TITLE = 3;
+function extractTitle(body) {
+    const info = body.chatInfo;
+    const metas = info?.chatMetas;
+    if (!Array.isArray(metas))
+        return null;
+    const titleMeta = metas.find((m) => m?.type === META_TYPE_TITLE);
+    const content = titleMeta?.content;
+    return typeof content === 'string' && content.length > 0 ? content : null;
+}
+function extractOpenLinkName(body) {
+    const ols = body.ols;
+    if (!Array.isArray(ols) || ols.length === 0)
+        return null;
+    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);
+}
+function getOpenLinkId(chat) {
+    return bsonToLong(chat.li) ?? null;
+}
 function matchesSearch(chat, term) {
     const names = (chat.k ?? []);
     const lower = term.toLowerCase();
@@ -174,12 +264,56 @@ function mergeSyncState(previous, loginResult) {
     }
     return next;
 }
-function formatMessages(logs, count) {
+function nullableString(v) {
+    return typeof v === 'string' && v.length > 0 ? v : null;
+}
+function nullableNumber(v) {
+    return typeof v === 'number' && Number.isFinite(v) ? v : null;
+}
+function isNonZeroLong(v) {
+    if (typeof v === 'number')
+        return v !== 0;
+    if (v && typeof v === 'object' && 'low' in v && 'high' in v) {
+        const { low, high } = v;
+        return low !== 0 || high !== 0;
+    }
+    return v !== undefined && v !== null;
+}
+// Reject synthetic LocoConnection close packets ({ statusCode: -1, body.error: 'connection closed' })
+// and explicit body-level failures. Required for any SDK method whose response body has no
+// 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 (response.statusCode !== 0) {
+        throw new Error(`${command} failed: statusCode=${response.statusCode}`);
+    }
+    const bodyStatus = response.body.status;
+    if (typeof bodyStatus === 'number' && bodyStatus !== 0) {
+        throw new Error(`${command} failed: body.status=${bodyStatus}`);
+    }
+}
+function formatMember(member) {
+    return {
+        user_id: longToString(member.userId),
+        nickname: typeof member.nickName === 'string' ? member.nickName : '',
+        profile_image_url: nullableString(member.profileImageUrl ?? member.pi),
+        full_profile_image_url: nullableString(member.fullProfileImageUrl ?? member.fpi),
+        original_profile_image_url: nullableString(member.originalProfileImageUrl ?? member.opi),
+        status_message: nullableString(member.statusMessage),
+        country_iso: nullableString(member.countryIso),
+        user_type: nullableNumber(member.type),
+        open_token: nullableNumber(member.opt),
+        open_profile_link_id: isNonZeroLong(member.pli) ? longToString(member.pli) : null,
+        open_permission: nullableNumber(member.mt),
+    };
+}
+function formatMessages(logs, count, chatId, nameCache) {
     logs.sort((a, b) => a.sendAt - b.sendAt);
     return logs.slice(-count).map((log) => ({
         log_id: longToString(log.logId),
         type: log.type,
         author_id: log.authorId,
+        author_name: nameCache.lookup(chatId, log.authorId),
         message: log.message,
         sent_at: log.sendAt,
     }));
@@ -192,6 +326,9 @@ export class KakaoTalkClient {
     state = null;
     initPromise = null;
     closed = false;
+    pushHandlers = new Set();
+    sessionEventHandlers = new Set();
+    nameCache = new MemberNameCache();
     async login(credentials, accountId) {
         if (credentials) {
             if (!credentials.oauthToken)
@@ -234,6 +371,7 @@ export class KakaoTalkClient {
         if (this.state)
             return this.state;
         // Guard against concurrent init — reuse the in-flight promise
+        const isOwner = !this.initPromise;
         if (!this.initPromise) {
             this.initPromise = this.connect();
         }
@@ -244,7 +382,11 @@ export class KakaoTalkClient {
                 state.session.close();
                 throw new KakaoTalkError('Client is closed', 'client_closed');
             }
+            const wasNew = this.state !== state;
             this.state = state;
+            if (isOwner && wasNew) {
+                this.emitSessionEvent({ type: 'connected', userId: this.userId });
+            }
             return state;
         }
         catch (error) {
@@ -254,6 +396,25 @@ export class KakaoTalkClient {
             throw error;
         }
     }
+    async acquireSession() {
+        const state = await this.ensureSession();
+        return state.session;
+    }
+    onPush(handler) {
+        this.pushHandlers.add(handler);
+        return () => {
+            this.pushHandlers.delete(handler);
+        };
+    }
+    onSessionEvent(handler) {
+        this.sessionEventHandlers.add(handler);
+        return () => {
+            this.sessionEventHandlers.delete(handler);
+        };
+    }
+    isConnected() {
+        return this.state !== null && !this.closed;
+    }
     async executeWithReconnect(operation) {
         let state = await this.ensureSession();
         try {
@@ -269,24 +430,30 @@ export class KakaoTalkClient {
                 state.session.close();
             }
             catch { }
-            this.initPromise = null;
+            // initPromise is intentionally NOT cleared here: a concurrent caller may already
+            // be awaiting an in-flight replacement, and starting a parallel one would send a
+            // second LOGINLIST with the same duuid — re-introducing the very self-eviction
+            // this layer prevents. Lifecycle paths (onClose / invalidateSession) own that field.
             state = await this.ensureSession();
             return operation(state);
         }
     }
     async connect() {
         const session = new LocoSession();
+        session.onPush((packet) => this.dispatchPush(session, packet));
+        session.onClose(() => {
+            if (this.state?.session === session) {
+                this.state = null;
+                this.initPromise = null;
+                this.emitSessionEvent({ type: 'disconnected' });
+            }
+        });
         try {
             const syncState = await loadSyncState(this.deviceUuid);
             const loginResult = await session.login(this.oauthToken, this.userId, this.deviceUuid, syncState, this.deviceType);
             const newSyncState = mergeSyncState(syncState, loginResult);
             await saveSyncState(this.deviceUuid, newSyncState);
-            session.onClose(() => {
-                if (this.state?.session === session) {
-                    this.state = null;
-                    this.initPromise = null;
-                }
-            });
+            this.nameCache.ingest((loginResult.chatDatas ?? []));
             return { session, loginResult };
         }
         catch (error) {
@@ -294,6 +461,59 @@ export class KakaoTalkClient {
             throw new KakaoTalkError(error instanceof Error ? error.message : String(error), 'login_failed', { cause: error });
         }
     }
+    dispatchPush(session, packet) {
+        // Only fan out pushes from the currently adopted session. While state is null
+        // (pre-adoption during connect, or post-invalidation during reconnect) the
+        // packet is discarded — we never want a not-yet-adopted or already-dead session
+        // to reach subscribers and look "live".
+        if (this.state?.session !== session)
+            return;
+        if (packet.method === 'KICKOUT') {
+            this.emitSessionEvent({ type: 'kicked', reason: 'Session kicked — another device logged in' });
+            this.invalidateSession(session);
+            return;
+        }
+        if (packet.method === 'CHANGESVR') {
+            for (const handler of this.pushHandlers) {
+                try {
+                    handler(packet);
+                }
+                catch { }
+            }
+            this.invalidateSession(session);
+            this.emitSessionEvent({ type: 'disconnected' });
+            this.ensureSession().catch(() => {
+                // ensureSession already cleared state on failure; subsequent API calls will retry
+                // and surface the error. Listeners do not receive 'connected' until a reconnect
+                // succeeds, which is the correct outcome.
+            });
+            return;
+        }
+        for (const handler of this.pushHandlers) {
+            try {
+                handler(packet);
+            }
+            catch { }
+        }
+    }
+    invalidateSession(session) {
+        if (this.state?.session === session) {
+            this.state = null;
+            this.initPromise = null;
+        }
+        try {
+            session.close();
+        }
+        catch { }
+    }
+    emitSessionEvent(event) {
+        for (const handler of this.sessionEventHandlers) {
+            try {
+                handler(event);
+            }
+            catch { }
+        }
+    }
     async getChats(options) {
         return this.executeWithReconnect(async ({ session, loginResult }) => {
             try {
@@ -324,6 +544,7 @@ export class KakaoTalkClient {
                         if (chatDatas.length === 0)
                             break;
                         collectChats(chatDatas, allChats, seenChatIds);
+                        this.nameCache.ingest(chatDatas);
                         cursor = body;
                         pages++;
                     }
@@ -333,13 +554,58 @@ export class KakaoTalkClient {
                 if (options?.search) {
                     results = allChats.filter((c) => matchesSearch(c, options.search));
                 }
-                return results.map(formatChat);
+                const titles = options?.resolveTitles
+                    ? await Promise.all(results.map((chat) => this.fetchChatTitle(session, parseLong(String(chat.c)), chat)))
+                    : null;
+                return results.map((chat, i) => formatChat(chat, titles ? titles[i] : null, this.nameCache));
             }
             catch (error) {
                 throw wrapError(error, 'get_chats_failed');
             }
         });
     }
+    /**
+     * Resolve the user-set room title via CHATINFO. Returns null on any error
+     * (network, malformed response, or no TITLE meta present). Designed to be
+     * fire-and-forget per chat — failures don't poison the whole `getChats` call.
+     */
+    async getChatTitle(chatId) {
+        let parsed;
+        try {
+            parsed = parseLong(chatId);
+        }
+        catch {
+            return null;
+        }
+        return this.executeWithReconnect(async ({ session, loginResult }) => {
+            const chat = (loginResult.chatDatas ?? []).find((c) => String(c.c) === chatId);
+            return this.fetchChatTitle(session, parsed, chat);
+        });
+    }
+    async fetchChatTitle(session, chatId, chat) {
+        let title = null;
+        try {
+            const response = await session.getChannelInfo(chatId);
+            title = extractTitle(response.body);
+        }
+        catch {
+            title = null;
+        }
+        if (title)
+            return title;
+        if (!chat || !isOpenChat(chat))
+            return null;
+        const linkId = getOpenLinkId(chat);
+        if (!linkId)
+            return null;
+        try {
+            const response = await session.getOpenLinkInfo([linkId]);
+            return extractOpenLinkName(response.body);
+        }
+        catch {
+            return null;
+        }
+    }
     async getMessages(chatId, options) {
         return this.executeWithReconnect(async ({ session }) => {
             try {
@@ -358,7 +624,7 @@ export class KakaoTalkClient {
                         }
                         const batch = (response.body.chatLogs ?? []).filter((log) => longToString(log.chatId) === chatId);
                         if (batch.length === 0) {
-                            return formatMessages(allMessages, count);
+                            return formatMessages(allMessages, count, chatId, this.nameCache);
                         }
                         for (const log of batch) {
                             const lid = longToString(log.logId);
@@ -369,7 +635,7 @@ export class KakaoTalkClient {
                         }
                         const maxLog = findMaxLogId(batch, 'logId');
                         if (!maxLog || maxLog.equals(cur) || response.body.eof) {
-                            return formatMessages(allMessages, count);
+                            return formatMessages(allMessages, count, chatId, this.nameCache);
                         }
                         cur = maxLog;
                     }
@@ -381,7 +647,7 @@ export class KakaoTalkClient {
                 }
                 if (allMessages.length > 0) {
                     warn(`[agent-kakaotalk] Warning: message fetch capped at ${MAX_PAGES} pages. Results may be incomplete.`);
-                    return formatMessages(allMessages, count);
+                    return formatMessages(allMessages, count, chatId, this.nameCache);
                 }
                 // Fetch fresh lastLogId via CHATONROOM (not the stale login-time snapshot)
                 const chatInfo = await session.getChatInfo(cid);
@@ -412,13 +678,44 @@ export class KakaoTalkClient {
                 if (!reachedEnd) {
                     warn(`[agent-kakaotalk] Warning: message fetch capped at ${MAX_PAGES} pages. Results may be incomplete.`);
                 }
-                return formatMessages(allMessages, count);
+                return formatMessages(allMessages, count, chatId, this.nameCache);
             }
             catch (error) {
                 throw wrapError(error, 'get_messages_failed');
             }
         });
     }
+    async getMembers(chatId) {
+        const parsedChatId = parseChatId(chatId);
+        return this.executeWithReconnect(async ({ session }) => {
+            try {
+                const response = await session.getAllMembers(parsedChatId);
+                assertLocoOk(response, 'GETMEM');
+                const members = (response.body.members ?? []);
+                return members.map(formatMember);
+            }
+            catch (error) {
+                throw wrapError(error, 'get_members_failed');
+            }
+        });
+    }
+    async getMembersByIds(chatId, userIds) {
+        if (userIds.length === 0)
+            return [];
+        const parsedChatId = parseChatId(chatId);
+        const memberIds = userIds.map((id) => parseUserId(id));
+        return this.executeWithReconnect(async ({ session }) => {
+            try {
+                const response = await session.getMembersByIds(parsedChatId, memberIds);
+                assertLocoOk(response, 'MEMBER');
+                const members = (response.body.members ?? []);
+                return members.map(formatMember);
+            }
+            catch (error) {
+                throw wrapError(error, 'get_members_failed');
+            }
+        });
+    }
     async sendMessage(chatId, text) {
         return this.executeWithReconnect(async ({ session }) => {
             try {
@@ -501,6 +798,12 @@ export class KakaoTalkClient {
         }
         this.state = null;
         this.initPromise = null;
+        this.pushHandlers.clear();
+        this.sessionEventHandlers.clear();
+        this.nameCache.clear();
+    }
+    lookupAuthorName(chatId, authorId) {
+        return this.nameCache.lookup(chatId, authorId);
     }
 }
 //# sourceMappingURL=client.js.map