agent-messenger 1.14.0 → 2.0.0

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

@@ -0,0 +1,48 @@
+import { expect, test } from 'bun:test'
+import {
+  CredentialManager,
+  LineAccountCredentialsSchema,
+  LineChatSchema,
+  LineClient,
+  LineConfigSchema,
+  LineCredentialManager,
+  LineError,
+  LineMessageSchema,
+  LineSendResultSchema,
+} from '@/platforms/line/index'
+
+test('LineClient is exported from barrel', () => {
+  expect(typeof LineClient).toBe('function')
+})
+
+test('LineError is exported from barrel', () => {
+  expect(typeof LineError).toBe('function')
+})
+
+test('CredentialManager is exported from barrel', () => {
+  expect(typeof CredentialManager).toBe('function')
+})
+
+test('LineCredentialManager is exported from barrel', () => {
+  expect(typeof LineCredentialManager).toBe('function')
+})
+
+test('LineChatSchema is exported from barrel', () => {
+  expect(typeof LineChatSchema.parse).toBe('function')
+})
+
+test('LineMessageSchema is exported from barrel', () => {
+  expect(typeof LineMessageSchema.parse).toBe('function')
+})
+
+test('LineSendResultSchema is exported from barrel', () => {
+  expect(typeof LineSendResultSchema.parse).toBe('function')
+})
+
+test('LineAccountCredentialsSchema is exported from barrel', () => {
+  expect(typeof LineAccountCredentialsSchema.parse).toBe('function')
+})
+
+test('LineConfigSchema is exported from barrel', () => {
+  expect(typeof LineConfigSchema.parse).toBe('function')
+})

package/src/platforms/line/index.ts

@@ -0,0 +1,27 @@
+export { LineClient } from './client'
+export { LineCredentialManager, CredentialManager } from './credential-manager'
+export { LineListener } from './listener'
+export { LineError } from './types'
+export type {
+  LineAccountCredentials,
+  LineChat,
+  LineConfig,
+  LineDevice,
+  LineFriend,
+  LineListenerEventMap,
+  LineLoginResult,
+  LineMessage,
+  LineProfile,
+  LinePushGenericEvent,
+  LinePushMessageEvent,
+  LineSendResult,
+} from './types'
+export {
+  LineAccountCredentialsSchema,
+  LineChatSchema,
+  LineConfigSchema,
+  LineFriendSchema,
+  LineMessageSchema,
+  LineProfileSchema,
+  LineSendResultSchema,
+} from './types'

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

