@2en/clawly-plugins 1.28.1 → 1.29.0-beta.1

package/lib/manualPluginInstall.ts

@@ -0,0 +1,148 @@
+/**
+ * Manual plugin install that bypasses OpenClaw's hardened extraction pipeline.
+ *
+ * OpenClaw ≥3.12 uses `copyFileWithinRoot` → `runPinnedWriteHelper` (python3)
+ * during tar extraction, which fails on sprite overlay/JuiceFS filesystems
+ * with `SafeOpenError: path is not a regular file under root`.
+ *
+ * Supports both npm spec and local absolute path. Install uses rsync:
+ * `rsync -a --delete` syncs source into targetDir — overwrites changed files,
+ * adds new files, and removes stale files not in source. The target directory
+ * is never moved or deleted, so the plugin stays functional during the sync.
+ * Staging artifacts (tgz, pkg) are cleaned up in finally.
+ */
+
+import assert from 'node:assert'
+import fs from 'node:fs'
+import path from 'node:path'
+import {$} from 'zx'
+
+const PLUGIN_SENTINEL = 'openclaw.plugin.json'
+
+interface Logger {
+  info?: (msg: string) => void
+  warn?: (msg: string) => void
+  error?: (msg: string) => void
+}
+
+async function withRetry<T>(fn: () => Promise<T>, maxAttempts: number): Promise<T> {
+  let lastErr: unknown
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn()
+    } catch (err) {
+      lastErr = err
+      if (attempt < maxAttempts) {
+        await new Promise((r) => setTimeout(r, 500 * attempt))
+      }
+    }
+  }
+  throw lastErr
+}
+
+export async function manualPluginInstall(params: {
+  spec: string
+  targetDir: string
+  stagingDir: string
+  logger?: Logger
+}): Promise<string> {
+  const {spec, targetDir, stagingDir, logger} = params
+  const isNpm = !path.isAbsolute(spec)
+  const pkgDir = path.join(stagingDir, 'pkg')
+
+  // 1. Ensure targetDir exists
+  fs.mkdirSync(targetDir, {recursive: true})
+
+  // 2. Create stagingDir
+  fs.mkdirSync(stagingDir, {recursive: true})
+
+  try {
+    let sourceDir: string
+    if (isNpm) {
+      // 3a. npm pack → stagingDir (retry 3x)
+      logger?.info?.(`downloading ${spec}...`)
+      const packResult = await withRetry(async () => {
+        const result = await $`npm pack ${spec} --pack-destination ${stagingDir}`
+        return result
+      }, 3)
+      const lastLine = packResult.stdout.trim().split('\n').pop() ?? ''
+      const tgzName = path.basename(lastLine)
+      if (!tgzName.endsWith('.tgz')) throw new Error(`unexpected npm pack output: ${lastLine}`)
+      const tgzPath = path.join(stagingDir, tgzName)
+
+      try {
+        // 3b. Extract to stagingDir/pkg
+        fs.mkdirSync(pkgDir, {recursive: true})
+        logger?.info?.(`extracting to ${pkgDir}...`)
+        await $`tar xzf ${tgzPath} --strip-components=1 -C ${pkgDir}`
+      } finally {
+        try {
+          fs.unlinkSync(tgzPath)
+        } catch {}
+      }
+
+      // 3c. npm install in pkg (retry 3x)
+      const pkgPath = path.join(pkgDir, 'package.json')
+      if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+        if (pkg.dependencies && Object.keys(pkg.dependencies).length > 0) {
+          logger?.info?.('installing dependencies...')
+          await withRetry(
+            () => $({cwd: pkgDir})`npm install --omit=dev --omit=peer --ignore-scripts`,
+            3,
+          )
+        }
+      }
+      sourceDir = pkgDir
+    } else {
+      sourceDir = spec
+      if (!fs.existsSync(sourceDir)) {
+        throw new Error(`local spec path does not exist: ${sourceDir}`)
+      }
+    }
+
+    assert(
+      fs.existsSync(path.join(sourceDir, 'package.json')),
+      `plugin source missing package.json: ${sourceDir}`,
+    )
+    assert(
+      fs.existsSync(path.join(sourceDir, PLUGIN_SENTINEL)),
+      `plugin source missing openclaw.plugin.json: ${sourceDir}`,
+    )
+
+    // 4. rsync source → targetDir (overlay + delete stale files)
+    // npm pack output is already clean; local path needs dev file exclusions
+    logger?.info?.(`syncing to ${targetDir}...`)
+    if (isNpm) {
+      await $`rsync -a --delete --checksum ${sourceDir}/ ${targetDir}/`
+    } else {
+      await $`rsync -a --delete --checksum --exclude=node_modules --exclude=.git ${sourceDir}/ ${targetDir}/`
+    }
+
+    // 5. Verify sentinel
+    if (!fs.existsSync(path.join(targetDir, PLUGIN_SENTINEL))) {
+      throw new Error(`plugin files missing after install (${PLUGIN_SENTINEL} not found)`)
+    }
+
+    // 6. Local path: install production deps (rsync excludes node_modules)
+    if (!isNpm) {
+      const pkg = JSON.parse(fs.readFileSync(path.join(targetDir, 'package.json'), 'utf-8'))
+      if (pkg.dependencies && Object.keys(pkg.dependencies).length > 0) {
+        logger?.info?.('installing dependencies...')
+        await withRetry(
+          () => $({cwd: targetDir})`npm install --omit=dev --omit=peer --ignore-scripts`,
+          3,
+        )
+      }
+    }
+
+    return `Installed ${spec} to ${targetDir}`
+  } finally {
+    // 6. Remove stagingDir (tgz + pkg artifacts)
+    try {
+      if (fs.existsSync(stagingDir)) {
+        fs.rmSync(stagingDir, {recursive: true, force: true})
+      }
+    } catch {}
+  }
+}

