agent-messenger 2.19.0 → 2.19.2

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

@@ -1,6 +1,7 @@
-import { describe, expect, it } from 'bun:test'
+import { describe, expect, it, mock } from 'bun:test'
 
 import { LineClient } from './client'
+import type { LineRawEvent } from './client'
 import { LineError } from './types'
 import type { LineChat, LineDevice, LineLoginResult, LineMessage, LineSendResult } from './types'
 
@@ -54,6 +55,178 @@ describe('LineClient', () => {
     })
   })
 
+  describe('getMessages()', () => {
+    function clientWithTalk(talk: Record<string, unknown>): LineClient {
+      const client = new LineClient()
+      ;(client as any).client = { base: { talk } }
+      return client
+    }
+
+    it('returns empty when the chat has no messages', async () => {
+      const client = clientWithTalk({
+        getServerTime: async () => 1700000000000,
+        getPreviousMessagesV2WithRequest: async () => [],
+      })
+      expect(await client.getMessages('chat1')).toEqual([])
+    })
+
+    it('queries from the latest message regardless of message-box position', async () => {
+      let request: any
+      const client = clientWithTalk({
+        getServerTime: async () => 1700000000000,
+        getPreviousMessagesV2WithRequest: async (args: any) => {
+          request = args.request
+          return [{ id: '30', from: 'u1', text: 'c', contentType: 'NONE', createdTime: 3 }]
+        },
+      })
+
+      const result = await client.getMessages('chat-not-in-top-boxes', { count: 10 })
+      expect(request.messageBoxId).toBe('chat-not-in-top-boxes')
+      expect(request.endMessageId.messageId).toBe(9223372036854775807n)
+      expect(result.map((m) => m.message_id)).toEqual(['30'])
+    })
+
+    it('maps vendor fields and preserves order/count from the request', async () => {
+      const raw = [
+        { id: '30', from: 'u1', text: 'c', contentType: 'NONE', createdTime: 1700000003000 },
+        { id: '20', from: 'u1', text: 'b', contentType: 'NONE', createdTime: 1700000002000 },
+      ]
+      let requestedCount: number | undefined
+      const client = clientWithTalk({
+        getServerTime: async () => 1700000000000,
+        getPreviousMessagesV2WithRequest: async (args: any) => {
+          requestedCount = args.request.messagesCount
+          return raw
+        },
+      })
+
+      const result = await client.getMessages('chat1', { count: 2 })
+      expect(requestedCount).toBe(2)
+      expect(result.map((m) => m.message_id)).toEqual(['30', '20'])
+      expect(result.map((m) => m.text)).toEqual(['c', 'b'])
+    })
+  })
+
+  describe('sendMessage()', () => {
+    function clientWithTalk(talk: Record<string, unknown>): LineClient {
+      const client = new LineClient()
+      ;(client as any).client = { base: { talk } }
+      return client
+    }
+
+    it('sends with E2EE when available', async () => {
+      const sendMessage = mock(async () => ({ id: '1', createdTime: 1700000000000 }))
+      const client = clientWithTalk({ sendMessage })
+      const result = await client.sendMessage('chat1', 'hi')
+
+      expect(result.success).toBe(true)
+      expect(result.message_id).toBe('1')
+      expect(sendMessage.mock.calls[0][0]).toMatchObject({ e2ee: true })
+    })
+
+    it('falls back to plain text when E2EE key is unavailable', async () => {
+      let call = 0
+      const sendMessage = mock(async () => {
+        call++
+        if (call === 1) throw new Error('E2EE Key has not been saved')
+        return { id: '2', createdTime: 1700000001000 }
+      })
+      const client = clientWithTalk({ sendMessage })
+      const result = await client.sendMessage('chat1', 'hi')
+
+      expect(result.message_id).toBe('2')
+      expect(sendMessage.mock.calls[1][0]).toMatchObject({ e2ee: false })
+    })
+
+    it('throws e2ee_required when the chat mandates encryption and plain is rejected', async () => {
+      const sendMessage = mock(async (args: { e2ee: boolean }) => {
+        if (args.e2ee) throw new Error('E2EE Key has not been saved')
+        throw new Error('{"code":"E2EE_RETRY_ENCRYPT","reason":"can not send using plain mode"}')
+      })
+      const client = clientWithTalk({ sendMessage })
+
+      await expect(client.sendMessage('chat1', 'hi')).rejects.toMatchObject({ code: 'e2ee_required' })
+    })
+
+    it('rethrows non-E2EE send errors unchanged', async () => {
+      const sendMessage = mock(async () => {
+        throw new Error('rate limited')
+      })
+      const client = clientWithTalk({ sendMessage })
+
+      await expect(client.sendMessage('chat1', 'hi')).rejects.toMatchObject({ code: 'send_message_failed' })
+    })
+  })
+
+  describe('streamEvents()', () => {
+    function clientWithStream(ops: unknown[], decrypt: (m: unknown) => Promise<unknown>): LineClient {
+      const client = new LineClient()
+      ;(client as any).client = {
+        base: {
+          profile: { mid: 'me' },
+          createPolling: () => ({
+            // eslint-disable-next-line require-yield
+            async *_listenTalkEvents() {
+              for (const op of ops) yield op
+            },
+          }),
+          e2ee: { decryptE2EEMessage: decrypt },
+        },
+      }
+      return client
+    }
+
+    async function collect(client: LineClient): Promise<LineRawEvent[]> {
+      const out: LineRawEvent[] = []
+      for await (const e of client.streamEvents(new AbortController().signal)) out.push(e)
+      return out
+    }
+
+    it('decrypts messages and emits event + message', async () => {
+      const op = { type: 'RECEIVE_MESSAGE', message: { id: '1', from: 'u1', to: 'me' } }
+      const client = clientWithStream([op], async () => ({ id: '1', from: 'u1', to: 'me', text: 'hello' }))
+
+      const events = await collect(client)
+      expect(events.map((e) => e.kind)).toEqual(['event', 'message'])
+      const msg = events[1] as Extract<LineRawEvent, { kind: 'message' }>
+      expect(msg.message.text).toBe('hello')
+    })
+
+    it('keeps streaming when E2EE decryption fails (no reconnect loop)', async () => {
+      const ops = [
+        { type: 'RECEIVE_MESSAGE', message: { id: '1', from: 'u1', to: 'me', text: 'plain-on-raw' } },
+        { type: 'NOTIFIED_READ_MESSAGE' },
+      ]
+      const client = clientWithStream(ops, async () => {
+        throw new Error('E2EE decrypt failed')
+      })
+
+      const events = await collect(client)
+      expect(events.map((e) => e.kind)).toEqual(['event', 'message', 'event'])
+      const msg = events[1] as Extract<LineRawEvent, { kind: 'message' }>
+      expect(msg.message.from.id).toBe('u1')
+      expect(msg.message.text).toBeNull()
+    })
+
+    it('propagates polling errors so the listener can reconnect', async () => {
+      const client = new LineClient()
+      ;(client as any).client = {
+        base: {
+          profile: { mid: 'me' },
+          createPolling: () => ({
+            async *_listenTalkEvents(opts: { onError?: (e: unknown) => void }) {
+              opts.onError?.(new Error('sync failed'))
+              yield undefined as never
+            },
+          }),
+          e2ee: { decryptE2EEMessage: async (m: unknown) => m },
+        },
+      }
+
+      await expect(collect(client)).rejects.toThrow('sync failed')
+    })
+  })
+
   describe('login() without credentials', () => {
     it('throws LineError when no saved credentials exist', async () => {
       const { LineCredentialManager } = require('./credential-manager')

package/src/platforms/line/client.ts

@@ -1,6 +1,8 @@
 import { mkdirSync } from 'node:fs'
 import { join } from 'node:path'
 
+import type { Operation as LineOperation } from '@jsr/evex__linejs-types'
+
 import { getConfigDir } from '@/shared/utils/config-dir'
 import { FileStorage } from '@/vendor/linejs/base/storage/mod.js'
 import {
@@ -23,12 +25,39 @@ import type {
 } from './types'
 import { LineError } from './types'
 
+export interface LineRawMessage {
+  raw: { id: unknown; contentType?: unknown; createdTime?: unknown; toType?: unknown; to?: unknown; from?: unknown }
+  to: { id: unknown }
+  from: { id: unknown }
+  isMyMessage: boolean
+  text: string | null
+}
+
+export type LineRawEvent = { kind: 'message'; message: LineRawMessage } | { kind: 'event'; op: LineOperation }
+
+const MAX_MESSAGE_ID = 9223372036854775807n
+
 function wrapError(error: unknown, code: string): LineError {
   if (error instanceof LineError) return error
   const message = error instanceof Error ? error.message : String(error)
   return new LineError(code, message)
 }
 
+function isE2EEUnavailableError(message: string): boolean {
+  return /E2EE|e2ee|KeyNotFound|saveE2EE/.test(message)
+}
+
+function requiresEncryption(message: string): boolean {
+  return /RETRY_ENCRYPT|can not send using plain mode|cannot send using plain mode/i.test(message)
+}
+
+// Writes to stderr so partial-result degradation stays visible without
+// corrupting the JSON the CLI prints to stdout.
+function warnDegraded(action: string, error: unknown): void {
+  const message = error instanceof Error ? error.message : String(error)
+  console.warn(`[line] could not ${action}: ${message}`)
+}
+
 function mapChatType(rawType: unknown): 'user' | 'group' | 'room' | 'square' {
   if (rawType === 'GROUP' || rawType === 0) return 'group'
   if (rawType === 'ROOM' || rawType === 1) return 'room'
@@ -209,7 +238,10 @@ export class LineClient {
           },
           syncReason: 'INTERNAL',
         }),
-        client.fetchJoinedChats().catch(() => []),
+        client.fetchJoinedChats().catch((error: unknown) => {
+          warnDegraded('fetch joined group/room chats', error)
+          return []
+        }),
       ])
 
       for (const chat of joinedChats) {
@@ -239,7 +271,9 @@ export class LineClient {
           for (const c of contacts ?? []) {
             nameMap.set(c.mid, { name: c.displayName, type: 'user' })
           }
-        } catch {}
+        } catch (error) {
+          warnDegraded('resolve user display names', error)
+        }
       }
 
       if (groupMids.length > 0) {
@@ -253,7 +287,9 @@ export class LineClient {
               memberCount: memberMids ? Object.keys(memberMids).length : undefined,
             })
           }