@@ -0,0 +1,341 @@
+import { afterEach, describe, expect, mock, test } from 'bun:test'
+
+import { LineListener } from '@/platforms/line/listener'
+import type { LinePushGenericEvent, LinePushMessageEvent } from '@/platforms/line/types'
+
+const mockGetProfile = mock(() => Promise.resolve({ mid: 'u123', displayName: 'Test User' }))
+
+let mockInternalClientInstance: MockInternalClient
+
+class MockInternalClient {
+  handlers: Record<string, ((...args: any[]) => void)[]> = {}
+  private listenReject: ((e: Error) => void) | null = null
+
+  on(event: string, handler: (...args: any[]) => void): void {
+    if (!this.handlers[event]) this.handlers[event] = []
+    this.handlers[event].push(handler)
+  }
+
+  listen(opts: { signal?: AbortSignal } = {}): Promise<void> {
+    return new Promise((_resolve, reject) => {
+      this.listenReject = reject
+      opts.signal?.addEventListener('abort', () => {
+        const err = new Error('The operation was aborted')
+        err.name = 'AbortError'
+        reject(err)
+      })
+    })
+  }
+
+  simulateMessage(msg: unknown): void {
+    this.handlers['message']?.forEach((h) => h(msg))
+  }
+
+  simulateEvent(op: unknown): void {
+    this.handlers['event']?.forEach((h) => h(op))
+  }
+
+  simulateListenError(error: Error): void {
+    this.listenReject?.(error)
+  }
+
+  base = {
+    talk: { getProfile: mockGetProfile },
+  }
+}
+
+const mockLogin = mock((): Promise<void> => {
+  mockInternalClientInstance = new MockInternalClient()
+  return Promise.resolve()
+})
+
+function createMockLineClient() {
+  return {
+    login: mockLogin,
+    get client() {
+      return mockInternalClientInstance
+    },
+  } as any
+}
+
+describe('LineListener', () => {
+  let listener: LineListener
+
+  afterEach(() => {
+    listener?.stop()
+    mockLogin.mockReset()
+    mockLogin.mockImplementation((): Promise<void> => {
+      mockInternalClientInstance = new MockInternalClient()
+      return Promise.resolve()
+    })
+    mockGetProfile.mockReset()
+    mockGetProfile.mockResolvedValue({ mid: 'u123', displayName: 'Test User' })
+  })
+
+  describe('start', () => {
+    test('calls login on LineClient', async () => {
+      const client = createMockLineClient()
+      listener = new LineListener(client)
+
+      await listener.start()
+
+      expect(mockLogin).toHaveBeenCalledTimes(1)
+    })
+
+    test('is idempotent', async () => {
+      const client = createMockLineClient()
+      listener = new LineListener(client)
+
+      await listener.start()
+      await listener.start()
+
+      expect(mockLogin).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('connected event', () => {
+    test('emits connected with account_id after successful login', async () => {
+      const client = createMockLineClient()
+      listener = new LineListener(client)
+
+      const connected: Array<{ account_id: string }> = []
+      listener.on('connected', (info) => connected.push(info))
+
+      await listener.start()
+
+      expect(connected.length).toBe(1)
+      expect(connected[0].account_id).toBe('u123')
+    })
+  })
+
+  describe('message events', () => {
+    test('emits message with parsed fields on incoming message', async () => {
+      const client = createMockLineClient()
+      listener = new LineListener(client)
+
+      const messages: LinePushMessageEvent[] = []
+      listener.on('message', (event) => messages.push(event))
+
+      await listener.start()
+      mockInternalClientInstance.simulateMessage({
+        isMyMessage: false,
+        from: { type: 'USER', id: 'u456' },
+        to: { type: 'USER', id: 'u123' },
+        text: 'hello world',
+        raw: {
+          id: 'msg001',
+          contentType: 'NONE',
+          createdTime: 1700000000000,
+        },
+      })
+
+      expect(messages.length).toBe(1)
+      expect(messages[0].type).toBe('message')
+      expect(messages[0].chat_id).toBe('u456')
+      expect(messages[0].message_id).toBe('msg001')
+      expect(messages[0].author_id).toBe('u456')
+      expect(messages[0].text).toBe('hello world')
+      expect(messages[0].content_type).toBe('NONE')
+    })
+
+    test('uses to.id as chat_id for own messages', async () => {
+      const client = createMockLineClient()
+      listener = new LineListener(client)
+
+      const messages: LinePushMessageEvent[] = []
+      listener.on('message', (event) => messages.push(event))
+
+      await listener.start()
+      mockInternalClientInstance.simulateMessage({
+        isMyMessage: true,
+        from: { type: 'USER', id: 'u123' },
+        to: { type: 'USER', id: 'u456' },
+        text: 'sent by me',
+        raw: { id: 'msg002', contentType: 'NONE', createdTime: 1700000001000 },
+      })
+
+      expect(messages.length).toBe(1)
+      expect(messages[0].chat_id).toBe('u456')
+    })
+  })
+
+  describe('line_event catch-all', () => {
+    test('emits line_event for every message', async () => {
+      const client = createMockLineClient()
+      listener = new LineListener(client)
+
+      const events: LinePushGenericEvent[] = []
+      listener.on('line_event', (event) => events.push(event))
+
+      await listener.start()
+      mockInternalClientInstance.simulateMessage({
+        isMyMessage: false,
+        from: { type: 'USER', id: 'u456' },
+        to: { type: 'USER', id: 'u123' },
+        text: 'hi',
+        raw: { id: 'msg003', contentType: 'NONE', createdTime: 1700000002000 },
+      })
+
+      expect(events.length).toBe(1)
+      expect(events[0].type).toBe('message')
+    })
+
+    test('emits line_event for raw operation events', async () => {
+      const client = createMockLineClient()
+      listener = new LineListener(client)
+
+      const events: LinePushGenericEvent[] = []
+      listener.on('line_event', (event) => events.push(event))
+
+      await listener.start()
+      mockInternalClientInstance.simulateEvent({ type: 'NOTIFIED_READ_MESSAGE', revision: 42 })
+
+      expect(events.length).toBe(1)
+      expect(events[0].type).toBe('NOTIFIED_READ_MESSAGE')
+      expect(events[0].revision).toBe('42')
+    })
+  })
+
+  describe('stop', () => {
+    test('aborts and prevents reconnection', async () => {
+      const client = createMockLineClient()
+      listener = new LineListener(client)
+
+      await listener.start()
+      listener.stop()
+
+      await new Promise((r) => setTimeout(r, 50))
+      expect(mockLogin).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('reconnection', () => {
+    test('reconnects on listen error when still running', async () => {
+      const client = createMockLineClient()
+      listener = new LineListener(client)
+
+      const disconnected: boolean[] = []
+      listener.on('disconnected', () => disconnected.push(true))
+
+      await listener.start()
+      const firstInstance = mockInternalClientInstance
+      firstInstance.simulateListenError(new Error('connection_dropped'))
+
+      await new Promise((r) => setTimeout(r, 50))
+      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((): Promise<void> => {
+        callCount++
+        if (callCount === 1) return Promise.reject(new Error('network_error'))
+        mockInternalClientInstance = new MockInternalClient()
+        return Promise.resolve()
+      })
+
+      const client = createMockLineClient()
+      listener = new LineListener(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)
+    })
+
+    test('does not reconnect after stop', async () => {
+      const client = createMockLineClient()
+      listener = new LineListener(client)
+
+      await listener.start()
+      listener.stop()
+
+      mockInternalClientInstance.simulateListenError(new Error('late_error'))
+
+      await new Promise((r) => setTimeout(r, 50))
+      expect(mockLogin).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('on/off/once', () => {
+    test('off removes listener', async () => {
+      const client = createMockLineClient()
+      listener = new LineListener(client)
+
+      const messages: LinePushMessageEvent[] = []
+      const handler = (event: LinePushMessageEvent) => messages.push(event)
+      listener.on('message', handler)
+
+      await listener.start()
+      mockInternalClientInstance.simulateMessage({
+        isMyMessage: false,
+        from: { type: 'USER', id: 'u456' },
+        to: { type: 'USER', id: 'u123' },
+        text: 'first',
+        raw: { id: 'msg004', contentType: 'NONE', createdTime: 1700000003000 },
+      })
+
+      listener.off('message', handler)
+      mockInternalClientInstance.simulateMessage({
+        isMyMessage: false,
+        from: { type: 'USER', id: 'u456' },
+        to: { type: 'USER', id: 'u123' },
+        text: 'second',
+        raw: { id: 'msg005', contentType: 'NONE', createdTime: 1700000004000 },
+      })
+
+      expect(messages.length).toBe(1)
+      expect(messages[0].text).toBe('first')
+    })
+
+    test('once fires only once', async () => {
+      const client = createMockLineClient()
+      listener = new LineListener(client)
+
+      const messages: LinePushMessageEvent[] = []
+      listener.once('message', (event) => messages.push(event))
+
+      await listener.start()
+      mockInternalClientInstance.simulateMessage({
+        isMyMessage: false,
+        from: { type: 'USER', id: 'u456' },
+        to: { type: 'USER', id: 'u123' },
+        text: 'first',
+        raw: { id: 'msg006', contentType: 'NONE', createdTime: 1700000005000 },
+      })
+      mockInternalClientInstance.simulateMessage({
+        isMyMessage: false,
+        from: { type: 'USER', id: 'u456' },
+        to: { type: 'USER', id: 'u123' },
+        text: 'second',
+        raw: { id: 'msg007', contentType: 'NONE', createdTime: 1700000006000 },
+      })
+
+      expect(messages.length).toBe(1)
+      expect(messages[0].text).toBe('first')
+    })
+  })
+
+  describe('start after stop', () => {
+    test('resets reconnect attempts on fresh start', async () => {
+      const client = createMockLineClient()
+      listener = new LineListener(client)
+
+      await listener.start()
+      ;(listener as any).reconnectAttempts = 5
+      listener.stop()
+
+      await listener.start()
+      expect((listener as any).reconnectAttempts).toBe(0)
+    })
+  })
+})

package/src/platforms/line/listener.ts

@@ -0,0 +1,138 @@
+import { EventEmitter } from 'events'
+
+import type { LineClient } from './client'
+import type { LineListenerEventMap, LinePushGenericEvent, LinePushMessageEvent } from './types'
+import { LineError } from './types'
+
+const RECONNECT_BASE_DELAY = 1_000
+const RECONNECT_MAX_DELAY = 30_000
+
+type EventKey = keyof LineListenerEventMap
+
+export class LineListener {
+  private lineClient: LineClient
+  private running = false
+  private emitter = new EventEmitter()
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  private reconnectAttempts = 0
+  private abortController: AbortController | null = null
+
+  constructor(client: LineClient) {
+    this.lineClient = client
+    // Prevent EventEmitter from throwing on unhandled 'error' events
+    this.emitter.on('error', () => {})
+  }
+
+  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.abortController) {
+      this.abortController.abort()
+      this.abortController = null
+    }
+  }
+
+  on<K extends EventKey>(event: K, listener: (...args: LineListenerEventMap[K]) => void): this {
+    this.emitter.on(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  off<K extends EventKey>(event: K, listener: (...args: LineListenerEventMap[K]) => void): this {
+    this.emitter.off(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  once<K extends EventKey>(event: K, listener: (...args: LineListenerEventMap[K]) => void): this {
+    this.emitter.once(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  private async connect(): Promise<void> {
+    if (!this.running) return
+
+    try {
+      await this.lineClient.login()
+      if (!this.running) return
+
+      const internalClient = (this.lineClient as any).client
+      if (!internalClient) {
+        throw new LineError('not_connected', 'Failed to get internal LINE client')
+      }
+
+      this.abortController = new AbortController()
+
+      internalClient.on('message', (msg: any) => {
+        try {
+          const toType = msg.raw.toType
+          const isGroupOrRoom = toType === 'GROUP' || toType === 'ROOM' || toType === 0 || toType === 1
+          const chatId = isGroupOrRoom ? msg.to.id : (msg.isMyMessage ? msg.to.id : msg.from.id)
+
+          const event: LinePushMessageEvent = {
+            type: 'message',
+            chat_id: chatId,
+            message_id: String(msg.raw.id),
+            author_id: msg.from.id,
+            text: msg.text ?? null,
+            content_type: String(msg.raw.contentType ?? 'NONE'),
+            sent_at: new Date(Number(msg.raw.createdTime)).toISOString(),
+          }
+          this.emitter.emit('message', event)
+          this.emitter.emit('line_event', { ...event })
+        } catch (error) {
+          this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
+        }
+      })
+
+      internalClient.on('event', (op: any) => {
+        const event: LinePushGenericEvent = {
+          type: String(op.type ?? 'unknown'),
+          ...(op.revision !== undefined && { revision: String(op.revision) }),
+          ...(op.createdTime !== undefined && {
+            created_time: new Date(Number(op.createdTime)).toISOString(),
+          }),
+        }
+        this.emitter.emit('line_event', event)
+      })
+
+      internalClient.listen({ signal: this.abortController.signal })?.catch((error: unknown) => {
+        if (!this.running) return
+        const err = error instanceof Error ? error : new Error(String(error))
+        if (err.name === 'AbortError') return
+        this.emitter.emit('error', err)
+        this.emitter.emit('disconnected')
+        this.scheduleReconnect()
+      })
+
+      this.reconnectAttempts = 0
+
+      const profile = await internalClient.base.talk.getProfile()
+      this.emitter.emit('connected', { account_id: profile.mid })
+    } catch (error) {
+      this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
+      if (this.running) {
+        this.scheduleReconnect()
+      }
+    }
+  }
+
+  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
+    }
+  }
+}