@honor-claw/yoyo 0.0.1-beta.3 → 0.0.1-beta.5

package/index.ts

@@ -4,16 +4,20 @@ import { registerCommands } from "./src/commands/index.js";
 import { YoyoPluginConfigSchema } from "./src/schemas.js";
 import { ClawConnectionService } from "./src/services/connection/index.js";
 import { setClawLogger } from "./src/utils/logger.js";
+import { copyTemplateToWorkspace } from "./src/agent/index.js";
 
 const plugin = {
   id: "yoyo",
   name: "YOYOClaw",
   description: "OpenClaw Honor Yoyo connection plugin",
   configSchema: YoyoPluginConfigSchema,
-  register(api: OpenClawPluginApi) {
+  async register(api: OpenClawPluginApi) {
     setYoyoRuntime(api.runtime);
     setClawLogger(api.logger);
 
+    // 复制智能体模板到工作目录
+    await copyTemplateToWorkspace(api)
+
     // 利用服务来管理核心连接任务进行~
     api.registerService(ClawConnectionService);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@honor-claw/yoyo",
-  "version": "0.0.1-beta.3",
+  "version": "0.0.1-beta.5",
   "type": "module",
   "description": "OpenClaw Honor Yoyo connection plugin",
   "scripts": {

package/skills/yoyo-control/SKILL.md

@@ -5,7 +5,7 @@ description: Whenever a task requires **operating or controlling the phone**, eg
 metadata: { "openclaw": { "emoji": "📱", "always": true } }
 ---
 
-# Control phone with YOYO
+# YOYO Control
 
 Follow the workflow to control phone or pad with YOYO, Don't guess the commands.
 
@@ -13,9 +13,9 @@ Follow the workflow to control phone or pad with YOYO, Don't guess the commands.
 
 Follow this **4-step workflow** when using the skill:
 
-1. Query the device status to identify available device nodes.
-2. Determine the target node, required tool, and execution parameters based on the user's intent.
-3. Call the node tool using the correct parameter format.
+1. Query the nodes status to identify available device, and determine the target device.
+2. Plan the tool to use, and extract command & parameters according to the tool reference.
+3. Invoke node with correct nodeId, command and parameters.
 4. Present the result and confirm whether the operation was successful.
 
 ### Step 1. Discover Nodes
@@ -26,9 +26,11 @@ Follow this **4-step workflow** when using the skill:
 
 **Execution result**:
 
+```markdown
 | Node       | ID       | IP       | Detail   | Status   | Caps   |
 | ---------- | -------- | -------- | -------- | -------- | ------ |
 | <nodeName> | <nodeId> | <nodeIP> | <detail> | <status> | <caps> |
+```
 
 #### Capability Matching Logic
 
@@ -74,17 +76,19 @@ Before executing any device control operation, you **MUST** consult the correspo
 
 ### Available Tool References
 
-| Reference File                     | Capability       | Description                                                                                                                                                          | Required Node Caps     |
-| ---------------------------------- | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- |
-| `references/volume.md`             | Volume Control   | Adjust, set, increase, decrease, mute/unmute device volume; query current volume status; fine-grained control by stream type (media, call, ringtone, notification)   | `volume.operate`       |
-| `references/phone-call.md`         | Phone Call       | Initiate and manage phone calls; unified control for call operations                                                                                                 | `phone.call`           |
-| `references/screen-recorder.md`    | Screen Recording | Start/stop screen recording; configure recording parameters; query recording status; app-specific recording control                                                  | `screen.record`        |
-| `references/capture-screenshot.md` | Screenshot       | Capture current screen content as image; support standard and scrolling screenshot modes                                                                             | `capture.shot`         |
-| `references/schedule.md`           | Schedule         | Provides the ability to create schedules                                                                                                                             | `schedule.create`      |
-| `references/search-contact.md`     | Contact          | Provides the ability to search contacts                                                                                                                              | `search.contact `      |
-| `references/open-app.md`           | Open Application | Used to help users open a specified app without any specific app internals.                                                                                          | `app.open`             |
-| `references/send-message.md`       | Send Message     | Provide SMS sending services, users can send SMS content to specified numbers by providing phone numbers or contact information.                                     | `send.message`         |
-| `references/local-search.md`       | Local Search     | Search native data for documents, notes, calendars, galleries, yoyo memories, wallets, and more for direct answers to user questions or generate at-a-glance content | `message.send.message` |
+| Reference File                     | Tool Name               | Description                                                                                                                                                          | Required Node Caps |
+| ---------------------------------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ |
+| `references/volume.md`             | volume                  | Adjust, set, increase, decrease, mute/unmute device volume; query current volume status; fine-grained control by stream type (media, call, ringtone, notification)   | `volume.operate`   |
+| `references/phone-call.md`         | phone_call              | Initiate and manage phone calls; unified control for call operations                                                                                                 | `phone.call`       |
+| `references/screen-recorder.md`    | screen_recorder         | Start/stop screen recording; configure recording parameters; query recording status; app-specific recording control                                                  | `screen.record`    |
+| `references/capture-screenshot.md` | capture_screenshot      | Capture current screen content as image; support standard and scrolling screenshot modes                                                                             | `capture.shot`     |
+| `references/schedule.md`           | Schedschedule_createule | Provides the ability to create schedules                                                                                                                             | `schedule.create`  |
+| `references/search-contact.md`     | search_contact          | Provides the ability to search contacts                                                                                                                              | `search.contact `  |
+| `references/open-app.md`           | open_app                | Used to help users open a specified app without any specific app internals.                                                                                          | `app.open`         |
+| `references/send-message.md`       | send_message            | Provide SMS sending services, users can send SMS content to specified numbers by providing phone numbers or contact information.                                     | `send.message`     |
+| `references/local-search.md`       | local_search            | Search native data for documents, notes, calendars, galleries, yoyo memories, wallets, and more for direct answers to user questions or generate at-a-glance content | `loacal.search`    |
+| `references/hot-spot.md`           | hot_spot                | 手机热点控制能力                                                                                                                                                     | `hot.spot`         |
+| `references/no-disturb.md`         | hot_spot                | 手机勿扰模式控制力                                                                                                                                                   | `no.disturb`       |
 
 ### Parameter Construction Workflow
 
@@ -181,17 +185,32 @@ Execute the following steps **in strict order** for each operation:
 
 ### Parameter Format Requirements
 
-| Platform                     | Format                                  | Example                 |
-| ---------------------------- | --------------------------------------- | ----------------------- |
-| **Bash (Linux/macOS)**       | Single quotes wrapping JSON             | `'{"level":50}'`        |
-| **Windows (PowerShell/CMD)** | Double quotes with escaped inner quotes | `"{\"level\":50}"`      |
-| **Complex Objects**          | Create JSON file first                  | `--params @params.json` |
+**Platform-specific JSON parameter format:**
+
+| Platform    | Shell | Quote Style                     | Example                         |
+| ----------- | ----- | ------------------------------- | ------------------------------- |
+| **Windows** | CMD   | Double quotes, escape inner `"` | `"{\"actionType\":\"打电话\"}"` |
+| **Linux**   | Bash  | Single quotes                   | `'{"actionType":"打电话"}'`     |
+| **macOS**   | Bash  | Single quotes                   | `'{"actionType":"打电话"}'`     |
+
+**Windows CMD Execution:**
+
+```cmd
+openclaw nodes invoke <nodeId> --command phone.call --params "{\"actionType\":\"打电话\",\"phoneNumber\":\"10086\"}"
+```
+
+**Linux/macOS Bash Execution:**
+
+```bash
+openclaw nodes invoke <nodeId> --command phone.call --params '{"actionType":"打电话","phoneNumber":"10086"}'
+```
 
 **Additional Requirements**:
 
 - Parameters must be valid JSON
 - Enum values must match documentation exactly (case-sensitive)
 - Numeric values must be within defined ranges
+- On Windows, always use CMD (not PowerShell) to avoid quote parsing issues
 
 ### Examples
 
@@ -334,13 +353,3 @@ Would you like to check other nodes or retry later?"
 - ❌ **DO NOT** expose raw error codes to users
 - ❌ **DO NOT** assume user knows technical details
 - ❌ **DO NOT** leave user without next steps on failure
-
-## 快速参考命令
-
-```bash
-# 获取所有节点状态
-openclaw nodes status
-
-# 调用工具
-openclaw nodes invoke --node <id|name|ip> --command <command> --params <json>
-```

package/skills/yoyo-control/references/hot-spot.md

@@ -0,0 +1,19 @@
+# hot_spot 手机热点控制工具使用说明
+
+## Tool Command
+
+```bash
+hot.spot
+```
+
+## Tool Parameters and Examples
+
+```json
+{
+  "name": "hot_spot",
+  "description": "该工具提供对设备热点控制",
+  "parameters": {},
+  "required": [],
+  "examples": []
+}
+```

package/skills/yoyo-control/references/no-disturb.md

@@ -0,0 +1,19 @@
+# no_disturb 勿扰模式工具使用说明
+
+## Tool Command
+
+```bash
+no.disturb
+```
+
+## Tool Parameters and Examples
+
+```json
+{
+  "name": "no_disturb",
+  "description": "手机勿扰模式",
+  "parameters": {},
+  "required": [],
+  "examples": []
+}
+```

package/skills/yoyo-control/references/phone-call.md

@@ -65,7 +65,7 @@ phone.call
 ```json
 {
   "name": "phone_call",
-  "description": "提供打电话能力，支持指定姓名、电话号码电话；支持选择打电话的卡；支持重拨、回拨已接听来电、回拨未接听来电、回拨电话",
+  "description": "提供打电话的功能，支持指定姓名、电话号码；支持选择打电话的卡；支持重拨、回拨已接听来电、回拨未接听来电、回拨电话",
   "parameters": {
     "actionType": {
       "type": "string",
@@ -91,125 +91,38 @@ phone.call
     },
     "contact": {
       "type": "string",
-      "description": "泛化的"联系人"概念，可为：自然人名或昵称（如：张三、王总）、非自然实体（机构、部门、服务名称，如：招生办、物业客服）"
+      "description": "泛化的“联系人”概念，可为：自然人名或昵称（如：张三、王总）、非自然实体（机构、部门、服务名称，如：招生办、物业客服）"
     }
   },
   "examples": [
     {
-      "scenario": "User provides phoneNumber directly",
-      "query": "打电话给15651621029",
-      "workflow": "Direct call (no contact search needed)",
+      "query": "拨打电话",
       "arguments": {
-        "actionType": "打电话",
-        "phoneNumber": "15651621029"
-      }
-    },
-    {
-      "scenario": "User provides contact name only",
-      "query": "打电话给妈妈",
-      "workflow": "search_contact → phone.call",
-      "step1": {
-        "tool": "search_contact",
-        "arguments": {
-          "contact": "妈妈"
-        },
-        "result": {
-          "name": "妈妈",
-          "phoneNumber": "13900139000"
-        }
-      },
-      "step2": {
-        "tool": "phone.call",
-        "arguments": {
-          "actionType": "打电话",
-          "phoneNumber": "13900139000"
-        }
+        "actionType": "打电话"
       }
     },
     {
-      "scenario": "User provides contact with phoneCard",
-      "query": "用移动卡打电话给张三",
-      "workflow": "search_contact → phone.call with phoneCard",
-      "step1": {
-        "tool": "search_contact",
-        "arguments": {
-          "contact": "张三"
-        },
-        "result": {
-          "name": "张三",
-          "phoneNumber": "15651621029"
-        }
-      },
-      "step2": {
-        "tool": "phone.call",
-        "arguments": {
-          "actionType": "打电话",
-          "phoneNumber": "15651621029",
-          "phoneCard": "移动"
-        }
-      }
-    },
-    {
-      "scenario": "User requests redial",
-      "query": "重拨",
-      "workflow": "Direct redial (no contact search needed)",
+      "query": "打电话给15651621029",
       "arguments": {
-        "actionType": "重拨"
+        "actionType": "打电话",
+        "phoneNumber": "15651621029"
       }
     },
     {
-      "scenario": "User requests callback missed call",
-      "query": "回拨未接来电",
-      "workflow": "Direct callback (no contact search needed)",
+      "query": "打电话给张三",
       "arguments": {
-        "actionType": "回拨",
-        "recallType": "回拨未接听来电"
-      }
-    },
-    {
-      "scenario": "User provides contact with multiple matches",
-      "query": "打电话给李四",
-      "workflow": "search_contact → user selects → phone.call",
-      "step1": {
-        "tool": "search_contact",
-        "arguments": {
-          "contact": "李四"
-        },
-        "result": {
-          "matches": [
-            { "name": "李四(公司)", "phoneNumber": "13800138001" },
-            { "name": "李四(家里)", "phoneNumber": "13800138002" }
-          ]
-        }
-      },
-      "step2": {
-        "action": "Ask user to select",
-        "prompt": "找到多个李四，请选择：1. 李四(公司) 2. 李四(家里)"
-      },
-      "step3": {
-        "tool": "phone.call",
-        "arguments": {
-          "actionType": "打电话",
-          "phoneNumber": "13800138001"
-        }
+        "actionType": "打电话",
+        "contact": "张三",
+        "phoneNumber": "15651621029"
       }
     },
     {
-      "scenario": "User provides contact with no match",
-      "query": "打电话给王五",
-      "workflow": "search_contact → no match → ask for phoneNumber",
-      "step1": {
-        "tool": "search_contact",
-        "arguments": {
-          "contact": "王五"
-        },
-        "result": {
-          "matches": []
-        }
-      },
-      "step2": {
-        "action": "Ask user for phoneNumber",
-        "prompt": "未找到联系人王五，请提供电话号码"
+      "query": "用移动手机卡打电话给于洋",
+      "arguments": {
+        "actionType": "打电话",
+        "contact": "张三",
+        "phoneNumber": "15651621029",
+        "phoneCard": "移动手机卡"
       }
     }
   ]

package/skills/yoyo-control/references/volume.md

@@ -1,6 +1,6 @@
 # volumn 音量控制工具使用说明
 
-## 工具指令 command 定义
+## Tool Command
 
 ```bash
 volume.operate

package/src/agent/copy-templates.ts

@@ -0,0 +1,56 @@
+import fs from "node:fs/promises";
+import path from "path";
+import { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { safeWriteFile, SafeFsError, type WriteMode } from "../utils/fs-safe.js";
+
+type TemplateEntry = {
+  file: string;
+  mode: WriteMode;
+};
+
+const TEMPLATE_FILE_LIST: TemplateEntry[] = [
+  { file: "AGENTS.md", mode: "overwrite" },
+];
+
+function resolveWorkspaceDir(api: OpenClawPluginApi): string {
+  const configuredWorkspace = api.config.agents?.defaults?.workspace?.trim();
+  if (configuredWorkspace) {
+    return api.resolvePath(configuredWorkspace);
+  }
+  return api.resolvePath("~/.openclaw/workspace");
+}
+
+export async function copyTemplateToWorkspace(api: OpenClawPluginApi): Promise<void> {
+  const pluginDir = path.dirname(api.source);
+  const templateDir = path.join(pluginDir, "src", "agent", "templates");
+  const workspaceDir = resolveWorkspaceDir(api);
+
+  for (const entry of TEMPLATE_FILE_LIST) {
+    const sourcePath = path.join(templateDir, entry.file);
+
+    try {
+      const content = await fs.readFile(sourcePath, "utf-8");
+
+      await safeWriteFile({
+        rootDir: workspaceDir,
+        relativePath: entry.file,
+        data: content,
+        mode: entry.mode,
+        mkdir: true,
+      });
+      api.logger.info(`Successfully wrote ${entry.file} to workspace (${entry.mode} mode)`);
+    } catch (error) {
+      if (error instanceof SafeFsError) {
+        if (error.code === "not-found") {
+          api.logger.warn(`Source file does not exist: ${sourcePath}`);
+          continue;
+        }
+        api.logger.error(`Failed to write ${entry.file}: ${error.message}`);
+      } else {
+        api.logger.error(
+          `Failed to write ${entry.file}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+}

package/src/agent/index.ts

@@ -0,0 +1,3 @@
+import { copyTemplateToWorkspace } from "./copy-templates.js";
+
+export { copyTemplateToWorkspace };

package/src/commands/index.ts

@@ -1,7 +1,7 @@
 import { type OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { registerLoginCommand } from "./login/index.js";
 import { registerStatusCommand } from "./status/index.js";
-import { registerLogoutCommand } from "./logout/index.js";
+// import { registerLogoutCommand } from "./logout/index.js";
 
 export function registerCommands(api: OpenClawPluginApi) {
   api.registerCli(
@@ -10,7 +10,9 @@ export function registerCommands(api: OpenClawPluginApi) {
         .command("honor")
         .description("Commands for honor yoyoclaw");
 
+      // @ts-ignore
       registerLoginCommand(api, rootCommand);
+      // @ts-ignore
       registerStatusCommand(api, rootCommand);
       // registerLogoutCommand(api, rootCommand);
     },

package/src/modules/claw-configs/config-manager.ts

@@ -21,8 +21,7 @@ export class ConfigManager {
       return runtime.config.loadConfig();
     } catch (error) {
       throw new Error(
-        `Failed to load config: ${
-          error instanceof Error ? error.message : String(error)
+        `Failed to load config: ${error instanceof Error ? error.message : String(error)
         }`
       );
     }
@@ -37,8 +36,7 @@ export class ConfigManager {
       await runtime.config.writeConfigFile(config);
     } catch (error) {
       throw new Error(
-        `Failed to save config: ${
-          error instanceof Error ? error.message : String(error)
+        `Failed to save config: ${error instanceof Error ? error.message : String(error)
         }`
       );
     }
@@ -138,8 +136,7 @@ export class ConfigManager {
       await this.saveConfig(updatedConfig);
     } catch (error) {
       throw new Error(
-        `Failed to update user config: ${
-          error instanceof Error ? error.message : String(error)
+        `Failed to update user config: ${error instanceof Error ? error.message : String(error)
         }`
       );
     }
@@ -171,8 +168,7 @@ export class ConfigManager {
       await this.saveConfig(updatedConfig);
     } catch (error) {
       throw new Error(
-        `Failed to clear user config: ${
-          error instanceof Error ? error.message : String(error)
+        `Failed to clear user config: ${error instanceof Error ? error.message : String(error)
         }`
       );
     }
@@ -212,6 +208,14 @@ export class ConfigManager {
         "schedule.update",
         "schedule.delete",
         "schedule.search",
+        "mobile.data",
+        "hot.spot",
+        "no.disturb",
+        "quiet.mode",
+        "sound.vibration",
+        "ringing.mode",
+        "vibration.mode",
+        "close.app"
       ];
 
       const currentAllowCommands =
@@ -239,8 +243,7 @@ export class ConfigManager {
       await this.saveConfig(updatedConfig);
     } catch (error) {
       throw new Error(
-        `failed to initialize plugin config: ${
-          error instanceof Error ? error.message : String(error)
+        `failed to initialize plugin config: ${error instanceof Error ? error.message : String(error)
         }`
       );
     }

package/src/utils/fs-safe.ts

@@ -0,0 +1,544 @@
+import { randomUUID } from "node:crypto";
+import type { Stats } from "node:fs";
+import { constants as fsConstants } from "node:fs";
+import type { FileHandle } from "node:fs/promises";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+export type SafeFsErrorCode =
+  | "invalid-path"
+  | "not-found"
+  | "outside-root"
+  | "symlink"
+  | "not-file"
+  | "path-mismatch"
+  | "too-large"
+  | "write-failed";
+
+export class SafeFsError extends Error {
+  code: SafeFsErrorCode;
+
+  constructor(code: SafeFsErrorCode, message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.code = code;
+    this.name = "SafeFsError";
+  }
+}
+
+export type WriteMode = "overwrite" | "append";
+
+export type SafeWriteOptions = {
+  rootDir: string;
+  relativePath: string;
+  data: string | Buffer;
+  encoding?: BufferEncoding;
+  mode?: WriteMode;
+  mkdir?: boolean;
+  maxBytes?: number;
+};
+
+export type SafeReadResult = {
+  buffer: Buffer;
+  realPath: string;
+  stat: Stats;
+};
+
+export type SafeWriteResult = {
+  realPath: string;
+  bytesWritten: number;
+  created: boolean;
+};
+
+const NOT_FOUND_CODES = new Set(["ENOENT", "ENOTDIR"]);
+const SYMLINK_OPEN_CODES = new Set(["ELOOP", "EINVAL", "ENOTSUP"]);
+
+function isNodeError(value: unknown): value is NodeJS.ErrnoException {
+  return Boolean(
+    value && typeof value === "object" && "code" in (value as Record<string, unknown>)
+  );
+}
+
+function isNotFoundPathError(value: unknown): boolean {
+  return isNodeError(value) && typeof value.code === "string" && NOT_FOUND_CODES.has(value.code);
+}
+
+function isSymlinkOpenError(value: unknown): boolean {
+  return isNodeError(value) && typeof value.code === "string" && SYMLINK_OPEN_CODES.has(value.code);
+}
+
+function normalizeWindowsPathForComparison(input: string): string {
+  let normalized = path.win32.normalize(input);
+  if (normalized.startsWith("\\\\?\\")) {
+    normalized = normalized.slice(4);
+    if (normalized.toUpperCase().startsWith("UNC\\")) {
+      normalized = `\\\\${normalized.slice(4)}`;
+    }
+  }
+  return normalized.replaceAll("/", "\\").toLowerCase();
+}
+
+function isPathInside(root: string, target: string): boolean {
+  const resolvedRoot = path.resolve(root);
+  const resolvedTarget = path.resolve(target);
+
+  if (process.platform === "win32") {
+    const rootForCompare = normalizeWindowsPathForComparison(resolvedRoot);
+    const targetForCompare = normalizeWindowsPathForComparison(resolvedTarget);
+    const relative = path.win32.relative(rootForCompare, targetForCompare);
+    return relative === "" || (!relative.startsWith("..") && !path.win32.isAbsolute(relative));
+  }
+
+  const relative = path.relative(resolvedRoot, resolvedTarget);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+type FileIdentityStat = {
+  dev: number | bigint;
+  ino: number | bigint;
+};
+
+function isZero(value: number | bigint): boolean {
+  return value === 0 || value === 0n;
+}
+
+function sameFileIdentity(
+  left: FileIdentityStat,
+  right: FileIdentityStat,
+  platform: NodeJS.Platform = process.platform
+): boolean {
+  if (left.ino !== right.ino) {
+    return false;
+  }
+  if (left.dev === right.dev) {
+    return true;
+  }
+  return platform === "win32" && (isZero(left.dev) || isZero(right.dev));
+}
+
+const SUPPORTS_NOFOLLOW = process.platform !== "win32" && "O_NOFOLLOW" in fsConstants;
+const OPEN_READ_FLAGS = fsConstants.O_RDONLY | (SUPPORTS_NOFOLLOW ? fsConstants.O_NOFOLLOW : 0);
+const OPEN_WRITE_CREATE_FLAGS =
+  fsConstants.O_WRONLY |
+  fsConstants.O_CREAT |
+  fsConstants.O_EXCL |
+  (SUPPORTS_NOFOLLOW ? fsConstants.O_NOFOLLOW : 0);
+const OPEN_APPEND_FLAGS =
+  fsConstants.O_WRONLY | fsConstants.O_APPEND | (SUPPORTS_NOFOLLOW ? fsConstants.O_NOFOLLOW : 0);
+
+const ensureTrailingSep = (value: string) => (value.endsWith(path.sep) ? value : value + path.sep);
+
+function expandHomePrefix(input: string, home?: string): string {
+  if (!input.startsWith("~")) {
+    return input;
+  }
+  const resolvedHome = home ?? process.env.HOME ?? process.env.USERPROFILE ?? os.homedir();
+  if (!resolvedHome) {
+    return input;
+  }
+  return input.replace(/^~(?=$|[\\/])/, resolvedHome);
+}
+
+async function resolvePathWithinRoot(params: {
+  rootDir: string;
+  relativePath: string;
+}): Promise<{ rootReal: string; rootWithSep: string; resolved: string }> {
+  let rootReal: string;
+  try {
+    rootReal = await fs.realpath(params.rootDir);
+  } catch (err) {
+    if (isNotFoundPathError(err)) {
+      throw new SafeFsError("not-found", "root dir not found");
+    }
+    throw err;
+  }
+  const rootWithSep = ensureTrailingSep(rootReal);
+  const expanded = expandHomePrefix(params.relativePath);
+  const resolved = path.resolve(rootWithSep, expanded);
+  if (!isPathInside(rootWithSep, resolved)) {
+    throw new SafeFsError("outside-root", "file is outside workspace root");
+  }
+  return { rootReal, rootWithSep, resolved };
+}
+
+async function openVerifiedLocalFile(
+  filePath: string,
+  options?: { rejectHardlinks?: boolean }
+): Promise<{ handle: FileHandle; realPath: string; stat: Stats }> {
+  try {
+    const preStat = await fs.lstat(filePath);
+    if (preStat.isDirectory()) {
+      throw new SafeFsError("not-file", "not a file");
+    }
+  } catch (err) {
+    if (err instanceof SafeFsError) {
+      throw err;
+    }
+  }
+
+  let handle: FileHandle;
+  try {
+    handle = await fs.open(filePath, OPEN_READ_FLAGS);
+  } catch (err) {
+    if (isNotFoundPathError(err)) {
+      throw new SafeFsError("not-found", "file not found");
+    }
+    if (isSymlinkOpenError(err)) {
+      throw new SafeFsError("symlink", "symlink open blocked", { cause: err });
+    }
+    if (isNodeError(err) && err.code === "EISDIR") {
+      throw new SafeFsError("not-file", "not a file");
+    }
+    throw err;
+  }
+
+  try {
+    const [stat, lstat] = await Promise.all([handle.stat(), fs.lstat(filePath)]);
+    if (lstat.isSymbolicLink()) {
+      throw new SafeFsError("symlink", "symlink not allowed");
+    }
+    if (!stat.isFile()) {
+      throw new SafeFsError("not-file", "not a file");
+    }
+    if (options?.rejectHardlinks && stat.nlink > 1) {
+      throw new SafeFsError("invalid-path", "hardlinked path not allowed");
+    }
+    if (!sameFileIdentity(stat, lstat)) {
+      throw new SafeFsError("path-mismatch", "path changed during read");
+    }
+
+    const realPath = await fs.realpath(filePath);
+    const realStat = await fs.stat(realPath);
+    if (options?.rejectHardlinks && realStat.nlink > 1) {
+      throw new SafeFsError("invalid-path", "hardlinked path not allowed");
+    }
+    if (!sameFileIdentity(stat, realStat)) {
+      throw new SafeFsError("path-mismatch", "path mismatch");
+    }
+
+    return { handle, realPath, stat };
+  } catch (err) {
+    await handle.close().catch(() => { });
+    if (err instanceof SafeFsError) {
+      throw err;
+    }
+    if (isNotFoundPathError(err)) {
+      throw new SafeFsError("not-found", "file not found");
+    }
+    throw err;
+  }
+}
+
+export async function safeReadFile(params: {
+  rootDir: string;
+  relativePath: string;
+  maxBytes?: number;
+}): Promise<SafeReadResult> {
+  const { rootWithSep, resolved } = await resolvePathWithinRoot(params);
+
+  const opened = await openVerifiedLocalFile(resolved);
+
+  if (!isPathInside(rootWithSep, opened.realPath)) {
+    await opened.handle.close().catch(() => { });
+    throw new SafeFsError("outside-root", "file is outside workspace root");
+  }
+
+  try {
+    if (params.maxBytes !== undefined && opened.stat.size > params.maxBytes) {
+      throw new SafeFsError(
+        "too-large",
+        `file exceeds limit of ${params.maxBytes} bytes (got ${opened.stat.size})`
+      );
+    }
+    const buffer = await opened.handle.readFile();
+    return {
+      buffer,
+      realPath: opened.realPath,
+      stat: opened.stat,
+    };
+  } finally {
+    await opened.handle.close().catch(() => { });
+  }
+}
+
+function buildAtomicWriteTempPath(targetPath: string): string {
+  const dir = path.dirname(targetPath);
+  const base = path.basename(targetPath);
+  return path.join(dir, `.${base}.${process.pid}.${randomUUID()}.tmp`);
+}
+
+async function writeTempFileForAtomicReplace(params: {
+  tempPath: string;
+  data: string | Buffer;
+  encoding?: BufferEncoding;
+  mode: number;
+}): Promise<Stats> {
+  const tempHandle = await fs.open(params.tempPath, OPEN_WRITE_CREATE_FLAGS, params.mode);
+  try {
+    if (typeof params.data === "string") {
+      await tempHandle.writeFile(params.data, params.encoding ?? "utf8");
+    } else {
+      await tempHandle.writeFile(params.data);
+    }
+    return await tempHandle.stat();
+  } finally {
+    await tempHandle.close().catch(() => { });
+  }
+}
+
+async function verifyAtomicWriteResult(params: {
+  rootDir: string;
+  targetPath: string;
+  expectedStat: Stats;
+}): Promise<void> {
+  const rootReal = await fs.realpath(params.rootDir);
+  const rootWithSep = ensureTrailingSep(rootReal);
+  const opened = await openVerifiedLocalFile(params.targetPath, { rejectHardlinks: true });
+  try {
+    if (!sameFileIdentity(opened.stat, params.expectedStat)) {
+      throw new SafeFsError("path-mismatch", "path changed during write");
+    }
+    if (!isPathInside(rootWithSep, opened.realPath)) {
+      throw new SafeFsError("outside-root", "file is outside workspace root");
+    }
+  } finally {
+    await opened.handle.close().catch(() => { });
+  }
+}
+
+export async function safeWriteFile(params: SafeWriteOptions): Promise<SafeWriteResult> {
+  const { rootWithSep, resolved } = await resolvePathWithinRoot(params);
+
+  if (params.mkdir !== false) {
+    await fs.mkdir(path.dirname(resolved), { recursive: true });
+  }
+
+  let ioPath = resolved;
+  let existingFile = false;
+
+  try {
+    const resolvedRealPath = await fs.realpath(resolved);
+    if (!isPathInside(rootWithSep, resolvedRealPath)) {
+      throw new SafeFsError("outside-root", "file is outside workspace root");
+    }
+    ioPath = resolvedRealPath;
+    existingFile = true;
+  } catch (err) {
+    if (err instanceof SafeFsError) {
+      throw err;
+    }
+    if (!isNotFoundPathError(err)) {
+      throw err;
+    }
+  }
+
+  const fileMode = 0o600;
+  const isAppend = params.mode === "append";
+
+  if (isAppend && !existingFile) {
+    throw new SafeFsError("not-found", "cannot append to non-existent file");
+  }
+
+  if (isAppend) {
+    return await appendToFile({
+      ioPath,
+      rootWithSep,
+      data: params.data,
+      encoding: params.encoding,
+      maxBytes: params.maxBytes,
+    });
+  }
+
+  return await overwriteFile({
+    ioPath,
+    rootWithSep,
+    rootDir: params.rootDir,
+    data: params.data,
+    encoding: params.encoding,
+    existingFile,
+    fileMode,
+  });
+}
+
+async function appendToFile(params: {
+  ioPath: string;
+  rootWithSep: string;
+  data: string | Buffer;
+  encoding?: BufferEncoding;
+  maxBytes?: number;
+}): Promise<SafeWriteResult> {
+  let handle: FileHandle;
+  try {
+    handle = await fs.open(params.ioPath, OPEN_APPEND_FLAGS);
+  } catch (err) {
+    if (isNotFoundPathError(err)) {
+      throw new SafeFsError("not-found", "file not found");
+    }
+    if (isSymlinkOpenError(err)) {
+      throw new SafeFsError("symlink", "symlink open blocked", { cause: err });
+    }
+    throw err;
+  }
+
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile()) {
+      throw new SafeFsError("not-file", "path is not a regular file");
+    }
+
+    const lstat = await fs.lstat(params.ioPath);
+    if (lstat.isSymbolicLink()) {
+      throw new SafeFsError("symlink", "path is a symlink");
+    }
+    if (!sameFileIdentity(stat, lstat)) {
+      throw new SafeFsError("path-mismatch", "path changed during write");
+    }
+
+    const realPath = await fs.realpath(params.ioPath);
+    if (!isPathInside(params.rootWithSep, realPath)) {
+      throw new SafeFsError("outside-root", "file is outside workspace root");
+    }
+
+    const dataSize = typeof params.data === "string"
+      ? Buffer.byteLength(params.data, params.encoding ?? "utf8")
+      : params.data.length;
+
+    if (params.maxBytes !== undefined && stat.size + dataSize > params.maxBytes) {
+      throw new SafeFsError(
+        "too-large",
+        `file would exceed limit of ${params.maxBytes} bytes`
+      );
+    }
+
+    if (typeof params.data === "string") {
+      await handle.writeFile(params.data, params.encoding ?? "utf8");
+    } else {
+      await handle.writeFile(params.data);
+    }
+
+    return {
+      realPath,
+      bytesWritten: dataSize,
+      created: false,
+    };
+  } finally {
+    await handle.close().catch(() => { });
+  }
+}
+
+async function overwriteFile(params: {
+  ioPath: string;
+  rootWithSep: string;
+  rootDir: string;
+  data: string | Buffer;
+  encoding?: BufferEncoding;
+  existingFile: boolean;
+  fileMode: number;
+}): Promise<SafeWriteResult> {
+  let tempPath: string | null = null;
+  const destinationPath = params.ioPath;
+
+  try {
+    tempPath = buildAtomicWriteTempPath(destinationPath);
+    const writtenStat = await writeTempFileForAtomicReplace({
+      tempPath,
+      data: params.data,
+      encoding: params.encoding,
+      mode: params.fileMode,
+    });
+
+    await fs.rename(tempPath, destinationPath);
+    tempPath = null;
+
+    try {
+      await verifyAtomicWriteResult({
+        rootDir: params.rootDir,
+        targetPath: destinationPath,
+        expectedStat: writtenStat,
+      });
+    } catch (err) {
+      // 修复：重新抛出错误
+      throw new SafeFsError("write-failed", `${JSON.stringify(err)}`);
+    }
+
+    const dataSize = typeof params.data === "string"
+      ? Buffer.byteLength(params.data, params.encoding ?? "utf8")
+      : params.data.length;
+
+    return {
+      realPath: destinationPath,
+      bytesWritten: dataSize,
+      created: !params.existingFile,
+    };
+  } finally {
+    if (tempPath) {
+      await fs.rm(tempPath, { force: true }).catch(() => { });
+    }
+  }
+}
+
+export async function safeCopyFile(params: {
+  sourcePath: string;
+  rootDir: string;
+  relativePath: string;
+  maxBytes?: number;
+  mkdir?: boolean;
+}): Promise<void> {
+  const source = await openVerifiedLocalFile(params.sourcePath, { rejectHardlinks: true });
+
+  if (params.maxBytes !== undefined && source.stat.size > params.maxBytes) {
+    await source.handle.close().catch(() => { });
+    throw new SafeFsError(
+      "too-large",
+      `file exceeds limit of ${params.maxBytes} bytes (got ${source.stat.size})`
+    );
+  }
+
+  const { resolved } = await resolvePathWithinRoot({
+    rootDir: params.rootDir,
+    relativePath: params.relativePath,
+  });
+
+  if (params.mkdir !== false) {
+    await fs.mkdir(path.dirname(resolved), { recursive: true });
+  }
+
+  let tempPath: string | null = null;
+  let tempHandle: FileHandle | null = null;
+
+  try {
+    tempPath = buildAtomicWriteTempPath(resolved);
+    tempHandle = await fs.open(tempPath, OPEN_WRITE_CREATE_FLAGS, 0o600);
+
+    const sourceStream = source.handle.createReadStream();
+    const targetStream = tempHandle.createWriteStream();
+
+    await new Promise<void>((resolve, reject) => {
+      sourceStream.pipe(targetStream);
+      sourceStream.on("end", resolve);
+      sourceStream.on("error", reject);
+      targetStream.on("error", reject);
+    });
+
+    await tempHandle.close().catch(() => { });
+    tempHandle = null;
+
+    const writtenStat = await fs.stat(tempPath);
+    await fs.rename(tempPath, resolved);
+    tempPath = null;
+
+    await verifyAtomicWriteResult({
+      rootDir: params.rootDir,
+      targetPath: resolved,
+      expectedStat: writtenStat,
+    });
+  } finally {
+    if (tempPath) {
+      await fs.rm(tempPath, { force: true }).catch(() => { });
+    }
+    if (tempHandle) {
+      await tempHandle.close().catch(() => { });
+    }
+    await source.handle.close().catch(() => { });
+  }
+}

package/skills/yoyo-control/scripts/README.md

@@ -1,103 +0,0 @@
-# 设备控制脚本使用说明
-
-本脚本提供统一的设备控制接口，避免 Windows PowerShell 对 JSON 参数的引号处理问题。
-
-## 快速开始
-
-### 1. 获取设备ID
-
-```bash
-npx openclaw nodes status
-```
-
-### 2. 创建配置文件
-
-复制并修改示例配置文件，将 `YOUR_DEVICE_ID` 替换为实际的设备ID。
-
-```json
-{
-  "nodeId": "f5f8916028aa52091fd9e97bdb77b294b73dcef339541e33d0b51a3b8d595b6c",
-  "command": "volume.operate",
-  "params": {
-    "actionType": "关闭"
-  }
-}
-```
-
-### 3. 执行命令
-
-```bash
-cd claw-yoyo-ext
-node skills/devices-control/scripts/invoke.js skills/devices-control/scripts/volume-close.json
-```
-
-## 使用示例
-
-### 音量控制
-
-```bash
-# 关闭音量
-node skills/devices-control/scripts/invoke.js skills/devices-control/scripts/volume-close.json
-
-# 调大音量
-node skills/devices-control/scripts/invoke.js skills/devices-control/scripts/volume-up.json
-
-# 设置音量为50
-node skills/devices-control/scripts/invoke.js skills/devices-control/scripts/volume-set-50.json
-```
-
-### 电话拨打
-
-```bash
-# 拨打电话
-node skills/devices-control/scripts/invoke.js skills/devices-control/scripts/phone-call.json
-```
-
-### 屏幕录制
-
-```bash
-# 开始录制
-node skills/devices-control/scripts/invoke.js skills/devices-control/scripts/screen-record-start.json
-```
-
-## 调试模式
-
-启用调试模式查看详细执行信息：
-
-```bash
-node skills/devices-control/scripts/invoke.js config.json --debug
-```
-
-## 配置文件格式
-
-```json
-{
-  "nodeId": "设备ID（必填）",
-  "command": "命令标识（必填）",
-  "params": {
-    // 命令参数（可选）
-  }
-}
-```
-
-## 常用命令标识
-
-| 功能 | 命令标识 |
-|------|----------|
-| 音量控制 | `volume.operate` |
-| 电话拨打 | `phone.call` |
-| 屏幕录制 | `screen_recorder.control` |
-
-## 故障排查
-
-### 问题：找不到 openclaw 命令
-
-确保在 `claw-yoyo-ext` 目录下执行命令，或确保 `openclaw` 已全局安装。
-
-### 问题：设备ID无效
-
-使用 `npx openclaw nodes status` 查看有效的设备ID。
-
-### 问题：参数格式错误
-
-参考 `examples.json` 查看完整的参数示例。

package/skills/yoyo-control/scripts/invoke.js

@@ -1,119 +0,0 @@
-#!/usr/bin/env node
-/**
- * Device Control Invoke Script
- *
- * 封装 openclaw nodes invoke 命令，提供统一的设备控制接口
- * 使用配置文件方式避免 Windows PowerShell 对 JSON 参数的引号处理问题
- */
-
-import { exec } from "child_process";
-import { readFileSync } from "fs";
-import { resolve } from "path";
-import { promisify } from "util";
-
-const execAsync = promisify(exec);
-
-/**
- * 显示使用说明
- */
-function usage() {
-  console.error("用法: node invoke.js <config_file> [--debug]");
-  console.error("");
-  console.error("参数:");
-  console.error("  config_file - JSON 配置文件路径");
-  console.error("  --debug     - 启用调试模式");
-  console.error("");
-  console.error("配置文件格式:");
-  console.error("{");
-  console.error('  "nodeId": "设备ID",');
-  console.error('  "command": "命令标识",');
-  console.error('  "params": { ...参数对象 }');
-  console.error("}");
-  console.error("");
-  console.error("示例:");
-  console.error("  node invoke.js config.json");
-  console.error("  node invoke.js config.json --debug");
-  process.exit(2);
-}
-
-/**
- * 执行节点命令
- */
-async function invokeNode(nodeId, command, params, timeout = 15000, debug = false) {
-  const paramsStr = JSON.stringify(params);
-  const cmd = `npx openclaw nodes invoke --node ${nodeId} --command ${command} --params "${paramsStr.replace(/"/g, '\\"')}"`;
-
-  if (debug) {
-    console.log("=== 调试信息 ===");
-    console.log("执行命令:", cmd);
-    console.log("设备 ID:", nodeId);
-    console.log("命令标识:", command);
-    console.log("参数对象:", JSON.stringify(params, null, 2));
-    console.log("================");
-  }
-
-  try {
-    const { stdout, stderr } = await execAsync(cmd, {
-      timeout,
-      env: { ...process.env },
-      cwd: process.cwd()
-    });
-
-    if (debug) {
-      console.log("=== 执行结果 ===");
-      console.log("标准输出:", stdout.trim());
-      console.log("错误输出:", stderr.trim());
-      console.log("================");
-    }
-
-    return {
-      success: true,
-      data: stdout.trim(),
-      error: stderr.trim() || null
-    };
-  } catch (error) {
-    if (debug) {
-      console.log("=== 执行失败 ===");
-      console.log("错误信息:", error.message);
-      console.log("标准输出:", error.stdout?.trim() || "");
-      console.log("错误输出:", error.stderr?.trim() || "");
-      console.log("================");
-    }
-
-    return {
-      success: false,
-      data: error.stdout?.trim() || "",
-      error: error.stderr?.trim() || error.message
-    };
-  }
-}
-
-// 主程序
-const args = process.argv.slice(2);
-const debugIndex = args.indexOf("--debug");
-const debug = debugIndex !== -1;
-if (debug) args.splice(debugIndex, 1);
-
-if (args.length === 0 || args[0] === "-h" || args[0] === "--help") {
-  usage();
-}
-
-const configPath = resolve(args[0]);
-
-try {
-  const configContent = readFileSync(configPath, "utf-8");
-  const config = JSON.parse(configContent);
-  const { nodeId, command, params } = config;
-
-  if (!nodeId || !command) {
-    console.error("错误: 配置文件缺少必要字段: nodeId 或 command");
-    process.exit(1);
-  }
-
-  const result = await invokeNode(nodeId, command, params || {}, 15000, debug);
-  console.log(JSON.stringify(result, null, 2));
-  process.exit(result.success ? 0 : 1);
-} catch (error) {
-  console.error(`错误: ${error.message}`);
-  process.exit(1);
-}

package/skills/yoyo-control/scripts/volume-up.json

@@ -1,7 +0,0 @@
-{
-  "nodeId": "YOUR_DEVICE_ID",
-  "command": "volume.operate",
-  "params": {
-    "actionType": "调大"
-  }
-}