agent-messenger 2.12.1 → 2.13.0

package/src/platforms/kakaotalk/client.ts

@@ -9,8 +9,16 @@ import { warn } from '@/shared/utils/stderr'
 
 import { LANG, PC_OS_NAME, getLocoDeviceConfig } from './protocol/config'
 import { LocoSession } from './protocol/session'
-import type { ChatListResponse, LoginListResponse, SyncState } from './protocol/types'
-import type { KakaoChat, KakaoDeviceType, KakaoMessage, KakaoProfile, KakaoSendResult } from './types'
+import type { ChatListResponse, LocoPacket, LoginListResponse, SyncState } from './protocol/types'
+import type { KakaoChat, KakaoDeviceType, KakaoMember, KakaoMessage, KakaoProfile, KakaoSendResult } from './types'
+
+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 class KakaoTalkError extends Error {
   code: string
@@ -29,6 +37,58 @@ interface SessionState {
   loginResult: LoginListResponse
 }
 
+class MemberNameCache {
+  private byChatId = new Map<string, Map<number, string>>()
+
+  ingest(chatDatas: readonly ChatData[]): void {
+    for (const chat of chatDatas) {
+      const ids = chat.i as Array<{ low: number; high: number } | number> | undefined
+      const names = chat.k as string[] | undefined
+      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: string, userId: number): string | null {
+    return this.byChatId.get(chatId)?.get(userId) ?? null
+  }
+
+  forget(chatId: string): void {
+    this.byChatId.delete(chatId)
+  }
+
+  clear(): void {
+    this.byChatId.clear()
+  }
+}
+
+function toNumericUserId(v: unknown): number | null {
+  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 as { low: number; high: number }
+    // 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: unknown): Long | undefined {
   if (v && typeof v === 'object' && 'high' in v && 'low' in v) {
     const { high, low } = v as { high: number; low: number }
@@ -52,20 +112,39 @@ function parseLong(s: string): Long {
   return new Long(low, high)
 }
 
-function formatChat(chat: ChatData): KakaoChat {
+function parseChatId(chatId: string): Long {
+  try {
+    return parseLong(chatId)
+  } catch (cause) {
+    throw new KakaoTalkError(`Invalid chatId: ${chatId}`, 'invalid_chat_id', { cause })
+  }
+}
+
+function parseUserId(userId: string): Long {
+  try {
+    return parseLong(userId)
+  } catch (cause) {
+    throw new KakaoTalkError(`Invalid userId: ${userId}`, 'invalid_user_id', { cause })
+  }
+}
+
+function formatChat(chat: ChatData, title: string | null, nameCache: MemberNameCache): KakaoChat {
   const memberNames = (chat.k ?? []) as string[]
   const lastLog = chat.l as Record<string, unknown> | null
   const displayName = memberNames.join(', ') || null
+  const chatId = String(chat.c)
 
   return {
-    chat_id: String(chat.c),
+    chat_id: chatId,
     type: chat.t as number,
     display_name: displayName,
+    title,
     active_members: chat.a as number,
     unread_count: chat.n as number,
     last_message: lastLog
       ? {
           author_id: lastLog.authorId as number,
+          author_name: nameCache.lookup(chatId, lastLog.authorId as number),
           message: lastLog.message as string,
           sent_at: lastLog.sendAt as number,
         }
@@ -73,6 +152,50 @@ function formatChat(chat: ChatData): KakaoChat {
   }
 }
 
+const META_TYPE_TITLE = 3
+
+interface ChannelMetaEntry {
+  type?: number
+  content?: string
+}
+
+interface ChannelInfoResponse {
+  chatInfo?: {
+    chatMetas?: ChannelMetaEntry[]
+  }
+}
+
+function extractTitle(body: Record<string, unknown>): string | null {
+  const info = (body as ChannelInfoResponse).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
+}
+
+interface OpenLinkInfoResponse {
+  ols?: Array<{ ln?: unknown }>
+}
+
+function extractOpenLinkName(body: Record<string, unknown>): string | null {
+  const ols = (body as OpenLinkInfoResponse).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: ChatData): boolean {
+  return typeof chat.t === 'string' && OPEN_CHAT_TYPES.has(chat.t)
+}
+
+function getOpenLinkId(chat: ChatData): Long | null {
+  return bsonToLong(chat.li) ?? null
+}
+
 function matchesSearch(chat: ChatData, term: string): boolean {
   const names = (chat.k ?? []) as string[]
   const lower = term.toLowerCase()
@@ -214,13 +337,66 @@ function mergeSyncState(previous: SyncState | undefined, loginResult: LoginListR
   return next
 }
 
-function formatMessages(logs: Array<Record<string, unknown>>, count: number): KakaoMessage[] {
+function nullableString(v: unknown): string | null {
+  return typeof v === 'string' && v.length > 0 ? v : null
+}
+
+function nullableNumber(v: unknown): number | null {
+  return typeof v === 'number' && Number.isFinite(v) ? v : null
+}
+
+function isNonZeroLong(v: unknown): boolean {
+  if (typeof v === 'number') return v !== 0
+  if (v && typeof v === 'object' && 'low' in v && 'high' in v) {
+    const { low, high } = v as { low: number; high: number }
+    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: LocoPacket, command: string): void {
+  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: Record<string, unknown>): KakaoMember {
+  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: Array<Record<string, unknown>>,
+  count: number,
+  chatId: string,
+  nameCache: MemberNameCache,
+): KakaoMessage[] {
   logs.sort((a, b) => (a.sendAt as number) - (b.sendAt as number))
 
   return logs.slice(-count).map((log) => ({
     log_id: longToString(log.logId),
     type: log.type as number,
     author_id: log.authorId as number,
+    author_name: nameCache.lookup(chatId, log.authorId as number),
     message: log.message as string,
     sent_at: log.sendAt as number,
   }))
@@ -234,6 +410,9 @@ export class KakaoTalkClient {
   private state: SessionState | null = null
   private initPromise: Promise<SessionState> | null = null
   private closed = false
+  private pushHandlers = new Set<KakaoPushHandler>()
+  private sessionEventHandlers = new Set<KakaoSessionEventHandler>()
+  private nameCache = new MemberNameCache()
 
   async login(
     credentials?: { oauthToken: string; userId: string; deviceUuid?: string; deviceType?: KakaoDeviceType },
@@ -280,6 +459,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()
     }
@@ -291,7 +471,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) {
       // Reset so next call retries cleanly; connect() already wraps in KakaoTalkError
@@ -301,6 +485,29 @@ export class KakaoTalkClient {
     }
   }
 
+  async acquireSession(): Promise<LocoSession> {
+    const state = await this.ensureSession()
+    return state.session
+  }
+
+  onPush(handler: KakaoPushHandler): () => void {
+    this.pushHandlers.add(handler)
+    return () => {
+      this.pushHandlers.delete(handler)
+    }
+  }
+
+  onSessionEvent(handler: KakaoSessionEventHandler): () => void {
+    this.sessionEventHandlers.add(handler)
+    return () => {
+      this.sessionEventHandlers.delete(handler)
+    }
+  }
+
+  isConnected(): boolean {
+    return this.state !== null && !this.closed
+  }
+
   private async executeWithReconnect<T>(operation: (state: SessionState) => Promise<T>): Promise<T> {
     let state = await this.ensureSession()
     try {
@@ -314,7 +521,10 @@ export class KakaoTalkClient {
       try {
         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)
     }
@@ -322,6 +532,15 @@ export class KakaoTalkClient {
 
   private async connect(): Promise<SessionState> {
     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(
@@ -335,12 +554,7 @@ export class KakaoTalkClient {
       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 ?? []) as ChatData[])
 
       return { session, loginResult }
     } catch (error) {
@@ -349,7 +563,61 @@ export class KakaoTalkClient {
     }
   }
 
-  async getChats(options?: { all?: boolean; search?: string }): Promise<KakaoChat[]> {
+  private dispatchPush(session: LocoSession, packet: LocoPacket): void {
+    // 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 {}
+    }
+  }
+
+  private invalidateSession(session: LocoSession): void {
+    if (this.state?.session === session) {
+      this.state = null
+      this.initPromise = null
+    }
+    try {
+      session.close()
+    } catch {}
+  }
+
+  private emitSessionEvent(event: KakaoSessionEvent): void {
+    for (const handler of this.sessionEventHandlers) {
+      try {
+        handler(event)
+      } catch {}
+    }
+  }
+
+  async getChats(options?: { all?: boolean; search?: string; resolveTitles?: boolean }): Promise<KakaoChat[]> {
     return this.executeWithReconnect(async ({ session, loginResult }) => {
       try {
         const allChats: ChatData[] = []
@@ -383,6 +651,7 @@ export class KakaoTalkClient {
             if (chatDatas.length === 0) break
 
             collectChats(chatDatas, allChats, seenChatIds)
+            this.nameCache.ingest(chatDatas)
             cursor = body
             pages++
           }
@@ -395,13 +664,58 @@ export class KakaoTalkClient {
           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: string): Promise<string | null> {
+    let parsed: Long
+    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)
+    })
+  }
+
+  private async fetchChatTitle(session: LocoSession, chatId: Long, chat: ChatData | undefined): Promise<string | null> {
+    let title: string | null = null
+    try {
+      const response = await session.getChannelInfo(chatId)
+      title = extractTitle(response.body as Record<string, unknown>)
+    } 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 as Record<string, unknown>)
+    } catch {
+      return null
+    }
+  }
+
   async getMessages(chatId: string, options?: { count?: number; from?: string }): Promise<KakaoMessage[]> {
     return this.executeWithReconnect(async ({ session }) => {
       try {
@@ -426,7 +740,7 @@ export class KakaoTalkClient {
               (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) {
@@ -439,7 +753,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
@@ -452,7 +766,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)
@@ -489,13 +803,43 @@ export class KakaoTalkClient {
           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: string): Promise<KakaoMember[]> {
+    const parsedChatId = parseChatId(chatId)
+    return this.executeWithReconnect(async ({ session }) => {
+      try {
+        const response = await session.getAllMembers(parsedChatId)
+        assertLocoOk(response, 'GETMEM')
+        const members = (response.body.members ?? []) as Array<Record<string, unknown>>
+        return members.map(formatMember)
+      } catch (error) {
+        throw wrapError(error, 'get_members_failed')
+      }
+    })
+  }
+
+  async getMembersByIds(chatId: string, userIds: string[]): Promise<KakaoMember[]> {
+    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 ?? []) as Array<Record<string, unknown>>
+        return members.map(formatMember)
+      } catch (error) {
+        throw wrapError(error, 'get_members_failed')
+      }
+    })
+  }
+
   async sendMessage(chatId: string, text: string): Promise<KakaoSendResult> {
     return this.executeWithReconnect(async ({ session }) => {
       try {
@@ -584,5 +928,12 @@ export class KakaoTalkClient {
     }
     this.state = null
     this.initPromise = null
+    this.pushHandlers.clear()
+    this.sessionEventHandlers.clear()
+    this.nameCache.clear()
+  }
+
+  lookupAuthorName(chatId: string, authorId: number): string | null {
+    return this.nameCache.lookup(chatId, authorId)
   }
 }

package/src/platforms/kakaotalk/commands/chat.ts

@@ -9,11 +9,12 @@ async function listAction(options: {
   account?: string
   all?: boolean
   search?: string
+  resolveTitles?: boolean
   pretty?: boolean
 }): Promise<void> {
   try {
     const chats = await withKakaoClient(options, (client) =>
-      client.getChats({ all: options.all, search: options.search }),
+      client.getChats({ all: options.all, search: options.search, resolveTitles: options.resolveTitles }),
     )
     console.log(formatOutput(chats, options.pretty))
   } catch (error) {
@@ -29,6 +30,7 @@ export const chatCommand = new Command('chat')
       .option('--account <id>', 'Use a specific KakaoTalk account')
       .option('--all', 'Fetch all chats (paginate beyond login snapshot)')
       .option('--search <name>', 'Search for a chat by display name')
+      .option('--resolve-titles', 'Fetch user-set room titles via CHATINFO (slower; one extra LOCO call per chat)')
       .option('--pretty', 'Pretty print JSON output')
       .action(listAction),
   )

package/src/platforms/kakaotalk/commands/index.ts

@@ -1,4 +1,5 @@
 export { authCommand } from './auth'
 export { chatCommand } from './chat'
+export { memberCommand } from './member'
 export { messageCommand } from './message'
 export { whoamiCommand } from './whoami'

package/src/platforms/kakaotalk/commands/member.test.ts

@@ -0,0 +1,102 @@
+import { afterEach, beforeEach, describe, expect, mock, it } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+const mockWithKakaoClient = mock(async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+  return fn(mockClient)
+})
+
+const mockGetMembers = mock(() =>
+  Promise.resolve([
+    {
+      user_id: '42',
+      nickname: 'Alice',
+      profile_image_url: null,
+      full_profile_image_url: null,
+      original_profile_image_url: null,
+      status_message: null,
+      country_iso: null,
+      user_type: 100,
+      open_token: null,
+      open_profile_link_id: null,
+      open_permission: null,
+    },
+  ]),
+)
+
+const mockClient = {
+  getMembers: mockGetMembers,
+}
+
+mock.module('./shared', () => ({
+  withKakaoClient: mockWithKakaoClient,
+}))
+
+import { memberCommand } from './member'
+
+describe('member commands', () => {
+  let consoleLogSpy: ReturnType<typeof mock>
+
+  beforeEach(() => {
+    mockWithKakaoClient.mockReset()
+    mockGetMembers.mockReset()
+
+    mockWithKakaoClient.mockImplementation(async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+      return fn(mockClient)
+    })
+    mockGetMembers.mockImplementation(() =>
+      Promise.resolve([
+        {
+          user_id: '42',
+          nickname: 'Alice',
+          profile_image_url: null,
+          full_profile_image_url: null,
+          original_profile_image_url: null,
+          status_message: null,
+          country_iso: null,
+          user_type: 100,
+          open_token: null,
+          open_profile_link_id: null,
+          open_permission: null,
+        },
+      ]),
+    )
+
+    consoleLogSpy = mock((..._args: unknown[]) => {})
+    console.log = consoleLogSpy
+  })
+
+  afterEach(() => {
+    console.log = originalConsoleLog
+  })
+
+  describe('list', () => {
+    it('lists members of a chat room', async () => {
+      await memberCommand.parseAsync(['list', '9876543210'], { from: 'user' })
+
+      expect(mockGetMembers).toHaveBeenCalledWith('9876543210')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toHaveLength(1)
+      expect(output[0].user_id).toBe('42')
+      expect(output[0].nickname).toBe('Alice')
+    })
+
+    it('passes --account option to withKakaoClient', async () => {
+      await memberCommand.parseAsync(['list', '9876543210', '--account', 'my-account'], { from: 'user' })
+
+      expect(mockWithKakaoClient).toHaveBeenCalledWith(
+        expect.objectContaining({ account: 'my-account' }),
+        expect.any(Function),
+      )
+    })
+
+    it('outputs empty array when chat has no members', async () => {
+      mockGetMembers.mockImplementation(() => Promise.resolve([]))
+
+      await memberCommand.parseAsync(['list', '9876543210'], { from: 'user' })
+
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toEqual([])
+    })
+  })
+})