agent-messenger 2.12.0 → 2.12.2

package/src/platforms/kakaotalk/client-listener-integration.test.ts

@@ -0,0 +1,411 @@
+import { afterEach, beforeEach, describe, expect, mock, it } from 'bun:test'
+
+import { KakaoTalkClient } from './client'
+import { KakaoTalkListener } from './listener'
+import type { LocoPacket } from './protocol/types'
+import type { KakaoTalkPushMessageEvent } from './types'
+
+const sessions: MockLocoSession[] = []
+const loginCalls: Array<{
+  oauthToken: string
+  userId: string
+  deviceUuid: string
+  syncState: unknown
+  deviceType: string
+}> = []
+
+class MockLocoSession {
+  pushHandler: ((packet: LocoPacket) => void) | null = null
+  closeHandler: (() => void) | null = null
+  closed = false
+  loginResult: Record<string, unknown> = {
+    chatDatas: [],
+    lastTokenId: { low: 0, high: 0 },
+    lastChatId: { low: 0, high: 0 },
+    eof: true,
+  }
+
+  loginImpl: (
+    oauthToken: string,
+    userId: string,
+    deviceUuid: string,
+    syncState: unknown,
+    deviceType: string,
+  ) => Promise<unknown> = async (oauthToken, userId, deviceUuid, syncState, deviceType) => {
+    loginCalls.push({ oauthToken, userId, deviceUuid, syncState, deviceType })
+    return this.loginResult
+  }
+
+  sendMessageImpl: (chatId: unknown, text: string) => Promise<unknown> = async () => ({
+    statusCode: 0,
+    body: { logId: { low: 1, high: 0 }, sendAt: 1 },
+  })
+
+  getChatLogsImpl: () => Promise<unknown> = async () => ({
+    body: { status: 0, chatLogs: [], eof: true },
+  })
+
+  constructor() {
+    sessions.push(this)
+  }
+
+  login(
+    oauthToken: string,
+    userId: string,
+    deviceUuid: string,
+    syncState: unknown,
+    deviceType: string,
+  ): Promise<unknown> {
+    return this.loginImpl(oauthToken, userId, deviceUuid, syncState, deviceType)
+  }
+
+  sendMessage(chatId: unknown, text: string): Promise<unknown> {
+    return this.sendMessageImpl(chatId, text)
+  }
+
+  getChatLogs(): Promise<unknown> {
+    return this.getChatLogsImpl()
+  }
+
+  getChatList(): Promise<unknown> {
+    return Promise.resolve({ body: { chatDatas: [], lastTokenId: { low: 0, high: 0 }, eof: true } })
+  }
+
+  getChatInfo(): Promise<unknown> {
+    return Promise.resolve({ body: { l: { low: 0, high: 0 } } })
+  }
+
+  syncMessages(): Promise<unknown> {
+    return Promise.resolve({ body: { chatLogs: [], isOK: true } })
+  }
+
+  onPush(handler: (packet: LocoPacket) => void): void {
+    this.pushHandler = handler
+  }
+
+  onClose(handler: () => void): void {
+    this.closeHandler = handler
+  }
+
+  close(): void {
+    if (this.closed) return
+    this.closed = true
+    this.closeHandler?.()
+  }
+
+  simulatePush(method: string, body: Record<string, unknown> = {}): void {
+    this.pushHandler?.({ packetId: 0, statusCode: 0, method, bodyType: 0, body })
+  }
+
+  simulateRemoteClose(): void {
+    if (this.closed) return
+    this.closed = true
+    this.closeHandler?.()
+  }
+}
+
+mock.module('./protocol/session', () => ({ LocoSession: MockLocoSession }))
+
+const CREDS = {
+  oauthToken: 'tok',
+  userId: 'user1',
+  deviceUuid: 'device-uuid-1',
+  deviceType: 'tablet' as const,
+}
+
+function currentSession(): MockLocoSession {
+  return sessions[sessions.length - 1]!
+}
+
+describe('KakaoTalkClient + KakaoTalkListener integration (shared LOCO session)', () => {
+  beforeEach(() => {
+    sessions.length = 0
+    loginCalls.length = 0
+  })
+
+  afterEach(() => {
+    sessions.length = 0
+    loginCalls.length = 0
+  })
+
+  it('opens exactly ONE LocoSession when a client and listener are used together', async () => {
+    // given — a client logged in and a listener attached
+    const client = await new KakaoTalkClient().login(CREDS)
+    const listener = new KakaoTalkListener(client)
+
+    // when — listener starts AND client makes API calls
+    await listener.start()
+    await client.sendMessage('100', 'hi')
+    await client.getChats()
+
+    // then — only one LocoSession was constructed; only one LOGINLIST sent
+    expect(sessions.length).toBe(1)
+    expect(loginCalls.length).toBe(1)
+    expect(loginCalls[0].deviceUuid).toBe(CREDS.deviceUuid)
+
+    listener.stop()
+    client.close()
+  })
+
+  it('never sends a duplicate LOGINLIST with the same duuid while a session is alive', async () => {
+    // given — a strict guard: any second login while the first session is still open is a self-KICKOUT.
+    const client = await new KakaoTalkClient().login(CREDS)
+    const listener = new KakaoTalkListener(client)
+    await listener.start()
+
+    // when — heavy interleaving of outbound calls and inbound pushes
+    for (let i = 0; i < 10; i++) {
+      await client.sendMessage(String(100 + i), `msg-${i}`)
+      currentSession().simulatePush('MSG', {
+        chatId: { low: 100 + i, high: 0 },
+        chatLog: { logId: { low: i, high: 0 }, authorId: 1, message: `pushed-${i}`, type: 1, sendAt: i },
+      })
+    }
+
+    // then — still exactly one LOGINLIST, never a second one against the live session
+    const liveSessions = sessions.filter((s) => !s.closed)
+    expect(liveSessions.length).toBe(1)
+    expect(loginCalls.length).toBe(1)
+
+    listener.stop()
+    client.close()
+  })
+
+  it('listener still receives push events when only the listener is used (no API calls)', async () => {
+    const client = await new KakaoTalkClient().login(CREDS)
+    const listener = new KakaoTalkListener(client)
+
+    const messages: KakaoTalkPushMessageEvent[] = []
+    listener.on('message', (event) => messages.push(event))
+
+    await listener.start()
+    expect(sessions.length).toBe(1)
+
+    currentSession().simulatePush('MSG', {
+      chatId: { low: 100, high: 0 },
+      chatLog: {
+        logId: { low: 1, high: 0 },
+        authorId: 42,
+        message: 'hello',
+        type: 1,
+        sendAt: 1700000000,
+      },
+    })
+
+    expect(messages.length).toBe(1)
+    expect(messages[0].chat_id).toBe('100')
+    expect(messages[0].message).toBe('hello')
+
+    listener.stop()
+    client.close()
+  })
+
+  it('client-only usage still works (no listener)', async () => {
+    const client = await new KakaoTalkClient().login(CREDS)
+    const result = await client.sendMessage('100', 'hi')
+
+    expect(result.success).toBe(true)
+    expect(sessions.length).toBe(1)
+
+    client.close()
+  })
+
+  it('real KICKOUT propagates to listener and closes the session', async () => {
+    // given — client + listener sharing a session
+    const client = await new KakaoTalkClient().login(CREDS)
+    const listener = new KakaoTalkListener(client)
+
+    const errors: Error[] = []
+    listener.on('error', (err) => errors.push(err))
+
+    await listener.start()
+    expect(sessions.length).toBe(1)
+    const sharedSession = currentSession()
+
+    // when — server pushes a KICKOUT (a different real device logged in)
+    sharedSession.simulatePush('KICKOUT', {})
+
+    // then — listener emits the canonical error and stops itself
+    expect(errors.length).toBe(1)
+    expect(errors[0].message).toContain('kicked')
+    expect((listener as unknown as { running: boolean }).running).toBe(false)
+
+    listener.stop()
+    client.close()
+  })
+
+  it('reconnect after a TCP-level disconnect produces ONE replacement session shared by both halves', async () => {
+    // given — listener + client on a shared session
+    const client = await new KakaoTalkClient().login(CREDS)
+    const listener = new KakaoTalkListener(client)
+
+    const disconnects: number[] = []
+    const connects: Array<{ userId: string }> = []
+    listener.on('disconnected', () => disconnects.push(Date.now()))
+    listener.on('connected', (info) => connects.push(info))
+
+    await listener.start()
+    expect(sessions.length).toBe(1)
+    expect(connects.length).toBe(1)
+
+    // when — the underlying socket dies (not a KICKOUT)
+    currentSession().simulateRemoteClose()
+
+    // then — listener observed the disconnect
+    expect(disconnects.length).toBe(1)
+
+    // and — the next API call transparently opens exactly ONE replacement session
+    await client.sendMessage('100', 'after-reconnect')
+
+    expect(sessions.length).toBe(2)
+    // and — the listener was re-attached to that replacement session (i.e. push fan-out works again)
+    const messages: KakaoTalkPushMessageEvent[] = []
+    listener.on('message', (event) => messages.push(event))
+    currentSession().simulatePush('MSG', {
+      chatId: { low: 100, high: 0 },
+      chatLog: { logId: { low: 9, high: 0 }, authorId: 1, message: 'after-reconnect-push', type: 1, sendAt: 1 },
+    })
+    expect(messages.length).toBe(1)
+    expect(connects.length).toBe(2)
+
+    listener.stop()
+    client.close()
+  })
+
+  it('CHANGESVR triggers an active session migration', async () => {
+    // given — a listener attached to a shared session
+    const client = await new KakaoTalkClient().login(CREDS)
+    const listener = new KakaoTalkListener(client)
+
+    const disconnects: number[] = []
+    const connects: Array<{ userId: string }> = []
+    const generic: Array<{ type: string }> = []
+    listener.on('disconnected', () => disconnects.push(1))
+    listener.on('connected', (info) => connects.push(info))
+    listener.on('kakaotalk_event', (event) => generic.push(event))
+
+    await listener.start()
+    expect(sessions.length).toBe(1)
+    expect(connects.length).toBe(1)
+
+    // when — the server pushes CHANGESVR (asking us to migrate to a new gateway)
+    sessions[0]!.simulatePush('CHANGESVR', {})
+
+    // then — the client actively migrates: old session closed, new one opened
+    await new Promise((r) => setTimeout(r, 0))
+    expect(sessions.length).toBe(2)
+    expect(sessions[0]!.closed).toBe(true)
+    expect(disconnects.length).toBe(1)
+    expect(connects.length).toBe(2)
+
+    // and — the listener re-attached to the replacement session for push events
+    const messages: KakaoTalkPushMessageEvent[] = []
+    listener.on('message', (event) => messages.push(event))
+    sessions[1]!.simulatePush('MSG', {
+      chatId: { low: 100, high: 0 },
+      chatLog: { logId: { low: 7, high: 0 }, authorId: 1, message: 'after-changesvr', type: 1, sendAt: 1 },
+    })
+    expect(messages.length).toBe(1)
+
+    // and — CHANGESVR was still surfaced as a generic event for observers that care
+    expect(generic.some((e) => e.type === 'CHANGESVR')).toBe(true)
+
+    listener.stop()
+    client.close()
+  })
+
+  it('does not open duplicate LOGINLIST when concurrent calls trigger executeWithReconnect retry', async () => {
+    // given — a client+listener with a slow LOGINLIST so concurrent reconnects can collide
+    let inflight = 0
+    let peakInflight = 0
+    const originalLogin = MockLocoSession.prototype.login
+    MockLocoSession.prototype.login = async function (oauthToken, userId, deviceUuid, syncState, deviceType) {
+      inflight++
+      peakInflight = Math.max(peakInflight, inflight)
+      try {
+        await new Promise((r) => setTimeout(r, 20))
+        return await originalLogin.call(this, oauthToken, userId, deviceUuid, syncState, deviceType)
+      } finally {
+        inflight--
+      }
+    }
+
+    try {
+      const client = await new KakaoTalkClient().login(CREDS)
+      await client.sendMessage('100', 'prime')
+      expect(sessions.length).toBe(1)
+      expect(loginCalls.length).toBe(1)
+
+      // Make the live session's sendMessage drop the socket and then throw — modeling a
+      // mid-flight TCP reset where the remote-close handler nulls this.state synchronously
+      // before the operation rejection bubbles up to executeWithReconnect's catch block.
+      // This is the precise window the executeWithReconnect retry path was designed for.
+      const dead = sessions[0]!
+      dead.sendMessageImpl = async function () {
+        dead.simulateRemoteClose()
+        throw new Error('socket closed')
+      }
+
+      // when — three concurrent sendMessage calls all hit the dead session and retry
+      await Promise.all([
+        client.sendMessage('100', 'a'),
+        client.sendMessage('100', 'b'),
+        client.sendMessage('100', 'c'),
+      ])
+
+      // then — exactly ONE replacement LOGINLIST regardless of retry collisions
+      expect(peakInflight).toBe(1)
+      expect(loginCalls.length).toBe(2)
+      expect(sessions.length).toBe(2)
+
+      client.close()
+    } finally {
+      MockLocoSession.prototype.login = originalLogin
+    }
+  })
+
+  it('drops pushes from a session that has not been adopted as the active state', async () => {
+    // given — a listener subscribed to push events, before any session is opened
+    const client = await new KakaoTalkClient().login(CREDS)
+    const listener = new KakaoTalkListener(client)
+    const messages: KakaoTalkPushMessageEvent[] = []
+    listener.on('message', (event) => messages.push(event))
+
+    // Slow down login so we can fire a push DURING the connect()/login window,
+    // when LocoSession has been constructed but this.state is still null.
+    let preAdoptionPushFired = false
+    const originalLogin = MockLocoSession.prototype.login
+    MockLocoSession.prototype.login = async function (oauthToken, userId, deviceUuid, syncState, deviceType) {
+      if (!preAdoptionPushFired) {
+        preAdoptionPushFired = true
+        this.simulatePush('MSG', {
+          chatId: { low: 1, high: 0 },
+          chatLog: { logId: { low: 1, high: 0 }, authorId: 1, message: 'too-early', type: 1, sendAt: 1 },
+        })
+      }
+      return originalLogin.call(this, oauthToken, userId, deviceUuid, syncState, deviceType)
+    }
+
+    try {
+      // when — start the listener, which triggers connect() and a pre-adoption push
+      await listener.start()
+      expect(preAdoptionPushFired).toBe(true)
+
+      // then — the pre-adoption push must NOT have leaked to subscribers
+      expect(messages.length).toBe(0)
+
+      // and — once the session is adopted, fresh pushes flow normally
+      sessions[0]!.simulatePush('MSG', {
+        chatId: { low: 1, high: 0 },
+        chatLog: { logId: { low: 2, high: 0 }, authorId: 1, message: 'fresh', type: 1, sendAt: 2 },
+      })
+      expect(messages.length).toBe(1)
+      expect(messages[0].message).toBe('fresh')
+
+      listener.stop()
+      client.close()
+    } finally {
+      MockLocoSession.prototype.login = originalLogin
+    }
+  })
+})

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

