agent-messenger 2.12.1 → 2.13.0

package/src/platforms/kakaotalk/listener.ts

@@ -1,7 +1,6 @@
 import { EventEmitter } from 'events'
 
-import type { KakaoTalkClient } from './client'
-import { LocoSession } from './protocol/session'
+import type { KakaoSessionEvent, KakaoTalkClient } from './client'
 import type { LocoPacket } from './protocol/types'
 import type {
   KakaoTalkListenerEventMap,
@@ -11,9 +10,6 @@ import type {
   KakaoTalkPushReadEvent,
 } from './types'
 
-const RECONNECT_BASE_DELAY = 1_000
-const RECONNECT_MAX_DELAY = 30_000
-
 type EventKey = keyof KakaoTalkListenerEventMap
 
 function longToString(v: unknown): string {
@@ -27,11 +23,9 @@ function longToString(v: unknown): string {
 export class KakaoTalkListener {
   private client: KakaoTalkClient
   private running = false
-  private session: LocoSession | null = null
   private emitter = new EventEmitter()
-  private reconnectTimer: ReturnType<typeof setTimeout> | null = null
-  private reconnectAttempts = 0
-  private userId: string | null = null
+  private unsubscribePush: (() => void) | null = null
+  private unsubscribeSession: (() => void) | null = null
 
   constructor(client: KakaoTalkClient) {
     this.client = client
@@ -40,17 +34,33 @@ export class KakaoTalkListener {
   async start(): Promise<void> {
     if (this.running) return
     this.running = true
-    this.reconnectAttempts = 0
-    await this.connect()
+
+    this.unsubscribePush = this.client.onPush((packet) => this.handlePush(packet))
+    this.unsubscribeSession = this.client.onSessionEvent((event) => this.handleSessionEvent(event))
+
+    const alreadyConnected = this.client.isConnected()
+
+    try {
+      await this.client.acquireSession()
+      if (!this.running) return
+      if (alreadyConnected) {
+        const { userId } = this.client.getCredentials()
+        this.emitter.emit('connected', { userId })
+      }
+    } catch (error) {
+      this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
+      this.running = false
+      this.teardown()
+    }
   }
 
   stop(): void {
-    this.running = false
-    this.clearTimers()
-    if (this.session) {
-      this.session.close()
-      this.session = null
+    if (!this.running) {
+      this.teardown()
+      return
     }
+    this.running = false
+    this.teardown()
   }
 
   on<K extends EventKey>(event: K, listener: (...args: KakaoTalkListenerEventMap[K]) => void): this {
@@ -68,41 +78,28 @@ export class KakaoTalkListener {
     return this
   }
 
-  private async connect(): Promise<void> {
-    if (!this.running) return
-
-    try {
-      const { oauthToken, userId, deviceUuid, deviceType } = this.client.getCredentials()
-      if (!this.running) return
-
-      this.userId = userId
-      const session = new LocoSession()
-
-      session.onPush((packet) => this.handlePush(packet))
-      session.onClose(() => {
-        if (this.session !== session) return
-        this.session = null
-        if (this.running) {
-          this.emitter.emit('disconnected')
-          this.scheduleReconnect()
-        }
-      })
-
-      await session.login(oauthToken, userId, deviceUuid, undefined, deviceType)
+  private teardown(): void {
+    this.unsubscribePush?.()
+    this.unsubscribePush = null
+    this.unsubscribeSession?.()
+    this.unsubscribeSession = null
+  }
 
-      if (!this.running) {
-        session.close()
-        return
-      }
+  private handleSessionEvent(event: KakaoSessionEvent): void {
+    if (!this.running) return
 
-      this.reconnectAttempts = 0
-      this.session = session
-      this.emitter.emit('connected', { userId })
-    } catch (error) {
-      this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
-      if (this.running) {
-        this.scheduleReconnect()
-      }
+    switch (event.type) {
+      case 'connected':
+        this.emitter.emit('connected', { userId: event.userId })
+        break
+      case 'disconnected':
+        this.emitter.emit('disconnected')
+        break
+      case 'kicked':
+        this.emitter.emit('error', new Error(event.reason))
+        this.running = false
+        this.teardown()
+        break
     }
   }
 
@@ -112,11 +109,14 @@ export class KakaoTalkListener {
     switch (method) {
       case 'MSG': {
         const chatLog = body.chatLog as Record<string, unknown>
+        const chatId = longToString(body.chatId)
+        const authorId = chatLog.authorId as number
         const event: KakaoTalkPushMessageEvent = {
           type: 'MSG',
-          chat_id: longToString(body.chatId),
+          chat_id: chatId,
           log_id: longToString(chatLog.logId),
-          author_id: chatLog.authorId as number,
+          author_id: authorId,
+          author_name: this.client.lookupAuthorName?.(chatId, authorId) ?? null,
           message: chatLog.message as string,
           message_type: chatLog.type as number,
           sent_at: chatLog.sendAt as number,
@@ -162,23 +162,6 @@ export class KakaoTalkListener {
         break
       }
 
-      case 'CHANGESVR': {
-        this.reconnectAttempts = 0
-        const prev = this.session
-        this.session = null
-        prev?.close()
-        this.connect()
-        break
-      }
-
-      case 'KICKOUT': {
-        this.emitter.emit('error', new Error('Session kicked — another device logged in'))
-        this.running = false
-        this.session?.close()
-        this.session = null
-        break
-      }
-
       default: {
         const event: KakaoTalkPushGenericEvent = { type: method, ...body }
         this.emitter.emit('kakaotalk_event', event)
@@ -186,18 +169,4 @@ export class KakaoTalkListener {
       }
     }
   }
-
-  private scheduleReconnect(): void {
-    this.clearTimers()
-    const delay = Math.min(RECONNECT_BASE_DELAY * 2 ** this.reconnectAttempts, RECONNECT_MAX_DELAY)
-    this.reconnectAttempts++
-    this.reconnectTimer = setTimeout(() => this.connect(), delay)
-  }
-
-  private clearTimers(): void {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer)
-      this.reconnectTimer = null
-    }
-  }
 }

package/src/platforms/kakaotalk/protocol/session.ts

@@ -149,6 +149,50 @@ export class LocoSession {
     return this.connection.sendPacket('CHATONROOM', { chatId })
   }
 
+  /**
+   * Fetch detailed channel info (CHATINFO). Unlike CHATONROOM, this returns
+   * a `chatInfo` sub-document containing `chatMetas` (room title, notice, etc.)
+   * and `displayMembers` (user_id ↔ nickname pairs). Used to resolve the
+   * canonical user-set room title.
+   */
+  async getChannelInfo(chatId: Long): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('CHATINFO', { chatId })
+  }
+
+  /**
+   * Fetch open-link info (INFOLINK) for one or more openchat links. The
+   * response body has shape `{ ols: OpenLinkStruct[] }` where each struct's
+   * `ln` field carries the open-chat link name — the canonical fallback when
+   * an open chat has no user-set TITLE meta.
+   */
+  async getOpenLinkInfo(linkIds: Long[]): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('INFOLINK', { lis: linkIds })
+  }
+
+  /**
+   * Fetch the full member list for a chat (GETMEM). Response body has shape
+   * `{ members: NormalMemberStruct[] | OpenMemberStruct[], token: number }`.
+   * Use this to resolve nicknames for users not present in the chat list's
+   * "display members" cache — necessary for groups with more than ~5 members.
+   */
+  async getAllMembers(chatId: Long): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('GETMEM', { chatId })
+  }
+
+  /**
+   * Fetch info for a specific subset of members in a chat (MEMBER). Response
+   * body has shape `{ chatId, members: NormalMemberStruct[] | OpenMemberStruct[] }`.
+   * Useful when you already have user IDs (e.g. from a CHATONROOM `mi` array
+   * for >100-member rooms) and only need to resolve a few of them.
+   */
+  async getMembersByIds(chatId: Long, memberIds: Long[]): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('MEMBER', { chatId, memberIds })
+  }
+
   async getChatList(lastTokenId?: Long, lastChatId?: Long): Promise<LocoPacket> {
     if (!this.connection) throw new Error('Not connected')
     return this.connection.sendPacket('LCHATLIST', {

package/src/platforms/kakaotalk/types.ts

@@ -73,10 +73,12 @@ export interface KakaoChat {
   chat_id: string
   type: number
   display_name: string | null
+  title: string | null
   active_members: number
   unread_count: number
   last_message: {
     author_id: number
+    author_name: string | null
     message: string
     sent_at: number
   } | null
@@ -86,10 +88,28 @@ export interface KakaoMessage {
   log_id: string
   type: number
   author_id: number
+  author_name: string | null
   message: string
   sent_at: number
 }
 
+export interface KakaoMember {
+  user_id: string
+  nickname: string
+  profile_image_url: string | null
+  full_profile_image_url: string | null
+  original_profile_image_url: string | null
+  status_message: string | null
+  country_iso: string | null
+  /** KakaoTalk UserType: 100=FRIEND, 1000=OPEN_PROFILE, etc. `null` when the server omits the field. */
+  user_type: number | null
+  /** Open-chat-only fields below; `null` for normal chats. */
+  open_token: number | null
+  open_profile_link_id: string | null
+  /** OpenChannelUserPerm bitfield: 1=OWNER, 2=NONE, 4=MANAGER, 8=BOT. Forward-compatible with future values. */
+  open_permission: number | null
+}
+
 export interface KakaoSendResult {
   success: boolean
   status_code: number
@@ -102,11 +122,13 @@ export const KakaoChatSchema = z.object({
   chat_id: z.string(),
   type: z.number(),
   display_name: z.string().nullable(),
+  title: z.string().nullable(),
   active_members: z.number(),
   unread_count: z.number(),
   last_message: z
     .object({
       author_id: z.number(),
+      author_name: z.string().nullable(),
       message: z.string(),
       sent_at: z.number(),
     })
@@ -117,10 +139,25 @@ export const KakaoMessageSchema = z.object({
   log_id: z.string(),
   type: z.number(),
   author_id: z.number(),
+  author_name: z.string().nullable(),
   message: z.string(),
   sent_at: z.number(),
 })
 
+export const KakaoMemberSchema = z.object({
+  user_id: z.string(),
+  nickname: z.string(),
+  profile_image_url: z.string().nullable(),
+  full_profile_image_url: z.string().nullable(),
+  original_profile_image_url: z.string().nullable(),
+  status_message: z.string().nullable(),
+  country_iso: z.string().nullable(),
+  user_type: z.number().nullable(),
+  open_token: z.number().nullable(),
+  open_profile_link_id: z.string().nullable(),
+  open_permission: z.number().nullable(),
+})
+
 export const KakaoSendResultSchema = z.object({
   success: z.boolean(),
   status_code: z.number(),
@@ -183,6 +220,7 @@ export interface KakaoTalkPushMessageEvent {
   chat_id: string
   log_id: string
   author_id: number
+  author_name: string | null
   message: string
   message_type: number
   sent_at: number
@@ -228,6 +266,7 @@ export const KakaoTalkPushMessageEventSchema = z.object({
   chat_id: z.string(),
   log_id: z.string(),
   author_id: z.number(),
+  author_name: z.string().nullable(),
   message: z.string(),
   message_type: z.number(),
   sent_at: z.number(),

package/src/platforms/slackbot/client.test.ts

@@ -243,6 +243,73 @@ describe('SlackBotClient', () => {
       expect(result.ts).toBe('1234567890.123456')
       expect(result.text).toBe('Hello')
     })
+
+    it('does not pass blocks/attachments when omitted', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.postMessage('C123', 'Hello')
+
+      // then
+      expect(mockChat.postMessage).toHaveBeenCalledWith({
+        channel: 'C123',
+        text: 'Hello',
+        thread_ts: undefined,
+        blocks: undefined,
+        attachments: undefined,
+        unfurl_links: undefined,
+        unfurl_media: undefined,
+        mrkdwn: undefined,
+      })
+    })
+
+    it('forwards blocks to chat.postMessage', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+      const blocks = [
+        {
+          type: 'section',
+          text: { type: 'mrkdwn', text: '*hello*' },
+        },
+      ]
+
+      // when
+      await client.postMessage('C123', 'Hello', { blocks })
+
+      // then
+      expect(mockChat.postMessage).toHaveBeenCalledWith(
+        expect.objectContaining({ channel: 'C123', text: 'Hello', blocks }),
+      )
+    })
+
+    it('forwards thread_ts, attachments, and unfurl/mrkdwn flags', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+      const attachments = [{ text: 'attached' }]
+
+      // when
+      await client.postMessage('C123', 'Hello', {
+        thread_ts: '1234567890.000001',
+        attachments,
+        unfurl_links: false,
+        unfurl_media: false,
+        mrkdwn: true,
+      })
+
+      // then
+      expect(mockChat.postMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          channel: 'C123',
+          text: 'Hello',
+          thread_ts: '1234567890.000001',
+          attachments,
+          unfurl_links: false,
+          unfurl_media: false,
+          mrkdwn: true,
+        }),
+      )
+    })
   })
 
   describe('getConversationHistory', () => {

package/src/platforms/slackbot/client.ts

@@ -103,12 +103,28 @@ export class SlackBotClient {
     })
   }
 
-  async postMessage(channel: string, text: string, options?: { thread_ts?: string }): Promise<SlackMessage> {
+  async postMessage(
+    channel: string,
+    text: string,
+    options?: {
+      thread_ts?: string
+      blocks?: unknown[]
+      attachments?: unknown[]
+      unfurl_links?: boolean
+      unfurl_media?: boolean
+      mrkdwn?: boolean
+    },
+  ): Promise<SlackMessage> {
     return this.withRetry(async () => {
       const response = await this.ensureAuth().chat.postMessage({
         channel,
         text,
         thread_ts: options?.thread_ts,
+        blocks: options?.blocks as any,
+        attachments: options?.attachments as any,
+        unfurl_links: options?.unfurl_links,
+        unfurl_media: options?.unfurl_media,
+        mrkdwn: options?.mrkdwn,
       })
       this.checkResponse(response)
 

package/src/tui/adapters/kakaotalk-adapter.ts

@@ -26,10 +26,10 @@ export class KakaoTalkAdapter implements PlatformAdapter {
 
   async getChannels(): Promise<UnifiedChannel[]> {
     const client = this.ensureClient()
-    const chats = await client.getChats()
+    const chats = await client.getChats({ resolveTitles: true })
     return chats.map((chat) => ({
       id: chat.chat_id,
-      name: chat.display_name || `Chat ${chat.chat_id}`,
+      name: chat.title || chat.display_name || `Chat ${chat.chat_id}`,
     }))
   }
 
@@ -39,7 +39,7 @@ export class KakaoTalkAdapter implements PlatformAdapter {
     return messages.map((msg) => ({
       id: msg.log_id,
       channelId,
-      author: String(msg.author_id),
+      author: msg.author_name || String(msg.author_id),
       content: msg.message ?? '',
       timestamp: String(msg.sent_at),
     }))