@2en/clawly-plugins 1.29.0-beta.1 → 1.29.0-beta.2

package/gateway/audit.ts

@@ -7,7 +7,7 @@
  */
 
 import {$} from 'zx'
-import {stripCliLogsFull} from '../lib/stripCliLogs'
+import {stripCliLogs} from '../lib/stripCliLogs'
 import type {PluginApi} from '../types'
 
 const TIMEOUT_MS = 30_000
@@ -27,7 +27,7 @@ export function registerAudit(api: PluginApi) {
         })
         return
       }
-      const json = stripCliLogsFull(result.stdout)
+      const json = stripCliLogs(result.stdout)
       respond(true, JSON.parse(json))
     } catch (err) {
       respond(false, undefined, {message: err instanceof Error ? err.message : 'Unknown error'})

package/gateway/cron-delivery.test.ts

@@ -0,0 +1,385 @@
+import {beforeEach, describe, expect, mock, test} from 'bun:test'
+import type {PluginApi} from '../types'
+
+// ── Mocks ────────────────────────────────────────────────────────
+
+let mockResolvedKey = 'agent:clawly:main'
+let mockInjectResult = {ok: true, messageId: 'msg-001'}
+let mockResolveError: Error | null = null
+let mockInjectError: Error | null = null
+let resolveSessionKeyCalls: string[] = []
+let injectCalls: {sessionKey: string; message: string}[] = []
+
+mock.module('./inject', () => ({
+  resolveSessionKey: async (agentId: string) => {
+    resolveSessionKeyCalls.push(agentId)
+    if (mockResolveError) throw mockResolveError
+    return mockResolvedKey
+  },
+  injectAssistantMessage: async (params: {sessionKey: string; message: string}) => {
+    injectCalls.push(params)
+    if (mockInjectError) throw mockInjectError
+    return mockInjectResult
+  },
+}))
+
+// Do NOT mock cron-telemetry — it uses module-internal state (Maps) that
+// cron-telemetry.test.ts depends on, and Bun's mock.module contaminates
+// across test files in the same process. Assert on logs + inject calls instead.
+
+// autoUpdateJobId is a `let` export — ESM namespace objects are frozen,
+// so we can't mutate it between tests. We set it to 'test-auto-update-id'
+// and test the job-ID matching path using a sessionKey that embeds this ID.
+const MOCK_AUTO_UPDATE_ID = 'test-auto-update-id'
+
+mock.module('../internal/hooks/auto-update', () => ({
+  autoUpdateJobId: MOCK_AUTO_UPDATE_ID,
+  JOB_NAME: 'Clawly Plugins Auto-Update',
+}))
+
+// Must import after mocks
+const {registerCronDelivery} = await import('./cron-delivery')
+
+// ── Helpers ──────────────────────────────────────────────────────
+
+type Handler = (event: Record<string, unknown>, ctx?: Record<string, unknown>) => Promise<void>
+
+function createMockApi(): {
+  api: PluginApi
+  logs: {level: string; msg: string}[]
+  handlers: Map<string, Handler>
+} {
+  const logs: {level: string; msg: string}[] = []
+  const handlers = new Map<string, Handler>()
+  const api = {
+    id: 'test',
+    name: 'test',
+    logger: {
+      info: (msg: string) => logs.push({level: 'info', msg}),
+      warn: (msg: string) => logs.push({level: 'warn', msg}),
+      error: (msg: string) => logs.push({level: 'error', msg}),
+    },
+    on: (hookName: string, handler: (...args: any[]) => any) => {
+      handlers.set(hookName, handler as any)
+    },
+  } as unknown as PluginApi
+  return {api, logs, handlers}
+}
+
+function makeMessages(assistantContent: string | object[]) {
+  return [
+    {role: 'user', content: 'trigger message'},
+    {role: 'assistant', content: assistantContent},
+  ]
+}
+
+// ── Tests ────────────────────────────────────────────────────────
+
+beforeEach(() => {
+  mockResolvedKey = 'agent:clawly:main'
+  mockInjectResult = {ok: true, messageId: 'msg-001'}
+  mockResolveError = null
+  mockInjectError = null
+  resolveSessionKeyCalls = []
+  injectCalls = []
+})
+
+describe('cron-delivery', () => {
+  describe('session filtering', () => {
+    test('skips non-cron sessions (main)', async () => {
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Hello!')},
+        {sessionKey: 'agent:clawly:main', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(resolveSessionKeyCalls).toHaveLength(0)
+    })
+
+    test('skips non-cron sessions (telegram)', async () => {
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Hello!')},
+        {sessionKey: 'agent:clawly:telegram:12345', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+    })
+
+    test('skips when sessionKey is missing', async () => {
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!({messages: makeMessages('Hello!')}, {})
+
+      expect(injectCalls).toHaveLength(0)
+    })
+  })
+
+  describe('assistant text extraction', () => {
+    test('skips when no assistant message in event', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: [{role: 'user', content: 'Hello'}]},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({
+        level: 'info',
+        msg: 'cron-delivery: skipped (no assistant message)',
+      })
+    })
+
+    test('skips when messages is undefined', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({
+        level: 'info',
+        msg: 'cron-delivery: skipped (no assistant message)',
+      })
+    })
+
+    test('extracts string content', async () => {
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Weather is sunny today!')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(1)
+      expect(injectCalls[0].message).toBe('Weather is sunny today!')
+    })
+
+    test('extracts array content (multi-part text)', async () => {
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {
+          messages: makeMessages([
+            {type: 'text', text: 'Part 1 '},
+            {type: 'text', text: 'Part 2'},
+          ]),
+        },
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(1)
+      expect(injectCalls[0].message).toBe('Part 1 Part 2')
+    })
+
+    test('preserves raw formatting (newlines)', async () => {
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Line one\n\nLine two')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(1)
+      // cron-delivery uses getRawLastAssistantText which preserves newlines
+      expect(injectCalls[0].message).toBe('Line one\n\nLine two')
+    })
+  })
+
+  describe('auto-update filtering', () => {
+    test('skips by job ID match in sessionKey', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      // sessionKey embeds MOCK_AUTO_UPDATE_ID — matches the primary job-ID check
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Update complete')},
+        {sessionKey: `agent:clawly:cron:${MOCK_AUTO_UPDATE_ID}`, agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({level: 'info', msg: 'cron-delivery: skipped (auto-update job)'})
+    })
+
+    test('skips by JOB_NAME text match (fallback)', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      // sessionKey does NOT match the job ID — falls through to text-based detection
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Clawly Plugins Auto-Update completed successfully')},
+        {sessionKey: 'agent:clawly:cron:some-other-id', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({level: 'info', msg: 'cron-delivery: skipped (auto-update job)'})
+    })
+  })
+
+  describe('noise filtering', () => {
+    test('skips NO_REPLY', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('NO_REPLY')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({
+        level: 'info',
+        msg: expect.stringContaining('skipped (filtered: silent reply)'),
+      })
+    })
+
+    test('skips HEARTBEAT_OK (bare)', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('HEARTBEAT_OK')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({
+        level: 'info',
+        msg: expect.stringContaining('skipped (filtered: heartbeat ack)'),
+      })
+    })
+
+    test('skips empty text', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('   ')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({
+        level: 'info',
+        msg: expect.stringContaining('skipped (filtered: empty assistant)'),
+      })
+    })
+
+    test('does not skip meaningful content ending with HEARTBEAT_OK', async () => {
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Weather is good today. HEARTBEAT_OK')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(1)
+    })
+  })
+
+  describe('agentId validation', () => {
+    test('skips when agentId is missing', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Weather report')},
+        {sessionKey: 'agent:clawly:cron:weather-check'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(resolveSessionKeyCalls).toHaveLength(0)
+      expect(logs).toContainEqual({
+        level: 'error',
+        msg: 'cron-delivery: skipped (no agentId on ctx)',
+      })
+    })
+  })
+
+  describe('happy path', () => {
+    test('resolves session key and injects message', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Weather is sunny today!')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(resolveSessionKeyCalls).toEqual(['clawly'])
+      expect(injectCalls).toEqual([
+        {sessionKey: 'agent:clawly:main', message: 'Weather is sunny today!'},
+      ])
+      expect(logs).toContainEqual({
+        level: 'info',
+        msg: 'cron-delivery: injected into agent:clawly:main (messageId=msg-001)',
+      })
+    })
+
+    test('uses resolved session key (not hardcoded)', async () => {
+      mockResolvedKey = 'agent:luna:main'
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Report ready')},
+        {sessionKey: 'agent:clawly:cron:daily-report', agentId: 'luna'},
+      )
+
+      expect(resolveSessionKeyCalls).toEqual(['luna'])
+      expect(injectCalls[0].sessionKey).toBe('agent:luna:main')
+    })
+  })
+
+  describe('error handling', () => {
+    test('handles resolveSessionKey failure gracefully', async () => {
+      mockResolveError = new Error('sessions.resolve failed: JSON parse error')
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Weather report')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({
+        level: 'error',
+        msg: 'cron-delivery: sessions.resolve failed: JSON parse error',
+      })
+    })
+
+    test('handles injectAssistantMessage failure gracefully', async () => {
+      mockInjectError = new Error('chat.inject failed: timeout')
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Weather report')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      // injectAssistantMessage was called (recorded) but threw
+      expect(injectCalls).toHaveLength(1)
+      expect(logs).toContainEqual({
+        level: 'error',
+        msg: 'cron-delivery: chat.inject failed: timeout',
+      })
+    })
+  })
+})

