@2en/clawly-plugins 1.18.1 → 1.18.2

package/gateway/notification.ts

@@ -13,7 +13,11 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 
+import {$} from 'zx'
 import type {PluginApi} from '../index'
+import {stripCliLogs} from '../lib/stripCliLogs'
+
+$.verbose = false
 
 const TOKEN_DIR = path.join(os.homedir(), '.openclaw', 'clawly')
 const TOKEN_FILE = path.join(TOKEN_DIR, 'expo-push-token.json')
@@ -42,8 +46,38 @@ export function getPushToken(): string | null {
   return null
 }
 
+/**
+ * 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
+  }
+}
+
+/**
+ * Build a push notification title from agent identity.
+ * Falls back to "🦞 Clawly" when identity is unavailable.
+ */
+export async function resolveAgentTitle(agentId?: string): Promise<string> {
+  const identity = await getAgentIdentity(agentId)
+  return `${identity?.emoji ?? '🦞'} ${identity?.name ?? 'Clawly'}`
+}
+
 export async function sendPushNotification(
-  opts: {body: string; title?: string; data?: Record<string, unknown>},
+  opts: {body: string; title?: string; agentId?: string; data?: Record<string, unknown>},
   api: PluginApi,
   extras?: Record<string, unknown>,
 ): Promise<boolean> {
@@ -53,6 +87,8 @@ export async function sendPushNotification(
     return false
   }
 
+  const title = opts.title ?? (await resolveAgentTitle(opts.agentId))
+
   try {
     const res = await fetch(EXPO_PUSH_URL, {
       method: 'POST',
@@ -60,7 +96,7 @@ export async function sendPushNotification(
       body: JSON.stringify({
         to: token,
         sound: 'default',
-        title: opts.title ?? 'Clawly',
+        title,
         body: opts.body,
         data: opts.data,
         ...extras,

package/gateway/offline-push.test.ts

@@ -1,8 +1,6 @@
 import {beforeEach, describe, expect, mock, test} from 'bun:test'
 import type {PluginApi} from '../index'
 import {
-  PUSH_COOLDOWN_S,
-  _resetCooldowns,
   getLastAssistantPreview,
   getLastAssistantText,
   registerOfflinePush,
@@ -13,41 +11,41 @@ import {
 
 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
+let lastPushOpts: {
+  body: string
+  title?: string
+  agentId?: string
+  data?: Record<string, unknown>
+} | null = null
+let lastPushExtras: Record<string, unknown> | undefined = undefined
 
 mock.module('./presence', () => ({
   isClientOnline: async () => mockOnline,
 }))
 
 mock.module('./notification', () => ({
-  sendPushNotification: async (opts: {
-    body: string
-    title?: string
-    data?: Record<string, unknown>
-  }) => {
+  sendPushNotification: async (
+    opts: {body: string; title?: string; agentId?: string; data?: Record<string, unknown>},
+    _api: PluginApi,
+    extras?: Record<string, unknown>,
+  ) => {
     lastPushOpts = opts
+    lastPushExtras = extras
     return mockPushSent
   },
 }))
 
-mock.module('./offline-push', () => {
-  const original = require('./offline-push')
-  return {
-    ...original,
-    getAgentIdentity: async () => mockIdentity,
-  }
-})
-
 // ── 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, (event: Record<string, unknown>) => Promise<void>>
+  handlers: Map<string, Handler>
 } {
   const logs: {level: string; msg: string}[] = []
-  const handlers = new Map<string, (event: Record<string, unknown>) => Promise<void>>()
+  const handlers = new Map<string, Handler>()
   const api = {
     id: 'test',
     name: 'test',
@@ -68,9 +66,8 @@ function createMockApi(): {
 beforeEach(() => {
   mockOnline = false
   mockPushSent = true
-  mockIdentity = null
   lastPushOpts = null
-  _resetCooldowns()
+  lastPushExtras = undefined
 })
 
 describe('offline-push', () => {
@@ -79,7 +76,7 @@ describe('offline-push', () => {
     registerOfflinePush(api)
 
     const handler = handlers.get('agent_end')!
-    await handler({sessionKey: 'sess-1'})
+    await handler({}, {sessionKey: 'sess-1'})
 
     expect(logs).toContainEqual({
       level: 'info',
@@ -92,130 +89,68 @@ describe('offline-push', () => {
     const {api, logs, handlers} = createMockApi()
     registerOfflinePush(api)
 
-    await handlers.get('agent_end')!({sessionKey: 'sess-1'})
+    await handlers.get('agent_end')!({}, {sessionKey: 'sess-1'})
 
     expect(logs.filter((l) => l.msg.includes('notified'))).toHaveLength(0)
     expect(logs.filter((l) => l.msg.includes('skipped'))).toHaveLength(0)
   })
 
-  test('respects per-session cooldown', async () => {
+  test('sends push for consecutive calls on same session', async () => {
     const {api, logs, handlers} = createMockApi()
     registerOfflinePush(api)
 
     const handler = handlers.get('agent_end')!
 
-    // First call — should send
-    await handler({sessionKey: 'sess-1'})
-    expect(logs.filter((l) => l.msg.includes('notified'))).toHaveLength(1)
+    await handler({}, {sessionKey: 'sess-1'})
+    await handler({}, {sessionKey: 'sess-1'})
 
-    // Second call same session — should be cooldown-skipped
-    await handler({sessionKey: 'sess-1'})
-    expect(logs).toContainEqual({
-      level: 'info',
-      msg: expect.stringContaining('skipped (cooldown, session=sess-1)'),
-    })
+    expect(logs.filter((l) => l.msg.includes('notified'))).toHaveLength(2)
   })
 
-  test('different sessions have independent cooldowns', async () => {
+  test('sends push when ctx is missing', async () => {
     const {api, logs, handlers} = createMockApi()
     registerOfflinePush(api)
 
     const handler = handlers.get('agent_end')!
-
-    await handler({sessionKey: 'sess-1'})
-    await handler({sessionKey: 'sess-2'})
-
-    const notified = logs.filter((l) => l.msg.includes('notified'))
-    expect(notified).toHaveLength(2)
-    expect(notified[0].msg).toContain('sess-1')
-    expect(notified[1].msg).toContain('sess-2')
-  })
-
-  test('uses __global__ key when sessionKey is missing', async () => {
-    const {api, logs, handlers} = createMockApi()
-    registerOfflinePush(api)
-
-    const handler = handlers.get('agent_end')!
-    await handler({})
     await handler({})
 
     expect(logs).toContainEqual({
       level: 'info',
       msg: expect.stringContaining('notified (session=unknown)'),
     })
-    expect(logs).toContainEqual({
-      level: 'info',
-      msg: expect.stringContaining('skipped (cooldown, session=__global__)'),
-    })
   })
 
-  test('does not update cooldown when push is not sent', async () => {
-    mockPushSent = false
-    const {api, logs, handlers} = createMockApi()
-    registerOfflinePush(api)
-
-    const handler = handlers.get('agent_end')!
-
-    // Push returns false (e.g. no token) — cooldown should NOT be set
-    await handler({sessionKey: 'sess-1'})
-    expect(logs.filter((l) => l.msg.includes('notified'))).toHaveLength(0)
-
-    // Second call should NOT be cooldown-skipped since first wasn't sent
-    mockPushSent = true
-    await handler({sessionKey: 'sess-1'})
-    expect(logs).toContainEqual({
-      level: 'info',
-      msg: expect.stringContaining('notified (session=sess-1)'),
-    })
-  })
-
-  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
+  test('passes agentId from ctx to sendPushNotification', async () => {
     const {api, handlers} = createMockApi()
     registerOfflinePush(api)
 
-    await handlers.get('agent_end')!({sessionKey: 'sess-1'})
+    await handlers.get('agent_end')!({}, {sessionKey: 'sess-1', agentId: 'luna'})
 
-    expect(lastPushOpts?.title).toBe('🦞 Clawly')
+    expect(lastPushOpts?.agentId).toBe('luna')
   })
 
-  test('title uses default emoji when identity has name but no emoji', async () => {
-    mockIdentity = {name: 'Atlas'}
+  test('does not pass title — delegates to sendPushNotification', async () => {
     const {api, handlers} = createMockApi()
     registerOfflinePush(api)
 
-    await handlers.get('agent_end')!({sessionKey: 'sess-1'})
+    await handlers.get('agent_end')!({}, {sessionKey: 'sess-1'})
 
-    expect(lastPushOpts?.title).toBe('🦞 Atlas')
+    expect(lastPushOpts?.title).toBeUndefined()
   })
 
   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?'},
-      ],
-    })
+    await handlers.get('agent_end')!(
+      {
+        messages: [
+          {role: 'user', content: 'Hello'},
+          {role: 'assistant', content: 'Hi there! How can I help you today?'},
+        ],
+      },
+      {sessionKey: 'sess-1'},
+    )
 
     expect(lastPushOpts?.body).toBe('Hi there! How can I help you today?')
   })
@@ -224,7 +159,7 @@ describe('offline-push', () => {
     const {api, handlers} = createMockApi()
     registerOfflinePush(api)
 
-    await handlers.get('agent_end')!({sessionKey: 'sess-1'})
+    await handlers.get('agent_end')!({}, {sessionKey: 'sess-1'})
 
     expect(lastPushOpts?.body).toBe('Your response is ready')
   })
@@ -233,10 +168,10 @@ describe('offline-push', () => {
     const {api, handlers} = createMockApi()
     registerOfflinePush(api)
 
-    await handlers.get('agent_end')!({
-      sessionKey: 'sess-1',
-      messages: [{role: 'user', content: 'Hello'}],
-    })
+    await handlers.get('agent_end')!(
+      {messages: [{role: 'user', content: 'Hello'}]},
+      {sessionKey: 'sess-1'},
+    )
 
     expect(lastPushOpts?.body).toBe('Your response is ready')
   })
@@ -284,8 +219,6 @@ describe('getLastAssistantText', () => {
       {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('')
   })
 
@@ -356,10 +289,10 @@ describe('offline-push with filtered messages', () => {
     const {api, logs, handlers} = createMockApi()
     registerOfflinePush(api)
 
-    await handlers.get('agent_end')!({
-      sessionKey: 'sess-1',
-      messages: [{role: 'assistant', content: 'NO_REPLY'}],
-    })
+    await handlers.get('agent_end')!(
+      {messages: [{role: 'assistant', content: 'NO_REPLY'}]},
+      {sessionKey: 'sess-1'},
+    )
 
     expect(logs).toContainEqual({
       level: 'info',
@@ -372,10 +305,10 @@ describe('offline-push with filtered messages', () => {
     const {api, logs, handlers} = createMockApi()
     registerOfflinePush(api)
 
-    await handlers.get('agent_end')!({
-      sessionKey: 'sess-1',
-      messages: [{role: 'assistant', content: 'HEARTBEAT_OK'}],
-    })
+    await handlers.get('agent_end')!(
+      {messages: [{role: 'assistant', content: 'HEARTBEAT_OK'}]},
+      {sessionKey: 'sess-1'},
+    )
 
     expect(logs).toContainEqual({
       level: 'info',
@@ -388,10 +321,10 @@ describe('offline-push with filtered messages', () => {
     const {api, logs, handlers} = createMockApi()
     registerOfflinePush(api)
 
-    await handlers.get('agent_end')!({
-      sessionKey: 'sess-1',
-      messages: [{role: 'assistant', content: '   '}],
-    })
+    await handlers.get('agent_end')!(
+      {messages: [{role: 'assistant', content: '   '}]},
+      {sessionKey: 'sess-1'},
+    )
 
     expect(logs).toContainEqual({
       level: 'info',
@@ -403,10 +336,10 @@ describe('offline-push with filtered messages', () => {
     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!'}],
-    })
+    await handlers.get('agent_end')!(
+      {messages: [{role: 'assistant', content: 'I finished the task you asked about!'}]},
+      {sessionKey: 'sess-1'},
+    )
 
     expect(logs).toContainEqual({
       level: 'info',
@@ -418,8 +351,7 @@ describe('offline-push with filtered messages', () => {
     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'})
+    await handlers.get('agent_end')!({}, {sessionKey: 'sess-1'})
 
     expect(logs).toContainEqual({
       level: 'info',

package/gateway/offline-push.ts

@@ -4,49 +4,15 @@
  *
  * 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.
@@ -123,7 +89,7 @@ export function shouldSkipPushForMessage(text: string): string | null {
 }
 
 export function registerOfflinePush(api: PluginApi) {
-  api.on('agent_end', async (event: Record<string, unknown>) => {
+  api.on('agent_end', async (event: Record<string, unknown>, ctx?: Record<string, unknown>) => {
     try {
       // Skip if client is still connected — they got the response in real-time.
       const online = await isClientOnline()
@@ -141,28 +107,17 @@ export function registerOfflinePush(api: PluginApi) {
         }
       }
 
-      const sessionKey = typeof event.sessionKey === 'string' ? event.sessionKey : undefined
-      const cooldownKey = sessionKey ?? '__global__'
+      // agentId and sessionKey live on ctx (PluginHookAgentContext), not event.
+      const sessionKey = typeof ctx?.sessionKey === 'string' ? ctx.sessionKey : undefined
+      const agentId = typeof ctx?.agentId === 'string' ? ctx.agentId : undefined
 
-      // Cooldown: skip if a push was sent recently for this session
-      // (e.g. by clawly.agent.send).
-      const now = Date.now() / 1000
-      const lastPush = lastPushBySession.get(cooldownKey) ?? 0
-      if (now - lastPush < PUSH_COOLDOWN_S) {
-        api.logger.info(`offline-push: skipped (cooldown, session=${cooldownKey})`)
-        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(
         {
-          title,
           body,
+          agentId,
           data: {
             type: 'agent_end',
             ...(sessionKey ? {sessionKey} : {}),
@@ -172,7 +127,6 @@ export function registerOfflinePush(api: PluginApi) {
       )
 
       if (sent) {
-        lastPushBySession.set(cooldownKey, Date.now() / 1000)
         api.logger.info(`offline-push: notified (session=${sessionKey ?? 'unknown'})`)
       }
     } catch (err) {
@@ -182,8 +136,3 @@ export function registerOfflinePush(api: PluginApi) {
 
   api.logger.info('offline-push: registered agent_end hook')
 }
-
-/** @internal — exposed for testing */
-export function _resetCooldowns() {
-  lastPushBySession.clear()
-}

package/package.json

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