agent-messenger 2.37.0 → 2.37.1

package/src/platforms/kakaotalk/client.ts

@@ -12,6 +12,7 @@ import { isOpenKakaoChatType } from './chat-classifier'
 import { detectImageDimensions } from './image-meta'
 import { sha1Hex } from './media-upload'
 import { LANG, PC_OS_NAME, getLocoDeviceConfig } from './protocol/config'
+import { isSyntheticConnectionClose } from './protocol/login-response'
 import { uploadMediaToLoco, uploadMultiMediaEntry } from './protocol/media-uploader'
 import { LocoSession } from './protocol/session'
 import type { ChatListResponse, LocoPacket, LoginListResponse, SyncState } from './protocol/types'
@@ -41,15 +42,57 @@ export type KakaoSessionEvent =
 export type KakaoPushHandler = (packet: LocoPacket) => void
 export type KakaoSessionEventHandler = (event: KakaoSessionEvent) => void
 
+export type KakaoTalkResponseFailureKind = 'provider_rejection' | 'transient_or_unknown'
+export type KakaoTalkResponseStatusSource = 'packet' | 'body'
+export type KakaoTalkGetChatFailureReason =
+  | 'provider_rejection'
+  | 'synthetic_connection_close'
+  | 'chat_info_absent'
+  | 'transport_or_unknown'
+
 export class KakaoTalkError extends Error {
   code: string
   readonly serverStatus?: number
-
-  constructor(message: string, code: string, options?: { cause?: unknown; serverStatus?: number }) {
+  readonly responseFailureKind?: KakaoTalkResponseFailureKind
+  readonly responseStatusSource?: KakaoTalkResponseStatusSource
+  readonly getChatFailureReason?: KakaoTalkGetChatFailureReason
+
+  constructor(
+    message: string,
+    code: string,
+    options?: {
+      cause?: unknown
+      serverStatus?: number
+      responseFailureKind?: KakaoTalkResponseFailureKind
+      responseStatusSource?: KakaoTalkResponseStatusSource
+      getChatFailureReason?: KakaoTalkGetChatFailureReason
+    },
+  ) {
     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 {
+  readonly serverStatus?: number
+  readonly responseFailureKind: KakaoTalkResponseFailureKind
+  readonly responseStatusSource?: KakaoTalkResponseStatusSource
+
+  constructor(
+    message: string,
+    responseFailureKind: KakaoTalkResponseFailureKind,
+    options?: { serverStatus?: number; responseStatusSource?: KakaoTalkResponseStatusSource },
+  ) {
+    super(message)
+    this.name = 'LocoResponseError'
+    this.serverStatus = options?.serverStatus
+    this.responseFailureKind = responseFailureKind
+    this.responseStatusSource = options?.responseStatusSource
   }
 }
 
@@ -187,7 +230,7 @@ function formatChat(chat: ChatData, title: string | null, nameCache: MemberNameC
 
   return {
     chat_id: chatId,
-    type: chat.t as KakaoChat['type'],
+    type: requiredChatType(chat.t),
     display_name: displayName,
     title,
     active_members: chat.a as number,
@@ -258,7 +301,7 @@ function requiredNonNegativeInteger(value: unknown, field: string): number {
 }
 
 function requiredChatType(value: unknown): KakaoChat['type'] {
-  if (typeof value === 'string' && isOpenKakaoChatType(value)) {
+  if (typeof value === 'string' && value.length > 0) {
     return value
   }
   return requiredNonNegativeInteger(value, 'type')
@@ -352,10 +395,46 @@ function collectChats(chatDatas: ChatData[], into: ChatData[], seen: Set<string>
   }
 }
 
-function wrapError(error: unknown, code: string): KakaoTalkError {
-  if (error instanceof KakaoTalkError) return error
+function wrapError(
+  error: unknown,
+  code: string,
+  options?: { classifyResponseFailure?: boolean; classifyGetChatFailure?: boolean },
+): KakaoTalkError {
+  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(
@@ -502,12 +581,27 @@ function isNonZeroLong(v: unknown): boolean {
 // 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 (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',
+    })
   }
 }
 
@@ -946,6 +1040,7 @@ export class KakaoTalkClient {
         if (options?.all || options?.search || snapshotEmpty) {
           let cursor: ChatListResponse = 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
@@ -958,15 +1053,28 @@ export class KakaoTalkClient {
             const lastChatId = bsonToLong(cursor.lastChatId)
 
             const response = await session.getChatList(lastTokenId, lastChatId)
+            if (requireCompleteList) assertLocoOk(response, 'LCHATLIST')
             const body = response.body as unknown as ChatListResponse
+            if (requireCompleteList && !Array.isArray(body.chatDatas)) {
+              throw new Error('LCHATLIST pagination incomplete: chatDatas unavailable')
+            }
             const chatDatas = (body.chatDatas ?? []) as ChatData[]
+            cursor = body
+            pages++
 
-            if (chatDatas.length === 0) break
+            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`)
           }
         }
 
@@ -996,6 +1104,9 @@ export class KakaoTalkClient {
    * 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: string): Promise<KakaoChat> {
     const parsedChatId = parseChatId(chatId)
@@ -1005,6 +1116,21 @@ export class KakaoTalkClient {
         const response = await session.getChannelInfo(parsedChatId)
         assertLocoOk(response, 'CHATINFO')
         const body = response.body as Record<string, unknown>
+        const chatInfo = body.chatInfo
+        const isLeftChatInfo =
+          chatInfo !== null &&
+          typeof chatInfo === 'object' &&
+          !Array.isArray(chatInfo) &&
+          (chatInfo as Record<string, unknown>).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])
 
@@ -1023,7 +1149,10 @@ export class KakaoTalkClient {
 
         return formatChat(chat, title, this.nameCache)
       } catch (error) {
-        throw wrapError(error, 'get_chat_failed')
+        throw wrapError(error, 'get_chat_failed', {
+          classifyResponseFailure: true,
+          classifyGetChatFailure: true,
+        })
       }
     })
   }

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

@@ -49,6 +49,33 @@ it('KakaoChatSchema is exported from barrel', () => {
   expect(typeof KakaoChatSchema.parse).toBe('function')
 })
 
+it('KakaoChatSchema preserves a non-empty string channel type', () => {
+  for (const channelType of ['DirectChat', 'MultiChat', 'PlusChat', 'MemoChat', 'OM', 'OD', 'FutureChat']) {
+    expect(
+      KakaoChatSchema.parse({
+        chat_id: '300',
+        type: channelType,
+        display_name: null,
+        title: null,
+        active_members: 2,
+        unread_count: 0,
+        last_message: null,
+      }).type,
+    ).toBe(channelType)
+  }
+  expect(() =>
+    KakaoChatSchema.parse({
+      chat_id: '300',
+      type: '',
+      display_name: null,
+      title: null,
+      active_members: 2,
+      unread_count: 0,
+      last_message: null,
+    }),
+  ).toThrow()
+})
+
 it('KakaoMessageSchema is exported from barrel', () => {
   expect(typeof KakaoMessageSchema.parse).toBe('function')
 })

package/src/platforms/kakaotalk/index.ts

@@ -1,4 +1,9 @@
 export { KakaoTalkClient, KakaoTalkError } from './client'
+export type {
+  KakaoTalkGetChatFailureReason,
+  KakaoTalkResponseFailureKind,
+  KakaoTalkResponseStatusSource,
+} from './client'
 export { classifyKakaoChat, isOpenKakaoChatType } from './chat-classifier'
 export type { KakaoChatKind } from './chat-classifier'
 export { KakaoCredentialManager, CredentialManager } from './credential-manager'

package/src/platforms/kakaotalk/protocol/connection.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'bun:test'
+
+import { LocoConnection } from './connection'
+import { encodePacket } from './packet'
+import type { LocoPacket } from './types'
+
+interface ConnectionInternals {
+  socket: {
+    write: (data: Buffer, callback: (error?: Error) => void) => boolean
+  } | null
+  pendingResolvers: Map<number, unknown>
+  timedOutIds: Set<number>
+  onData: (chunk: Buffer) => void
+}
+
+function internals(connection: LocoConnection): ConnectionInternals {
+  return connection as unknown as ConnectionInternals
+}
+
+describe('LocoConnection.sendPacket', () => {
+  it('resolves a response delivered synchronously during write without double settlement', async () => {
+    const connection = new LocoConnection()
+    const owned = internals(connection)
+    const response: LocoPacket = {
+      packetId: 1,
+      statusCode: 0,
+      method: 'FAST',
+      bodyType: 0,
+      body: { accepted: true },
+    }
+    const pushed: LocoPacket[] = []
+    connection.onPush((packet) => pushed.push(packet))
+    owned.socket = {
+      write: (_data, callback) => {
+        owned.onData(encodePacket(response))
+        callback(new Error('late write callback failure'))
+        return false
+      },
+    }
+
+    await expect(connection.sendPacket('FAST')).resolves.toEqual(response)
+    expect(pushed).toEqual([])
+    expect(owned.pendingResolvers.size).toBe(0)
+    expect(owned.timedOutIds.size).toBe(0)
+  })
+
+  it('rejects a write failure and clears only its pending entry', async () => {
+    const connection = new LocoConnection()
+    const owned = internals(connection)
+    const pushed: LocoPacket[] = []
+    const sentinelTimer = setTimeout(() => {}, 60_000)
+    const sentinel = { resolve: () => {}, timer: sentinelTimer }
+    owned.pendingResolvers.set(99, sentinel)
+    connection.onPush((packet) => pushed.push(packet))
+    owned.socket = {
+      write: (_data, callback) => {
+        callback(new Error('socket write failed'))
+        return false
+      },
+    }
+
+    try {
+      await expect(connection.sendPacket('FAIL')).rejects.toThrow('socket write failed')
+      expect(owned.pendingResolvers.size).toBe(1)
+      expect(owned.pendingResolvers.get(99)).toBe(sentinel)
+      expect(owned.timedOutIds.has(1)).toBe(true)
+
+      owned.onData(
+        encodePacket({
+          packetId: 1,
+          statusCode: 0,
+          method: 'FAIL',
+          bodyType: 0,
+          body: { late: true },
+        }),
+      )
+
+      expect(pushed).toEqual([])
+      expect(owned.pendingResolvers.size).toBe(1)
+      expect(owned.pendingResolvers.get(99)).toBe(sentinel)
+      expect(owned.timedOutIds.size).toBe(0)
+    } finally {
+      clearTimeout(sentinelTimer)
+      owned.pendingResolvers.delete(99)
+    }
+  })
+})

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

@@ -73,15 +73,28 @@ export class LocoConnection {
 
     const raw = encodePacket(packet)
     const data = this.crypto ? this.crypto.encrypt(raw) : raw
-    await this.write(data)
 
     return new Promise((resolve, reject) => {
+      let entry: {
+        resolve: (packet: LocoPacket) => void
+        timer: ReturnType<typeof setTimeout>
+      }
       const timer = setTimeout(() => {
+        if (this.pendingResolvers.get(packetId) !== entry) return
         this.pendingResolvers.delete(packetId)
         this.timedOutIds.add(packetId)
         reject(new Error(`LOCO packet timeout: ${method} (${DEFAULT_SEND_TIMEOUT_MS}ms)`))
       }, DEFAULT_SEND_TIMEOUT_MS)
-      this.pendingResolvers.set(packetId, { resolve, timer })
+      entry = { resolve, timer }
+      this.pendingResolvers.set(packetId, entry)
+
+      void this.write(data).catch((error: unknown) => {
+        if (this.pendingResolvers.get(packetId) !== entry) return
+        clearTimeout(entry.timer)
+        this.pendingResolvers.delete(packetId)
+        this.timedOutIds.add(packetId)
+        reject(error)
+      })
     })
   }
 

package/src/platforms/kakaotalk/protocol/login-response.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'bun:test'
 
-import { validateLoginListResponse } from './login-response'
+import { isSyntheticConnectionClose, validateLoginListResponse } from './login-response'
 import type { LocoPacket } from './types'
 
 function packet(statusCode: number, body: Record<string, unknown>): LocoPacket {
@@ -54,11 +54,22 @@ describe('LOGINLIST response classification', () => {
   })
 
   it('keeps a synthetic socket close on the transport-error path', () => {
-    const error = captureError(() => validateLoginListResponse(packet(-1, { error: 'connection closed' })))
+    const response = packet(-1, { error: 'connection closed' })
+    const error = captureError(() => validateLoginListResponse(response))
 
+    expect(isSyntheticConnectionClose(response)).toBe(true)
     expect(error).toBeInstanceOf(Error)
     expect(error).toMatchObject({ message: 'KakaoTalk LOGINLIST transport failed: connection closed' })
     expect(error).not.toHaveProperty('code')
     expect(error).not.toHaveProperty('serverStatus')
   })
+
+  it('does not classify status -1 with a nonmatching body as a synthetic socket close', () => {
+    const response = packet(-1, { error: 'provider rejected' })
+
+    expect(isSyntheticConnectionClose(response)).toBe(false)
+    expect(() => validateLoginListResponse(response)).toThrow(
+      expect.objectContaining({ code: 'login_rejected', serverStatus: -1 }),
+    )
+  })
 })

package/src/platforms/kakaotalk/protocol/login-response.ts

@@ -17,7 +17,7 @@ export class KakaoLoginResponseError extends Error {
   }
 }
 
-function isSyntheticConnectionClose(response: LocoPacket): boolean {
+export function isSyntheticConnectionClose(response: LocoPacket): boolean {
   return response.statusCode === CONNECTION_CLOSED_STATUS && response.body.error === 'connection closed'
 }
 

package/src/platforms/kakaotalk/types.ts

@@ -71,7 +71,15 @@ export const KAKAO_NEXT_ACTIONS: Record<string, { next_action: string; message:
 }
 
 export type KakaoOpenChatType = 2 | 13 | 14 | 15 | 16 | 'OM' | 'OD'
-export type KakaoChatType = number | Extract<KakaoOpenChatType, string>
+export const KNOWN_KAKAO_CHAT_STRING_TYPES = ['DirectChat', 'MultiChat', 'PlusChat', 'MemoChat', 'OM', 'OD'] as const
+export type KakaoChatType = number | string
+
+export function isKnownKakaoChatStringType(value: unknown): value is (typeof KNOWN_KAKAO_CHAT_STRING_TYPES)[number] {
+  return (
+    typeof value === 'string' &&
+    KNOWN_KAKAO_CHAT_STRING_TYPES.includes(value as (typeof KNOWN_KAKAO_CHAT_STRING_TYPES)[number])
+  )
+}
 
 export interface KakaoChat {
   chat_id: string
@@ -239,7 +247,7 @@ export interface KakaoTypingResult {
 
 export const KakaoChatSchema = z.object({
   chat_id: z.string(),
-  type: z.union([z.number(), z.literal('OM'), z.literal('OD')]),
+  type: z.union([z.number(), z.string().min(1)]),
   display_name: z.string().nullable(),
   title: z.string().nullable(),
   active_members: z.number(),