agent-messenger 2.12.1 → 2.12.2

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()
   }
 }

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

@@ -1,59 +1,61 @@
-import { afterEach, describe, expect, mock, it } from 'bun:test'
+import { afterEach, describe, expect, it } from 'bun:test'
 
-import { KakaoTalkListener } from '@/platforms/kakaotalk/listener'
-import type { LocoPacket } from '@/platforms/kakaotalk/protocol/types'
+import type { KakaoSessionEvent, KakaoSessionEventHandler, KakaoPushHandler, KakaoTalkClient } from './client'
+import { KakaoTalkListener } from './listener'
+import type { LocoPacket } from './protocol/types'
 import type {
   KakaoTalkPushGenericEvent,
   KakaoTalkPushMemberEvent,
   KakaoTalkPushMessageEvent,
   KakaoTalkPushReadEvent,
-} from '@/platforms/kakaotalk/types'
-
-const mockLogin = mock(() => Promise.resolve({}))
-const mockSessionClose = mock(() => {})
-
-let mockSessionInstance: MockLocoSession
+} from './types'
+
+class FakeClient {
+  acquireCalls = 0
+  pushHandlers = new Set<KakaoPushHandler>()
+  sessionHandlers = new Set<KakaoSessionEventHandler>()
+  acquireImpl: () => Promise<void> = async () => {}
+  connected = false
+
+  async acquireSession(): Promise<unknown> {
+    this.acquireCalls++
+    await this.acquireImpl()
+    this.connected = true
+    return {}
+  }
 
-class MockLocoSession {
-  pushHandler: ((packet: LocoPacket) => void) | null = null
-  closeHandler: (() => void) | null = null
-  login = mockLogin
-  close = mockSessionClose
+  isConnected(): boolean {
+    return this.connected
+  }
 
-  constructor() {
-    // oxlint-disable-next-line typescript-eslint/no-this-alias
-    mockSessionInstance = this
+  getCredentials(): { oauthToken: string; userId: string; deviceUuid: string; deviceType: 'tablet' } {
+    return { oauthToken: 'token', userId: 'user1', deviceUuid: 'device1', deviceType: 'tablet' }
   }
 
-  onPush(handler: (packet: LocoPacket) => void): void {
-    this.pushHandler = handler
+  onPush(handler: KakaoPushHandler): () => void {
+    this.pushHandlers.add(handler)
+    return () => this.pushHandlers.delete(handler)
   }
 
-  onClose(handler: () => void): void {
-    this.closeHandler = handler
+  onSessionEvent(handler: KakaoSessionEventHandler): () => void {
+    this.sessionHandlers.add(handler)
+    return () => this.sessionHandlers.delete(handler)
   }
 
-  simulatePush(method: string, body: Record<string, unknown>): void {
-    this.pushHandler?.({ packetId: 0, statusCode: 0, method, bodyType: 0, body })
+  emitPush(method: string, body: Record<string, unknown>): void {
+    const packet: LocoPacket = { packetId: 0, statusCode: 0, method, bodyType: 0, body }
+    for (const handler of this.pushHandlers) handler(packet)
   }
 
-  simulateClose(): void {
-    this.closeHandler?.()
+  emitSessionEvent(event: KakaoSessionEvent): void {
+    for (const handler of this.sessionHandlers) handler(event)
   }
 }
 
-mock.module('./protocol/session', () => ({ LocoSession: MockLocoSession }))
-
-function createMockClient(overrides: Record<string, unknown> = {}) {
-  return {
-    getCredentials: mock(() => ({
-      oauthToken: 'token',
-      userId: 'user1',
-      deviceUuid: 'device1',
-      deviceType: 'tablet' as const,
-    })),
-    ...overrides,
-  } as any
+function createListener(overrides: Partial<FakeClient> = {}): { listener: KakaoTalkListener; client: FakeClient } {
+  const client = Object.assign(new FakeClient(), overrides)
+  const listener = new KakaoTalkListener(client as unknown as KakaoTalkClient)
+  return { listener, client }
 }
 
 describe('KakaoTalkListener', () => {
@@ -61,58 +63,69 @@ describe('KakaoTalkListener', () => {
 
   afterEach(() => {
     listener?.stop()
-    mockLogin.mockReset()
-    mockLogin.mockResolvedValue({})
-    mockSessionClose.mockReset()
   })
 
   describe('start', () => {
-    it('calls login on LocoSession', async () => {
-      const client = createMockClient()
-      listener = new KakaoTalkListener(client)
+    it('acquires the shared session from the client', async () => {
+      const { listener: l, client } = createListener()
+      listener = l
 
       await listener.start()
 
-      expect(mockLogin).toHaveBeenCalledTimes(1)
-      expect(mockLogin).toHaveBeenCalledWith('token', 'user1', 'device1', undefined, 'tablet')
+      expect(client.acquireCalls).toBe(1)
     })
 
     it('is idempotent', async () => {
-      const client = createMockClient()
-      listener = new KakaoTalkListener(client)
+      const { listener: l, client } = createListener()
+      listener = l
 
       await listener.start()
       await listener.start()
 
-      expect(mockLogin).toHaveBeenCalledTimes(1)
+      expect(client.acquireCalls).toBe(1)
     })
   })
 
   describe('connected event', () => {
-    it('emits connected with userId after successful login', async () => {
-      const client = createMockClient()
-      listener = new KakaoTalkListener(client)
+    it('emits connected after acquiring an already-active session', async () => {
+      const { listener: l, client } = createListener()
+      listener = l
+      client.connected = true
+
+      const events: Array<{ userId: string }> = []
+      listener.on('connected', (info) => events.push(info))
+
+      await listener.start()
+
+      expect(events.length).toBe(1)
+      expect(events[0].userId).toBe('user1')
+    })
 
-      const connected: Array<{ userId: string }> = []
-      listener.on('connected', (info) => connected.push(info))
+    it('emits connected from session-event when client connects after listener starts', async () => {
+      const { listener: l, client } = createListener()
+      listener = l
+
+      const events: Array<{ userId: string }> = []
+      listener.on('connected', (info) => events.push(info))
 
       await listener.start()
+      client.emitSessionEvent({ type: 'connected', userId: 'user1' })
 
-      expect(connected.length).toBe(1)
-      expect(connected[0].userId).toBe('user1')
+      expect(events.length).toBe(1)
+      expect(events[0].userId).toBe('user1')
     })
   })
 
   describe('message events', () => {
     it('emits message on MSG push with parsed fields', async () => {
-      const client = createMockClient()
-      listener = new KakaoTalkListener(client)
+      const { listener: l, client } = createListener()
+      listener = l
 
       const messages: KakaoTalkPushMessageEvent[] = []
       listener.on('message', (event) => messages.push(event))
 
       await listener.start()
-      mockSessionInstance.simulatePush('MSG', {
+      client.emitPush('MSG', {
         chatId: { high: 0, low: 100 },
         chatLog: {
           logId: { high: 0, low: 200 },
@@ -136,14 +149,14 @@ describe('KakaoTalkListener', () => {
 
   describe('member events', () => {
     it('emits member_joined on NEWMEM push', async () => {
-      const client = createMockClient()
-      listener = new KakaoTalkListener(client)
+      const { listener: l, client } = createListener()
+      listener = l
 
       const joined: KakaoTalkPushMemberEvent[] = []
       listener.on('member_joined', (event) => joined.push(event))
 
       await listener.start()
-      mockSessionInstance.simulatePush('NEWMEM', {
+      client.emitPush('NEWMEM', {
         chatId: { high: 0, low: 100 },
         chatLog: { authorId: 42 },
       })
@@ -155,14 +168,14 @@ describe('KakaoTalkListener', () => {
     })
 
     it('emits member_left on DELMEM push', async () => {
-      const client = createMockClient()
-      listener = new KakaoTalkListener(client)
+      const { listener: l, client } = createListener()
+      listener = l
 
       const left: KakaoTalkPushMemberEvent[] = []
       listener.on('member_left', (event) => left.push(event))
 
       await listener.start()
-      mockSessionInstance.simulatePush('DELMEM', {
+      client.emitPush('DELMEM', {
         chatId: { high: 0, low: 100 },
         chatLog: { authorId: 42 },
       })
@@ -176,14 +189,14 @@ describe('KakaoTalkListener', () => {
 
   describe('read events', () => {
     it('emits read on DECUNREAD push with watermark', async () => {
-      const client = createMockClient()
-      listener = new KakaoTalkListener(client)
+      const { listener: l, client } = createListener()
+      listener = l
 
       const reads: KakaoTalkPushReadEvent[] = []
       listener.on('read', (event) => reads.push(event))
 
       await listener.start()
-      mockSessionInstance.simulatePush('DECUNREAD', {
+      client.emitPush('DECUNREAD', {
         chatId: { high: 0, low: 100 },
         userId: 42,
         watermark: { high: 0, low: 999 },
@@ -199,22 +212,22 @@ describe('KakaoTalkListener', () => {
 
   describe('kakaotalk_event catch-all', () => {
     it('emits kakaotalk_event for every push event', async () => {
-      const client = createMockClient()
-      listener = new KakaoTalkListener(client)
+      const { listener: l, client } = createListener()
+      listener = l
 
       const events: KakaoTalkPushGenericEvent[] = []
       listener.on('kakaotalk_event', (event) => events.push(event))
 
       await listener.start()
-      mockSessionInstance.simulatePush('MSG', {
+      client.emitPush('MSG', {
         chatId: { high: 0, low: 1 },
         chatLog: { logId: { high: 0, low: 2 }, authorId: 1, message: 'hi', type: 1, sendAt: 1 },
       })
-      mockSessionInstance.simulatePush('NEWMEM', {
+      client.emitPush('NEWMEM', {
         chatId: { high: 0, low: 1 },
         chatLog: { authorId: 1 },
       })
-      mockSessionInstance.simulatePush('CUSTOM_EVENT', { some: 'data' })
+      client.emitPush('CUSTOM_EVENT', { some: 'data' })
 
       expect(events.length).toBe(3)
       expect(events[0].type).toBe('MSG')
@@ -224,112 +237,72 @@ describe('KakaoTalkListener', () => {
   })
 
   describe('stop', () => {
-    it('closes session and prevents reconnection', async () => {
-      const client = createMockClient()
-      listener = new KakaoTalkListener(client)
+    it('unsubscribes from client push and session events', async () => {
+      const { listener: l, client } = createListener()
+      listener = l
 
       await listener.start()
+      expect(client.pushHandlers.size).toBe(1)
+      expect(client.sessionHandlers.size).toBe(1)
 
       listener.stop()
-      mockSessionInstance.simulateClose()
 
-      await new Promise((r) => setTimeout(r, 50))
-      expect(mockLogin).toHaveBeenCalledTimes(1)
+      expect(client.pushHandlers.size).toBe(0)
+      expect(client.sessionHandlers.size).toBe(0)
     })
   })
 
-  describe('reconnection', () => {
-    it('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)
-    })
-
-    it('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('disconnected event', () => {
+    it('emits disconnected when the client session drops', async () => {
+      const { listener: l, client } = createListener()
+      listener = l
 
-  describe('CHANGESVR', () => {
-    it('resets reconnect attempts to 0 on CHANGESVR push', async () => {
-      const client = createMockClient()
-      listener = new KakaoTalkListener(client)
+      const disconnects: number[] = []
+      listener.on('disconnected', () => disconnects.push(1))
 
       await listener.start()
-      ;(listener as any).reconnectAttempts = 5
+      client.emitSessionEvent({ type: 'disconnected' })
 
-      mockSessionInstance.simulatePush('CHANGESVR', {})
-
-      expect((listener as any).reconnectAttempts).toBe(0)
+      expect(disconnects.length).toBe(1)
     })
   })
 
   describe('KICKOUT', () => {
-    it('emits error and stops without reconnecting', async () => {
-      const client = createMockClient()
-      listener = new KakaoTalkListener(client)
+    it('emits error and stops the listener when the client reports a kicked session', async () => {
+      const { listener: l, client } = createListener()
+      listener = l
 
       const errors: Error[] = []
       listener.on('error', (err) => errors.push(err))
 
       await listener.start()
-      mockSessionInstance.simulatePush('KICKOUT', {})
+      client.emitSessionEvent({ type: 'kicked', reason: 'Session kicked — another device logged in' })
 
       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)
+      expect((listener as unknown as { running: boolean }).running).toBe(false)
+      expect(client.pushHandlers.size).toBe(0)
+      expect(client.sessionHandlers.size).toBe(0)
     })
   })
 
   describe('on/off/once', () => {
     it('off removes listener', async () => {
-      const client = createMockClient()
-      listener = new KakaoTalkListener(client)
+      const { listener: l, client } = createListener()
+      listener = l
 
       const messages: KakaoTalkPushMessageEvent[] = []
       const handler = (event: KakaoTalkPushMessageEvent) => messages.push(event)
       listener.on('message', handler)
 
       await listener.start()
-      mockSessionInstance.simulatePush('MSG', {
+      client.emitPush('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', {
+      client.emitPush('MSG', {
         chatId: { high: 0, low: 1 },
         chatLog: { logId: { high: 0, low: 2 }, authorId: 1, message: 'second', type: 1, sendAt: 2 },
       })
@@ -339,18 +312,18 @@ describe('KakaoTalkListener', () => {
     })
 
     it('once fires only once', async () => {
-      const client = createMockClient()
-      listener = new KakaoTalkListener(client)
+      const { listener: l, client } = createListener()
+      listener = l
 
       const messages: KakaoTalkPushMessageEvent[] = []
       listener.once('message', (event) => messages.push(event))
 
       await listener.start()
-      mockSessionInstance.simulatePush('MSG', {
+      client.emitPush('MSG', {
         chatId: { high: 0, low: 1 },
         chatLog: { logId: { high: 0, low: 1 }, authorId: 1, message: 'first', type: 1, sendAt: 1 },
       })
-      mockSessionInstance.simulatePush('MSG', {
+      client.emitPush('MSG', {
         chatId: { high: 0, low: 1 },
         chatLog: { logId: { high: 0, low: 2 }, authorId: 1, message: 'second', type: 1, sendAt: 2 },
       })
@@ -360,17 +333,50 @@ describe('KakaoTalkListener', () => {
     })
   })
 
-  describe('start after stop', () => {
-    it('resets reconnect attempts on fresh start', async () => {
-      const client = createMockClient()
-      listener = new KakaoTalkListener(client)
+  describe('error during start', () => {
+    it('emits error and tears down subscriptions when acquireSession fails', async () => {
+      const client = new FakeClient()
+      client.acquireImpl = async () => {
+        throw new Error('login_failed')
+      }
+      const l = new KakaoTalkListener(client as unknown as KakaoTalkClient)
+      listener = l
+
+      const errors: Error[] = []
+      listener.on('error', (err) => errors.push(err))
 
       await listener.start()
-      ;(listener as any).reconnectAttempts = 5
-      listener.stop()
 
+      expect(errors.length).toBe(1)
+      expect(errors[0].message).toBe('login_failed')
+      expect(client.pushHandlers.size).toBe(0)
+      expect(client.sessionHandlers.size).toBe(0)
+    })
+
+    it('can be restarted after a failed start()', async () => {
+      // given — a client whose first acquire fails but later succeeds
+      const client = new FakeClient()
+      let attempts = 0
+      client.acquireImpl = async () => {
+        attempts++
+        if (attempts === 1) throw new Error('login_failed')
+      }
+      const l = new KakaoTalkListener(client as unknown as KakaoTalkClient)
+      listener = l
+
+      const errors: Error[] = []
+      listener.on('error', (err) => errors.push(err))
+
+      // when — first start() fails, then we try again
       await listener.start()
-      expect((listener as any).reconnectAttempts).toBe(0)
+      expect(errors.length).toBe(1)
+
+      await listener.start()
+
+      // then — second start succeeds (subscriptions re-attached, acquire was retried)
+      expect(attempts).toBe(2)
+      expect(client.pushHandlers.size).toBe(1)
+      expect(client.sessionHandlers.size).toBe(1)
     })
   })
 })