@2en/clawly-plugins 1.30.0-beta.4 → 1.30.0-beta.6

package/clawly-config-defaults.json5

@@ -179,9 +179,23 @@
     },
   },
 
+  // gateway.reload — use "hot" mode to prevent spurious SIGUSR1 restarts.
+  // config-setup writes restart-requiring keys (commands.*, gateway.*, env.*)
+  // after the gateway has already captured its startup config snapshot.
+  // In "hybrid" (default) mode, any subsequent config file write triggers the
+  // file watcher to diff against the stale snapshot, discover the config-setup
+  // changes as "new", and issue SIGUSR1. "hot" mode makes the watcher ignore
+  // restart-requiring diffs — only hot-reloadable changes (heartbeat, cron,
+  // hooks, browser) are applied. Direct SIGUSR1 from explicit restart commands
+  // and plugin auto-update is unaffected. If you manually edit a restart-
+  // requiring field in openclaw.json, run `openclaw restart` to apply it.
+  //
   // gateway.nodes — allowlist dangerous node commands so the AI agent can
   // invoke them on connected Clawly nodes (browser, reminders, calendar, device).
   gateway: {
+    reload: {
+      mode: "hot",
+    },
     nodes: {
       allowCommands: [
         // Browser commands (Mac nodes)

package/gateway/config-model.ts

@@ -0,0 +1,68 @@
+/**
+ * Model switch RPC: writes agents.defaults.model.primary to openclaw.json
+ * without triggering a gateway restart.
+ *
+ * OpenClaw reads agents.defaults.model.primary dynamically on each chat
+ * request (loadConfig() has a ~200ms cache). A disk write takes effect
+ * within that window — no SIGUSR1 needed.
+ *
+ * Uses the runtime config APIs (loadConfig + writeConfigFile) for atomic
+ * writes, env var preservation, and config validation.
+ *
+ * Methods:
+ * - clawly.config.setModel({ model }) → { changed, model }
+ */
+
+import type {PluginApi} from '../types'
+import type {OpenClawConfig} from '../types/openclaw'
+
+export function registerConfigModel(api: PluginApi) {
+  api.registerGatewayMethod('clawly.config.setModel', async ({params, respond}) => {
+    const model = typeof params.model === 'string' ? params.model : ''
+    if (!model) {
+      respond(true, {changed: false, model: '', error: 'Missing model param'})
+      return
+    }
+
+    let config: OpenClawConfig
+    try {
+      config = {...(api.runtime.config.loadConfig() as OpenClawConfig)}
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      respond(true, {changed: false, model, error: `Load failed: ${msg}`})
+      return
+    }
+
+    const current = (config.agents as Record<string, unknown> | undefined)?.defaults as
+      | Record<string, unknown>
+      | undefined
+    const currentModel = (current?.model as Record<string, unknown> | undefined)?.primary
+
+    if (currentModel === model) {
+      respond(true, {changed: false, model})
+      return
+    }
+
+    // Shallow-copy nested objects to avoid polluting the loadConfig() cache
+    // if writeConfigFile fails below.
+    const agents = {...((config.agents ?? {}) as Record<string, unknown>)}
+    const defaults = {...((agents.defaults ?? {}) as Record<string, unknown>)}
+    const modelObj = {...((defaults.model ?? {}) as Record<string, unknown>)}
+    modelObj.primary = model
+    defaults.model = modelObj
+    agents.defaults = defaults
+    config.agents = agents
+
+    try {
+      await api.runtime.config.writeConfigFile(config)
+      api.logger.info(`config-model: set model.primary to ${model}`)
+      respond(true, {changed: true, model})
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      api.logger.error(`config-model: write failed — ${msg}`)
+      respond(true, {changed: false, model, error: `Write failed: ${msg}`})
+    }
+  })
+
+  api.logger.info('config-model: registered clawly.config.setModel')
+}

package/gateway/config-timezone.ts

@@ -2,14 +2,15 @@
  * Timezone sync RPC: writes agents.defaults.userTimezone to openclaw.json
  * without triggering a gateway restart.
  *
+ * Uses the runtime config APIs (loadConfig + writeConfigFile) for atomic
+ * writes, env var preservation, and config validation.
+ *
  * Methods:
  * - clawly.config.setTimezone({ timezone }) → { changed, timezone }
  */
 
-import path from 'node:path'
-
 import type {PluginApi} from '../types'
-import {readOpenclawConfig, writeOpenclawConfig} from '../model-gateway-setup'
+import type {OpenClawConfig} from '../types/openclaw'
 
 export function registerConfigTimezone(api: PluginApi) {
   api.registerGatewayMethod('clawly.config.setTimezone', async ({params, respond}) => {
@@ -19,30 +20,34 @@ export function registerConfigTimezone(api: PluginApi) {
       return
     }
 
-    const stateDir = api.runtime.state.resolveStateDir()
-    if (!stateDir) {
-      respond(true, {changed: false, timezone, error: 'Cannot resolve state dir'})
+    let config: OpenClawConfig
+    try {
+      config = {...(api.runtime.config.loadConfig() as OpenClawConfig)}
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      respond(true, {changed: false, timezone, error: `Load failed: ${msg}`})
       return
     }
 
-    const configPath = path.join(stateDir, 'openclaw.json')
-    const config = readOpenclawConfig(configPath)
-
-    const agents = (config.agents ?? {}) as Record<string, unknown>
-    const defaults = (agents.defaults ?? {}) as Record<string, unknown>
-    const current = defaults.userTimezone
+    const currentDefaults = (config.agents as Record<string, unknown> | undefined)?.defaults as
+      | Record<string, unknown>
+      | undefined
 
-    if (current === timezone) {
+    if (currentDefaults?.userTimezone === timezone) {
       respond(true, {changed: false, timezone})
       return
     }
 
+    // Shallow-copy nested objects to avoid polluting the loadConfig() cache
+    // if writeConfigFile fails below.
+    const agents = {...((config.agents ?? {}) as Record<string, unknown>)}
+    const defaults = {...((agents.defaults ?? {}) as Record<string, unknown>)}
     defaults.userTimezone = timezone
     agents.defaults = defaults
     config.agents = agents
 
     try {
-      writeOpenclawConfig(configPath, config)
+      await api.runtime.config.writeConfigFile(config)
       api.logger.info(`config-timezone: set userTimezone to ${timezone}`)
       respond(true, {changed: true, timezone})
     } catch (err) {

package/gateway/cron-delivery.test.ts

@@ -263,6 +263,22 @@ describe('cron-delivery', () => {
       })
     })
 
+    test('skips HEARTBEAT OK with space (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)

package/gateway/index.ts

@@ -4,6 +4,7 @@ import {registerCalendarNative} from './calendar-native'
 import {registerAnalytics} from './analytics'
 import {registerAudit} from './audit'
 import {registerClawhub2gateway} from './clawhub2gateway'
+import {registerConfigModel} from './config-model'
 import {registerConfigRepair} from './config-repair'
 import {registerConfigTimezone} from './config-timezone'
 import {registerCronDelivery} from './cron-delivery'
@@ -57,6 +58,7 @@ export function registerGateway(api: PluginApi) {
   registerCronTelemetry(api)
   registerMessageLog(api)
   registerAnalytics(api)
+  registerConfigModel(api)
   registerConfigRepair(api)
   registerConfigTimezone(api)
   registerSessionSanitize(api)

package/gateway/offline-push.test.ts

@@ -446,6 +446,22 @@ describe('shouldSkipPushForMessage', () => {
     expect(shouldSkipPushForMessage('The token HEARTBEAT_OK is used for health checks.')).toBeNull()
   })
 
+  test('skips heartbeat ack with space variant (HEARTBEAT OK)', () => {
+    expect(shouldSkipPushForMessage('HEARTBEAT OK')).toBe('heartbeat ack')
+    expect(shouldSkipPushForMessage('HEARTBEAT OK.')).toBe('heartbeat ack')
+    expect(shouldSkipPushForMessage('HEARTBEAT OK\n')).toBe('heartbeat ack')
+  })
+
+  test('skips short content ending with HEARTBEAT OK (space variant)', () => {
+    expect(shouldSkipPushForMessage('All good. HEARTBEAT OK')).toBe('heartbeat ack')
+    expect(shouldSkipPushForMessage('Nothing to report. HEARTBEAT OK。')).toBe('heartbeat ack')
+  })
+
+  test('skips HEARTBEAT OK at start with short status note (space variant)', () => {
+    expect(shouldSkipPushForMessage('HEARTBEAT OK — all systems nominal.')).toBe('heartbeat ack')
+    expect(shouldSkipPushForMessage('HEARTBEAT OK. Nothing to report.')).toBe('heartbeat ack')
+  })
+
   test('skips system prompt leak', () => {
     expect(
       shouldSkipPushForMessage('Here is some Conversation info (untrusted metadata) text'),
@@ -584,6 +600,33 @@ describe('offline-push with filtered messages', () => {
     expect(lastPushOpts?.body?.endsWith('…')).toBe(true)
   })
 
+  test('sends push for long content and strips HEARTBEAT OK (space variant) from body', async () => {
+    const {api, logs, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    const longContent = 'A'.repeat(301)
+    await handlers.get('agent_end')!(
+      {
+        messages: [
+          {
+            role: 'assistant',
+            content: `${longContent}\n\nHEARTBEAT OK`,
+          },
+        ],
+      },
+      {sessionKey: 'agent:clawly:main'},
+    )
+
+    expect(logs).toContainEqual({
+      level: 'info',
+      msg: expect.stringContaining('notified (session=agent:clawly:main)'),
+    })
+    // HEARTBEAT OK should be stripped from body, content truncated to 140
+    expect(lastPushOpts?.body?.length).toBe(141)
+    expect(lastPushOpts?.body?.endsWith('…')).toBe(true)
+    expect(lastPushOpts?.body).not.toContain('HEARTBEAT')
+  })
+
   test('sends push for normal message text', async () => {
     const {api, logs, handlers} = createMockApi()
     registerOfflinePush(api)

package/gateway/offline-push.ts

@@ -160,12 +160,12 @@ export function shouldSkipPushForMessage(text: string): string | null {
   // Heartbeat acknowledgment — strip HEARTBEAT_OK from both edges (mirrors
   // OpenClaw's stripTokenAtEdges). Skip if remaining text ≤ ackMaxChars (300).
   const HEARTBEAT_ACK_MAX_CHARS = 300
-  const hasAtEnd = /HEARTBEAT_OK[\p{P}\s]*$/u.test(text)
-  const hasAtStart = /^[\p{P}\s]*HEARTBEAT_OK/u.test(text)
+  const hasAtEnd = /HEARTBEAT[_ ]OK[\p{P}\s]*$/u.test(text)
+  const hasAtStart = /^[\p{P}\s]*HEARTBEAT[_ ]OK/u.test(text)
   if (hasAtEnd || hasAtStart) {
     let stripped = text
-    if (hasAtEnd) stripped = stripped.replace(/HEARTBEAT_OK[\p{P}\s]*$/u, '')
-    if (hasAtStart) stripped = stripped.replace(/^[\p{P}\s]*HEARTBEAT_OK[\p{P}\s]*/u, '')
+    if (hasAtEnd) stripped = stripped.replace(/HEARTBEAT[_ ]OK[\p{P}\s]*$/u, '')
+    if (hasAtStart) stripped = stripped.replace(/^[\p{P}\s]*HEARTBEAT[_ ]OK[\p{P}\s]*/u, '')
     stripped = stripped.trim()
     if (stripped.length <= HEARTBEAT_ACK_MAX_CHARS) return 'heartbeat ack'
   }
@@ -308,12 +308,12 @@ export function registerOfflinePush(api: PluginApi) {
       const noHeartbeat =
         (() => {
           if (!fullText) return null
-          const atEnd = /HEARTBEAT_OK[\p{P}\s]*$/u.test(fullText)
-          const atStart = /^[\p{P}\s]*HEARTBEAT_OK/u.test(fullText)
+          const atEnd = /HEARTBEAT[_ ]OK[\p{P}\s]*$/u.test(fullText)
+          const atStart = /^[\p{P}\s]*HEARTBEAT[_ ]OK/u.test(fullText)
           if (!atEnd && !atStart) return fullText.trim()
           let s = fullText
-          if (atEnd) s = s.replace(/HEARTBEAT_OK[\p{P}\s]*$/u, '')
-          if (atStart) s = s.replace(/^[\p{P}\s]*HEARTBEAT_OK[\p{P}\s]*/u, '')
+          if (atEnd) s = s.replace(/HEARTBEAT[_ ]OK[\p{P}\s]*$/u, '')
+          if (atStart) s = s.replace(/^[\p{P}\s]*HEARTBEAT[_ ]OK[\p{P}\s]*/u, '')
           return s.trim()
         })() ?? null
       const cleaned = noHeartbeat ? stripPlaceholders(noHeartbeat) : null

package/gateway/presence.ts

@@ -27,14 +27,17 @@ export function isOnlineEntry(entry: PresenceEntry | undefined): boolean {
 }
 
 /**
- * Shells out to `openclaw gateway call system-presence` and checks
- * whether ANY device has a foreground presence entry.
+ * Shells out to `openclaw gateway call system-presence` and returns true
+ * if any device has a `foreground` presence entry.
+ *
+ * False-negatives (beacon lapsed) are handled client-side — the mobile
+ * app suppresses `agent_end` notifications while in the foreground.
  */
 export async function isClientOnline(): Promise<boolean> {
   try {
     const result = await $`openclaw gateway call system-presence --json`
-    const jsonStr = stripCliLogs(result.stdout)
-    const entries: PresenceEntry[] = JSON.parse(jsonStr)
+    const parsed: unknown = JSON.parse(stripCliLogs(result.stdout))
+    const entries: PresenceEntry[] = Array.isArray(parsed) ? parsed : []
     return entries.some(isOnlineEntry)
   } catch {
     return false

package/gateway-fetch.ts

@@ -11,11 +11,18 @@ export type HandlerResult = {ok: boolean; data?: unknown; error?: {code: string;
 export function getGatewayConfig(api: PluginApi): GatewayCfg {
   const cfg = api.pluginConfig && typeof api.pluginConfig === 'object' ? api.pluginConfig : {}
   const c = cfg as Record<string, unknown>
-  const baseUrl =
-    typeof c.skillGatewayBaseUrl === 'string'
-      ? (c.skillGatewayBaseUrl as string).replace(/\/$/, '')
-      : ''
-  const token = typeof c.skillGatewayToken === 'string' ? (c.skillGatewayToken as string) : ''
+
+  // URL: prefer clawlyApiBaseUrl, fall back to deprecated skillGatewayBaseUrl
+  const rawUrl =
+    (typeof c.clawlyApiBaseUrl === 'string' ? (c.clawlyApiBaseUrl as string) : '') ||
+    (typeof c.skillGatewayBaseUrl === 'string' ? (c.skillGatewayBaseUrl as string) : '')
+  const baseUrl = rawUrl.replace(/\/$/, '')
+
+  // Token: prefer modelGatewayToken, fall back to deprecated skillGatewayToken
+  const token =
+    (typeof c.modelGatewayToken === 'string' ? (c.modelGatewayToken as string) : '') ||
+    (typeof c.skillGatewayToken === 'string' ? (c.skillGatewayToken as string) : '')
+
   return {baseUrl, token}
 }
 

package/index.ts

@@ -80,7 +80,7 @@ export default {
     registerAutoPair(api)
     registerAutoUpdate(api)
 
-    // Email & calendar (optional — requires skillGatewayBaseUrl + skillGatewayToken in config)
+    // Email & calendar (optional — requires API base URL + token)
     const gw = getGatewayConfig(api)
     if (gw.baseUrl && gw.token) {
       registerEmail(api, gw)

package/lib/calendar-cache.ts

@@ -23,6 +23,9 @@ export interface NativeCalendar {
   type: string
 }
 
+export type AlarmMethod = 'alarm' | 'alert' | 'email' | 'default' | 'sms'
+export type AlarmInput = {relativeOffset?: number; method?: AlarmMethod}
+
 export interface NativeCalendarEvent {
   id: string
   calendarId: string
@@ -35,6 +38,7 @@ export interface NativeCalendarEvent {
   url: string
   timeZone: string
   organizer: string
+  alarms?: AlarmInput[]
 }
 
 export interface CalendarCache {

package/openclaw.plugin.json

@@ -47,6 +47,7 @@
       "defaultNoInput": { "type": "boolean" },
       "defaultTimeoutMs": { "type": "number", "minimum": 1000 },
       "configPath": { "type": "string" },
+      "clawlyApiBaseUrl": { "type": "string" },
       "skillGatewayBaseUrl": { "type": "string" },
       "skillGatewayToken": { "type": "string" },
       "modelGatewayBaseUrl": { "type": "string" },

package/package.json

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

package/tools/clawly-calendar.ts

@@ -158,6 +158,26 @@ export function registerCalendarTools(api: PluginApi) {
         location: {type: 'string', description: 'Event location'},
         notes: {type: 'string', description: 'Event description/notes'},
         timeZone: {type: 'string', description: 'IANA time zone (e.g. America/New_York)'},
+        alarms: {
+          type: 'array',
+          description:
+            'Array of alarm objects to set reminders. Each alarm has a relativeOffset in minutes (negative = before event). Example: [{relativeOffset: -15}] for 15 minutes before. Only alarms with valid relativeOffset (number) or method (string) will be applied. To verify reminders were set, use clawly_calendar_list_events after creation.',
+          items: {
+            type: 'object',
+            properties: {
+              relativeOffset: {
+                type: 'number',
+                description:
+                  'Minutes relative to the event start time. Use negative values for reminders before the event (e.g. -15 = 15 min before, -60 = 1 hour before).',
+              },
+              method: {
+                type: 'string',
+                enum: ['alarm', 'alert', 'email', 'default', 'sms'],
+                description: 'Alarm method (Android only). iOS always uses notification.',
+              },
+            },
+          },
+        },
       },
     },
     async execute(_toolCallId, params) {
@@ -211,6 +231,9 @@ export function registerCalendarTools(api: PluginApi) {
         ...(params.location ? {location: params.location} : {}),
         ...(params.notes ? {notes: params.notes} : {}),
         ...(params.timeZone ? {timeZone: params.timeZone} : {}),
+        ...(Array.isArray(params.alarms) && params.alarms.length > 0
+          ? {alarms: params.alarms}
+          : {}),
       }
 
       const resultPromise = waitForActionResult(actionId)
@@ -290,6 +313,26 @@ export function registerCalendarTools(api: PluginApi) {
         location: {type: 'string', description: 'New event location'},
         notes: {type: 'string', description: 'New event description/notes'},
         timeZone: {type: 'string', description: 'IANA time zone (e.g. America/New_York)'},
+        alarms: {
+          type: 'array',
+          description:
+            'Array of alarm objects to set reminders. Each alarm has a relativeOffset in minutes (negative = before event). Example: [{relativeOffset: -15}] for 15 minutes before. Replaces all existing alarms. Pass an empty array [] to clear all existing reminders.',
+          items: {
+            type: 'object',
+            properties: {
+              relativeOffset: {
+                type: 'number',
+                description:
+                  'Minutes relative to the event start time. Use negative values for reminders before the event (e.g. -15 = 15 min before, -60 = 1 hour before).',
+              },
+              method: {
+                type: 'string',
+                enum: ['alarm', 'alert', 'email', 'default', 'sms'],
+                description: 'Alarm method (Android only). iOS always uses notification.',
+              },
+            },
+          },
+        },
       },
     },
     async execute(_toolCallId, params) {
@@ -314,6 +357,7 @@ export function registerCalendarTools(api: PluginApi) {
         ...(params.location !== undefined ? {location: params.location} : {}),
         ...(params.notes !== undefined ? {notes: params.notes} : {}),
         ...(params.timeZone !== undefined ? {timeZone: params.timeZone} : {}),
+        ...(Array.isArray(params.alarms) ? {alarms: params.alarms} : {}),
       }
 
       const resultPromise = waitForActionResult(actionId)