@2en/clawly-plugins 1.24.8-beta.1 → 1.25.0-beta.2

package/gateway/notification.ts

@@ -5,6 +5,7 @@
  * Methods:
  * - clawly.notification.setToken({ token }) → { registered: boolean }
  * - clawly.notification.send({ body, title?, data? }) → { sent: boolean }
+ * - clawly.notification.clearBadge({}) → { cleared: boolean }
  *
  * Internal: sendPushNotification({ body, title?, data? })
  */
@@ -29,6 +30,7 @@ function extractEmoji(value: string | undefined): string | null {
 
 const TOKEN_DIR = path.join(os.homedir(), '.openclaw', 'clawly')
 const TOKEN_FILE = path.join(TOKEN_DIR, 'expo-push-token.json')
+const BADGE_FILE = path.join(TOKEN_DIR, 'badge-count.json')
 const EXPO_PUSH_URL = 'https://exp.host/--/api/v2/push/send'
 
 function persistToken(token: string, api: PluginApi): void {
@@ -54,6 +56,59 @@ export function getPushToken(): string | null {
   return null
 }
 
+// ── Badge counter ────────────────────────────────────────────────
+// In-memory counter avoids TOCTOU races between concurrent agent_end
+// handlers. File is only for persistence across process restarts.
+
+let badgeCounter: number | null = null
+
+function loadBadgeCount(): number {
+  if (badgeCounter != null) return badgeCounter
+  try {
+    if (fs.existsSync(BADGE_FILE)) {
+      const data = JSON.parse(fs.readFileSync(BADGE_FILE, 'utf-8'))
+      if (typeof data.count === 'number') {
+        badgeCounter = data.count
+        return badgeCounter
+      }
+    }
+  } catch {}
+  badgeCounter = 0
+  return 0
+}
+
+function persistBadgeCount(count: number): void {
+  try {
+    fs.mkdirSync(TOKEN_DIR, {recursive: true})
+    fs.writeFileSync(BADGE_FILE, JSON.stringify({count}))
+  } catch {}
+}
+
+/**
+ * Atomically increment badge counter (sync — safe in single-threaded Node.js).
+ * Persists to disk immediately so the count survives process restarts.
+ */
+export function incrementBadgeCount(): number {
+  const next = loadBadgeCount() + 1
+  badgeCounter = next
+  persistBadgeCount(next)
+  return next
+}
+
+/** Roll back one increment (e.g. when push delivery fails). */
+export function decrementBadgeCount(): void {
+  const current = loadBadgeCount()
+  if (current > 0) {
+    badgeCounter = current - 1
+    persistBadgeCount(current - 1)
+  }
+}
+
+function resetBadgeCount(): void {
+  badgeCounter = 0
+  persistBadgeCount(0)
+}
+
 /**
  * Fetch agent display identity (name, emoji) via gateway RPC.
  * Returns null on failure so the caller can fall back to defaults.
@@ -118,6 +173,16 @@ export async function sendPushNotification(
       return false
     }
 
+    // Expo returns 200 but marks tickets as errors (e.g. DeviceNotRegistered).
+    // Single-message POST returns data as a plain object, not an array.
+    const ticket = Array.isArray(json?.data) ? json.data[0] : json?.data
+    if (ticket?.status === 'error') {
+      api.logger.warn(
+        `notification: push ticket error — ${ticket.message} (${ticket.details?.error})`,
+      )
+      return false
+    }
+
     api.logger.info(`notification: push sent — "${opts.body}"`)
     return true
   } catch (err) {
@@ -160,7 +225,13 @@ export function registerNotification(api: PluginApi) {
     respond(sent, {sent})
   })
 
+  api.registerGatewayMethod('clawly.notification.clearBadge', async ({respond}) => {
+    resetBadgeCount()
+    api.logger.info('notification: badge count cleared')
+    respond(true, {cleared: true})
+  })
+
   api.logger.info(
-    'notification: registered clawly.notification.setToken + clawly.notification.send',
+    'notification: registered clawly.notification.setToken + clawly.notification.send + clawly.notification.clearBadge',
   )
 }

package/gateway/offline-push.test.ts

@@ -18,12 +18,21 @@ let lastPushOpts: {
   data?: Record<string, unknown>
 } | null = null
 let lastPushExtras: Record<string, unknown> | undefined = undefined
+let mockBadgeCount = 0
 
 mock.module('./presence', () => ({
   isClientOnline: async () => mockOnline,
 }))
 
 mock.module('./notification', () => ({
+  getPushToken: () => 'ExponentPushToken[mock]',
+  incrementBadgeCount: () => {
+    mockBadgeCount += 1
+    return mockBadgeCount
+  },
+  decrementBadgeCount: () => {
+    if (mockBadgeCount > 0) mockBadgeCount -= 1
+  },
   sendPushNotification: async (
     opts: {body: string; title?: string; agentId?: string; data?: Record<string, unknown>},
     _api: PluginApi,
@@ -68,6 +77,7 @@ beforeEach(() => {
   mockPushSent = true
   lastPushOpts = null
   lastPushExtras = undefined
+  mockBadgeCount = 0
 })
 
 describe('offline-push', () => {
@@ -110,6 +120,32 @@ describe('offline-push', () => {
     expect(logs.filter((l) => l.msg.includes('notified'))).toHaveLength(2)
   })
 
+  test('passes incrementing badge count in push extras', async () => {
+    const {api, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    const handler = handlers.get('agent_end')!
+
+    await handler({}, {sessionKey: 'agent:clawly:main'})
+    expect(lastPushExtras).toEqual({badge: 1})
+    expect(mockBadgeCount).toBe(1)
+
+    await handler({}, {sessionKey: 'agent:clawly:main'})
+    expect(lastPushExtras).toEqual({badge: 2})
+    expect(mockBadgeCount).toBe(2)
+  })
+
+  test('rolls back badge count when push fails', async () => {
+    mockPushSent = false
+    const {api, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    await handlers.get('agent_end')!({}, {sessionKey: 'agent:clawly:main'})
+
+    expect(lastPushExtras).toEqual({badge: 1})
+    expect(mockBadgeCount).toBe(0) // incremented then decremented
+  })
+
   test('skips push for non-main session (e.g. telegram)', async () => {
     const {api, logs, handlers} = createMockApi()
     registerOfflinePush(api)

package/gateway/offline-push.ts

@@ -10,7 +10,12 @@
  */
 
 import type {PluginApi} from '../types'
-import {sendPushNotification} from './notification'
+import {
+  decrementBadgeCount,
+  getPushToken,
+  incrementBadgeCount,
+  sendPushNotification,
+} from './notification'
 import {isClientOnline} from './presence'
 
 /** Strip [[type:value]], [[word]], and MEDIA:xxx placeholders from text (canonical: apps/mobile/lib/stripPlaceholders.ts). */
@@ -141,6 +146,12 @@ export function registerOfflinePush(api: PluginApi) {
       const preview = cleaned && cleaned.length > 140 ? `${cleaned.slice(0, 140)}…` : cleaned
       const body = preview || 'Your response is ready'
 
+      if (!getPushToken()) {
+        api.logger.warn('offline-push: skipped (no push token)')
+        return
+      }
+
+      const badge = incrementBadgeCount()
       const sent = await sendPushNotification(
         {
           body,
@@ -151,10 +162,13 @@ export function registerOfflinePush(api: PluginApi) {
           },
         },
         api,
+        {badge},
       )
 
       if (sent) {
         api.logger.info(`offline-push: notified (session=${sessionKey ?? 'unknown'})`)
+      } else {
+        decrementBadgeCount()
       }
     } catch (err) {
       api.logger.error(`offline-push: ${err instanceof Error ? err.message : String(err)}`)

package/package.json

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