@2en/clawly-plugins 1.21.6 → 1.22.1

package/gateway/index.ts

@@ -8,6 +8,7 @@ import {registerNotification} from './notification'
 import {registerOfflinePush} from './offline-push'
 import {registerPlugins} from './plugins'
 import {registerPresence} from './presence'
+import {registerVersion} from './version'
 
 export function registerGateway(api: PluginApi) {
   registerPresence(api)
@@ -19,4 +20,5 @@ export function registerGateway(api: PluginApi) {
   registerOfflinePush(api)
   registerConfigRepair(api)
   registerPairing(api)
+  registerVersion(api)
 }

package/gateway/plugins.ts

@@ -72,19 +72,19 @@ async function withPluginBackup<T>(
   if (!stateDir) return operation()
 
   const extensionDir = path.join(stateDir, 'extensions', pluginId)
-  const backupDir = `${extensionDir}.update-backup`
+  const backupZip = `${extensionDir}.update-backup.zip`
 
   // Back up only if there's a valid existing installation.
   // If backup fails, abort — a working plugin is more valuable than a risky update.
   const hasExisting = fs.existsSync(path.join(extensionDir, PLUGIN_SENTINEL))
   if (hasExisting) {
     try {
-      if (fs.existsSync(backupDir)) await $`rm -rf ${backupDir}`
-      await $`cp -a ${extensionDir} ${backupDir}`
+      if (fs.existsSync(backupZip)) fs.unlinkSync(backupZip)
+      const extDir = path.join(stateDir, 'extensions')
+      await $({cwd: extDir})`zip -rqy ${backupZip} ${pluginId}`
       api.logger.info(`plugins: backed up ${pluginId}`)
     } catch (err) {
-      // Clean up partial backup before aborting
-      if (fs.existsSync(backupDir)) await $`rm -rf ${backupDir}`.catch(() => {})
+      if (fs.existsSync(backupZip)) fs.unlinkSync(backupZip)
       throw new Error(
         `plugin backup failed, aborting update: ${err instanceof Error ? err.message : String(err)}`,
       )
@@ -104,17 +104,16 @@ async function withPluginBackup<T>(
     }
 
     // Clean backup on success
-    if (fs.existsSync(backupDir)) {
-      await $`rm -rf ${backupDir}`.catch(() => {})
-    }
+    if (fs.existsSync(backupZip)) fs.unlinkSync(backupZip)
 
     return result
   } catch (err) {
-    if (fs.existsSync(backupDir)) {
+    if (fs.existsSync(backupZip)) {
       api.logger.warn(`plugins: rolling back ${pluginId} from backup`)
       try {
         if (fs.existsSync(extensionDir)) await $`rm -rf ${extensionDir}`
-        await $`mv ${backupDir} ${extensionDir}`
+        await $`unzip -qo ${backupZip} -d ${path.join(stateDir, 'extensions')}`
+        fs.unlinkSync(backupZip)
         api.logger.info(`plugins: rollback complete`)
       } catch (rollbackErr) {
         api.logger.error(

package/gateway/version.ts

@@ -0,0 +1,44 @@
+/**
+ * OpenClaw version check — runs `openclaw --version` and returns the result.
+ *
+ * Method: clawly.version({}) → { version: string }
+ */
+
+import type {PluginApi} from '../index'
+
+export function registerVersion(api: PluginApi) {
+  api.registerGatewayMethod('clawly.version', async ({respond}) => {
+    const run = api.runtime.system?.runCommandWithTimeout
+    if (!run) {
+      respond(false, undefined, {
+        code: 'no_runtime',
+        message: 'runCommandWithTimeout not available',
+      })
+      return
+    }
+
+    try {
+      const result = await run(['openclaw', '--version'], {timeoutMs: 5000})
+      if (result.code !== 0) {
+        const message = result.killed
+          ? `Process killed${result.signal ? ` by ${result.signal}` : ''}`
+          : `Exited with code ${result.code}`
+        respond(false, undefined, {code: 'non_zero_exit', message})
+        return
+      }
+      const raw = (result.stdout + result.stderr).trim()
+      // openclaw --version typically outputs something like "openclaw/2026.2.24 ..."
+      // Extract just the version portion
+      const match = raw.match(/(\d{4}\.\d+\.\d+)/)
+      const version = match ? match[1] : raw
+      respond(true, {version})
+    } catch (err) {
+      respond(false, undefined, {
+        code: 'exec_failed',
+        message: err instanceof Error ? err.message : 'Failed to get version',
+      })
+    }
+  })
+
+  api.logger.info('version: registered clawly.version method')
+}

package/index.ts

@@ -8,6 +8,7 @@
  * - clawly.notification.send    — send a push notification directly
  * - clawly.agent.send        — trigger agent turn with a message (+ optional push)
  * - clawly.agent.echo        — echo-wrapped agent message (bypasses LLM)
+ * - clawly.version            — get the OpenClaw server version
  * - memory-browser.list      — list all .md files in the memory directory
  * - memory-browser.get       — return content of a single .md file
  * - clawhub2gateway.*        — ClawHub CLI RPC bridge (search/install/update/list/explore/inspect/star/unstar)
@@ -36,12 +37,28 @@ import {registerEmail} from './email'
 import {registerGateway} from './gateway'
 import {getGatewayConfig} from './gateway-fetch'
 import {setupModelGateway} from './model-gateway-setup'
-import {setupSession} from './session-setup'
 import {registerOutboundHook, registerOutboundHttpRoute, registerOutboundMethods} from './outbound'
+import {setupSession} from './session-setup'
 import {registerSkillCommandRestore} from './skill-command-restore'
 import {registerTools} from './tools'
 
-type PluginRuntime = {
+// ---------------------------------------------------------------------------
+// Types aligned with OpenClaw plugin API (openclaw/src/plugins/types.ts)
+// ---------------------------------------------------------------------------
+
+export type PluginLogger = {
+  debug?: (message: string) => void
+  info: (message: string) => void
+  warn: (message: string) => void
+  error: (message: string) => void
+}
+
+export type PluginRuntime = {
+  version?: string
+  config?: {
+    loadConfig?: (...args: unknown[]) => unknown
+    writeConfigFile?: (...args: unknown[]) => unknown
+  }
   system?: {
     runCommandWithTimeout?: (
       argv: string[],
@@ -59,31 +76,43 @@ type PluginRuntime = {
   }
 }
 
+export type GatewayRequestHandler = (opts: {
+  params: Record<string, unknown>
+  respond: (ok: boolean, payload?: unknown, error?: {code?: string; message?: string}) => void
+}) => Promise<void> | void
+
+export type PluginHookName =
+  | 'before_agent_start'
+  | 'agent_end'
+  | 'before_compaction'
+  | 'after_compaction'
+  | 'before_reset'
+  | 'message_received'
+  | 'message_sending'
+  | 'message_sent'
+  | 'before_tool_call'
+  | 'after_tool_call'
+  | 'tool_result_persist'
+  | 'session_start'
+  | 'session_end'
+  | 'gateway_start'
+  | 'gateway_stop'
+
 export type PluginApi = {
+  /** id from openclaw.plugin.json */
   id: string
+  /** name from openclaw.plugin.json */
   name: string
+  /** version from openclaw.plugin.json */
+  version?: string
+  /** description from openclaw.plugin.json */
+  description?: string
+  source?: string
+  config?: Record<string, unknown>
   pluginConfig?: Record<string, unknown>
-  logger: {
-    info: (msg: string) => void
-    warn: (msg: string) => void
-    error: (msg: string) => void
-  }
   runtime: PluginRuntime
-  registerGatewayMethod: (
-    method: string,
-    handler: (opts: {
-      params: Record<string, unknown>
-      respond: (ok: boolean, payload?: unknown, error?: {code?: string; message?: string}) => void
-    }) => Promise<void> | void,
-  ) => void
-  on: (hookName: string, handler: (...args: any[]) => any, opts?: {priority?: number}) => void
-  registerCommand: (cmd: {
-    name: string
-    description?: string
-    acceptsArgs?: boolean
-    requireAuth?: boolean
-    handler: (ctx: {args?: string}) => Promise<{text: string}> | {text: string}
-  }) => void
+  logger: PluginLogger
+  registerGatewayMethod: (method: string, handler: GatewayRequestHandler) => void
   registerTool: (
     tool: {
       name: string
@@ -96,7 +125,28 @@ export type PluginApi = {
     },
     opts?: {optional?: boolean},
   ) => void
-  registerChannel: (registration: {plugin: any}) => void
+  registerHook?: (
+    events: string | string[],
+    handler: (...args: unknown[]) => unknown,
+    opts?: {name?: string; description?: string; register?: boolean},
+  ) => void
+  registerCommand: (cmd: {
+    name: string
+    description?: string
+    acceptsArgs?: boolean
+    requireAuth?: boolean
+    handler: (ctx: {
+      args?: string
+      [key: string]: unknown
+    }) => Promise<{text: string}> | {text: string}
+  }) => void
+  registerChannel: (registration: {plugin: unknown; dock?: unknown}) => void
+  registerHttpHandler?: (
+    handler: (
+      req: import('node:http').IncomingMessage,
+      res: import('node:http').ServerResponse,
+    ) => Promise<boolean> | boolean,
+  ) => void
   registerHttpRoute: (params: {
     path: string
     handler: (
@@ -104,6 +154,22 @@ export type PluginApi = {
       res: import('node:http').ServerResponse,
     ) => Promise<void> | void
   }) => void
+  registerCli?: (
+    registrar: (...args: unknown[]) => void | Promise<void>,
+    opts?: {commands?: string[]},
+  ) => void
+  registerService?: (service: {
+    id: string
+    start: (...args: unknown[]) => void | Promise<void>
+    stop?: (...args: unknown[]) => void | Promise<void>
+  }) => void
+  registerProvider?: (provider: Record<string, unknown>) => void
+  resolvePath?: (input: string) => string
+  on: (
+    hookName: PluginHookName | (string & {}),
+    handler: (...args: any[]) => any,
+    opts?: {priority?: number},
+  ) => void
 }
 
 export default {

package/lib/stripCliLogs.test.ts

@@ -36,9 +36,18 @@ describe('stripCliLogs', () => {
     expect(stripCliLogs('')).toBe('')
   })
 
-  test('does not strip lines that merely contain a timestamp mid-line', () => {
-    const input = 'some prefix 11:40:09 [x] y\n{"ok":true}'
-    expect(stripCliLogs(input)).toBe('some prefix 11:40:09 [x] y\n{"ok":true}')
+  test('strips config warnings box between logs and JSON', () => {
+    const input = [
+      '04:49:48 [plugins] feishu_wiki: Registered feishu_wiki tool',
+      '│',
+      '◇  Config warnings ──────────────────────╮',
+      '│                                         │',
+      '│  - plugins.entries.clawly-plugins: ...   │',
+      '│                                         │',
+      '├─────────────────────────────────────────╯',
+      '{"channel":"discord","requests":[]}',
+    ].join('\n')
+    expect(stripCliLogs(input)).toBe('{"channel":"discord","requests":[]}')
   })
 
   test('strips ANSI color codes from log lines', () => {

package/lib/stripCliLogs.ts

@@ -8,18 +8,21 @@
  *   \x1b[35m[plugins] tool: registered clawly_send_app_push agent tool
  *   [{"id":"clawly-plugins", ...}]
  *
- * This function strips ANSI escape sequences, drops every line that looks
- * like a log prefix (`HH:MM:SS [tag] ...` or `[tag] ...`), and returns the
+ * It may also emit a "Config warnings" box using box-drawing characters
+ * (│, ◇, ├, ─, ╮, ╯) between log lines and the JSON body.
+ *
+ * This function strips ANSI escape sequences, drops every leading line that
+ * is not JSON (log prefixes, warning boxes, blank lines), and returns the
  * remaining text (the JSON body).
  */
 
 const ANSI_RE = /\x1b\[[0-9;]*m/g
-const LOG_LINE_RE = /^(\d{1,2}:\d{2}:\d{2} )?\[\w[\w-]*\] /
+const JSON_START_RE = /^\{|^\[[\s\]\[{"]/
 
 export function stripCliLogs(output: string): string {
   const cleaned = output.replace(ANSI_RE, '')
   const lines = cleaned.split('\n')
-  const firstNonLog = lines.findIndex((line) => !LOG_LINE_RE.test(line))
-  if (firstNonLog === -1) return ''
-  return lines.slice(firstNonLog).join('\n').trim()
+  const firstJson = lines.findIndex((line) => JSON_START_RE.test(line))
+  if (firstJson === -1) return ''
+  return lines.slice(firstJson).join('\n').trim()
 }

package/package.json

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