agent-messenger 2.19.1 → 2.19.3

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

@@ -1,60 +1,95 @@
 import { afterEach, describe, expect, mock, it } from 'bun:test'
 
+import type { LineRawEvent } from '@/platforms/line/client'
 import { LineListener } from '@/platforms/line/listener'
 import type { LinePushGenericEvent, LinePushMessageEvent } from '@/platforms/line/types'
 
-const mockGetProfile = mock(() => Promise.resolve({ mid: 'u123', displayName: 'Test User' }))
+const mockGetProfile = mock(() => Promise.resolve({ mid: 'u123', display_name: 'Test User' }))
 
-let mockInternalClientInstance: MockInternalClient
+let mockInternalClientInstance: MockEventSource
 
-class MockInternalClient {
-  handlers: Record<string, ((...args: any[]) => void)[]> = {}
-  private listenReject: ((e: Error) => void) | null = null
+class MockEventSource {
+  private queue: LineRawEvent[] = []
+  private resolveNext: ((value: IteratorResult<LineRawEvent>) => void) | null = null
+  private streamError: Error | null = null
+  private done = false
 
-  on(event: string, handler: (...args: any[]) => void): void {
-    if (!this.handlers[event]) this.handlers[event] = []
-    this.handlers[event].push(handler)
-  }
+  async *streamEvents(signal: AbortSignal): AsyncGenerator<LineRawEvent, void, unknown> {
+    signal.addEventListener('abort', () => {
+      const err = new Error('The operation was aborted')
+      err.name = 'AbortError'
+      this.fail(err)
+    })
 
-  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)
+    while (!this.done) {
+      if (this.streamError) {
+        const err = this.streamError
+        this.streamError = null
+        throw err
+      }
+      if (this.queue.length > 0) {
+        yield this.queue.shift()!
+        continue
+      }
+      const next = await new Promise<IteratorResult<LineRawEvent>>((resolve) => {
+        this.resolveNext = resolve
       })
-    })
+      if (next.done) return
+      if (this.streamError) {
+        const err = this.streamError
+        this.streamError = null
+        throw err
+      }
+      yield next.value
+    }
+  }
+
+  private push(event: LineRawEvent): void {
+    if (this.resolveNext) {
+      const resolve = this.resolveNext
+      this.resolveNext = null
+      resolve({ value: event, done: false })
+    } else {
+      this.queue.push(event)
+    }
+  }
+
+  private fail(error: Error): void {
+    this.streamError = error
+    if (this.resolveNext) {
+      const resolve = this.resolveNext
+      this.resolveNext = null
+      resolve({ value: undefined as never, done: false })
+    }
   }
 
-  simulateMessage(msg: unknown): void {
-    this.handlers['message']?.forEach((h) => h(msg))
+  simulateMessage(message: unknown): void {
+    this.push({ kind: 'message', message: message as never })
   }
 
   simulateEvent(op: unknown): void {
-    this.handlers['event']?.forEach((h) => h(op))
+    this.push({ kind: 'event', op: op as never })
   }
 
   simulateListenError(error: Error): void {
-    this.listenReject?.(error)
+    this.fail(error)
   }
+}
 
-  base = {
-    talk: { getProfile: mockGetProfile },
-  }
+function flush(): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, 0))
 }
 
 const mockLogin = mock((): Promise<void> => {
-  mockInternalClientInstance = new MockInternalClient()
+  mockInternalClientInstance = new MockEventSource()
   return Promise.resolve()
 })
 
 function createMockLineClient() {
   return {
     login: mockLogin,
-    get client() {
-      return mockInternalClientInstance
-    },
+    getProfile: mockGetProfile,
+    streamEvents: (signal: AbortSignal) => mockInternalClientInstance.streamEvents(signal),
   } as any
 }
 
