@2en/clawly-plugins 1.5.0 → 1.7.0

package/gateway/index.ts

@@ -3,6 +3,7 @@ import {registerAgentSend} from './agent'
 import {registerClawhub2gateway} from './clawhub2gateway'
 import {registerMemoryBrowser} from './memory'
 import {registerNotification} from './notification'
+import {registerPlugins} from './plugins'
 import {registerPresence} from './presence'
 
 export function registerGateway(api: PluginApi) {
@@ -11,4 +12,5 @@ export function registerGateway(api: PluginApi) {
   registerAgentSend(api)
   registerMemoryBrowser(api)
   registerClawhub2gateway(api)
+  registerPlugins(api)
 }

package/gateway/plugins.ts

@@ -0,0 +1,243 @@
+/**
+ * Plugin version check and update management.
+ *
+ * Methods:
+ * - clawly.plugins.version({ pluginId, npmPkgName }) → VersionResult
+ * - clawly.plugins.update({ pluginId, npmPkgName, strategy, targetVersion?, restart? }) → UpdateResult
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import {$} from 'zx'
+
+import type {PluginApi} from '../index'
+import {LruCache} from '../lib/lruCache'
+import {isUpdateAvailable} from '../lib/semver'
+import {stripCliLogs} from '../lib/stripCliLogs'
+
+$.verbose = false
+
+interface NpmViewCache {
+  version: string
+  versions: string[]
+}
+
+const npmCache = new LruCache<NpmViewCache>({maxSize: 5, ttlMs: 5 * 60 * 1000})
+
+function resolveStateDir(api: PluginApi): string {
+  return api.runtime.state?.resolveStateDir?.(process.env) ?? process.env.OPENCLAW_STATE_DIR ?? ''
+}
+
+function readExtensionVersion(stateDir: string, pluginId: string): string | null {
+  try {
+    const pkgPath = path.join(stateDir, 'extensions', pluginId, 'package.json')
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+    return typeof pkg.version === 'string' ? pkg.version : null
+  } catch {
+    return null
+  }
+}
+
+async function fetchNpmView(npmPkgName: string): Promise<NpmViewCache | null> {
+  const cached = npmCache.get(npmPkgName)
+  if (cached) return cached
+
+  try {
+    const result = await $`npm view ${npmPkgName} --json`
+    const parsed = JSON.parse(stripCliLogs(result.stdout))
+    const entry: NpmViewCache = {
+      version: typeof parsed.version === 'string' ? parsed.version : '',
+      versions: Array.isArray(parsed.versions) ? parsed.versions : [],
+    }
+    npmCache.set(npmPkgName, entry)
+    return entry
+  } catch {
+    return null
+  }
+}
+
+export function registerPlugins(api: PluginApi) {
+  // ── clawly.plugins.version ──────────────────────────────────────
+
+  api.registerGatewayMethod('clawly.plugins.version', async ({params, respond}) => {
+    const pluginId = typeof params.pluginId === 'string' ? params.pluginId.trim() : ''
+    const npmPkgName = typeof params.npmPkgName === 'string' ? params.npmPkgName.trim() : ''
+
+    if (!pluginId || !npmPkgName) {
+      respond(false, undefined, {
+        code: 'invalid_params',
+        message: 'pluginId and npmPkgName are required',
+      })
+      return
+    }
+
+    const stateDir = resolveStateDir(api)
+    api.logger.info(`plugins.version: checking ${pluginId} (${npmPkgName})`)
+    let latestNpmVersion: string | null = null
+    let allNpmVersions: string[] = []
+    let updateAvailable = false
+    const errors: string[] = []
+
+    // Step 1: Read installed version from extensions/<id>/package.json
+    const npmPackageVersion = stateDir ? readExtensionVersion(stateDir, pluginId) : null
+    api.logger.info(`plugins.version: installed version = ${npmPackageVersion ?? 'not found'}`)
+
+    // Step 2: Fetch npm registry info
+    try {
+      const npm = await fetchNpmView(npmPkgName)
+      if (npm) {
+        latestNpmVersion = npm.version
+        allNpmVersions = npm.versions
+        api.logger.info(
+          `plugins.version: npm registry latest=${latestNpmVersion}, ${allNpmVersions.length} versions available`,
+        )
+      } else {
+        api.logger.warn(`plugins.version: npm view returned null for ${npmPkgName}`)
+      }
+    } catch (err) {
+      errors.push(`npm view: ${err instanceof Error ? err.message : String(err)}`)
+      api.logger.error(`plugins.version: npm view failed — ${errors[errors.length - 1]}`)
+    }
+
+    // Step 3: Compute update availability
+    if (npmPackageVersion && latestNpmVersion) {
+      updateAvailable = isUpdateAvailable(npmPackageVersion, latestNpmVersion)
+    }
+
+    api.logger.info(
+      `plugins.version: result current=${npmPackageVersion} latest=${latestNpmVersion} updateAvailable=${updateAvailable}`,
+    )
+
+    respond(true, {
+      pluginVersion: npmPackageVersion,
+      npmPackageVersion,
+      latestNpmVersion,
+      allNpmVersions,
+      updateAvailable,
+      ...(errors.length ? {error: errors.join('; ')} : {}),
+    })
+  })
+
+  // ── clawly.plugins.update ──────────────────────────────────────
+
+  api.registerGatewayMethod('clawly.plugins.update', async ({params, respond}) => {
+    const pluginId = typeof params.pluginId === 'string' ? params.pluginId.trim() : ''
+    const npmPkgName = typeof params.npmPkgName === 'string' ? params.npmPkgName.trim() : ''
+    const strategy = typeof params.strategy === 'string' ? params.strategy.trim() : ''
+    const targetVersion =
+      typeof params.targetVersion === 'string' ? params.targetVersion.trim() : undefined
+    const restart = params.restart === true
+
+    if (!pluginId || !npmPkgName || !strategy) {
+      respond(false, undefined, {
+        code: 'invalid_params',
+        message: 'pluginId, npmPkgName, and strategy are required',
+      })
+      return
+    }
+
+    if (!['force', 'update', 'install'].includes(strategy)) {
+      respond(false, undefined, {
+        code: 'invalid_params',
+        message: `invalid strategy: ${strategy}`,
+      })
+      return
+    }
+
+    const installTarget = targetVersion ? `${npmPkgName}@${targetVersion}` : npmPkgName
+
+    try {
+      let output = ''
+
+      if (strategy === 'force') {
+        const stateDir = resolveStateDir(api)
+        if (!stateDir) throw new Error('cannot resolve openclaw state dir')
+
+        const configPath = path.join(stateDir, 'openclaw.json')
+
+        // 1. Save current plugins.entries.<id> config (preserve user settings)
+        let savedEntry: Record<string, unknown> = {enabled: true}
+        try {
+          const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+          const entry = config?.plugins?.entries?.[pluginId]
+          if (entry && typeof entry === 'object') {
+            savedEntry = entry as Record<string, unknown>
+          }
+        } catch {
+          // config unreadable — use default
+        }
+        api.logger.info(`plugins: force — saved entry config for ${pluginId}`)
+
+        // 2. Delete plugins.entries.<id> from config so install starts clean
+        try {
+          const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+          if (config?.plugins?.entries?.[pluginId]) {
+            delete config.plugins.entries[pluginId]
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n')
+          }
+        } catch {
+          // ignore
+        }
+
+        // 3. Remove extension dir to force clean install
+        const extensionDir = path.join(stateDir, 'extensions', pluginId)
+        if (fs.existsSync(extensionDir)) {
+          api.logger.info(`plugins: force — removing ${extensionDir}`)
+          await $`rm -rf ${extensionDir}`
+        }
+
+        // 4. Install fresh
+        api.logger.info(`plugins: force — installing ${installTarget}`)
+        const result = await $`openclaw plugins install ${installTarget}`
+        output = result.stdout.trim()
+
+        // 5. Merge saved config back into plugins.entries.<id>
+        try {
+          const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+          if (!config.plugins) config.plugins = {}
+          if (!config.plugins.entries) config.plugins.entries = {}
+          config.plugins.entries[pluginId] = {
+            ...config.plugins.entries[pluginId],
+            ...savedEntry,
+          }
+          fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n')
+          api.logger.info(`plugins: force — restored entry config for ${pluginId}`)
+        } catch (err) {
+          api.logger.warn(
+            `plugins: force — failed to restore entry config: ${err instanceof Error ? err.message : String(err)}`,
+          )
+        }
+      } else if (strategy === 'update') {
+        const result = await $`openclaw plugins update ${pluginId}`
+        output = result.stdout.trim()
+      } else {
+        // install
+        const result = await $`openclaw plugins install ${installTarget}`
+        output = result.stdout.trim()
+      }
+
+      // Invalidate npm cache for this package
+      npmCache.delete(npmPkgName)
+
+      let restarted = false
+      if (restart) {
+        try {
+          await $`openclaw gateway restart`
+          restarted = true
+        } catch (err) {
+          api.logger.warn(
+            `plugins: gateway restart failed — ${err instanceof Error ? err.message : String(err)}`,
+          )
+        }
+      }
+
+      respond(true, {ok: true, strategy, output, restarted})
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      api.logger.error(`plugins: update failed — ${msg}`)
+      respond(false, {ok: false, strategy, error: msg})
+    }
+  })
+
+  api.logger.info('plugins: registered clawly.plugins.version + clawly.plugins.update')
+}

package/gateway/presence.ts

@@ -8,6 +8,7 @@
 import {$} from 'zx'
 
 import type {PluginApi} from '../index'
+import {stripCliLogs} from '../lib/stripCliLogs'
 
 $.verbose = false
 
@@ -25,12 +26,7 @@ interface PresenceEntry {
 export async function isClientOnline(host = DEFAULT_HOST): Promise<boolean> {
   try {
     const result = await $`openclaw gateway call system-presence --json`
-    const output = result.stdout.trim()
-    let jsonStr = output
-    if (!output.startsWith('[')) {
-      jsonStr = output.slice(output.indexOf('\n['))
-    }
-    console.log({jsonStr})
+    const jsonStr = stripCliLogs(result.stdout)
     const entries: PresenceEntry[] = JSON.parse(jsonStr)
     const entry = entries.find((e) => e.host === host)
     if (!entry) return false

package/gateway-fetch.ts

@@ -1,5 +1,5 @@
 /**
- * Shared helpers for plugins that proxy to the Clawly model-gateway backend.
+ * Shared helpers for plugins that proxy to the Clawly skill-gateway backend.
  */
 
 import type {PluginApi} from './index'
@@ -10,14 +10,12 @@ 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 (cfg as Record<string, unknown>).gatewayBaseUrl === 'string'
-      ? ((cfg as Record<string, unknown>).gatewayBaseUrl as string).replace(/\/$/, '')
-      : ''
-  const token =
-    typeof (cfg as Record<string, unknown>).gatewayToken === 'string'
-      ? ((cfg as Record<string, unknown>).gatewayToken as string)
+    typeof c.skillGatewayBaseUrl === 'string'
+      ? (c.skillGatewayBaseUrl as string).replace(/\/$/, '')
       : ''
+  const token = typeof c.skillGatewayToken === 'string' ? (c.skillGatewayToken as string) : ''
   return {baseUrl, token}
 }
 