-        } catch {}
+        } catch (error) {
+          warnDegraded('resolve group/room names', error)
+        }
       }
 
       for (const box of messageBoxes) {
@@ -279,13 +315,16 @@ export class LineClient {
       const client = this.ensureClient()
       const count = options?.count ?? 20
 
+      // getPreviousMessagesV2WithRequest pages backward from endMessageId. A
+      // messageId:0 sentinel returns nothing; the max int64 id acts as "from the
+      // latest message" and works for any chat regardless of message-box position.
       const serverTime = await client.base.talk.getServerTime()
       const rawMessages = await client.base.talk.getPreviousMessagesV2WithRequest({
         request: {
           messageBoxId: chatId,
           endMessageId: {
             deliveredTime: BigInt(serverTime),
-            messageId: BigInt(0),
+            messageId: MAX_MESSAGE_ID,
           },
           messagesCount: count,
         },
@@ -313,10 +352,22 @@ export class LineClient {
         sent = await client.base.talk.sendMessage({ to: chatId, text, e2ee: true })
       } catch (e2eeError) {
         const msg = e2eeError instanceof Error ? e2eeError.message : String(e2eeError)
-        if (msg.includes('E2EE') || msg.includes('e2ee') || msg.includes('KeyNotFound') || msg.includes('saveE2EE')) {
+        if (!isE2EEUnavailableError(msg)) throw e2eeError
+
+        try {
           sent = await client.base.talk.sendMessage({ to: chatId, text, e2ee: false })
-        } else {
-          throw e2eeError
+        } catch (plainError) {
+          const plainMsg = plainError instanceof Error ? plainError.message : String(plainError)
+          // Some chats force Letter Sealing and reject plain mode. This session
+          // authenticated via auth token and has no local E2EE private key, so it
+          // cannot encrypt. Surface a clear error and keep the original cause.
+          if (requiresEncryption(plainMsg)) {
+            throw new LineError(
+              'e2ee_required',
+              `This chat requires end-to-end encryption (Letter Sealing), which this auth-token session cannot provide. Original error: ${msg}`,
+            )
+          }
+          throw plainError
         }
       }
 
@@ -331,6 +382,53 @@ export class LineClient {
     }
   }
 
+  // Drives the vendor polling generator (talk.sync()) instead of Client.listen().
+  // Client.listen() uses a LEGY HTTP/2 push connection (duplex:'half' streaming
+  // fetch) that yields zero bytes under Bun and dies immediately, so no events
+  // ever arrive (evex-dev/linejs#117). The upstream "fix" (linejs#134, v2.7.0+)
+  // only adds an undici+allowH2 path for Node.js and explicitly skips Bun
+  // ("Bun" in globalThis -> return false), falling back to Bun's native fetch,
+  // which still can't stream duplex:'half' HTTP/2 (oven-sh/bun#30342, #31881).
+  // Polling works on every runtime. Messages are normalized like Client.listen().
+  async *streamEvents(signal: AbortSignal): AsyncGenerator<LineRawEvent, void, unknown> {
+    const client = this.ensureClient()
+    const polling = client.base.createPolling()
+    const selfMid = client.base.profile?.mid
+
+    for await (const op of polling._listenTalkEvents({
+      signal,
+      onError: (error) => {
+        throw error instanceof Error ? error : new Error(String(error))
+      },
+    })) {
+      yield { kind: 'event', op }
+      if (op.type === 'SEND_MESSAGE' || op.type === 'RECEIVE_MESSAGE') {
+        // A single undecryptable message must not kill the stream: the failing
+        // op stays in the sync window and would be re-fetched every poll, causing
+        // an endless decrypt-fail -> reconnect loop. Fall back to the raw op and
+        // surface the message with null text, since its text is unreadable.
+        let raw = op.message
+        let decrypted = true
+        try {
+          raw = await client.base.e2ee.decryptE2EEMessage(op.message)
+        } catch {
+          raw = op.message
+          decrypted = false
+        }
+        yield {
+          kind: 'message',
+          message: {
+            raw,
+            to: { id: raw.to },
+            from: { id: raw.from },
+            isMyMessage: selfMid === raw.from,
+            text: decrypted ? (raw.text ?? null) : null,
+          },
+        }
+      }
+    }
+  }
+
   close(): void {
     this.client = null
   }

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')
@@ -153,6 +189,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 +212,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 +227,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 +272,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 +322,7 @@ describe('LineListener', () => {
         text: 'first',
         raw: { id: 'msg004', contentType: 'NONE', createdTime: 1700000003000 },
       })
+      await flush()
 
       listener.off('message', handler)
       mockInternalClientInstance.simulateMessage({
@@ -292,6 +332,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 +360,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 +380,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)
+    })
+  })
 })