@2en/clawly-plugins 1.16.3 → 1.17.0

package/gateway/offline-push.test.ts

@@ -1,10 +1,12 @@
-import {afterEach, beforeEach, describe, expect, mock, test} from 'bun:test'
+import {beforeEach, describe, expect, mock, test} from 'bun:test'
 import type {PluginApi} from '../index'
 import {
   PUSH_COOLDOWN_S,
   _resetCooldowns,
   getLastAssistantPreview,
+  getLastAssistantText,
   registerOfflinePush,
+  shouldSkipPushForMessage,
 } from './offline-push'
 
 // ── Mocks ────────────────────────────────────────────────────────
@@ -240,13 +242,13 @@ describe('offline-push', () => {
   })
 })
 
-// ── getLastAssistantPreview unit tests ──────────────────────────
+// ── getLastAssistantText / getLastAssistantPreview unit tests ────
 
-describe('getLastAssistantPreview', () => {
+describe('getLastAssistantText', () => {
   test('returns null for non-array input', () => {
-    expect(getLastAssistantPreview(undefined)).toBeNull()
-    expect(getLastAssistantPreview(null)).toBeNull()
-    expect(getLastAssistantPreview('string')).toBeNull()
+    expect(getLastAssistantText(undefined)).toBeNull()
+    expect(getLastAssistantText(null)).toBeNull()
+    expect(getLastAssistantText('string')).toBeNull()
   })
 
   test('extracts string content from last assistant message', () => {
@@ -256,7 +258,7 @@ describe('getLastAssistantPreview', () => {
       {role: 'user', content: 'Another question'},
       {role: 'assistant', content: 'Second reply'},
     ]
-    expect(getLastAssistantPreview(messages)).toBe('Second reply')
+    expect(getLastAssistantText(messages)).toBe('Second reply')
   })
 
   test('handles array content with text parts', () => {
@@ -269,14 +271,31 @@ describe('getLastAssistantPreview', () => {
         ],
       },
     ]
-    expect(getLastAssistantPreview(messages)).toBe('Hello world!')
+    expect(getLastAssistantText(messages)).toBe('Hello world!')
   })
 
   test('collapses newlines into spaces', () => {
     const messages = [{role: 'assistant', content: 'Line one\n\nLine two\nLine three'}]
-    expect(getLastAssistantPreview(messages)).toBe('Line one Line two Line three')
+    expect(getLastAssistantText(messages)).toBe('Line one Line two Line three')
+  })
+
+  test('returns empty string for last assistant with empty content', () => {
+    const messages = [
+      {role: 'assistant', content: 'Good reply'},
+      {role: 'assistant', content: ''},
+    ]
+    // Returns '' for the last assistant message (not fall-through to earlier)
+    // so the push filter can detect and skip it
+    expect(getLastAssistantText(messages)).toBe('')
+  })
+
+  test('returns null when no assistant messages exist', () => {
+    const messages = [{role: 'user', content: 'Hello'}]
+    expect(getLastAssistantText(messages)).toBeNull()
   })
+})
 
+describe('getLastAssistantPreview', () => {
   test('truncates long messages with ellipsis', () => {
     const longText = 'a'.repeat(200)
     const messages = [{role: 'assistant', content: longText}]
@@ -285,16 +304,126 @@ describe('getLastAssistantPreview', () => {
     expect(result.endsWith('…')).toBe(true)
   })
 
-  test('skips assistant messages with empty content', () => {
-    const messages = [
-      {role: 'assistant', content: 'Good reply'},
-      {role: 'assistant', content: ''},
-    ]
-    expect(getLastAssistantPreview(messages)).toBe('Good reply')
+  test('returns short messages untruncated', () => {
+    const messages = [{role: 'assistant', content: 'Short reply'}]
+    expect(getLastAssistantPreview(messages, 140)).toBe('Short reply')
   })
 
-  test('returns null when no assistant messages exist', () => {
-    const messages = [{role: 'user', content: 'Hello'}]
-    expect(getLastAssistantPreview(messages)).toBeNull()
+  test('returns null when no assistant messages', () => {
+    expect(getLastAssistantPreview([])).toBeNull()
+  })
+})
+
+// ── Push-filter tests ───────────────────────────────────────────
+
+describe('shouldSkipPushForMessage', () => {
+  test('skips empty assistant text', () => {
+    expect(shouldSkipPushForMessage('')).toBe('empty assistant')
+    expect(shouldSkipPushForMessage('   ')).toBe('empty assistant')
+    expect(shouldSkipPushForMessage('\n\n')).toBe('empty assistant')
+  })
+
+  test('skips NO_REPLY sentinel', () => {
+    expect(shouldSkipPushForMessage('NO_REPLY')).toBe('silent reply')
+    expect(shouldSkipPushForMessage(' NO_REPLY ')).toBe('silent reply')
+  })
+
+  test('skips short heartbeat ack', () => {
+    expect(shouldSkipPushForMessage('HEARTBEAT_OK')).toBe('heartbeat ack')
+    expect(shouldSkipPushForMessage('All good. HEARTBEAT_OK')).toBe('heartbeat ack')
+  })
+
+  test('does not skip long message containing HEARTBEAT_OK', () => {
+    const longMsg = 'HEARTBEAT_OK ' + 'x'.repeat(400)
+    expect(shouldSkipPushForMessage(longMsg)).toBeNull()
+  })
+
+  test('skips system prompt leak', () => {
+    expect(
+      shouldSkipPushForMessage('Here is some Conversation info (untrusted metadata) text'),
+    ).toBe('system prompt leak')
+  })
+
+  test('does not skip normal assistant messages', () => {
+    expect(shouldSkipPushForMessage('Hey! How can I help you?')).toBeNull()
+    expect(shouldSkipPushForMessage('Here is the weather report for today.')).toBeNull()
+    expect(shouldSkipPushForMessage('I completed the task you asked about.')).toBeNull()
+  })
+})
+
+describe('offline-push with filtered messages', () => {
+  test('skips push for NO_REPLY message', async () => {
+    const {api, logs, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    await handlers.get('agent_end')!({
+      sessionKey: 'sess-1',
+      messages: [{role: 'assistant', content: 'NO_REPLY'}],
+    })
+
+    expect(logs).toContainEqual({
+      level: 'info',
+      msg: expect.stringContaining('skipped (filtered: silent reply)'),
+    })
+    expect(logs.filter((l) => l.msg.includes('notified'))).toHaveLength(0)
+  })
+
+  test('skips push for heartbeat ack', async () => {
+    const {api, logs, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    await handlers.get('agent_end')!({
+      sessionKey: 'sess-1',
+      messages: [{role: 'assistant', content: 'HEARTBEAT_OK'}],
+    })
+
+    expect(logs).toContainEqual({
+      level: 'info',
+      msg: expect.stringContaining('skipped (filtered: heartbeat ack)'),
+    })
+    expect(logs.filter((l) => l.msg.includes('notified'))).toHaveLength(0)
+  })
+
+  test('skips push for empty assistant text', async () => {
+    const {api, logs, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    await handlers.get('agent_end')!({
+      sessionKey: 'sess-1',
+      messages: [{role: 'assistant', content: '   '}],
+    })
+
+    expect(logs).toContainEqual({
+      level: 'info',
+      msg: expect.stringContaining('skipped (filtered: empty assistant)'),
+    })
+  })
+
+  test('sends push for normal message text', async () => {
+    const {api, logs, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    await handlers.get('agent_end')!({
+      sessionKey: 'sess-1',
+      messages: [{role: 'assistant', content: 'I finished the task you asked about!'}],
+    })
+
+    expect(logs).toContainEqual({
+      level: 'info',
+      msg: expect.stringContaining('notified (session=sess-1)'),
+    })
+  })
+
+  test('sends push when event has no messages (safe default)', async () => {
+    const {api, logs, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    // No messages field — can't determine if filtered, so send push
+    await handlers.get('agent_end')!({sessionKey: 'sess-1'})
+
+    expect(logs).toContainEqual({
+      level: 'info',
+      msg: expect.stringContaining('notified (session=sess-1)'),
+    })
   })
 })

package/gateway/offline-push.ts

@@ -2,10 +2,14 @@
  * Offline push notification on agent_end — sends a push notification
  * when an agent run completes and the mobile client is disconnected.
  *
- * Hook: agent_end → check presence → send Expo push if offline
+ * Hook: agent_end → check presence → filter noise → send Expo push if offline
  *
  * Avoids double-push with clawly.agent.send (which pushes at dispatch
  * time for cron/external triggers) via a 30-second cooldown window.
+ *
+ * Skips push for messages the mobile UI would filter (heartbeat acks,
+ * NO_REPLY, compaction markers, etc.) — mirrors shouldFilterMessage()
+ * logic from apps/mobile/lib/messageFilter.ts.
  */
 
 import {$} from 'zx'
@@ -44,10 +48,11 @@ export async function getAgentIdentity(
 }
 
 /**
- * Extract the last assistant message text and truncate to `maxLen` chars.
- * Handles both string content and `{type:'text', text}[]` content formats.
+ * Extract the last assistant message's full text from a messages array.
+ * Handles both string and `{type:'text', text}[]` content formats.
+ * Returns the collapsed (newlines → spaces) but untruncated text, or null.
  */
-export function getLastAssistantPreview(messages: unknown, maxLen = 140): string | null {
+export function getLastAssistantText(messages: unknown): string | null {
   if (!Array.isArray(messages)) return null
 
   // Walk backwards to find the last assistant message
@@ -69,15 +74,50 @@ export function getLastAssistantPreview(messages: unknown, maxLen = 140): string
         .join('')
     }
 
-    if (!text) continue
+    // Collapse newlines → spaces, trim. Return even if empty — this IS
+    // the last assistant message; returning '' lets the filter catch it.
+    const collapsed = (text ?? '').replace(/\n+/g, ' ').trim()
+    return collapsed
+  }
 
-    // Collapse newlines → spaces, trim
-    const collapsed = text.replace(/\n+/g, ' ').trim()
-    if (!collapsed) continue
+  return null
+}
 
-    if (collapsed.length <= maxLen) return collapsed
-    return `${collapsed.slice(0, maxLen)}…`
-  }
+/**
+ * Extract the last assistant message text and truncate to `maxLen` chars.
+ * Convenience wrapper around `getLastAssistantText`.
+ */
+export function getLastAssistantPreview(messages: unknown, maxLen = 140): string | null {
+  const text = getLastAssistantText(messages)
+  if (!text) return null
+  if (text.length <= maxLen) return text
+  return `${text.slice(0, maxLen)}…`
+}
+
+// ── Push-filter: skip push for messages the mobile UI would hide ──
+
+/**
+ * Check whether the assistant message text is "noise" that the mobile
+ * UI would filter out via shouldFilterMessage(). If true, skip the push
+ * so the user isn't woken for nothing.
+ *
+ * Only covers assistant-role filter reasons — user-role triggers (heartbeat
+ * prompt, memory flush, etc.) are not directly available on the event.
+ */
+export function shouldSkipPushForMessage(text: string): string | null {
+  const trimmed = text.trim()
+
+  // Agent replied with empty content — mobile hides as "emptyAssistant"
+  if (trimmed === '') return 'empty assistant'
+
+  // Agent sentinel "nothing to say" — mobile hides as "silentReply"
+  if (trimmed === 'NO_REPLY') return 'silent reply'
+
+  // Short heartbeat acknowledgment — mobile hides as "heartbeatAck"
+  if (text.includes('HEARTBEAT_OK') && text.length < 400) return 'heartbeat ack'
+
+  // Agent echoed system prompt metadata — mobile hides as "systemPromptLeak"
+  if (text.includes('Conversation info (untrusted metadata)')) return 'system prompt leak'
 
   return null
 }
@@ -89,6 +129,18 @@ export function registerOfflinePush(api: PluginApi) {
       const online = await isClientOnline()
       if (online) return
 
+      // Extract full assistant text for filtering and preview.
+      const fullText = getLastAssistantText(event.messages)
+
+      // Skip if the message would be filtered by the mobile UI.
+      if (fullText != null) {
+        const reason = shouldSkipPushForMessage(fullText)
+        if (reason) {
+          api.logger.info(`offline-push: skipped (filtered: ${reason})`)
+          return
+        }
+      }
+
       const sessionKey = typeof event.sessionKey === 'string' ? event.sessionKey : undefined
       const cooldownKey = sessionKey ?? '__global__'
 
@@ -104,7 +156,7 @@ export function registerOfflinePush(api: PluginApi) {
       const agentId = typeof event.agentId === 'string' ? event.agentId : undefined
       const identity = await getAgentIdentity(agentId)
       const title = `${identity?.emoji ?? '🦞'} ${identity?.name ?? 'Clawly'}`
-      const preview = getLastAssistantPreview(event.messages, 140)
+      const preview = fullText && fullText.length > 140 ? `${fullText.slice(0, 140)}…` : fullText
       const body = preview ?? 'Your response is ready'
 
       const sent = await sendPushNotification(

package/package.json

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