@2en/clawly-plugins 1.16.2 → 1.17.0

package/gateway/offline-push.test.ts

@@ -1,20 +1,44 @@
-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, registerOfflinePush} from './offline-push'
+import {
+  PUSH_COOLDOWN_S,
+  _resetCooldowns,
+  getLastAssistantPreview,
+  getLastAssistantText,
+  registerOfflinePush,
+  shouldSkipPushForMessage,
+} from './offline-push'
 
 // ── Mocks ────────────────────────────────────────────────────────
 
 let mockOnline = false
 let mockPushSent = true
+let lastPushOpts: {body: string; title?: string; data?: Record<string, unknown>} | null = null
+let mockIdentity: {name?: string; emoji?: string} | null = null
 
 mock.module('./presence', () => ({
   isClientOnline: async () => mockOnline,
 }))
 
 mock.module('./notification', () => ({
-  sendPushNotification: async () => mockPushSent,
+  sendPushNotification: async (opts: {
+    body: string
+    title?: string
+    data?: Record<string, unknown>
+  }) => {
+    lastPushOpts = opts
+    return mockPushSent
+  },
 }))
 
+mock.module('./offline-push', () => {
+  const original = require('./offline-push')
+  return {
+    ...original,
+    getAgentIdentity: async () => mockIdentity,
+  }
+})
+
 // ── Helpers ──────────────────────────────────────────────────────
 
 function createMockApi(): {
@@ -44,6 +68,8 @@ function createMockApi(): {
 beforeEach(() => {
   mockOnline = false
   mockPushSent = true
+  mockIdentity = null
+  lastPushOpts = null
   _resetCooldowns()
 })
 
@@ -146,4 +172,258 @@ describe('offline-push', () => {
   test('exports PUSH_COOLDOWN_S as 30', () => {
     expect(PUSH_COOLDOWN_S).toBe(30)
   })
+
+  // ── Rich title/body tests ────────────────────────────────────
+
+  test('title shows agent emoji + name when identity is available', async () => {
+    mockIdentity = {name: 'Luna', emoji: '🐱'}
+    const {api, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    await handlers.get('agent_end')!({sessionKey: 'sess-1'})
+
+    expect(lastPushOpts?.title).toBe('🐱 Luna')
+  })
+
+  test('title falls back to 🦞 Clawly when identity fetch fails', async () => {
+    mockIdentity = null
+    const {api, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    await handlers.get('agent_end')!({sessionKey: 'sess-1'})
+
+    expect(lastPushOpts?.title).toBe('🦞 Clawly')
+  })
+
+  test('title uses default emoji when identity has name but no emoji', async () => {
+    mockIdentity = {name: 'Atlas'}
+    const {api, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    await handlers.get('agent_end')!({sessionKey: 'sess-1'})
+
+    expect(lastPushOpts?.title).toBe('🦞 Atlas')
+  })
+
+  test('body shows assistant message preview when messages are present', async () => {
+    const {api, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    await handlers.get('agent_end')!({
+      sessionKey: 'sess-1',
+      messages: [
+        {role: 'user', content: 'Hello'},
+        {role: 'assistant', content: 'Hi there! How can I help you today?'},
+      ],
+    })
+
+    expect(lastPushOpts?.body).toBe('Hi there! How can I help you today?')
+  })
+
+  test('body falls back when no messages', async () => {
+    const {api, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    await handlers.get('agent_end')!({sessionKey: 'sess-1'})
+
+    expect(lastPushOpts?.body).toBe('Your response is ready')
+  })
+
+  test('body falls back when messages has no assistant role', async () => {
+    const {api, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    await handlers.get('agent_end')!({
+      sessionKey: 'sess-1',
+      messages: [{role: 'user', content: 'Hello'}],
+    })
+
+    expect(lastPushOpts?.body).toBe('Your response is ready')
+  })
+})
+
+// ── getLastAssistantText / getLastAssistantPreview unit tests ────
+
+describe('getLastAssistantText', () => {
+  test('returns null for non-array input', () => {
+    expect(getLastAssistantText(undefined)).toBeNull()
+    expect(getLastAssistantText(null)).toBeNull()
+    expect(getLastAssistantText('string')).toBeNull()
+  })
+
+  test('extracts string content from last assistant message', () => {
+    const messages = [
+      {role: 'user', content: 'Hi'},
+      {role: 'assistant', content: 'First reply'},
+      {role: 'user', content: 'Another question'},
+      {role: 'assistant', content: 'Second reply'},
+    ]
+    expect(getLastAssistantText(messages)).toBe('Second reply')
+  })
+
+  test('handles array content with text parts', () => {
+    const messages = [
+      {
+        role: 'assistant',
+        content: [
+          {type: 'text', text: 'Hello '},
+          {type: 'text', text: '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(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}]
+    const result = getLastAssistantPreview(messages, 140)!
+    expect(result.length).toBe(141) // 140 chars + "…"
+    expect(result.endsWith('…')).toBe(true)
+  })
+
+  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', () => {
+    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,22 +2,126 @@
  * 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'
 import type {PluginApi} from '../index'
+import {stripCliLogs} from '../lib/stripCliLogs'
 import {sendPushNotification} from './notification'
 import {isClientOnline} from './presence'
 
+$.verbose = false
+
 /** Minimum seconds between consecutive push notifications per session. */
 export const PUSH_COOLDOWN_S = 30
 
 /** Per-session cooldown tracker. Key = sessionKey (or "__global__" for unknown). */
 const lastPushBySession = new Map<string, number>()
 
+/**
+ * Fetch agent display identity (name, emoji) via gateway RPC.
+ * Returns null on failure so the caller can fall back to defaults.
+ */
+export async function getAgentIdentity(
+  agentId: string | undefined,
+): Promise<{name?: string; emoji?: string} | null> {
+  if (!agentId) return null
+  try {
+    const rpcParams = JSON.stringify({agentId})
+    const result = await $`openclaw gateway call agent.identity.get --json --params ${rpcParams}`
+    const parsed = JSON.parse(stripCliLogs(result.stdout))
+    return {
+      name: typeof parsed.name === 'string' ? parsed.name : undefined,
+      emoji: typeof parsed.emoji === 'string' ? parsed.emoji : undefined,
+    }
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 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 getLastAssistantText(messages: unknown): string | null {
+  if (!Array.isArray(messages)) return null
+
+  // Walk backwards to find the last assistant message
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]
+    if (typeof msg !== 'object' || msg === null) continue
+    if ((msg as any).role !== 'assistant') continue
+
+    const content = (msg as any).content
+    let text: string | undefined
+
+    if (typeof content === 'string') {
+      text = content
+    } else if (Array.isArray(content)) {
+      // Concatenate all text parts
+      text = content
+        .filter((p: any) => typeof p === 'object' && p !== null && p.type === 'text')
+        .map((p: any) => p.text)
+        .join('')
+    }
+
+    // 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
+  }
+
+  return null
+}
+
+/**
+ * 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
+}
+
 export function registerOfflinePush(api: PluginApi) {
   api.on('agent_end', async (event: Record<string, unknown>) => {
     try {
@@ -25,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__'
 
@@ -37,9 +153,16 @@ export function registerOfflinePush(api: PluginApi) {
         return
       }
 
+      const agentId = typeof event.agentId === 'string' ? event.agentId : undefined
+      const identity = await getAgentIdentity(agentId)
+      const title = `${identity?.emoji ?? '🦞'} ${identity?.name ?? 'Clawly'}`
+      const preview = fullText && fullText.length > 140 ? `${fullText.slice(0, 140)}…` : fullText
+      const body = preview ?? 'Your response is ready'
+
       const sent = await sendPushNotification(
         {
-          body: 'Your response is ready',
+          title,
+          body,
           data: {
             type: 'agent_end',
             ...(sessionKey ? {sessionKey} : {}),

package/package.json

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