@agentdevjs/shell-feature 0.1.0

package/dist/index.js

@@ -0,0 +1,1516 @@
+// src/index.ts
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+import { resolve as resolve3 } from "path";
+import { getPackageInfoFromSource } from "@agentdevjs/core";
+
+// src/tools.ts
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import * as path2 from "path";
+import { createTool } from "@agentdevjs/core";
+
+// src/shellQuoting.ts
+function containsHeredoc(command) {
+  if (/\d\s*<<\s*\d/.test(command) || /\[\[\s*\d+\s*<<\s*\d+\s*\]\]/.test(command) || /\$\(\(.*<<.*\)\)/.test(command)) {
+    return false;
+  }
+  const heredocRegex = /<<-?\s*(?:(['"]?)(\w+)\1|\\(\w+))/;
+  return heredocRegex.test(command);
+}
+function containsMultilineString(command) {
+  const singleQuoteMultiline = /'(?:[^'\\]|\\.)*\n(?:[^'\\]|\\.)*'/;
+  const doubleQuoteMultiline = /"(?:[^"\\]|\\.)*\n(?:[^"\\]|\\.)*"/;
+  return singleQuoteMultiline.test(command) || doubleQuoteMultiline.test(command);
+}
+function hasStdinRedirect(command) {
+  return /(?:^|[\s;&|])<(?![<(])\s*\S+/.test(command);
+}
+function shouldAddStdinRedirect(command) {
+  if (containsHeredoc(command)) {
+    return false;
+  }
+  if (hasStdinRedirect(command)) {
+    return false;
+  }
+  return true;
+}
+var NUL_REDIRECT_REGEX = /(\d?&?>+\s*)[Nn][Uu][Ll](?=\s|$|[|&;)\n])/g;
+function rewriteWindowsNullRedirect(command) {
+  return command.replace(NUL_REDIRECT_REGEX, "$1/dev/null");
+}
+function escapeForSingleQuote(str) {
+  return str.replace(/'/g, `'"'"'`);
+}
+function wrapSingleQuote(str) {
+  return `'${escapeForSingleQuote(str)}'`;
+}
+function quoteShellCommand(command, addStdinRedirect = true) {
+  if (containsHeredoc(command) || containsMultilineString(command)) {
+    const quoted2 = wrapSingleQuote(command);
+    if (containsHeredoc(command)) {
+      return quoted2;
+    }
+    return addStdinRedirect ? `${quoted2} < /dev/null` : quoted2;
+  }
+  const quoted = wrapSingleQuote(command);
+  if (addStdinRedirect) {
+    return `${quoted} < /dev/null`;
+  }
+  return quoted;
+}
+
+// src/shell-core.ts
+import { spawn } from "child_process";
+import { mkdir, writeFile } from "fs/promises";
+import * as path from "path";
+import { emitNotification, createToolProgress } from "@agentdevjs/core";
+var TERMINATION_DRAIN_FALLBACK_MS = 1e3;
+var TERMINATION_DRAIN_SAFETY_MS = 50;
+var PROGRESS_EMIT_INTERVAL_MS = 300;
+var PROGRESS_TAIL_LINES = 5;
+var SHELL_METADATA_OPEN = "<shell_metadata>";
+var SHELL_METADATA_CLOSE = "</shell_metadata>";
+function tailLines(text, lines) {
+  if (!text) return "";
+  const parts = text.split("\n");
+  const tail = parts.slice(-lines).join("\n");
+  return tail.length > 500 ? tail.slice(-500) : tail;
+}
+var MAX_OUTPUT_LENGTH = 3e4;
+function timestampSlug() {
+  const now = /* @__PURE__ */ new Date();
+  const ts = now.getFullYear().toString() + String(now.getMonth() + 1).padStart(2, "0") + String(now.getDate()).padStart(2, "0") + "-" + String(now.getHours()).padStart(2, "0") + String(now.getMinutes()).padStart(2, "0") + String(now.getSeconds()).padStart(2, "0");
+  const suffix = Math.random().toString(36).slice(2, 8);
+  return `${ts}-${suffix}`;
+}
+async function processOutputWithPersistence(output, workdir, limit = MAX_OUTPUT_LENGTH, forcePersist = false) {
+  if (!forcePersist && output.length <= limit) return [output, null];
+  let filePath = null;
+  try {
+    const tempDir = path.join(workdir, ".agentdev", "temp");
+    const fileName = `bash-output-${timestampSlug()}.log`;
+    filePath = path.join(tempDir, fileName);
+    await mkdir(tempDir, { recursive: true });
+    await writeFile(filePath, output, "utf-8");
+  } catch (err) {
+    console.error(`[shell] Failed to persist output: ${err}`);
+    filePath = null;
+  }
+  if (output.length <= limit) return [output, filePath];
+  const headSize = Math.floor(limit * 0.6);
+  const tailSize = limit - headSize;
+  const head = output.slice(0, headSize);
+  const tail = output.slice(-tailSize);
+  const omitted = output.length - limit;
+  const totalKB = Math.round(output.length / 1024);
+  const persistNotice = filePath ? `[Full output (${totalKB}KB) saved to: ${filePath}]
+Use the read tool to access the full output if needed.
+` : "";
+  return [
+    head + `
+
+... [truncated: omitted ${omitted} characters (${totalKB}KB total)] ...
+${persistNotice}
+` + tail,
+    filePath
+  ];
+}
+function makeKillChild(child) {
+  return () => {
+    try {
+      if (process.platform === "win32") {
+        const killer = spawn("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+        killer.once("error", (error) => {
+          console.warn(`[shell] taskkill failed for PID=${child.pid}:`, error);
+          child.kill("SIGKILL");
+        });
+        killer.once("close", (code) => {
+          if (code !== 0) {
+            console.warn(`[shell] taskkill exited with code ${code} for PID=${child.pid}; killing the direct child`);
+            child.kill("SIGKILL");
+          }
+        });
+      } else {
+        process.kill(-child.pid, "SIGKILL");
+      }
+    } catch {
+    }
+  };
+}
+function drainToEof(child, timeoutMs) {
+  return new Promise((resolve4) => {
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve4();
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    timer.unref();
+    child.once("close", finish);
+  });
+}
+function formatShellMetadata(meta) {
+  return [
+    SHELL_METADATA_OPEN,
+    `terminated: ${meta.terminated}`,
+    `reason: ${meta.reason}`,
+    `durationMs: ${Math.round(meta.durationMs)}`,
+    `exitCode: ${meta.exitCode === null ? "null" : meta.exitCode}`,
+    `outputBytes: ${meta.outputBytes}`,
+    `truncated: ${meta.truncated}`,
+    `logPath: ${meta.logPath ?? "null"}`,
+    SHELL_METADATA_CLOSE
+  ].join("\n");
+}
+function runCollectedProcess(opts) {
+  const { workdir, logPrefix, signal, termination, progress } = opts;
+  const startedAt = Date.now();
+  const cleanForRun = (raw) => opts.cleanStderr ? opts.cleanStderr(raw) : raw.trim();
+  const readTermination = () => termination?.() ?? "user";
+  return new Promise((resolve4, reject) => {
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let lastProgressAt = 0;
+    let progressTimer = null;
+    const stopProgressTimer = () => {
+      if (progressTimer !== null) {
+        clearInterval(progressTimer);
+        progressTimer = null;
+      }
+    };
+    const emitProgress = () => {
+      if (!progress) return;
+      const now = Date.now();
+      if (now - lastProgressAt < PROGRESS_EMIT_INTERVAL_MS) return;
+      lastProgressAt = now;
+      try {
+        emitNotification(createToolProgress({
+          callId: progress.callId ?? "",
+          toolName: progress.toolName,
+          startedAt,
+          elapsedMs: now - startedAt,
+          timeoutMs: progress.timeoutMs,
+          outputTail: tailLines(stdout || stderr, PROGRESS_TAIL_LINES)
+        }));
+      } catch {
+      }
+    };
+    const finishSettled = (fn) => {
+      stopProgressTimer();
+      fn();
+    };
+    const finishTerminated = async () => {
+      const combined = [stdout, cleanForRun(stderr)].filter(Boolean).join("\n");
+      const [text, logPath] = await processOutputWithPersistence(
+        combined || "",
+        workdir,
+        MAX_OUTPUT_LENGTH,
+        true
+      );
+      const meta = {
+        terminated: true,
+        reason: readTermination(),
+        durationMs: Date.now() - startedAt,
+        exitCode: null,
+        outputBytes: Buffer.byteLength(combined, "utf-8"),
+        truncated: text.length < combined.length,
+        logPath
+      };
+      return {
+        stdout: text,
+        stderr: "",
+        output: text ? `${text}
+${formatShellMetadata(meta)}` : formatShellMetadata(meta)
+      };
+    };
+    const child = spawn(opts.execPath, opts.args, {
+      cwd: workdir,
+      env: opts.env ?? { ...process.env },
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+      // On Linux/macOS, detached: true puts the child in its own process group
+      // so that process.kill(-pid) can terminate the entire group on abort.
+      ...process.platform !== "win32" ? { detached: true } : {}
+    });
+    const killChild = makeKillChild(child);
+    if (progress) {
+      emitProgress();
+      progressTimer = setInterval(emitProgress, PROGRESS_EMIT_INTERVAL_MS);
+      progressTimer.unref?.();
+    }
+    const cleanupSignal = () => {
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const terminateAndCollect = () => {
+      if (settled) return;
+      settled = true;
+      cleanupSignal();
+      stopProgressTimer();
+      console.log(`${logPrefix} signal abort detected, killing child PID=${child.pid}`);
+      killChild();
+      const deadline = opts.terminationDeadline?.();
+      const drainMs = Math.max(
+        0,
+        (deadline ?? Date.now() + TERMINATION_DRAIN_FALLBACK_MS) - Date.now() - TERMINATION_DRAIN_SAFETY_MS
+      );
+      void drainToEof(child, drainMs).then(finishTerminated).then((value) => finishSettled(() => resolve4(value))).catch((err) => finishSettled(() => reject(err)));
+    };
+    const onAbort = () => terminateAndCollect();
+    if (signal) {
+      if (signal.aborted) {
+        terminateAndCollect();
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      cleanupSignal();
+      stopProgressTimer();
+      const cleanStderr = cleanForRun(stderr);
+      if (signal?.aborted) {
+        void finishTerminated().then((value) => finishSettled(() => resolve4(value))).catch((err) => finishSettled(() => reject(err)));
+        return;
+      }
+      if (code === 0) {
+        Promise.all([
+          processOutputWithPersistence(stdout || "", workdir),
+          processOutputWithPersistence(cleanStderr || "", workdir)
+        ]).then(([truncatedStdout, truncatedStderr]) => {
+          finishSettled(() => resolve4({
+            stdout: truncatedStdout[0],
+            stderr: truncatedStderr[0],
+            output: truncatedStdout[0] || truncatedStderr[0]
+          }));
+        }).catch((err) => {
+          finishSettled(() => reject(err));
+        });
+      } else {
+        const combined = [stdout, cleanStderr].filter(Boolean).join("\n\n--- stderr ---\n");
+        processOutputWithPersistence(combined, workdir).then(([truncated]) => {
+          finishSettled(() => reject(new Error(truncated || `Command failed with exit code ${code}`)));
+        }).catch((err) => {
+          finishSettled(() => reject(err));
+        });
+      }
+    });
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      cleanupSignal();
+      finishSettled(() => reject(err));
+    });
+  });
+}
+
+// src/tools.ts
+var cachedBashPath = null;
+function findGitBashPath(configuredPath) {
+  if (cachedBashPath) return cachedBashPath;
+  if (configuredPath && existsSync(configuredPath)) {
+    cachedBashPath = configuredPath;
+    return cachedBashPath;
+  }
+  if (process.platform !== "win32") {
+    cachedBashPath = process.env.SHELL || "/bin/bash";
+    return cachedBashPath;
+  }
+  const candidates = [];
+  if (process.env.AGENTDEV_GIT_BASH_PATH) {
+    candidates.push(process.env.AGENTDEV_GIT_BASH_PATH);
+  }
+  candidates.push("C:\\Program Files\\Git\\bin\\bash.exe");
+  candidates.push("C:\\Program Files (x86)\\Git\\bin\\bash.exe");
+  try {
+    const result = execSync("where bash", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    for (const line of result.split("\n").map((l) => l.trim()).filter(Boolean)) {
+      if (line.toLowerCase().includes("git")) {
+        candidates.push(line);
+      }
+    }
+  } catch {
+  }
+  try {
+    const gitPath = execSync("where git", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).split("\n")[0]?.trim();
+    if (gitPath) {
+      const derived = path2.join(path2.dirname(path2.dirname(gitPath)), "bin", "bash.exe");
+      candidates.push(derived);
+    }
+  } catch {
+  }
+  for (const candidate of candidates) {
+    if (candidate && existsSync(candidate)) {
+      cachedBashPath = candidate;
+      return cachedBashPath;
+    }
+  }
+  cachedBashPath = null;
+  return null;
+}
+var DEFAULT_TIMEOUT_MS = 12e4;
+var MAX_TIMEOUT_MS = 6e5;
+async function runShellCommand(command, options = {}, context) {
+  const workspaceDir = options.workspaceDir || process.cwd();
+  const workdir = options.workdir || workspaceDir;
+  const resourceRoot = options.resourceRoot || process.cwd();
+  const bashrcPath = resourceRoot.replace(/\\/g, "/") + "/.agentdev/bashrc";
+  console.log(`[shell] ${command}`);
+  const normalizedCommand = rewriteWindowsNullRedirect(command);
+  const addStdinRedirect = shouldAddStdinRedirect(normalizedCommand);
+  const quotedCommand = quoteShellCommand(normalizedCommand, addStdinRedirect);
+  const quotedBashrc = `'${bashrcPath.replace(/'/g, `'\\''`)}'`;
+  const commandString = `source ${quotedBashrc} 2>/dev/null || true; eval ${quotedCommand}`;
+  const bashPath = options.bashPath || findGitBashPath();
+  if (!bashPath) {
+    const hint = process.platform === "win32" ? "Git Bash not found. Please install Git for Windows or configure the path in settings." : "Bash not found. Please ensure bash is installed or configure the path in settings.";
+    throw new Error(hint);
+  }
+  const isWin = process.platform === "win32";
+  return runCollectedProcess({
+    workdir,
+    execPath: bashPath,
+    args: ["-c", commandString],
+    env: {
+      ...process.env,
+      // MSYSTEM is only meaningful for Git Bash (MSYS2/MinGW) on Windows.
+      ...isWin ? { MSYSTEM: process.env.MSYSTEM || "MINGW64" } : {}
+    },
+    logPrefix: "[shell]",
+    signal: context?.signal,
+    termination: context?.termination,
+    terminationDeadline: context?.terminationDeadline,
+    progress: context?.progress,
+    cleanStderr: (stderr) => stderr.split("\n").filter((line) => !line.includes("process group") && !line.includes("job control")).join("\n").trim()
+  });
+}
+function createShellCommandTool(description, options = {}) {
+  const defaultTimeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxTimeoutMs = Math.max(options.maxTimeoutMs ?? MAX_TIMEOUT_MS, defaultTimeoutMs, 1);
+  return createTool({
+    name: "bash",
+    description,
+    parameters: {
+      type: "object",
+      properties: {
+        command: { type: "string" },
+        timeout: { type: "number", description: `Optional timeout in milliseconds (max ${maxTimeoutMs}). Defaults to ${defaultTimeoutMs}.` }
+      },
+      required: ["command"]
+    },
+    render: { call: "bash", result: "bash" },
+    // 计时职责归框架 executor（ticket 023）：args.timeout 经 fromArg 消费并 clamp
+    timeout: {
+      defaultMs: defaultTimeoutMs,
+      maxMs: maxTimeoutMs,
+      fromArg: "timeout"
+    },
+    execute: async (args, context) => {
+      const { command } = args;
+      const effectiveTimeoutMs = typeof context?.timeoutMs === "number" ? context.timeoutMs : null;
+      const result = await runShellCommand(command, options, {
+        signal: context?.signal,
+        termination: context?.termination,
+        terminationDeadline: context?.terminationDeadline,
+        progress: {
+          callId: context?.callId,
+          toolName: "bash",
+          timeoutMs: effectiveTimeoutMs
+        }
+      });
+      return result.output;
+    }
+  });
+}
+
+// src/powershell.ts
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { createTool as createTool2 } from "@agentdevjs/core";
+var cachedPsPath = void 0;
+function findPowerShellPath(configuredPath) {
+  if (cachedPsPath !== void 0) return cachedPsPath;
+  if (configuredPath && existsSync2(configuredPath)) {
+    cachedPsPath = configuredPath;
+    return cachedPsPath;
+  }
+  if (process.env.AGENTDEV_POWERSHELL_PATH && existsSync2(process.env.AGENTDEV_POWERSHELL_PATH)) {
+    cachedPsPath = process.env.AGENTDEV_POWERSHELL_PATH;
+    return cachedPsPath;
+  }
+  const isWin = process.platform === "win32";
+  const whereCmd = isWin ? "where" : "which";
+  try {
+    const result = execSync2(`${whereCmd} pwsh`, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    const p = result.split("\n").map((l) => l.trim()).filter(Boolean)[0];
+    if (p && existsSync2(p)) {
+      cachedPsPath = p;
+      return cachedPsPath;
+    }
+  } catch {
+  }
+  if (isWin) {
+    try {
+      const result = execSync2(`${whereCmd} powershell`, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+      const p = result.split("\n").map((l) => l.trim()).filter(Boolean)[0];
+      if (p && existsSync2(p)) {
+        cachedPsPath = p;
+        return cachedPsPath;
+      }
+    } catch {
+    }
+    const sysPath = "C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe";
+    if (existsSync2(sysPath)) {
+      cachedPsPath = sysPath;
+      return cachedPsPath;
+    }
+  }
+  cachedPsPath = null;
+  return null;
+}
+var DEFAULT_TIMEOUT_MS2 = 12e4;
+var MAX_TIMEOUT_MS2 = 6e5;
+async function runPowerShellCommand(command, options = {}, context) {
+  const workspaceDir = options.workspaceDir || process.cwd();
+  const workdir = options.workdir || workspaceDir;
+  const psPath = options.psPath || findPowerShellPath();
+  if (!psPath) {
+    throw new Error("PowerShell not found.");
+  }
+  console.log(`[powershell] ${command}`);
+  return runCollectedProcess({
+    workdir,
+    execPath: psPath,
+    args: ["-NoProfile", "-NonInteractive", "-Command", command],
+    env: { ...process.env },
+    logPrefix: "[powershell]",
+    signal: context?.signal,
+    termination: context?.termination,
+    terminationDeadline: context?.terminationDeadline,
+    progress: context?.progress
+  });
+}
+function createPowerShellTool(description, options = {}) {
+  const defaultTimeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  const maxTimeoutMs = Math.max(options.maxTimeoutMs ?? MAX_TIMEOUT_MS2, defaultTimeoutMs, 1);
+  return createTool2({
+    name: "powershell",
+    description,
+    parameters: {
+      type: "object",
+      properties: {
+        command: { type: "string" },
+        timeout: { type: "number", description: `Optional timeout in milliseconds (max ${maxTimeoutMs}). Defaults to ${defaultTimeoutMs}.` }
+      },
+      required: ["command"]
+    },
+    render: { call: "bash", result: "bash" },
+    // 与 bash 一致：计时职责归框架 executor（ticket 023）
+    timeout: {
+      defaultMs: defaultTimeoutMs,
+      maxMs: maxTimeoutMs,
+      fromArg: "timeout"
+    },
+    execute: async (args, context) => {
+      const { command } = args;
+      const effectiveTimeoutMs = typeof context?.timeoutMs === "number" ? context.timeoutMs : null;
+      const result = await runPowerShellCommand(command, options, {
+        signal: context?.signal,
+        termination: context?.termination,
+        terminationDeadline: context?.terminationDeadline,
+        progress: {
+          callId: context?.callId,
+          toolName: "powershell",
+          timeoutMs: effectiveTimeoutMs
+        }
+      });
+      return result.output;
+    }
+  });
+}
+
+// src/tools-trash.ts
+import { join as join7 } from "path";
+import { createTool as createTool3 } from "@agentdevjs/core";
+
+// src/lib/errors.ts
+var SafeRmError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "SafeRmError";
+    this.code = code;
+    this.details = details || {};
+  }
+  toDict() {
+    return {
+      success: false,
+      error_code: this.code,
+      error_message: this.message,
+      error_details: this.details
+    };
+  }
+  toSafeRmResult() {
+    return {
+      success: false,
+      moved: [],
+      failed: [this.message],
+      movedCount: 0,
+      failedCount: 1
+    };
+  }
+};
+function throwPathTooLongError(path3, length, max) {
+  throw new SafeRmError("ERROR_PATH_TOO_LONG" /* ERROR_PATH_TOO_LONG */, `\u8DEF\u5F84\u8FC7\u957F\uFF08\u6700\u5927 ${max} \u5B57\u7B26\uFF09`, { path: path3, length, max_length: max });
+}
+function throwIllegalCharError(path3, char) {
+  throw new SafeRmError("ERROR_INVALID_PATH" /* ERROR_INVALID_PATH */, `\u8DEF\u5F84\u5305\u542B\u975E\u6CD5\u5B57\u7B26: '${char}'`, { path: path3, illegal_char: char });
+}
+function throwFileNotFoundError(path3) {
+  throw new SafeRmError("ERROR_FILE_NOT_FOUND" /* ERROR_FILE_NOT_FOUND */, "\u6587\u4EF6\u4E0D\u5B58\u5728", { path: path3 });
+}
+function throwPermissionDeniedError(path3, action) {
+  throw new SafeRmError("ERROR_PERMISSION_DENIED" /* ERROR_PERMISSION_DENIED */, `\u6743\u9650\u4E0D\u8DB3\uFF0C\u65E0\u6CD5${action}`, { path: path3 });
+}
+function throwNoTrashDirError(trashDir) {
+  throw new SafeRmError("ERROR_NO_TRASH_DIR" /* ERROR_NO_TRASH_DIR */, "\u5783\u573E\u76EE\u5F55\u4E0D\u5B58\u5728", { trash_dir: trashDir });
+}
+function throwNoFilesSpecifiedError() {
+  throw new SafeRmError("ERROR_NO_FILES_SPECIFIED" /* ERROR_NO_FILES_SPECIFIED */, "\u8BF7\u6307\u5B9A\u8981\u5220\u9664\u7684\u6587\u4EF6", {});
+}
+
+// src/lib/fs.ts
+import {
+  existsSync as existsSync3,
+  lstatSync,
+  statSync,
+  readdirSync,
+  mkdirSync,
+  renameSync,
+  rmSync,
+  readFileSync,
+  writeFileSync,
+  copyFileSync
+} from "fs";
+import { join as join3, dirname as dirname2, basename, normalize } from "path";
+var MAX_PATH = 260;
+var ILLEGAL_CHARS = '<>:"|?*';
+var SYSTEM_DIRS = [
+  process.env.SystemRoot || "C:\\Windows",
+  "C:\\Windows",
+  "C:\\Program Files",
+  "C:\\Program Files (x86)",
+  "C:\\ProgramData"
+];
+var FileSystem = class _FileSystem {
+  static validatePath(path3) {
+    if (!path3 || typeof path3 !== "string") {
+      throw new SafeRmError("ERROR_INVALID_PATH" /* ERROR_INVALID_PATH */, "\u8DEF\u5F84\u65E0\u6548", { path: String(path3) });
+    }
+    if (path3.length > MAX_PATH) {
+      throwPathTooLongError(path3, path3.length, MAX_PATH);
+    }
+    for (const char of ILLEGAL_CHARS) {
+      if (path3.includes(char)) {
+        const colonContext = path3.length >= 2 && path3[1] === ":" && char === ":";
+        if (!colonContext) {
+          throwIllegalCharError(path3, char);
+        }
+      }
+    }
+  }
+  static exists(path3) {
+    return existsSync3(path3);
+  }
+  static lexists(path3) {
+    try {
+      lstatSync(path3);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  static isdir(path3) {
+    try {
+      return statSync(path3).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  static isfile(path3) {
+    try {
+      return statSync(path3).isFile();
+    } catch {
+      return false;
+    }
+  }
+  static islink(path3) {
+    try {
+      return lstatSync(path3).isSymbolicLink();
+    } catch {
+      return false;
+    }
+  }
+  static getsize(path3) {
+    try {
+      return statSync(path3).size;
+    } catch {
+      return 0;
+    }
+  }
+  static makedirs(path3, mode = 493) {
+    if (existsSync3(path3) && _FileSystem.isdir(path3)) return;
+    try {
+      mkdirSync(path3, { mode, recursive: true });
+    } catch (error) {
+      if (error.code === "EACCES" || error.code === "EPERM") {
+        throwPermissionDeniedError(path3, "\u521B\u5EFA\u76EE\u5F55");
+      }
+      throw new SafeRmError("ERROR_CREATE_PARENT_FAILED" /* ERROR_CREATE_PARENT_FAILED */, `\u65E0\u6CD5\u521B\u5EFA\u76EE\u5F55: ${error.message}`, { path: path3, os_error: error.code });
+    }
+  }
+  static move(src, dst) {
+    try {
+      const dstDir = dirname2(dst);
+      if (!existsSync3(dstDir)) {
+        this.makedirs(dstDir);
+      }
+      renameSync(src, dst);
+    } catch (error) {
+      if (error.code === "EXDEV" || error.code === "ENOENT") {
+        try {
+          this._copyAndDelete(src, dst);
+        } catch (copyError) {
+          if (copyError.code === "EACCES" || copyError.code === "EPERM") {
+            throw new SafeRmError("ERROR_FILE_LOCKED" /* ERROR_FILE_LOCKED */, "\u6587\u4EF6\u88AB\u5360\u7528\u6216\u65E0\u6743\u9650\u8BBF\u95EE", { source: src, destination: dst });
+          }
+          throw new SafeRmError("ERROR_UNKNOWN" /* ERROR_UNKNOWN */, `\u8DE8\u5377\u79FB\u52A8\u6587\u4EF6\u5931\u8D25: ${copyError.message}`, { source: src, destination: dst });
+        }
+        return;
+      }
+      if (error.code === "EACCES" || error.code === "EPERM") {
+        throw new SafeRmError("ERROR_FILE_LOCKED" /* ERROR_FILE_LOCKED */, "\u6587\u4EF6\u88AB\u5360\u7528\u6216\u65E0\u6743\u9650\u8BBF\u95EE", { source: src, destination: dst });
+      }
+      throw new SafeRmError("ERROR_UNKNOWN" /* ERROR_UNKNOWN */, `\u79FB\u52A8\u6587\u4EF6\u5931\u8D25: ${error.message}`, { source: src, destination: dst });
+    }
+  }
+  static _copyAndDelete(src, dst) {
+    const srcStat = statSync(src);
+    if (srcStat.isDirectory()) {
+      if (!existsSync3(dst)) {
+        mkdirSync(dst, { recursive: true });
+      }
+      const entries = readdirSync(src, { withFileTypes: true });
+      for (const entry of entries) {
+        const srcPath = join3(src, entry.name);
+        const dstPath = join3(dst, entry.name);
+        this._copyAndDelete(srcPath, dstPath);
+      }
+      rmSync(src, { recursive: true, force: true });
+    } else {
+      copyFileSync(src, dst);
+      rmSync(src, { force: true });
+    }
+  }
+  static remove(path3) {
+    try {
+      if (_FileSystem.isdir(path3)) {
+        rmSync(path3, { recursive: true, force: true });
+      } else {
+        rmSync(path3, { force: true });
+      }
+    } catch (error) {
+      if (error.code === "EACCES" || error.code === "EPERM") {
+        throwPermissionDeniedError(path3, "\u5220\u9664");
+      }
+      throw new SafeRmError("ERROR_UNKNOWN" /* ERROR_UNKNOWN */, `\u5220\u9664\u5931\u8D25: ${error.message}`, { path: path3 });
+    }
+  }
+  static isSystemFile(path3) {
+    try {
+      const absPath = normalize(path3).toLowerCase();
+      for (const sysDir of SYSTEM_DIRS) {
+        if (sysDir && absPath.startsWith(normalize(sysDir).toLowerCase())) {
+          return true;
+        }
+      }
+    } catch {
+    }
+    return false;
+  }
+  static readFile(path3) {
+    try {
+      return readFileSync(path3, "utf-8");
+    } catch (error) {
+      throw new SafeRmError("ERROR_UNKNOWN" /* ERROR_UNKNOWN */, `\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25: ${error.message}`, { path: path3 });
+    }
+  }
+  static writeFile(path3, content) {
+    try {
+      const dir = dirname2(path3);
+      if (!existsSync3(dir)) {
+        this.makedirs(dir);
+      }
+      writeFileSync(path3, content, "utf-8");
+    } catch (error) {
+      if (error.code === "EACCES" || error.code === "EPERM") {
+        throwPermissionDeniedError(path3, "\u5199\u5165");
+      }
+      throw new SafeRmError("ERROR_UNKNOWN" /* ERROR_UNKNOWN */, `\u5199\u5165\u6587\u4EF6\u5931\u8D25: ${error.message}`, { path: path3 });
+    }
+  }
+  static listDir(path3) {
+    try {
+      return readdirSync(path3);
+    } catch (error) {
+      throw new SafeRmError("ERROR_UNKNOWN" /* ERROR_UNKNOWN */, `\u5217\u51FA\u76EE\u5F55\u5931\u8D25: ${error.message}`, { path: path3 });
+    }
+  }
+  static normalizePath(path3) {
+    return normalize(path3).replace(/\\/g, "/");
+  }
+  static shouldSkipBySpecs(path3) {
+    const base = basename(path3);
+    return base === "." || base === "..";
+  }
+  static getFileSize(path3) {
+    if (!existsSync3(path3)) return 0;
+    if (_FileSystem.isfile(path3)) return _FileSystem.getsize(path3);
+    if (_FileSystem.isdir(path3)) {
+      let total = 0;
+      try {
+        const entries = readdirSync(path3, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = join3(path3, entry.name);
+          try {
+            if (entry.isDirectory()) {
+              total += this.getFileSize(fullPath);
+            } else if (entry.isFile()) {
+              total += _FileSystem.getsize(fullPath);
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+      return total;
+    }
+    return 0;
+  }
+};
+
+// src/lib/trashinfo.ts
+import { join as join4, basename as basename2 } from "path";
+function validateOperator(operator) {
+  if (operator === null || operator === void 0) return;
+  if (typeof operator !== "string") {
+    throw new SafeRmError("ERROR_INVALID_OPERATOR" /* ERROR_INVALID_OPERATOR */, "\u64CD\u4F5C\u8005\u540D\u79F0\u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+  }
+  if (!operator) {
+    throw new SafeRmError("ERROR_INVALID_OPERATOR" /* ERROR_INVALID_OPERATOR */, "\u64CD\u4F5C\u8005\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  const illegalChars = '<>:"|?*\\/()[]{}';
+  for (const char of illegalChars) {
+    if (operator.includes(char)) {
+      throw new SafeRmError("ERROR_INVALID_OPERATOR" /* ERROR_INVALID_OPERATOR */, `\u64CD\u4F5C\u8005\u540D\u79F0\u5305\u542B\u975E\u6CD5\u5B57\u7B26: '${char}'`, { operator, illegal_char: char });
+    }
+  }
+  if (operator.length > 64) {
+    throw new SafeRmError("ERROR_INVALID_OPERATOR" /* ERROR_INVALID_OPERATOR */, "\u64CD\u4F5C\u8005\u540D\u79F0\u8FC7\u957F\uFF08\u6700\u5927 64 \u5B57\u7B26\uFF09", { operator, length: operator.length });
+  }
+}
+function encodePath(path3) {
+  const normalized = FileSystem.normalizePath(path3);
+  return encodeURIComponent(normalized).replace(/%2F/g, "/");
+}
+function decodePath(encoded) {
+  try {
+    return decodeURIComponent(encoded);
+  } catch {
+    return encoded;
+  }
+}
+function generateTrashName(originalPath) {
+  const base = basename2(originalPath);
+  const extIndex = base.lastIndexOf(".");
+  let name;
+  let ext;
+  if (extIndex > 0) {
+    name = base.substring(0, extIndex);
+    ext = base.substring(extIndex);
+  } else {
+    name = base;
+    ext = "";
+  }
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.getFullYear().toString() + (now.getMonth() + 1).toString().padStart(2, "0") + now.getDate().toString().padStart(2, "0") + now.getHours().toString().padStart(2, "0") + now.getMinutes().toString().padStart(2, "0") + now.getSeconds().toString().padStart(2, "0");
+  const randomSuffix = Math.floor(Math.random() * 9e3) + 1e3;
+  return `${name}_${timestamp}_${randomSuffix}${ext}`;
+}
+function createTrashInfo(originalPath, trashName, trashDir, operator) {
+  const infoDir = join4(trashDir, "info");
+  const infoPath = join4(infoDir, `${trashName}.trashinfo`);
+  const encodedPath = encodePath(originalPath);
+  const now = /* @__PURE__ */ new Date();
+  const deletionDate = now.toISOString().replace(/\.\d{3}Z$/, "");
+  let content = `[Trash Info]
+Path=${encodedPath}
+DeletionDate=${deletionDate}
+`;
+  if (operator) {
+    content += `Operator=${operator}
+`;
+  }
+  FileSystem.writeFile(infoPath, content);
+  return infoPath;
+}
+function parseTrashInfo(infoPath, trashDir) {
+  try {
+    const content = FileSystem.readFile(infoPath);
+    let originalPath = null;
+    let deletionDate = null;
+    let operator = null;
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("Path=")) {
+        originalPath = decodePath(trimmed.substring(5));
+      } else if (trimmed.startsWith("DeletionDate=")) {
+        deletionDate = trimmed.substring(13);
+      } else if (trimmed.startsWith("Operator=")) {
+        operator = trimmed.substring(9);
+      }
+    }
+    if (!originalPath || !deletionDate) return null;
+    try {
+      FileSystem.validatePath(originalPath);
+    } catch {
+      return null;
+    }
+    const infoBasename = basename2(infoPath);
+    const trashBasename = infoBasename.replace(/\.trashinfo$/, "");
+    const trashFile = join4(trashDir, "files", trashBasename);
+    if (!FileSystem.exists(trashFile)) return null;
+    const size = FileSystem.getFileSize(trashFile);
+    return {
+      index: -1,
+      originalPath,
+      deletionDate,
+      operator,
+      trashFile,
+      infoFile: infoPath,
+      size
+    };
+  } catch {
+    return null;
+  }
+}
+function parseRmCommand(rmCommand) {
+  const trimmed = rmCommand.trim();
+  if (!trimmed) {
+    return { files: [], force: false, interactive: false, recursive: false };
+  }
+  const parts = [];
+  let current = "";
+  let inQuote = false;
+  let quoteChar = "";
+  for (let i = 0; i < trimmed.length; i++) {
+    const char = trimmed[i];
+    const nextChar = trimmed[i + 1] || "";
+    if (inQuote) {
+      if (char === quoteChar) {
+        if (nextChar === quoteChar) {
+          current += char;
+          i++;
+        } else {
+          inQuote = false;
+        }
+      } else {
+        current += char;
+      }
+    } else if (char === '"' || char === "'" || char === "`") {
+      inQuote = true;
+      quoteChar = char;
+    } else if (char === " " || char === "	") {
+      if (current) {
+        parts.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current) parts.push(current);
+  const files = [];
+  let force = false;
+  let interactive = false;
+  let recursive = false;
+  for (let part of parts) {
+    if (part.startsWith('"') && part.endsWith('"') || part.startsWith("'") && part.endsWith("'") || part.startsWith("`") && part.endsWith("`")) {
+      part = part.slice(1, -1);
+    }
+    if (!part) continue;
+    if (part.startsWith("-")) {
+      if (part.includes("f") || part === "--force") force = true;
+      if (part.includes("i") || part === "--interactive") interactive = true;
+      if (part.includes("r") || part.includes("R") || part === "--recursive") recursive = true;
+    } else {
+      files.push(part);
+    }
+  }
+  return { files, force, interactive, recursive };
+}
+
+// src/lib/trash.ts
+import { isAbsolute, join as join5, resolve } from "path";
+var SafeRm = class {
+  trashDir;
+  workingDir;
+  operator;
+  verbose;
+  constructor(options) {
+    this.trashDir = resolve(options.trashDir);
+    this.workingDir = options.workingDir || null;
+    this.operator = options.operator || null;
+    this.verbose = options.verbose || 0;
+    validateOperator(this.operator);
+    this._ensureTrashDir();
+  }
+  _ensureTrashDir() {
+    const parentDir = join5(this.trashDir, "..");
+    if (!FileSystem.exists(parentDir)) {
+      throw new SafeRmError("ERROR_NO_TRASH_DIR" /* ERROR_NO_TRASH_DIR */, "\u5783\u573E\u76EE\u5F55\u7684\u7236\u76EE\u5F55\u4E0D\u5B58\u5728", { trash_dir: this.trashDir, parent_dir: parentDir });
+    }
+    FileSystem.makedirs(this.trashDir);
+    FileSystem.makedirs(join5(this.trashDir, "info"));
+    FileSystem.makedirs(join5(this.trashDir, "files"));
+    const testFile = join5(this.trashDir, "info", ".write_test");
+    try {
+      FileSystem.writeFile(testFile, "test");
+      FileSystem.remove(testFile);
+    } catch {
+      throw new SafeRmError("ERROR_TRASH_NOT_WRITABLE" /* ERROR_TRASH_NOT_WRITABLE */, "\u5783\u573E\u76EE\u5F55\u4E0D\u53EF\u5199", { trash_dir: this.trashDir });
+    }
+  }
+  trashSingle(path3, mode) {
+    FileSystem.validatePath(path3);
+    if (FileSystem.shouldSkipBySpecs(path3)) return "Failure" /* FAILURE */;
+    const absPath = resolve(path3);
+    if (FileSystem.isSystemFile(absPath)) {
+      throw new SafeRmError("ERROR_SYSTEM_FILE" /* ERROR_SYSTEM_FILE */, "\u7CFB\u7EDF\u6587\u4EF6\u53D7\u4FDD\u62A4\uFF0C\u65E0\u6CD5\u5220\u9664", { path: path3 });
+    }
+    if (!FileSystem.lexists(path3)) {
+      if (mode === "mode_force" /* MODE_FORCE */) return "Success" /* SUCCESS */;
+      throwFileNotFoundError(path3);
+    }
+    try {
+      const trashName = generateTrashName(path3);
+      const destPath = join5(this.trashDir, "files", trashName);
+      createTrashInfo(path3, trashName, this.trashDir, this.operator);
+      FileSystem.move(path3, destPath);
+      return "Success" /* SUCCESS */;
+    } catch (error) {
+      if (error instanceof SafeRmError) throw error;
+      throw new SafeRmError("ERROR_UNKNOWN" /* ERROR_UNKNOWN */, `\u5220\u9664\u6587\u4EF6\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`, { path: path3 });
+    }
+  }
+  trashAll(paths, mode) {
+    const failedPaths = [];
+    const movedPaths = [];
+    for (const path3 of paths) {
+      try {
+        const result = this.trashSingle(path3, mode);
+        if (result === "Success" /* SUCCESS */) {
+          movedPaths.push(path3);
+        } else {
+          failedPaths.push(path3);
+        }
+      } catch {
+        failedPaths.push(path3);
+      }
+    }
+    return {
+      success: failedPaths.length === 0,
+      moved: movedPaths,
+      failed: failedPaths,
+      movedCount: movedPaths.length,
+      failedCount: failedPaths.length
+    };
+  }
+};
+function safeRm(workingDir, rmCommand, trashDir, operator = null, verbose = 0) {
+  validateOperator(operator);
+  const { files: parsedFiles, force, interactive } = parseRmCommand(rmCommand);
+  const files = parsedFiles.map((file) => {
+    if (!workingDir || isAbsolute(file)) {
+      return file;
+    }
+    return resolve(workingDir, file);
+  });
+  if (files.length === 0) throwNoFilesSpecifiedError();
+  let mode;
+  if (force) mode = "mode_force" /* MODE_FORCE */;
+  else if (interactive) mode = "mode_interactive" /* MODE_INTERACTIVE */;
+  else mode = "mode_unspecified" /* MODE_UNSPECIFIED */;
+  if (workingDir) {
+    if (!FileSystem.exists(workingDir)) {
+      throw new SafeRmError("ERROR_WORKING_DIR_NOT_FOUND" /* ERROR_WORKING_DIR_NOT_FOUND */, "\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u5B58\u5728", { working_dir: workingDir });
+    }
+  }
+  const safeRmInstance = new SafeRm({ trashDir, workingDir, operator, verbose });
+  return safeRmInstance.trashAll(files, mode);
+}
+
+// src/lib/restore.ts
+import { join as join6, resolve as resolve2, dirname as dirname3 } from "path";
+function matchesPattern(actualPath, pattern) {
+  const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexPattern}$`, "i");
+  return regex.test(actualPath) || regex.test(actualPath.replace(/\//g, "\\"));
+}
+function parseIndexSpec(spec) {
+  const indices = [];
+  for (const part of spec.split(",")) {
+    const trimmed = part.trim();
+    if (trimmed.includes("-")) {
+      const [startStr, endStr] = trimmed.split("-", 2);
+      const start = parseInt(startStr, 10);
+      const end = parseInt(endStr, 10);
+      if (isNaN(start) || isNaN(end)) {
+        throw new SafeRmError("ERROR_INVALID_INDEX" /* ERROR_INVALID_INDEX */, `\u65E0\u6548\u7684\u7D22\u5F15\u8303\u56F4: ${trimmed}`, { spec });
+      }
+      for (let i = start; i <= end; i++) indices.push(i);
+    } else {
+      const index = parseInt(trimmed, 10);
+      if (isNaN(index)) {
+        throw new SafeRmError("ERROR_INVALID_INDEX" /* ERROR_INVALID_INDEX */, `\u65E0\u6548\u7684\u7D22\u5F15: ${trimmed}`, { spec });
+      }
+      indices.push(index);
+    }
+  }
+  return indices;
+}
+var SafeRestore = class {
+  trashDir;
+  operator;
+  verbose;
+  constructor(options) {
+    this.trashDir = resolve2(options.trashDir);
+    this.operator = options.operator || null;
+    this.verbose = options.verbose || 0;
+    validateOperator(this.operator);
+    if (!FileSystem.exists(this.trashDir)) throwNoTrashDirError(this.trashDir);
+  }
+  _scanInfoFiles() {
+    const infoDir = join6(this.trashDir, "info");
+    const files = [];
+    if (!FileSystem.exists(infoDir)) return files;
+    const entries = FileSystem.listDir(infoDir);
+    for (const filename of entries) {
+      if (!filename.endsWith(".trashinfo")) continue;
+      const infoPath = join6(infoDir, filename);
+      const info = parseTrashInfo(infoPath, this.trashDir);
+      if (info && (this.operator === null || info.operator === this.operator)) {
+        files.push(info);
+      }
+    }
+    return files;
+  }
+  listTrashed() {
+    const files = this._scanInfoFiles();
+    files.sort((a, b) => a.deletionDate.localeCompare(b.deletionDate));
+    for (let i = 0; i < files.length; i++) files[i] = { ...files[i], index: i };
+    return files;
+  }
+  _matchesTarget(info, target) {
+    if (typeof target === "number") return info.index === target;
+    return matchesPattern(info.originalPath, target) || matchesPattern(info.originalPath.replace(/\//g, "\\"), target);
+  }
+  restore(target, overwrite = false, dryRun = false) {
+    const allFiles = this.listTrashed();
+    const restored = [];
+    const failed = [];
+    const skipped = [];
+    const targets = Array.isArray(target) ? target : [target];
+    const filesToRestore = /* @__PURE__ */ new Set();
+    for (const t of targets) {
+      let matched = false;
+      for (const info of allFiles) {
+        if (this._matchesTarget(info, t)) {
+          filesToRestore.add(info);
+          matched = true;
+        }
+      }
+      if (!matched && typeof t === "number") {
+        failed.push({ path: `index:${t}`, error: "\u7D22\u5F15\u6CA1\u6709\u627E\u5230\u5BF9\u5E94\u7684\u6587\u4EF6" });
+      }
+    }
+    for (const info of Array.from(filesToRestore)) {
+      try {
+        if (FileSystem.exists(info.originalPath) && !overwrite) {
+          failed.push({ path: info.originalPath, error: "file already exists" });
+          continue;
+        }
+        const parentDir = dirname3(info.originalPath);
+        if (parentDir && !FileSystem.exists(parentDir)) FileSystem.makedirs(parentDir);
+        if (dryRun) {
+          restored.push(info.originalPath);
+        } else {
+          FileSystem.move(info.trashFile, info.originalPath);
+          FileSystem.remove(info.infoFile);
+          restored.push(info.originalPath);
+        }
+      } catch (error) {
+        failed.push({ path: info.originalPath, error: error instanceof Error ? error.message : String(error) });
+      }
+    }
+    return {
+      success: failed.length === 0,
+      restored,
+      failed,
+      skipped,
+      restoredCount: restored.length,
+      failedCount: failed.length,
+      skippedCount: skipped.length
+    };
+  }
+};
+function listTrashed(trashDir, operator = null) {
+  validateOperator(operator);
+  const restorer = new SafeRestore({ trashDir, operator });
+  const infoList = restorer.listTrashed();
+  return { success: true, total: infoList.length, files: infoList };
+}
+function restore(trashDir, target, operator = null, overwrite = false, dryRun = false, parseIndexRanges = true) {
+  validateOperator(operator);
+  const restorer = new SafeRestore({ trashDir, operator });
+  let actualTarget = target;
+  if (parseIndexRanges && typeof target === "string") {
+    if (/^[\d,\s\-]+$/.test(target.trim())) {
+      try {
+        actualTarget = parseIndexSpec(target);
+      } catch {
+        actualTarget = target;
+      }
+    }
+  }
+  return restorer.restore(actualTarget, overwrite, dryRun);
+}
+
+// src/tools-trash.ts
+function formatSize(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
+}
+function createSafeTrashDeleteTool(workspaceDir = process.cwd()) {
+  const defaultTrashDir = join7(workspaceDir, ".trash");
+  return createTool3({
+    name: "safe_trash_delete",
+    description: "\u5B89\u5168\u5220\u9664\u6587\u4EF6\u6216\u76EE\u5F55\uFF0C\u79FB\u52A8\u5230\u5783\u573E\u76EE\u5F55\u800C\u975E\u6C38\u4E45\u5220\u9664\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        paths: { type: "array", items: { type: "string" } },
+        trashDir: { type: "string" }
+      },
+      required: ["paths"]
+    },
+    render: { call: "trash-delete", result: "trash-delete" },
+    execute: async (args) => {
+      const { paths, trashDir } = args;
+      const trashDirPath = trashDir || defaultTrashDir;
+      const result = safeRm(workspaceDir, paths.join(" "), trashDirPath, null, 0);
+      return {
+        success: result.success,
+        moved_count: result.movedCount,
+        moved: result.moved,
+        failed: result.failed
+      };
+    }
+  });
+}
+function createSafeTrashListTool(workspaceDir = process.cwd()) {
+  const defaultTrashDir = join7(workspaceDir, ".trash");
+  return createTool3({
+    name: "safe_trash_list",
+    description: "\u5217\u51FA\u5783\u573E\u76EE\u5F55\u4E2D\u7684\u6240\u6709\u53EF\u6062\u590D\u6587\u4EF6\u3002",
+    parallelizable: true,
+    parameters: {
+      type: "object",
+      properties: {
+        trashDir: { type: "string" }
+      }
+    },
+    render: { call: "trash-list", result: "trash-list" },
+    execute: async (args) => {
+      const { trashDir } = args;
+      const trashDirPath = trashDir || defaultTrashDir;
+      const result = listTrashed(trashDirPath, null);
+      return {
+        success: result.success,
+        total: result.total,
+        files: result.files.map((f) => ({ ...f, size_formatted: formatSize(f.size || 0) }))
+      };
+    }
+  });
+}
+function createSafeTrashRestoreTool(workspaceDir = process.cwd()) {
+  const defaultTrashDir = join7(workspaceDir, ".trash");
+  return createTool3({
+    name: "safe_trash_restore",
+    description: "\u4ECE\u5783\u573E\u76EE\u5F55\u6062\u590D\u6587\u4EF6\u5230\u539F\u4F4D\u7F6E\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        target: {
+          oneOf: [{ type: "string" }, { type: "number" }, { type: "array", items: { oneOf: [{ type: "number" }, { type: "string" }] } }]
+        },
+        trashDir: { type: "string" },
+        overwrite: { type: "boolean" }
+      },
+      required: ["target"]
+    },
+    render: { call: "trash-restore", result: "trash-restore" },
+    execute: async (args) => {
+      const { target, trashDir, overwrite } = args;
+      const trashDirPath = trashDir || defaultTrashDir;
+      const result = restore(trashDirPath, target, null, overwrite || false, false, true);
+      return {
+        success: result.success,
+        restored_count: result.restoredCount,
+        restored: result.restored,
+        failed: result.failed
+      };
+    }
+  });
+}
+var safeTrashDeleteTool = createSafeTrashDeleteTool();
+var safeTrashListTool = createSafeTrashListTool();
+var safeTrashRestoreTool = createSafeTrashRestoreTool();
+
+// src/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var DEFAULT_TIMEOUT_MS3 = 12e4;
+var MAX_TIMEOUT_MS3 = 6e5;
+function resolvePositiveNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+var ShellFeature = class {
+  name = "shell";
+  dependencies = [];
+  source = __filename.replace(/\\/g, "/");
+  description = "\u63D0\u4F9B Bash/PowerShell \u547D\u4EE4\u6267\u884C\u80FD\u529B\uFF0C\u4EE5\u53CA\u5B89\u5168\u5220\u9664\u3001\u6062\u590D\u548C\u67E5\u770B\u5783\u573E\u6876\u5DE5\u5177\u3002";
+  bashDescription;
+  powershellDescription;
+  _packageInfo = null;
+  workspaceDir;
+  workdir;
+  resourceRoot;
+  constructor(config = {}) {
+    this.workspaceDir = config.workspaceDir || process.cwd();
+    this.workdir = config.workdir || this.workspaceDir;
+    this.resourceRoot = config.resourceRoot || process.cwd();
+  }
+  /**
+   * 获取同步工具（垃圾桶工具）
+   */
+  getTools() {
+    return [
+      createSafeTrashDeleteTool(this.workdir),
+      createSafeTrashListTool(this.workdir),
+      createSafeTrashRestoreTool(this.workdir)
+    ];
+  }
+  getFeatureManifest() {
+    return {
+      schemaVersion: 1,
+      settings: {
+        properties: {
+          bashEnabled: {
+            type: "boolean",
+            title: "\u542F\u7528 Bash",
+            description: "\u542F\u7528\u540E\uFF0CAgent \u5C06\u83B7\u5F97 Bash \u5DE5\u5177\u3002Windows \u9700\u8981 Git for Windows\uFF1BLinux/macOS \u4F7F\u7528\u7CFB\u7EDF\u81EA\u5E26 Shell\u3002",
+            default: true
+          },
+          bashPath: {
+            type: "file",
+            title: "Bash \u8DEF\u5F84",
+            description: "Bash \u53EF\u6267\u884C\u6587\u4EF6\u8DEF\u5F84\u3002\u7559\u7A7A\u65F6\u81EA\u52A8\u68C0\u6D4B\u3002",
+            placeholder: "\u81EA\u52A8\u68C0\u6D4B"
+          },
+          powershellEnabled: {
+            type: "boolean",
+            title: "\u542F\u7528 PowerShell",
+            description: "\u542F\u7528\u540E\uFF0CAgent \u5C06\u83B7\u5F97 PowerShell \u5DE5\u5177\u3002Windows \u81EA\u5E26 PowerShell 5.1\uFF1BLinux/macOS \u9700\u5B89\u88C5 PowerShell Core (pwsh)\u3002",
+            default: true
+          },
+          powershellPath: {
+            type: "file",
+            title: "PowerShell \u8DEF\u5F84",
+            description: "PowerShell \u53EF\u6267\u884C\u6587\u4EF6\u8DEF\u5F84\u3002\u7559\u7A7A\u65F6\u81EA\u52A8\u68C0\u6D4B\u3002",
+            placeholder: "\u81EA\u52A8\u68C0\u6D4B"
+          },
+          defaultTimeoutMs: {
+            type: "number",
+            title: "\u9ED8\u8BA4\u547D\u4EE4\u8D85\u65F6\uFF08\u6BEB\u79D2\uFF09",
+            description: "\u547D\u4EE4\u6267\u884C\u7684\u9ED8\u8BA4\u8D85\u65F6\u65F6\u95F4\u3002\u6A21\u578B\u53EF\u901A\u8FC7 timeout \u53C2\u6570\u8986\u76D6\uFF08\u4E0D\u8D85\u8FC7\u6700\u5927\u8D85\u65F6\uFF09\u3002",
+            default: DEFAULT_TIMEOUT_MS3,
+            min: 1,
+            max: MAX_TIMEOUT_MS3,
+            step: 1e3
+          },
+          maxTimeoutMs: {
+            type: "number",
+            title: "\u6700\u5927\u547D\u4EE4\u8D85\u65F6\uFF08\u6BEB\u79D2\uFF09",
+            description: "\u547D\u4EE4\u8D85\u65F6\u7684\u786C\u4E0A\u9650\uFF0C\u4EFB\u4F55\u6765\u6E90\u7684\u8D85\u65F6\u503C\u90FD\u4F1A\u88AB\u9650\u5236\u5230\u6B64\u503C\u4EE5\u5185\u3002",
+            default: MAX_TIMEOUT_MS3,
+            min: 1,
+            step: 1e3
+          }
+        }
+      }
+    };
+  }
+  resolveShellConfig(featureConfig) {
+    if (!featureConfig || typeof featureConfig !== "object") {
+      return {
+        bashEnabled: true,
+        powershellEnabled: true,
+        defaultTimeoutMs: DEFAULT_TIMEOUT_MS3,
+        maxTimeoutMs: MAX_TIMEOUT_MS3
+      };
+    }
+    const c = featureConfig;
+    const maxTimeoutMs = Math.max(
+      resolvePositiveNumber(c.maxTimeoutMs, MAX_TIMEOUT_MS3),
+      1
+    );
+    return {
+      bashEnabled: c.bashEnabled !== false,
+      bashPath: typeof c.bashPath === "string" && c.bashPath.trim() ? c.bashPath.trim() : void 0,
+      powershellEnabled: c.powershellEnabled !== false,
+      powershellPath: typeof c.powershellPath === "string" && c.powershellPath.trim() ? c.powershellPath.trim() : void 0,
+      // default 不允许超过 max（配置面板顺序无关时的自洽保护）
+      defaultTimeoutMs: Math.min(
+        resolvePositiveNumber(c.defaultTimeoutMs, DEFAULT_TIMEOUT_MS3),
+        maxTimeoutMs
+      ),
+      maxTimeoutMs
+    };
+  }
+  /**
+   * 获取异步工具（bash/powershell 工具，条件注册）
+   */
+  async getAsyncTools(ctx) {
+    const config = this.resolveShellConfig(ctx.featureConfig);
+    const tools = [];
+    if (config.bashEnabled) {
+      const bashPath = findGitBashPath(config.bashPath);
+      if (bashPath) {
+        if (!this.bashDescription) {
+          try {
+            const descriptionPath = resolve3(this.resourceRoot, ".agentdev/prompts/tool-bash.md");
+            this.bashDescription = await readFile(descriptionPath, "utf-8");
+          } catch {
+            this.bashDescription = "\u6267\u884C Shell \u547D\u4EE4";
+          }
+        }
+        tools.push(createShellCommandTool(this.bashDescription, {
+          workspaceDir: this.workspaceDir,
+          workdir: this.workdir,
+          resourceRoot: this.resourceRoot,
+          bashPath,
+          timeoutMs: config.defaultTimeoutMs,
+          maxTimeoutMs: config.maxTimeoutMs
+        }));
+      } else {
+        console.warn("[shell] Bash is enabled but was not found on this system. Skipping Bash tool.");
+      }
+    }
+    if (config.powershellEnabled) {
+      const psPath = findPowerShellPath(config.powershellPath);
+      if (psPath) {
+        if (!this.powershellDescription) {
+          try {
+            const descriptionPath = resolve3(this.resourceRoot, ".agentdev/prompts/tool-powershell.md");
+            this.powershellDescription = await readFile(descriptionPath, "utf-8");
+          } catch {
+            this.powershellDescription = "\u6267\u884C PowerShell \u547D\u4EE4";
+          }
+        }
+        tools.push(createPowerShellTool(this.powershellDescription, {
+          workspaceDir: this.workspaceDir,
+          workdir: this.workdir,
+          resourceRoot: this.resourceRoot,
+          psPath,
+          timeoutMs: config.defaultTimeoutMs,
+          maxTimeoutMs: config.maxTimeoutMs
+        }));
+      } else {
+        console.warn("[shell] PowerShell is enabled but was not found on this system. Skipping PowerShell tool.");
+      }
+    }
+    return tools;
+  }
+  /**
+   * 获取包信息（统一打包方案）
+   */
+  getPackageInfo() {
+    if (!this._packageInfo) {
+      this._packageInfo = getPackageInfoFromSource(this.source);
+    }
+    return this._packageInfo;
+  }
+  /**
+   * 获取模板名称列表（统一打包方案）
+   */
+  getTemplateNames() {
+    return [
+      "bash",
+      "trash-delete",
+      "trash-list",
+      "trash-restore"
+    ];
+  }
+};
+export {
+  SHELL_METADATA_CLOSE,
+  SHELL_METADATA_OPEN,
+  ShellFeature,
+  containsHeredoc,
+  createPowerShellTool,
+  createSafeTrashDeleteTool,
+  createSafeTrashListTool,
+  createSafeTrashRestoreTool,
+  createShellCommandTool,
+  findGitBashPath,
+  findPowerShellPath,
+  formatShellMetadata,
+  hasStdinRedirect,
+  listTrashed,
+  processOutputWithPersistence,
+  quoteShellCommand,
+  restore,
+  rewriteWindowsNullRedirect,
+  runPowerShellCommand,
+  runShellCommand,
+  safeRm,
+  safeTrashDeleteTool,
+  safeTrashListTool,
+  safeTrashRestoreTool,
+  shouldAddStdinRedirect
+};
+//# sourceMappingURL=index.js.map