package/gateway/cron-delivery.ts

@@ -52,12 +52,13 @@ export function registerCronDelivery(api: PluginApi) {
   api.on('agent_end', async (event: Record<string, unknown>, ctx?: Record<string, unknown>) => {
     const sessionKey = typeof ctx?.sessionKey === 'string' ? ctx.sessionKey : undefined
     const agentId = typeof ctx?.agentId === 'string' ? ctx.agentId : undefined
-    api.logger.info(
-      `cron-delivery[debug]: agent_end fired sessionKey=${sessionKey ?? 'undefined'} agentId=${agentId ?? 'undefined'} trigger=${String(ctx?.trigger ?? 'undefined')}`,
-    )
     // Only fire for cron sessions
     if (!sessionKey?.startsWith('agent:clawly:cron:')) return
 
+    api.logger.info(
+      `cron-delivery[debug]: agent_end fired sessionKey=${sessionKey} agentId=${agentId ?? 'undefined'} trigger=${String(ctx?.trigger ?? 'undefined')}`,
+    )
+
     try {
       // Extract raw assistant text (preserving formatting)
       const text = getRawLastAssistantText(event.messages)
@@ -78,7 +79,10 @@ export function registerCronDelivery(api: PluginApi) {
         return
       }
 
-      // Filter noise — reuse the same logic as offline-push
+      // Filter noise — reuse the same logic as offline-push.
+      // Note: shouldSkipPushForMessage was designed for newline-collapsed text
+      // (via getLastAssistantText), but works correctly here with raw text
+      // because all its regexes use \s (matches \n) and $ without /m flag.
       const reason = shouldSkipPushForMessage(text)
       if (reason) {
         api.logger.info(`cron-delivery: skipped (filtered: ${reason})`)

package/internal/hooks/auto-update.ts

@@ -4,7 +4,7 @@
  */
 import {$} from 'zx'
 
-import {stripCliLogsFull} from '../../lib/stripCliLogs'
+import {stripCliLogs} from '../../lib/stripCliLogs'
 import type {PluginApi} from '../../types'
 
 $.verbose = false
@@ -90,7 +90,7 @@ function needsUpdate(job: CronJobEntry, config: JobConfig): boolean {
 async function findJobs(): Promise<[unknown, CronJobEntry[]]> {
   try {
     const {stdout} = await $`openclaw cron list --json`
-    const parsed = JSON.parse(stripCliLogsFull(stdout))
+    const parsed = JSON.parse(stripCliLogs(stdout))
     const jobs: unknown[] = parsed?.jobs ?? parsed ?? []
     if (!Array.isArray(jobs)) return [null, []]
     return [null, jobs.filter((j: any) => j.name === JOB_NAME) as CronJobEntry[]]
@@ -136,7 +136,7 @@ export function registerAutoUpdate(api: PluginApi) {
         const {stdout} =
           await $`openclaw cron add ${['--name', JOB_NAME, '--json', ...configToArgs(JOB_CONFIG)]}`
         try {
-          const result = JSON.parse(stripCliLogsFull(stdout))
+          const result = JSON.parse(stripCliLogs(stdout))
           autoUpdateJobId = result?.id ?? null
         } catch {
           // ID extraction failed — job was still created

package/lib/stripCliLogs.test.ts

@@ -1,5 +1,5 @@
 import {describe, expect, test} from 'bun:test'
-import {stripCliLogs, stripCliLogsFull} from './stripCliLogs'
+import {stripCliLogs} from './stripCliLogs'
 
 describe('stripCliLogs', () => {
   test('strips leading log lines', () => {
@@ -82,9 +82,7 @@ describe('stripCliLogs', () => {
     const input = ['11:40:09 [plugins] loading', '[', '  {"id":"test"}', ']'].join('\n')
     expect(stripCliLogs(input)).toBe('[\n  {"id":"test"}\n]')
   })
-})
 
-describe('stripCliLogsFull', () => {
   test('strips both leading and trailing log lines around pretty-printed JSON', () => {
     const input = [
       '19:48:48 [plugins] feishu_drive: Registered feishu_drive tool',
@@ -94,29 +92,19 @@ describe('stripCliLogsFull', () => {
       '}',
       '19:48:49 [plugins] echo: registered /clawly_echo command',
     ].join('\n')
-    expect(stripCliLogsFull(input)).toBe('{\n  "jobs": []\n}')
-    expect(JSON.parse(stripCliLogsFull(input))).toEqual({jobs: []})
+    expect(stripCliLogs(input)).toBe('{\n  "jobs": []\n}')
+    expect(JSON.parse(stripCliLogs(input))).toEqual({jobs: []})
   })
 
   test('strips trailing log lines after compact single-line JSON', () => {
     const input = ['{"ok":true}', '19:48:49 [plugins] echo: registered /clawly_echo command'].join(
       '\n',
     )
-    expect(stripCliLogsFull(input)).toBe('{"ok":true}')
-  })
-
-  test('behaves like stripCliLogs when no trailing log lines', () => {
-    const input = ['11:40:09 [plugins] loading', '{', '  "version": "1.0.0"', '}'].join('\n')
-    expect(stripCliLogsFull(input)).toBe(stripCliLogs(input))
-  })
-
-  test('returns empty string when all lines are logs', () => {
-    const input = '11:00:00 [a] foo\n12:00:00 [b] bar'
-    expect(stripCliLogsFull(input)).toBe('')
+    expect(stripCliLogs(input)).toBe('{"ok":true}')
   })
 
   test('handles JSON array with leading and trailing logs', () => {
     const input = ['[plugins] loading', '[', '  {"id":"test"}', ']', '[plugins] done'].join('\n')
-    expect(stripCliLogsFull(input)).toBe('[\n  {"id":"test"}\n]')
+    expect(stripCliLogs(input)).toBe('[\n  {"id":"test"}\n]')
   })
 })

package/lib/stripCliLogs.ts

@@ -1,42 +1,27 @@
 /**
- * Strip leading log lines from `openclaw ... --json` output.
+ * Strip leading and trailing log lines from `openclaw ... --json` output.
  *
  * OpenClaw CLI may emit log lines (with or without ANSI colors / timestamps)
- * before the actual JSON payload:
+ * before and after the actual JSON payload:
  *
  *   11:40:09 [plugins] echo: registered /clawly_echo command
  *   \x1b[35m[plugins] tool: registered clawly_send_app_push agent tool
  *   [{"id":"clawly-plugins", ...}]
+ *   19:48:49 [plugins] echo: registered /clawly_echo command
  *
  * It may also emit a "Config warnings" box using box-drawing characters
  * (│, ◇, ├, ─, ╮, ╯) between log lines and the JSON body.
  *
- * This function strips ANSI escape sequences, drops every leading line that
- * is not JSON (log prefixes, warning boxes, blank lines), and returns the
- * remaining text (the JSON body).
+ * This function strips ANSI escape sequences, drops every leading and trailing
+ * line that is not JSON (log prefixes, warning boxes, blank lines), and returns
+ * the remaining text (the JSON body).
  */
 
 const ANSI_RE = /\x1b\[[0-9;]*m/g
 const JSON_START_RE = /^\{|^\[$|^\[[\s\][{"]/
-
-export function stripCliLogs(output: string): string {
-  const cleaned = output.replace(ANSI_RE, '')
-  const lines = cleaned.split('\n')
-  const firstJson = lines.findIndex((line) => JSON_START_RE.test(line))
-  if (firstJson === -1) return ''
-  return lines.slice(firstJson).join('\n').trim()
-}
-
-/**
- * Strip both leading AND trailing non-JSON lines from CLI output.
- *
- * `stripCliLogs` only strips leading lines. This variant also removes
- * trailing log lines that appear after the JSON body closes — e.g.
- * `19:48:49 [plugins] echo: registered /clawly_echo command`.
- */
 const JSON_END_RE = /^[}\]]$/
 
-export function stripCliLogsFull(output: string): string {
+export function stripCliLogs(output: string): string {
   const cleaned = output.replace(ANSI_RE, '')
   const lines = cleaned.split('\n')
   const firstJson = lines.findIndex((line) => JSON_START_RE.test(line))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2en/clawly-plugins",
-  "version": "1.29.0-beta.1",
+  "version": "1.29.0-beta.2",
   "module": "index.ts",
   "type": "module",
   "repository": {