@@ -65,11 +100,11 @@ describe('LineListener', () => {
     listener?.stop()
     mockLogin.mockReset()
     mockLogin.mockImplementation((): Promise<void> => {
-      mockInternalClientInstance = new MockInternalClient()
+      mockInternalClientInstance = new MockEventSource()
       return Promise.resolve()
     })
     mockGetProfile.mockReset()
-    mockGetProfile.mockResolvedValue({ mid: 'u123', displayName: 'Test User' })
+    mockGetProfile.mockResolvedValue({ mid: 'u123', display_name: 'Test User' })
   })
 
   describe('start', () => {
@@ -128,6 +163,7 @@ describe('LineListener', () => {
           createdTime: 1700000000000,
         },
       })
+      await flush()
 
       expect(messages.length).toBe(1)
       expect(messages[0].type).toBe('message')
@@ -136,6 +172,64 @@ describe('LineListener', () => {
       expect(messages[0].author_id).toBe('u456')
       expect(messages[0].text).toBe('hello world')
       expect(messages[0].content_type).toBe('NONE')
+      expect(messages[0].content_metadata).toEqual({})
+    })
+
+    it('forwards contentMetadata for non-text 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: false,
+        from: { type: 'USER', id: 'u456' },
+        to: { type: 'USER', id: 'u123' },
+        text: null,
+        raw: {
+          id: 'msg010',
+          contentType: 'STICKER',
+          createdTime: 1700000007000,
+          contentMetadata: { STKID: '123', STKPKGID: '456', STKVER: '1' },
+        },
+      })
+      await flush()
+
+      expect(messages.length).toBe(1)
+      expect(messages[0].text).toBeNull()
+      expect(messages[0].content_type).toBe('STICKER')
+      expect(messages[0].content_metadata).toEqual({ STKID: '123', STKPKGID: '456', STKVER: '1' })
+    })
+
+    it('coerces non-string contentMetadata values to strings', 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: null,
+        raw: {
+          id: 'msg011',
+          contentType: 'IMAGE',
+          createdTime: 1700000008000,
+          contentMetadata: { FILE_SIZE: 2048, PREVIEW_URL: 'https://example.com/p.jpg', EMPTY: null },
+        },
+      })
+      await flush()
+
+      expect(messages.length).toBe(1)
+      expect(messages[0].content_metadata).toEqual({
+        FILE_SIZE: '2048',
+        PREVIEW_URL: 'https://example.com/p.jpg',
+      })
     })
 
     it('uses to.id as chat_id for own messages', async () => {
@@ -153,6 +247,7 @@ describe('LineListener', () => {
         text: 'sent by me',
         raw: { id: 'msg002', contentType: 'NONE', createdTime: 1700000001000 },
       })
+      await flush()
 
       expect(messages.length).toBe(1)
       expect(messages[0].chat_id).toBe('u456')
@@ -175,6 +270,7 @@ describe('LineListener', () => {
         text: 'hi',
         raw: { id: 'msg003', contentType: 'NONE', createdTime: 1700000002000 },
       })
+      await flush()
 
       expect(events.length).toBe(1)
       expect(events[0].type).toBe('message')
@@ -189,6 +285,7 @@ describe('LineListener', () => {
 
       await listener.start()
       mockInternalClientInstance.simulateEvent({ type: 'NOTIFIED_READ_MESSAGE', revision: 42 })
+      await flush()
 
       expect(events.length).toBe(1)
       expect(events[0].type).toBe('NOTIFIED_READ_MESSAGE')
@@ -233,7 +330,7 @@ describe('LineListener', () => {
       mockLogin.mockImplementation((): Promise<void> => {
         callCount++
         if (callCount === 1) return Promise.reject(new Error('network_error'))
-        mockInternalClientInstance = new MockInternalClient()
+        mockInternalClientInstance = new MockEventSource()
         return Promise.resolve()
       })
 
@@ -283,6 +380,7 @@ describe('LineListener', () => {
         text: 'first',
         raw: { id: 'msg004', contentType: 'NONE', createdTime: 1700000003000 },
       })
+      await flush()
 
       listener.off('message', handler)
       mockInternalClientInstance.simulateMessage({
@@ -292,6 +390,7 @@ describe('LineListener', () => {
         text: 'second',
         raw: { id: 'msg005', contentType: 'NONE', createdTime: 1700000004000 },
       })
+      await flush()
 
       expect(messages.length).toBe(1)
       expect(messages[0].text).toBe('first')
@@ -319,6 +418,7 @@ describe('LineListener', () => {
         text: 'second',
         raw: { id: 'msg007', contentType: 'NONE', createdTime: 1700000006000 },
       })
+      await flush()
 
       expect(messages.length).toBe(1)
       expect(messages[0].text).toBe('first')
@@ -338,4 +438,37 @@ describe('LineListener', () => {
       expect((listener as any).reconnectAttempts).toBe(0)
     })
   })
+
+  describe('event source consumption', () => {
+    it('consumes streamEvents and stops pumping after abort', async () => {
+      const streamCalls: AbortSignal[] = []
+      const client = {
+        login: mockLogin,
+        getProfile: mockGetProfile,
+        streamEvents: (signal: AbortSignal) => {
+          streamCalls.push(signal)
+          return mockInternalClientInstance.streamEvents(signal)
+        },
+      } as any
+      listener = new LineListener(client)
+
+      const messages: LinePushMessageEvent[] = []
+      listener.on('message', (event) => messages.push(event))
+
+      await listener.start()
+      expect(streamCalls.length).toBe(1)
+
+      listener.stop()
+      mockInternalClientInstance.simulateMessage({
+        isMyMessage: false,
+        from: { type: 'USER', id: 'u456' },
+        to: { type: 'USER', id: 'u123' },
+        text: 'after stop',
+        raw: { id: 'msg100', contentType: 'NONE', createdTime: 1700000010000 },
+      })
+      await flush()
+
+      expect(messages.length).toBe(0)
+    })
+  })
 })

package/src/platforms/line/listener.ts

@@ -2,7 +2,6 @@ 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
@@ -61,59 +60,13 @@ export class LineListener {
       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')
-      }
-
+      const profile = await this.lineClient.getProfile()
+      if (!this.running) return
       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 })
+
+      void this.pump(this.abortController.signal)
     } catch (error) {
       this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
       if (this.running) {
@@ -122,6 +75,59 @@ export class LineListener {
     }
   }
 
+  private async pump(signal: AbortSignal): Promise<void> {
+    try {
+      for await (const event of this.lineClient.streamEvents(signal)) {
+        if (event.kind === 'message') {
+          this.emitMessage(event.message)
+        } else {
+          this.emitOperation(event.op)
+        }
+      }
+    } catch (error) {
+      if (!this.running || signal.aborted) 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()
+    }
+  }
+
+  private emitMessage(msg: any): void {
+    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'),
+        content_metadata: normalizeContentMetadata(msg.raw.contentMetadata),
+        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)))
+    }
+  }
+
+  private emitOperation(op: any): void {
+    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)
+  }
+
   private scheduleReconnect(): void {
     this.clearTimers()
     const delay = Math.min(RECONNECT_BASE_DELAY * 2 ** this.reconnectAttempts, RECONNECT_MAX_DELAY)
@@ -136,3 +142,12 @@ export class LineListener {
     }
   }
 }
+
+function normalizeContentMetadata(raw: unknown): Record<string, string> {
+  if (!raw || typeof raw !== 'object') return {}
+  const result: Record<string, string> = {}
+  for (const [key, value] of Object.entries(raw as Record<string, unknown>)) {
+    if (value !== null && value !== undefined) result[key] = String(value)
+  }
+  return result
+}

package/src/platforms/line/types.ts

@@ -138,6 +138,8 @@ export interface LinePushMessageEvent {
   author_id: string
   text: string | null
   content_type: string
+  // Raw LINE contentMetadata (sticker IDs, file name/size, media URLs); empty for plain text.
+  content_metadata: Record<string, string>
   sent_at: string
 }