agent-messenger 1.14.0 → 2.0.0

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

@@ -0,0 +1,370 @@
+import { afterEach, describe, expect, mock, test } from 'bun:test'
+
+import { KakaoTalkListener } from '@/platforms/kakaotalk/listener'
+import type { LocoPacket } from '@/platforms/kakaotalk/protocol/types'
+import type {
+  KakaoTalkPushGenericEvent,
+  KakaoTalkPushMemberEvent,
+  KakaoTalkPushMessageEvent,
+  KakaoTalkPushReadEvent,
+} from '@/platforms/kakaotalk/types'
+
+const mockLogin = mock(() => Promise.resolve({}))
+const mockSessionClose = mock(() => {})
+
+let mockSessionInstance: MockLocoSession
+
+class MockLocoSession {
+  pushHandler: ((packet: LocoPacket) => void) | null = null
+  closeHandler: (() => void) | null = null
+  login = mockLogin
+  close = mockSessionClose
+
+  constructor() {
+    mockSessionInstance = this
+  }
+
+  onPush(handler: (packet: LocoPacket) => void): void {
+    this.pushHandler = handler
+  }
+
+  onClose(handler: () => void): void {
+    this.closeHandler = handler
+  }
+
+  simulatePush(method: string, body: Record<string, unknown>): void {
+    this.pushHandler?.({ packetId: 0, statusCode: 0, method, bodyType: 0, body })
+  }
+
+  simulateClose(): void {
+    this.closeHandler?.()
+  }
+}
+
+mock.module('./protocol/session', () => ({ LocoSession: MockLocoSession }))
+
+function createMockClient(overrides: Record<string, unknown> = {}) {
+  return {
+    getCredentials: mock(() => ({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })),
+    ...overrides,
+  } as any
+}
+
+describe('KakaoTalkListener', () => {
+  let listener: KakaoTalkListener
+
+  afterEach(() => {
+    listener?.stop()
+    mockLogin.mockReset()
+    mockLogin.mockResolvedValue({})
+    mockSessionClose.mockReset()
+  })
+
+  describe('start', () => {
+    test('calls login on LocoSession', async () => {
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      await listener.start()
+
+      expect(mockLogin).toHaveBeenCalledTimes(1)
+      expect(mockLogin).toHaveBeenCalledWith('token', 'user1', 'device1')
+    })
+
+    test('is idempotent', async () => {
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      await listener.start()
+      await listener.start()
+
+      expect(mockLogin).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('connected event', () => {
+    test('emits connected with userId after successful login', async () => {
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      const connected: Array<{ userId: string }> = []
+      listener.on('connected', (info) => connected.push(info))
+
+      await listener.start()
+
+      expect(connected.length).toBe(1)
+      expect(connected[0].userId).toBe('user1')
+    })
+  })
+
+  describe('message events', () => {
+    test('emits message on MSG push with parsed fields', async () => {
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      const messages: KakaoTalkPushMessageEvent[] = []
+      listener.on('message', (event) => messages.push(event))
+
+      await listener.start()
+      mockSessionInstance.simulatePush('MSG', {
+        chatId: { high: 0, low: 100 },
+        chatLog: {
+          logId: { high: 0, low: 200 },
+          authorId: 42,
+          message: 'hello world',
+          type: 1,
+          sendAt: 1700000000,
+        },
+      })
+
+      expect(messages.length).toBe(1)
+      expect(messages[0].type).toBe('MSG')
+      expect(messages[0].chat_id).toBe('100')
+      expect(messages[0].log_id).toBe('200')
+      expect(messages[0].author_id).toBe(42)
+      expect(messages[0].message).toBe('hello world')
+      expect(messages[0].message_type).toBe(1)
+      expect(messages[0].sent_at).toBe(1700000000)
+    })
+  })
+
+  describe('member events', () => {
+    test('emits member_joined on NEWMEM push', async () => {
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      const joined: KakaoTalkPushMemberEvent[] = []
+      listener.on('member_joined', (event) => joined.push(event))
+
+      await listener.start()
+      mockSessionInstance.simulatePush('NEWMEM', {
+        chatId: { high: 0, low: 100 },
+        chatLog: { authorId: 42 },
+      })
+
+      expect(joined.length).toBe(1)
+      expect(joined[0].type).toBe('NEWMEM')
+      expect(joined[0].chat_id).toBe('100')
+      expect(joined[0].member.user_id).toBe(42)
+    })
+
+    test('emits member_left on DELMEM push', async () => {
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      const left: KakaoTalkPushMemberEvent[] = []
+      listener.on('member_left', (event) => left.push(event))
+
+      await listener.start()
+      mockSessionInstance.simulatePush('DELMEM', {
+        chatId: { high: 0, low: 100 },
+        chatLog: { authorId: 42 },
+      })
+
+      expect(left.length).toBe(1)
+      expect(left[0].type).toBe('DELMEM')
+      expect(left[0].chat_id).toBe('100')
+      expect(left[0].member.user_id).toBe(42)
+    })
+  })
+
+  describe('read events', () => {
+    test('emits read on DECUNREAD push with watermark', async () => {
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      const reads: KakaoTalkPushReadEvent[] = []
+      listener.on('read', (event) => reads.push(event))
+
+      await listener.start()
+      mockSessionInstance.simulatePush('DECUNREAD', {
+        chatId: { high: 0, low: 100 },
+        userId: 42,
+        watermark: { high: 0, low: 999 },
+      })
+
+      expect(reads.length).toBe(1)
+      expect(reads[0].type).toBe('DECUNREAD')
+      expect(reads[0].chat_id).toBe('100')
+      expect(reads[0].user_id).toBe(42)
+      expect(reads[0].watermark).toBe('999')
+    })
+  })
+
+  describe('kakaotalk_event catch-all', () => {
+    test('emits kakaotalk_event for every push event', async () => {
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      const events: KakaoTalkPushGenericEvent[] = []
+      listener.on('kakaotalk_event', (event) => events.push(event))
+
+      await listener.start()
+      mockSessionInstance.simulatePush('MSG', {
+        chatId: { high: 0, low: 1 },
+        chatLog: { logId: { high: 0, low: 2 }, authorId: 1, message: 'hi', type: 1, sendAt: 1 },
+      })
+      mockSessionInstance.simulatePush('NEWMEM', {
+        chatId: { high: 0, low: 1 },
+        chatLog: { authorId: 1 },
+      })
+      mockSessionInstance.simulatePush('CUSTOM_EVENT', { some: 'data' })
+
+      expect(events.length).toBe(3)
+      expect(events[0].type).toBe('MSG')
+      expect(events[1].type).toBe('NEWMEM')
+      expect(events[2].type).toBe('CUSTOM_EVENT')
+    })
+  })
+
+  describe('stop', () => {
+    test('closes session and prevents reconnection', async () => {
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      await listener.start()
+
+      listener.stop()
+      mockSessionInstance.simulateClose()
+
+      await new Promise((r) => setTimeout(r, 50))
+      expect(mockLogin).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('reconnection', () => {
+    test('reconnects on session close when still running', async () => {
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      const disconnected: boolean[] = []
+      listener.on('disconnected', () => disconnected.push(true))
+
+      await listener.start()
+      mockSessionInstance.simulateClose()
+
+      expect(disconnected.length).toBe(1)
+
+      await new Promise((r) => setTimeout(r, 1500))
+      expect(mockLogin.mock.calls.length).toBeGreaterThanOrEqual(2)
+    })
+
+    test('emits error and reconnects on login failure', async () => {
+      let callCount = 0
+      mockLogin.mockImplementation(() => {
+        callCount++
+        if (callCount === 1) return Promise.reject(new Error('network_error'))
+        return Promise.resolve({})
+      })
+
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      const errors: Error[] = []
+      listener.on('error', (err) => errors.push(err))
+
+      await listener.start()
+
+      await new Promise((r) => setTimeout(r, 1500))
+
+      expect(errors.length).toBe(1)
+      expect(errors[0].message).toBe('network_error')
+      expect(mockLogin.mock.calls.length).toBeGreaterThanOrEqual(2)
+    })
+  })
+
+  describe('CHANGESVR', () => {
+    test('resets reconnect attempts to 0 on CHANGESVR push', async () => {
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      await listener.start()
+      ;(listener as any).reconnectAttempts = 5
+
+      mockSessionInstance.simulatePush('CHANGESVR', {})
+
+      expect((listener as any).reconnectAttempts).toBe(0)
+    })
+  })
+
+  describe('KICKOUT', () => {
+    test('emits error and stops without reconnecting', async () => {
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      const errors: Error[] = []
+      listener.on('error', (err) => errors.push(err))
+
+      await listener.start()
+      mockSessionInstance.simulatePush('KICKOUT', {})
+
+      expect(errors.length).toBe(1)
+      expect(errors[0].message).toContain('kicked')
+      expect((listener as any).running).toBe(false)
+
+      await new Promise((r) => setTimeout(r, 50))
+      expect(mockLogin).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('on/off/once', () => {
+    test('off removes listener', async () => {
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      const messages: KakaoTalkPushMessageEvent[] = []
+      const handler = (event: KakaoTalkPushMessageEvent) => messages.push(event)
+      listener.on('message', handler)
+
+      await listener.start()
+      mockSessionInstance.simulatePush('MSG', {
+        chatId: { high: 0, low: 1 },
+        chatLog: { logId: { high: 0, low: 1 }, authorId: 1, message: 'first', type: 1, sendAt: 1 },
+      })
+
+      listener.off('message', handler)
+      mockSessionInstance.simulatePush('MSG', {
+        chatId: { high: 0, low: 1 },
+        chatLog: { logId: { high: 0, low: 2 }, authorId: 1, message: 'second', type: 1, sendAt: 2 },
+      })
+
+      expect(messages.length).toBe(1)
+      expect(messages[0].message).toBe('first')
+    })
+
+    test('once fires only once', async () => {
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      const messages: KakaoTalkPushMessageEvent[] = []
+      listener.once('message', (event) => messages.push(event))
+
+      await listener.start()
+      mockSessionInstance.simulatePush('MSG', {
+        chatId: { high: 0, low: 1 },
+        chatLog: { logId: { high: 0, low: 1 }, authorId: 1, message: 'first', type: 1, sendAt: 1 },
+      })
+      mockSessionInstance.simulatePush('MSG', {
+        chatId: { high: 0, low: 1 },
+        chatLog: { logId: { high: 0, low: 2 }, authorId: 1, message: 'second', type: 1, sendAt: 2 },
+      })
+
+      expect(messages.length).toBe(1)
+      expect(messages[0].message).toBe('first')
+    })
+  })
+
+  describe('start after stop', () => {
+    test('resets reconnect attempts on fresh start', async () => {
+      const client = createMockClient()
+      listener = new KakaoTalkListener(client)
+
+      await listener.start()
+      ;(listener as any).reconnectAttempts = 5
+      listener.stop()
+
+      await listener.start()
+      expect((listener as any).reconnectAttempts).toBe(0)
+    })
+  })
+})

package/src/platforms/kakaotalk/listener.ts

@@ -0,0 +1,203 @@
+import { EventEmitter } from 'events'
+
+import type { KakaoTalkClient } from './client'
+import { LocoSession } from './protocol/session'
+import type { LocoPacket } from './protocol/types'
+import type {
+  KakaoTalkListenerEventMap,
+  KakaoTalkPushGenericEvent,
+  KakaoTalkPushMemberEvent,
+  KakaoTalkPushMessageEvent,
+  KakaoTalkPushReadEvent,
+} from './types'
+
+const RECONNECT_BASE_DELAY = 1_000
+const RECONNECT_MAX_DELAY = 30_000
+
+type EventKey = keyof KakaoTalkListenerEventMap
+
+function longToString(v: unknown): string {
+  if (v && typeof v === 'object' && 'high' in v && 'low' in v) {
+    const { high, low } = v as { high: number; low: number }
+    return ((BigInt(high >>> 0) << 32n) | BigInt(low >>> 0)).toString()
+  }
+  return String(v ?? 0)
+}
+
+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
+
+  constructor(client: KakaoTalkClient) {
+    this.client = client
+  }
+
+  async start(): Promise<void> {
+    if (this.running) return
+    this.running = true
+    this.reconnectAttempts = 0
+    await this.connect()
+  }
+
+  stop(): void {
+    this.running = false
+    this.clearTimers()
+    if (this.session) {
+      this.session.close()
+      this.session = null
+    }
+  }
+
+  on<K extends EventKey>(event: K, listener: (...args: KakaoTalkListenerEventMap[K]) => void): this {
+    this.emitter.on(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  off<K extends EventKey>(event: K, listener: (...args: KakaoTalkListenerEventMap[K]) => void): this {
+    this.emitter.off(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  once<K extends EventKey>(event: K, listener: (...args: KakaoTalkListenerEventMap[K]) => void): this {
+    this.emitter.once(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  private async connect(): Promise<void> {
+    if (!this.running) return
+
+    try {
+      const { oauthToken, userId, deviceUuid } = 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)
+
+      if (!this.running) {
+        session.close()
+        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()
+      }
+    }
+  }
+
+  private handlePush(packet: LocoPacket): void {
+    const { method, body } = packet
+
+    switch (method) {
+      case 'MSG': {
+        const chatLog = body.chatLog as Record<string, unknown>
+        const event: KakaoTalkPushMessageEvent = {
+          type: 'MSG',
+          chat_id: longToString(body.chatId),
+          log_id: longToString(chatLog.logId),
+          author_id: chatLog.authorId as number,
+          message: chatLog.message as string,
+          message_type: chatLog.type as number,
+          sent_at: chatLog.sendAt as number,
+        }
+        this.emitter.emit('message', event)
+        this.emitter.emit('kakaotalk_event', { type: method, ...body })
+        break
+      }
+
+      case 'NEWMEM': {
+        const chatLog = body.chatLog as Record<string, unknown>
+        const event: KakaoTalkPushMemberEvent = {
+          type: 'NEWMEM',
+          chat_id: longToString(body.chatId),
+          member: { user_id: chatLog.authorId as number },
+        }
+        this.emitter.emit('member_joined', event)
+        this.emitter.emit('kakaotalk_event', { type: method, ...body })
+        break
+      }
+
+      case 'DELMEM': {
+        const chatLog = body.chatLog as Record<string, unknown>
+        const event: KakaoTalkPushMemberEvent = {
+          type: 'DELMEM',
+          chat_id: longToString(body.chatId),
+          member: { user_id: chatLog.authorId as number },
+        }
+        this.emitter.emit('member_left', event)
+        this.emitter.emit('kakaotalk_event', { type: method, ...body })
+        break
+      }
+
+      case 'DECUNREAD': {
+        const event: KakaoTalkPushReadEvent = {
+          type: 'DECUNREAD',
+          chat_id: longToString(body.chatId),
+          user_id: body.userId as number,
+          watermark: longToString(body.watermark),
+        }
+        this.emitter.emit('read', event)
+        this.emitter.emit('kakaotalk_event', { type: method, ...body })
+        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)
+        break
+      }
+    }
+  }
+
+  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/NOTICE.md

@@ -0,0 +1,51 @@
+# Third-Party Notices
+
+This LOCO protocol implementation was written from scratch for agent-messenger.
+The protocol knowledge used to build it comes from the following open-source
+projects and their documentation. No code was copied from these projects.
+
+---
+
+## openkakao
+
+- Repository: https://github.com/JungHoonGhae/openkakao
+- License: MIT
+- Copyright (c) 2025 JungHoonGhae
+
+Primary protocol reference for: current encryption parameters (AES-128-GCM,
+key_encrypt_type=16, encrypt_type=3), RSA public key (PKCS#1, e=3), connection
+flow (Booking → Checkin → Login), packet structure, LOCO command reference,
+macOS credential extraction approach, and LOGINLIST field schema.
+
+---
+
+## loco-wrapper
+
+- Repository: https://github.com/NetRiceCake/loco-wrapper
+- License: No license specified
+- Note: Referenced for protocol behavior only; no code adapted.
+
+Referenced for: LOGINLIST packet field names and BSON types (LoginListOut.java),
+Android sub-device login flow, and connection patterns.
+
+---
+
+## node-kakao
+
+- Repository: https://github.com/storycraft/node-kakao
+- License: MIT
+- Copyright (c) 2020 storycraft
+
+Referenced for: LOCO packet format, BSON command schemas, authentication flow,
+X-VC signature algorithm, channel/chat type enumerations.
+
+---
+
+## Original LOCO Protocol Research
+
+- Author: Cai (bpak.org)
+- URL: http://www.bpak.org/blog/tag/loco/
+- Date: 2012-2013
+
+The foundational reverse engineering of the LOCO protocol that all subsequent
+implementations are based on.

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

@@ -0,0 +1,28 @@
+// Protocol constants for KakaoTalk LOCO.
+// See protocol/NOTICE.md for attribution of protocol knowledge.
+
+// LOCO RSA public key (PKCS#1 DER, base64). RSA-2048, e=3.
+// Source: openkakao (MIT) — extracted from KakaoTalk macOS binary.
+export const LOCO_RSA_PUBLIC_KEY_DER_B64 =
+  'MIIBCAKCAQEAo7B26MRFhR8ZpnDCMarG20Lv0JcX0GBIpcxWkGzRqye53zf/1QF+' +
+  'fBOhQFtdHD5IeaakmdPGGKckcrC1DKXvHvbupwNp2UE/5mLY4rR5qfchQu5wzubCr' +
+  'RIEXVKyXEogSiiWjjfwumpJ7j7J8qx6ZRhBYPIvYsQ6QGfNjSpvE9m4KYqwAnY9I' +
+  '2ydGHnX/OW4+pEIgrIeFSR+DQokeRMI5RmDYUQC6foDBXxX6eF4scw5/mcojvxGG' +
+  'UXLyqEdH8wSPnULhh8NRH6+PBFfQRpC3JXdsh2kJ3SlvLHd9/pfEGKAEMdPNvMcQ' +
+  'O/P4on9gbq6RKZVamwwEhBBS2Ajw/RjcQIBAw=='
+
+export const BOOKING_HOST = 'booking-loco.kakao.com'
+export const BOOKING_PORT = 443
+
+export const CHECKIN_HOST = 'ticket-loco.kakao.com'
+export const CHECKIN_PORT = 995
+
+export const APP_VERSION = '26.2.0'
+export const OS = 'mac'
+export const DTYPE = 2
+export const MCCMNC = '99999'
+export const LANG = 'ko'
+export const COUNTRY_ISO = 'KR'
+export const PROTOCOL_VERSION = '1'
+
+export const PING_INTERVAL_MS = 300_000