package/index.ts

@@ -105,7 +105,7 @@ export default {
     registerCronHook(api)
     registerGateway(api)
 
-    // Email & calendar (optional — requires gatewayBaseUrl + gatewayToken in config)
+    // Email & calendar (optional — requires skillGatewayBaseUrl + skillGatewayToken in config)
     const gw = getGatewayConfig(api)
     if (gw.baseUrl && gw.token) {
       registerEmail(api, gw)

package/lib/lruCache.test.ts

@@ -0,0 +1,85 @@
+import {afterEach, beforeEach, describe, expect, jest, test} from 'bun:test'
+import {LruCache} from './lruCache'
+
+describe('LruCache', () => {
+  test('get returns undefined for missing key', () => {
+    const cache = new LruCache<string>({maxSize: 3, ttlMs: 60_000})
+    expect(cache.get('missing')).toBeUndefined()
+  })
+
+  test('set and get', () => {
+    const cache = new LruCache<number>({maxSize: 3, ttlMs: 60_000})
+    cache.set('a', 1)
+    expect(cache.get('a')).toBe(1)
+    expect(cache.size).toBe(1)
+  })
+
+  test('evicts oldest when over maxSize', () => {
+    const cache = new LruCache<number>({maxSize: 2, ttlMs: 60_000})
+    cache.set('a', 1)
+    cache.set('b', 2)
+    cache.set('c', 3)
+    expect(cache.get('a')).toBeUndefined()
+    expect(cache.get('b')).toBe(2)
+    expect(cache.get('c')).toBe(3)
+    expect(cache.size).toBe(2)
+  })
+
+  test('get refreshes position (prevents eviction)', () => {
+    const cache = new LruCache<number>({maxSize: 2, ttlMs: 60_000})
+    cache.set('a', 1)
+    cache.set('b', 2)
+    // Access 'a' to refresh its position
+    cache.get('a')
+    // Insert 'c' — should evict 'b' (now oldest) instead of 'a'
+    cache.set('c', 3)
+    expect(cache.get('a')).toBe(1)
+    expect(cache.get('b')).toBeUndefined()
+    expect(cache.get('c')).toBe(3)
+  })
+
+  test('expired entries return undefined', () => {
+    const now = Date.now()
+    jest.setSystemTime(new Date(now))
+
+    const cache = new LruCache<string>({maxSize: 5, ttlMs: 1000})
+    cache.set('x', 'val')
+    expect(cache.get('x')).toBe('val')
+
+    // Advance past TTL
+    jest.setSystemTime(new Date(now + 1001))
+    expect(cache.get('x')).toBeUndefined()
+    expect(cache.size).toBe(0)
+
+    jest.restoreAllMocks()
+  })
+
+  test('delete removes entry', () => {
+    const cache = new LruCache<number>({maxSize: 5, ttlMs: 60_000})
+    cache.set('a', 1)
+    expect(cache.delete('a')).toBe(true)
+    expect(cache.get('a')).toBeUndefined()
+    expect(cache.delete('a')).toBe(false)
+  })
+
+  test('clear removes all entries', () => {
+    const cache = new LruCache<number>({maxSize: 5, ttlMs: 60_000})
+    cache.set('a', 1)
+    cache.set('b', 2)
+    cache.clear()
+    expect(cache.size).toBe(0)
+    expect(cache.get('a')).toBeUndefined()
+  })
+
+  test('overwriting a key updates value and refreshes position', () => {
+    const cache = new LruCache<number>({maxSize: 2, ttlMs: 60_000})
+    cache.set('a', 1)
+    cache.set('b', 2)
+    cache.set('a', 10)
+    // 'a' is refreshed, 'b' is oldest
+    cache.set('c', 3)
+    expect(cache.get('a')).toBe(10)
+    expect(cache.get('b')).toBeUndefined()
+    expect(cache.get('c')).toBe(3)
+  })
+})

package/lib/lruCache.ts

@@ -0,0 +1,50 @@
+interface CacheEntry<V> {
+  value: V
+  expiresAt: number
+}
+
+export class LruCache<V> {
+  private map = new Map<string, CacheEntry<V>>()
+  private maxSize: number
+  private ttlMs: number
+
+  constructor(opts: {maxSize: number; ttlMs: number}) {
+    this.maxSize = opts.maxSize
+    this.ttlMs = opts.ttlMs
+  }
+
+  get(key: string): V | undefined {
+    const entry = this.map.get(key)
+    if (!entry) return undefined
+    if (Date.now() > entry.expiresAt) {
+      this.map.delete(key)
+      return undefined
+    }
+    // Refresh position: delete and re-insert (Map preserves insertion order)
+    this.map.delete(key)
+    this.map.set(key, entry)
+    return entry.value
+  }
+
+  set(key: string, value: V): void {
+    this.map.delete(key)
+    if (this.map.size >= this.maxSize) {
+      // Evict oldest (first entry)
+      const oldest = this.map.keys().next().value
+      if (oldest !== undefined) this.map.delete(oldest)
+    }
+    this.map.set(key, {value, expiresAt: Date.now() + this.ttlMs})
+  }
+
+  delete(key: string): boolean {
+    return this.map.delete(key)
+  }
+
+  clear(): void {
+    this.map.clear()
+  }
+
+  get size(): number {
+    return this.map.size
+  }
+}

package/lib/semver.test.ts

@@ -0,0 +1,88 @@
+import {describe, expect, test} from 'bun:test'
+import {compareSemVer, isUpdateAvailable, parseSemVer} from './semver'
+
+describe('parseSemVer', () => {
+  test('parses simple version', () => {
+    const v = parseSemVer('1.2.3')
+    expect(v).toEqual({major: 1, minor: 2, patch: 3, prerelease: undefined, raw: '1.2.3'})
+  })
+
+  test('parses version with v prefix', () => {
+    const v = parseSemVer('v1.2.3')
+    expect(v).toEqual({major: 1, minor: 2, patch: 3, prerelease: undefined, raw: 'v1.2.3'})
+  })
+
+  test('parses version with prerelease', () => {
+    const v = parseSemVer('1.2.3-beta.1')
+    expect(v).toEqual({major: 1, minor: 2, patch: 3, prerelease: 'beta.1', raw: '1.2.3-beta.1'})
+  })
+
+  test('returns null for invalid input', () => {
+    expect(parseSemVer('')).toBeNull()
+    expect(parseSemVer('abc')).toBeNull()
+    expect(parseSemVer('1.2')).toBeNull()
+    expect(parseSemVer('1.2.3.4')).toBeNull()
+  })
+
+  test('trims whitespace', () => {
+    const v = parseSemVer('  1.0.0  ')
+    expect(v?.major).toBe(1)
+  })
+})
+
+describe('compareSemVer', () => {
+  test('equal versions return 0', () => {
+    expect(compareSemVer('1.0.0', '1.0.0')).toBe(0)
+  })
+
+  test('major difference', () => {
+    expect(compareSemVer('2.0.0', '1.0.0')).toBe(1)
+    expect(compareSemVer('1.0.0', '2.0.0')).toBe(-1)
+  })
+
+  test('minor difference', () => {
+    expect(compareSemVer('1.1.0', '1.0.0')).toBe(1)
+    expect(compareSemVer('1.0.0', '1.1.0')).toBe(-1)
+  })
+
+  test('patch difference', () => {
+    expect(compareSemVer('1.0.1', '1.0.0')).toBe(1)
+    expect(compareSemVer('1.0.0', '1.0.1')).toBe(-1)
+  })
+
+  test('release > prerelease at same version', () => {
+    expect(compareSemVer('1.0.0', '1.0.0-beta.1')).toBe(1)
+    expect(compareSemVer('1.0.0-beta.1', '1.0.0')).toBe(-1)
+  })
+
+  test('two prereleases at same version return 0', () => {
+    expect(compareSemVer('1.0.0-alpha', '1.0.0-beta')).toBe(0)
+  })
+
+  test('returns null for invalid input', () => {
+    expect(compareSemVer('abc', '1.0.0')).toBeNull()
+    expect(compareSemVer('1.0.0', 'abc')).toBeNull()
+  })
+})
+
+describe('isUpdateAvailable', () => {
+  test('returns true when latest > current', () => {
+    expect(isUpdateAvailable('1.0.0', '1.1.0')).toBe(true)
+    expect(isUpdateAvailable('1.0.0', '2.0.0')).toBe(true)
+    expect(isUpdateAvailable('1.5.0', '1.5.1')).toBe(true)
+  })
+
+  test('returns false when latest <= current', () => {
+    expect(isUpdateAvailable('1.0.0', '1.0.0')).toBe(false)
+    expect(isUpdateAvailable('2.0.0', '1.0.0')).toBe(false)
+  })
+
+  test('returns false when latest is prerelease', () => {
+    expect(isUpdateAvailable('1.0.0', '2.0.0-beta.1')).toBe(false)
+  })
+
+  test('returns false for invalid input', () => {
+    expect(isUpdateAvailable('abc', '1.0.0')).toBe(false)
+    expect(isUpdateAvailable('1.0.0', 'abc')).toBe(false)
+  })
+})

package/lib/semver.ts

@@ -0,0 +1,46 @@
+export interface SemVer {
+  major: number
+  minor: number
+  patch: number
+  prerelease: string | undefined
+  raw: string
+}
+
+const SEMVER_RE = /^v?(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/
+
+export function parseSemVer(version: string): SemVer | null {
+  const m = version.trim().match(SEMVER_RE)
+  if (!m) return null
+  return {
+    major: Number(m[1]),
+    minor: Number(m[2]),
+    patch: Number(m[3]),
+    prerelease: m[4] ?? undefined,
+    raw: version.trim(),
+  }
+}
+
+export function compareSemVer(a: string, b: string): -1 | 0 | 1 | null {
+  const pa = parseSemVer(a)
+  const pb = parseSemVer(b)
+  if (!pa || !pb) return null
+
+  for (const key of ['major', 'minor', 'patch'] as const) {
+    if (pa[key] > pb[key]) return 1
+    if (pa[key] < pb[key]) return -1
+  }
+
+  // Both equal in major.minor.patch — compare prerelease
+  // A release (no prerelease) is greater than a prerelease
+  if (!pa.prerelease && pb.prerelease) return 1
+  if (pa.prerelease && !pb.prerelease) return -1
+
+  return 0
+}
+
+export function isUpdateAvailable(current: string, latest: string): boolean {
+  const pl = parseSemVer(latest)
+  if (!pl || pl.prerelease) return false // latest must be stable
+  const cmp = compareSemVer(latest, current)
+  return cmp === 1
+}

package/lib/stripCliLogs.test.ts

@@ -0,0 +1,71 @@
+import {describe, expect, test} from 'bun:test'
+import {stripCliLogs} from './stripCliLogs'
+
+describe('stripCliLogs', () => {
+  test('strips leading log lines', () => {
+    const input = [
+      '11:40:09 [plugins] echo: registered /clawly_echo command',
+      '11:40:09 [plugins] tool: registered clawly_is_user_online agent tool',
+      '11:40:09 [plugins] tool: registered clawly_send_app_push agent tool',
+      '[{"id":"clawly-plugins","version":"1.5.0"}]',
+    ].join('\n')
+    expect(stripCliLogs(input)).toBe('[{"id":"clawly-plugins","version":"1.5.0"}]')
+  })
+
+  test('returns unchanged when no log lines', () => {
+    const input = '{"ok":true}'
+    expect(stripCliLogs(input)).toBe('{"ok":true}')
+  })
+
+  test('handles single-digit hour', () => {
+    const input = '9:05:01 [core] init\n{"data":1}'
+    expect(stripCliLogs(input)).toBe('{"data":1}')
+  })
+
+  test('returns empty string when all lines are logs', () => {
+    const input = '11:00:00 [a] foo\n12:00:00 [b] bar'
+    expect(stripCliLogs(input)).toBe('')
+  })
+
+  test('preserves multiline JSON after logs', () => {
+    const input = ['11:40:09 [plugins] loading', '{', '  "version": "1.0.0"', '}'].join('\n')
+    expect(stripCliLogs(input)).toBe('{\n  "version": "1.0.0"\n}')
+  })
+
+  test('handles empty input', () => {
+    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 ANSI color codes from log lines', () => {
+    const input = [
+      '\x1b[35m12:46:24 [plugins] presence: registered clawly.isOnline method',
+      '\x1b[35m12:46:24 [plugins] registered clawly.plugins.version',
+      '[{"id":"clawly-plugins","version":"1.5.0"}]',
+    ].join('\n')
+    expect(stripCliLogs(input)).toBe('[{"id":"clawly-plugins","version":"1.5.0"}]')
+  })
+
+  test('strips log lines without timestamps (after ANSI stripping)', () => {
+    const input = [
+      '\x1b[35m[plugins] echo: registered /clawly_echo command',
+      '\x1b[35m[plugins] tool: registered clawly_send_app_push agent tool',
+      '[{"id":"clawly-plugins"}]',
+    ].join('\n')
+    expect(stripCliLogs(input)).toBe('[{"id":"clawly-plugins"}]')
+  })
+
+  test('strips plain log lines without timestamps', () => {
+    const input = '[plugins] Loaded clawly-plugins plugin.\n{"ok":true}'
+    expect(stripCliLogs(input)).toBe('{"ok":true}')
+  })
+
+  test('preserves JSON arrays (not confused with log prefixes)', () => {
+    const input = '[{"id":"test"}]'
+    expect(stripCliLogs(input)).toBe('[{"id":"test"}]')
+  })
+})

package/lib/stripCliLogs.ts

@@ -0,0 +1,25 @@
+/**
+ * Strip leading log lines from `openclaw ... --json` output.
+ *
+ * OpenClaw CLI may emit log lines (with or without ANSI colors / timestamps)
+ * before the actual JSON payload:
+ *
+ *   11:40:09 [plugins] echo: registered /clawly_echo command
+ *   \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
+ * 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-]*\] /
+
+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()
+}

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "clawly-plugins",
   "name": "Clawly Plugins",
   "description": "Clawly utility RPC methods (clawly.*): file access, presence, push notifications, agent messaging, memory browser, and ClawHub CLI bridge.",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "uiHints": {
     "memoryDir": {
       "label": "Memory directory",
@@ -46,8 +46,8 @@
       "defaultNoInput": { "type": "boolean" },
       "defaultTimeoutMs": { "type": "number", "minimum": 1000 },
       "configPath": { "type": "string" },
-      "gatewayBaseUrl": { "type": "string" },
-      "gatewayToken": { "type": "string" }
+      "skillGatewayBaseUrl": { "type": "string" },
+      "skillGatewayToken": { "type": "string" }
     },
     "required": []
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2en/clawly-plugins",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "module": "index.ts",
   "type": "module",
   "repository": {
@@ -14,6 +14,7 @@
   "files": [
     "command",
     "gateway",
+    "lib",
     "tools",
     "index.ts",
     "calendar.ts",