package/openclaw.plugin.json

@@ -3,6 +3,7 @@
   "name": "Clawly Plugins",
   "description": "Clawly utility RPC methods (clawly.*): file access, presence, push notifications, agent messaging, memory browser, and ClawHub CLI bridge.",
   "version": "0.3.0",
+  "skills": ["skills/read-office-file"],
   "uiHints": {
     "memoryDir": {
       "label": "Memory directory",

package/outbound.ts

@@ -190,6 +190,18 @@ export function registerOutboundHttpRoute(api: PluginApi) {
     path: '/clawly/file/outbound',
     auth: 'plugin',
     handler: async (_req: IncomingMessage, res: ServerResponse) => {
+      res.setHeader('Access-Control-Allow-Origin', '*')
+
+      // Handle CORS preflight
+      if (_req.method === 'OPTIONS') {
+        res.setHeader('Access-Control-Allow-Methods', 'GET, HEAD, OPTIONS')
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization')
+        res.setHeader('Access-Control-Max-Age', '86400')
+        res.statusCode = 204
+        res.end()
+        return
+      }
+
       const url = new URL(_req.url ?? '/', 'http://localhost')
       if (!guardHttpAuth(api, _req, res, url)) return
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2en/clawly-plugins",
-  "version": "1.28.1",
+  "version": "1.29.0-beta.1",
   "module": "index.ts",
   "type": "module",
   "repository": {
@@ -36,7 +36,8 @@
     "resolve-gateway-credentials.ts",
     "skill-command-restore.ts",
     "openclaw.plugin.json",
-    "internal"
+    "internal",
+    "skills"
   ],
   "publishConfig": {
     "access": "public"

package/skills/read-office-file/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: read-office-file
+description: Convert Word, Excel, or PowerPoint files to Markdown using MarkItDown.
+metadata: { "openclaw": { "emoji": "📄" } }
+---
+
+# Read Office File
+
+Convert Word (.docx), Excel (.xlsx), or PowerPoint (.pptx) files to Markdown using [MarkItDown](https://github.com/microsoft/markitdown).
+
+## When to use
+
+- User asks to read, summarize, or extract content from a `.docx`, `.xlsx`, or `.pptx` file.
+- User shares or references an Office file path.
+
+## Steps
+
+1. Convert the file to Markdown (use the extra matching the file type):
+
+```bash
+# .docx
+uvx 'markitdown[docx]' <file_path>
+
+# .xlsx
+uvx 'markitdown[xlsx]' <file_path>
+
+# .pptx
+uvx 'markitdown[pptx]' <file_path>
+```
+
+2. Read the Markdown output and respond to the user's request.
+
+## Supported formats
+
+| Format | Extensions |
+|---|---|
+| Word | `.docx` |
+| Excel | `.xlsx` |
+| PowerPoint | `.pptx` |
+
+Legacy formats (`.doc`, `.xls`, `.ppt`) are **not supported**. Ask the user to convert to the modern format first.

package/tools/clawly-msg-break.ts

@@ -0,0 +1,32 @@
+/**
+ * Agent tool: clawly_msg_break — split the current response into multiple messages.
+ *
+ * When called, this tool acts as a structural boundary: the text before the
+ * tool call becomes one assistant message, and the text after becomes a new one.
+ * The client relies on the existing "text reset" mechanism (post-tool-call text
+ * detection) to create the split — the tool itself is a no-op.
+ *
+ * This is preferred over in-band separator tokens (e.g. [MSG_BREAK]) because
+ * tool calls are structured and never leak to other channels (Telegram, etc.).
+ */
+
+import type {PluginApi} from '../types'
+
+const TOOL_NAME = 'clawly_msg_break'
+
+export function registerMsgBreakTool(api: PluginApi) {
+  api.registerTool({
+    name: TOOL_NAME,
+    description:
+      'Split the current response into multiple messages. Call this between distinct thoughts or topics to send them as separate message bubbles. The text you wrote before this call becomes one message; continue writing after the call to start a new message.',
+    parameters: {
+      type: 'object',
+      properties: {},
+    },
+    async execute() {
+      return {content: [{type: 'text', text: JSON.stringify({ok: true})}]}
+    },
+  })
+
+  api.logger.info(`tool: registered ${TOOL_NAME} agent tool`)
+}

package/tools/index.ts

@@ -1,6 +1,7 @@
 import type {PluginApi} from '../types'
 import {registerCalendarTools} from './clawly-calendar'
 import {registerIsUserOnlineTool} from './clawly-is-user-online'
+import {registerMsgBreakTool} from './clawly-msg-break'
 import {registerDeepSearchTool, registerGrokSearchTool, registerSearchTool} from './clawly-search'
 import {registerSendAppPushTool} from './clawly-send-app-push'
 import {registerSendImageTool} from './clawly-send-image'
@@ -9,6 +10,7 @@ import {registerSendMessageTool} from './clawly-send-message'
 export function registerTools(api: PluginApi) {
   registerCalendarTools(api)
   registerIsUserOnlineTool(api)
+  registerMsgBreakTool(api)
   registerSearchTool(api)
   registerDeepSearchTool(api)
   registerGrokSearchTool(api)

package/gateway/node-browser-allowlist.ts

@@ -1,62 +0,0 @@
-/**
- * Ensures browser.* node commands are in gateway.nodes.allowCommands
- * so the AI agent can invoke them on connected Clawly Mac nodes.
- *
- * Runs on gateway_start. Writes directly to openclaw.json via
- * writeOpenclawConfig (no restart triggered — gateway.* changes are
- * classified as "none" by the config watcher).
- */
-import path from 'node:path'
-
-import type {PluginApi} from '../types'
-import {readOpenclawConfig, writeOpenclawConfig} from '../model-gateway-setup'
-
-const BROWSER_COMMANDS = [
-  'browser.proxy',
-  'browser.navigate',
-  'browser.click',
-  'browser.type',
-  'browser.screenshot',
-  'browser.read',
-  'browser.tabs',
-  'browser.back',
-  'browser.scroll',
-  'browser.evaluate',
-]
-
-export function registerNodeBrowserAllowlist(api: PluginApi) {
-  api.on('gateway_start', async () => {
-    let stateDir: string
-    try {
-      stateDir = api.runtime.state.resolveStateDir()
-    } catch {
-      api.logger.warn('node-browser-allowlist: cannot resolve state dir, skipping')
-      return
-    }
-
-    const configPath = path.join(stateDir, 'openclaw.json')
-    const config = readOpenclawConfig(configPath)
-
-    // Ensure gateway.nodes.allowCommands includes browser.* commands
-    const gateway = (config.gateway as Record<string, unknown>) ?? {}
-    const nodes = (gateway.nodes as Record<string, unknown>) ?? {}
-    const existing: string[] = Array.isArray(nodes.allowCommands)
-      ? (nodes.allowCommands as string[])
-      : []
-
-    const existingSet = new Set(existing)
-    const toAdd = BROWSER_COMMANDS.filter((cmd) => !existingSet.has(cmd))
-
-    if (toAdd.length === 0) {
-      api.logger.info('node-browser-allowlist: browser commands already allowlisted')
-      return
-    }
-
-    nodes.allowCommands = [...existing, ...toAdd]
-    gateway.nodes = nodes
-    config.gateway = gateway
-
-    writeOpenclawConfig(configPath, config)
-    api.logger.info(`node-browser-allowlist: added ${toAdd.length} browser commands to allowlist`)
-  })
-}