@honor-claw/yoyo 0.0.1-beta.2 → 0.0.1-beta.21

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/src/utils/version.ts

@@ -0,0 +1,29 @@
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+let g_isBetaVersion: boolean | null = null;
+
+/**
+ * 检查当前版本是否为 beta 版本
+ */
+export function isBetaVersion(): boolean {
+  if (g_isBetaVersion !== null) {
+    return !!g_isBetaVersion;
+  }
+
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const packagePath = join(__dirname, "../../package.json");
+    const pkgContent = readFileSync(packagePath, "utf-8");
+    const pkg = JSON.parse(pkgContent);
+    const version = pkg.version || "";
+
+    g_isBetaVersion = version.includes("beta");
+  } catch (error) {
+    console.error(`Failed to check version: ${error}`);
+  }
+
+  return !!g_isBetaVersion;
+}

package/src/utils/ws.ts

@@ -0,0 +1,21 @@
+import { Buffer } from "node:buffer";
+import type WebSocket from "ws";
+
+export function rawDataToString(
+  data: WebSocket.RawData,
+  encoding: BufferEncoding = "utf8",
+): string {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (Buffer.isBuffer(data)) {
+    return data.toString(encoding);
+  }
+  if (Array.isArray(data)) {
+    return Buffer.concat(data).toString(encoding);
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data).toString(encoding);
+  }
+  return Buffer.from(String(data)).toString(encoding);
+}

package/skills/yoyo-control/references/open-app.md

@@ -1,54 +0,0 @@
-# open_app 打开应用工具使用说明
-
-## Tool Command
-
-```bash
-app.open
-```
-
-## Tool Parameters and Examples
-
-```json
-{
-  "name": "open_app",
-  "description": "该工具用于帮助用户打开指定的 APP 应用，且不涉及任何具体 App 内部操作。",
-  "parameters": {
-    "app": {
-      "description": "需要打开的应用名称，若用户指定具体应用，则填写应用名称，若用户明确表示“所有应用”，则参数值为 all",
-      "type": "string"
-    },
-    "pkgName": {
-      "description": "应用包名",
-      "type": "string"
-    },
-    "app_description": {
-      "description": "类型描述。对 app 的补充描述，无论是否为空，都可以有这个参数，当且仅当 app 为空时才调用 description。示例：办公应用、聊天软件、音乐类应用。",
-      "type": "string"
-    }
-  },
-  "required": [],
-  "examples": [
-    {
-      "query": "打开小红书",
-      "arguments": {
-        "app": "网易云音乐",
-        "pkgName": "com.xingin.xhs"
-      }
-    },
-    {
-      "query": "打开淘宝",
-      "arguments": {
-        "app": "微信",
-        "pkgName": "com.taobao.taobao"
-      }
-    },
-    {
-      "query": "打开生活类软件",
-      "arguments": {
-        "app": "支付宝",
-        "app_description": "生活"
-      }
-    }
-  ]
-}
-```