@2en/clawly-plugins 1.29.0-beta.0 → 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})`)