@@ -11,6 +11,7 @@ const mockSyncMessages = mock(() => Promise.resolve({}))
 const mockSendMessage = mock(() => Promise.resolve({}))
 const mockClose = mock(() => {})
 const mockOnClose = mock((_handler: () => void) => {})
+const mockOnPush = mock((_handler: (packet: unknown) => void) => {})
 
 mock.module('./protocol/session', () => ({
   LocoSession: class MockLocoSession {
@@ -22,6 +23,7 @@ mock.module('./protocol/session', () => ({
     sendMessage = mockSendMessage
     close = mockClose
     onClose = mockOnClose
+    onPush = mockOnPush
   },
 }))
 
@@ -38,6 +40,7 @@ function resetAllMocks() {
   mockSendMessage.mockReset()
   mockClose.mockReset()
   mockOnClose.mockReset()
+  mockOnPush.mockReset()
 }
 
 // LOCO protocol uses plain numbers for chat.c, but Long-like objects for logIds/cursors

package/src/platforms/kakaotalk/client.ts

@@ -9,9 +9,17 @@ 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 { ChatListResponse, LocoPacket, LoginListResponse, SyncState } from './protocol/types'
 import type { KakaoChat, KakaoDeviceType, 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
 
@@ -234,6 +242,8 @@ 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>()
 
   async login(
     credentials?: { oauthToken: string; userId: string; deviceUuid?: string; deviceType?: KakaoDeviceType },
@@ -280,6 +290,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 +302,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 +316,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 +352,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 +363,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,13 +385,6 @@ 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
-        }
-      })
-
       return { session, loginResult }
     } catch (error) {
       session.close()
@@ -349,6 +392,60 @@ export class KakaoTalkClient {
     }
   }
 
+  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 }): Promise<KakaoChat[]> {
     return this.executeWithReconnect(async ({ session, loginResult }) => {
       try {
@@ -584,5 +681,7 @@ export class KakaoTalkClient {
     }
     this.state = null
     this.initPromise = null
+    this.pushHandlers.clear()
+    this.sessionEventHandlers.clear()
   }
 }