agent-messenger 2.36.1 → 2.37.1

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

@@ -10,10 +10,12 @@ import {
   KakaoChatSchema,
   KakaoConfigSchema,
   KakaoLeaveChatResultSchema,
+  KakaoMessagePageSchema,
   KakaoMessageSchema,
   KakaoSendResultSchema,
   KakaoTalkClient,
   KakaoTalkError,
+  isOpenKakaoChatType,
   KakaoTalkListener,
   KakaoTalkPushMemberEventSchema,
   KakaoTalkPushMessageEventSchema,
@@ -47,10 +49,41 @@ 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')
 })
 
+it('KakaoMessagePageSchema is exported from barrel', () => {
+  expect(typeof KakaoMessagePageSchema.parse).toBe('function')
+})
+
 it('KakaoSendResultSchema is exported from barrel', () => {
   expect(typeof KakaoSendResultSchema.parse).toBe('function')
 })
@@ -83,6 +116,12 @@ it('classifyKakaoChat is exported from barrel', () => {
   expect(typeof classifyKakaoChat).toBe('function')
 })
 
+it('isOpenKakaoChatType is exported from barrel', () => {
+  expect(isOpenKakaoChatType('OM')).toBe(true)
+  expect(isOpenKakaoChatType(13)).toBe(true)
+  expect(isOpenKakaoChatType('UNKNOWN')).toBe(false)
+})
+
 it('KakaoLeaveChatResultSchema is exported from barrel', () => {
   expect(typeof KakaoLeaveChatResultSchema.parse).toBe('function')
 })

package/src/platforms/kakaotalk/index.ts

@@ -1,5 +1,10 @@
 export { KakaoTalkClient, KakaoTalkError } from './client'
-export { classifyKakaoChat } from './chat-classifier'
+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'
 export { KakaoTalkListener } from './listener'
@@ -9,6 +14,8 @@ export type {
   KakaoAuthErrorCode,
   KakaoAuthMethod,
   KakaoChat,
+  KakaoChatType,
+  KakaoOpenChatType,
   KakaoConfig,
   KakaoDeviceType,
   KakaoEmoticonKind,
@@ -18,7 +25,9 @@ export type {
   KakaoLoginResult,
   KakaoMarkReadResult,
   KakaoMember,
+  KakaoMemberSnapshot,
   KakaoMessage,
+  KakaoMessagePage,
   KakaoMultiPhotoExtra,
   KakaoPhotoExtra,
   KakaoProfile,
@@ -44,7 +53,9 @@ export {
   KakaoLeaveChatResultSchema,
   KakaoMarkReadResultSchema,
   KakaoMemberSchema,
+  KakaoMemberSnapshotSchema,
   KakaoMessageSchema,
+  KakaoMessagePageSchema,
   KakaoProfileSchema,
   KakaoSendResultSchema,
   KakaoTalkPushEmoticonEventSchema,

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

@@ -70,9 +70,20 @@ export const KAKAO_NEXT_ACTIONS: Record<string, { next_action: string; message:
   },
 }
 
+export type KakaoOpenChatType = 2 | 13 | 14 | 15 | 16 | 'OM' | 'OD'
+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
-  type: number
+  type: KakaoChatType
   display_name: string | null
   title: string | null
   active_members: number
@@ -95,6 +106,12 @@ export interface KakaoMessage {
   sent_at: number
 }
 
+export interface KakaoMessagePage {
+  messages: KakaoMessage[]
+  next_cursor: string | null
+  complete: boolean
+}
+
 export interface KakaoMember {
   user_id: string
   nickname: string
@@ -112,6 +129,14 @@ export interface KakaoMember {
   open_permission: number | null
 }
 
+export interface KakaoMemberSnapshot {
+  chat_id: string
+  active_members: number
+  members: KakaoMember[]
+  complete: true
+  consistency_basis: 'stable_double_read_chatinfo_getmem'
+}
+
 export interface KakaoSendResult {
   success: boolean
   status_code: number
@@ -222,7 +247,7 @@ export interface KakaoTypingResult {
 
 export const KakaoChatSchema = z.object({
   chat_id: z.string(),
-  type: z.number(),
+  type: z.union([z.number(), z.string().min(1)]),
   display_name: z.string().nullable(),
   title: z.string().nullable(),
   active_members: z.number(),
@@ -247,6 +272,12 @@ export const KakaoMessageSchema = z.object({
   sent_at: z.number(),
 })
 
+export const KakaoMessagePageSchema = z.object({
+  messages: z.array(KakaoMessageSchema),
+  next_cursor: z.string().nullable(),
+  complete: z.boolean(),
+})
+
 export const KakaoMemberSchema = z.object({
   user_id: z.string(),
   nickname: z.string(),
@@ -261,6 +292,14 @@ export const KakaoMemberSchema = z.object({
   open_permission: z.number().nullable(),
 })
 
+export const KakaoMemberSnapshotSchema = z.object({
+  chat_id: z.string(),
+  active_members: z.number().int().nonnegative(),
+  members: z.array(KakaoMemberSchema),
+  complete: z.literal(true),
+  consistency_basis: z.literal('stable_double_read_chatinfo_getmem'),
+})
+
 export const KakaoSendResultSchema = z.object({
   success: z.boolean(),
   status_code: z.number(),