agent-messenger 2.19.1 → 2.19.3

package/skills/agent-kakaotalk/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-kakaotalk
 description: Interact with KakaoTalk - send messages, read chats, manage conversations
-version: 2.19.1
+version: 2.19.3
 allowed-tools: Bash(agent-kakaotalk:*)
 metadata:
   openclaw:

package/skills/agent-line/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-line
 description: Interact with LINE - send messages, read chats, manage conversations
-version: 2.19.1
+version: 2.19.3
 allowed-tools: Bash(agent-line:*)
 metadata:
   openclaw:
@@ -429,6 +429,7 @@ See the [LINE SDK documentation](https://agent-messenger.dev/docs/sdk/line) for
 
 - No auto-extraction of credentials (requires interactive login via QR code or email/password)
 - E2EE (Letter Sealing) may prevent reading some message content
+- Sending to chats that **require** E2EE (Letter Sealing) is not supported on auth-token sessions; such sends fail with `e2ee_required`
 - No file upload support yet
 - No sticker or rich message sending (text only)
 - No group creation or management

package/skills/agent-slack/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-slack
 description: Interact with Slack workspaces - send messages, read channels, manage reactions
-version: 2.19.1
+version: 2.19.3
 allowed-tools: Bash(agent-slack:*)
 metadata:
   openclaw:

package/skills/agent-slackbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-slackbot
 description: Interact with Slack workspaces using bot tokens - send messages, read channels, manage reactions
-version: 2.19.1
+version: 2.19.3
 allowed-tools: Bash(agent-slackbot:*)
 metadata:
   openclaw:

package/skills/agent-teams/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-teams
 description: Interact with Microsoft Teams - send messages, read channels, manage reactions
-version: 2.19.1
+version: 2.19.3
 allowed-tools: Bash(agent-teams:*)
 metadata:
   openclaw:

package/skills/agent-telegram/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-telegram
 description: Interact with Telegram through TDLib - authenticate, inspect chats, and send messages
-version: 2.19.1
+version: 2.19.3
 allowed-tools: Bash(agent-telegram:*)
 ---
 

package/skills/agent-telegrambot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-telegrambot
 description: Interact with Telegram using bot tokens - send messages, read chats, manage reactions
-version: 2.19.1
+version: 2.19.3
 allowed-tools: Bash(agent-telegrambot:*)
 metadata:
   openclaw:

package/skills/agent-webex/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-webex
 description: Interact with Cisco Webex - send messages, read spaces, manage memberships
-version: 2.19.1
+version: 2.19.3
 allowed-tools: Bash(agent-webex:*)
 metadata:
   openclaw:

package/skills/agent-wechatbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-wechatbot
 description: Interact with WeChat Official Account using API credentials - send messages, manage templates, list followers
-version: 2.19.1
+version: 2.19.3
 allowed-tools: Bash(agent-wechatbot:*)
 metadata:
   openclaw:

package/skills/agent-whatsapp/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-whatsapp
 description: Interact with WhatsApp - send messages, read chats, manage conversations
-version: 2.19.1
+version: 2.19.3
 allowed-tools: Bash(agent-whatsapp:*)
 metadata:
   openclaw:

package/skills/agent-whatsappbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-whatsappbot
 description: Interact with WhatsApp using Cloud API credentials - send messages, manage templates
-version: 2.19.1
+version: 2.19.3
 allowed-tools: Bash(agent-whatsappbot:*)
 metadata:
   openclaw:

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,216 @@ 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')
+    })
+
+    it('swallows empty long-poll errors so the connection is not torn down', async () => {
+      const client = new LineClient()
+      ;(client as any).client = {
+        base: {
+          profile: { mid: 'me' },
+          createPolling: () => ({
+            async *_listenTalkEvents(opts: { onError?: (e: unknown) => void }) {
+              // given: an idle long-poll returns an empty body, then a real op arrives
+              opts.onError?.(new Error('Request internal failed: Invalid response buffer <>'))
+              yield { type: 'NOTIFIED_READ_MESSAGE' }
+            },
+          }),
+          e2ee: { decryptE2EEMessage: async (m: unknown) => m },
+        },
+      }
+
+      const events = await collect(client)
+      expect(events.map((e) => e.kind)).toEqual(['event'])
+    })
+
+    it('propagates non-empty malformed buffer errors', 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('Request internal failed: Invalid response buffer <de ad be ef>'))
+              yield undefined as never
+            },
+          }),
+          e2ee: { decryptE2EEMessage: async (m: unknown) => m },
+        },
+      }
+
+      await expect(collect(client)).rejects.toThrow('Invalid response buffer <de ad be ef>')
+    })
+  })
+
   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,46 @@ 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)
+}
+
+// An idle long-poll returning zero bytes is normal, but the vendored Thrift reader
+// throws "Invalid response buffer <>" (empty brackets = empty body). Match only that
+// empty case so the poll loop continues; a non-empty malformed buffer still propagates.
+function isEmptyLongPollError(message: string): boolean {
+  return /Invalid response buffer <>/.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 +245,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 +278,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 +294,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 +322,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 +359,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 +389,55 @@ 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) => {
+        const message = error instanceof Error ? error.message : String(error)
+        if (isEmptyLongPollError(message)) return
+        throw error instanceof Error ? error : new Error(message)
+      },
+    })) {
+      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
   }