@zqagent/core 0.2.20 → 0.3.6

package/dist/internal/tools/shell.cjs

@@ -0,0 +1,771 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/tools/shell.ts
+var shell_exports = {};
+__export(shell_exports, {
+  decodeOutput: () => decodeOutput,
+  getShellCwd: () => getShellCwd,
+  killShellTask: () => killShellTask,
+  listShellTasks: () => listShellTasks,
+  registerShellTool: () => registerShellTool,
+  resetShellSession: () => resetShellSession
+});
+module.exports = __toCommonJS(shell_exports);
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+
+// src/tools/execAsync.ts
+var import_node_child_process2 = require("child_process");
+
+// src/tools/killTree.ts
+var import_node_child_process = require("child_process");
+function killTree(pid) {
+  if (!pid) return;
+  if (process.platform === "win32") {
+    try {
+      (0, import_node_child_process.spawnSync)("taskkill", ["/pid", String(pid), "/T", "/F"], { windowsHide: true });
+    } catch {
+    }
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+}
+
+// src/tools/execAsync.ts
+var liveChildren = /* @__PURE__ */ new Set();
+var exitCleanupInstalled = false;
+function trackChild(pid) {
+  if (!pid) return;
+  liveChildren.add(pid);
+  if (exitCleanupInstalled) return;
+  exitCleanupInstalled = true;
+  process.once("exit", () => {
+    for (const p of liveChildren) killTree(p);
+  });
+}
+var DEFAULT_MAX_BUFFER = 1024 * 1024 * 5;
+var KILL_GRACE_MS = 1e3;
+function makeSink(maxBuffer) {
+  const chunks = [];
+  let len = 0;
+  let over = false;
+  return {
+    push(chunk) {
+      if (len >= maxBuffer) {
+        over = true;
+        return;
+      }
+      const room = maxBuffer - len;
+      if (chunk.length > room) {
+        chunks.push(chunk.subarray(0, room));
+        len = maxBuffer;
+        over = true;
+        return;
+      }
+      chunks.push(chunk);
+      len += chunk.length;
+    },
+    done: () => Buffer.concat(chunks),
+    over: () => over
+  };
+}
+function execAsync(file, argv, opts = {}) {
+  return new Promise((resolve2) => {
+    const maxBuffer = opts.maxBuffer ?? DEFAULT_MAX_BUFFER;
+    const out = makeSink(maxBuffer);
+    const err = makeSink(maxBuffer);
+    if (opts.signal?.aborted) {
+      resolve2({
+        status: null,
+        stdout: Buffer.alloc(0),
+        stderr: Buffer.alloc(0),
+        timedOut: false,
+        truncated: false,
+        aborted: true
+      });
+      return;
+    }
+    let child;
+    try {
+      child = (0, import_node_child_process2.spawn)(file, argv, {
+        ...opts.cwd !== void 0 ? { cwd: opts.cwd } : {},
+        ...opts.env !== void 0 ? { env: opts.env } : {},
+        // 自成进程组（POSIX）：超时/中断时用 killTree 一次收掉整棵进程树
+        detached: process.platform !== "win32",
+        stdio: [opts.input === void 0 ? "ignore" : "pipe", "pipe", "pipe"],
+        windowsHide: true
+      });
+    } catch (e) {
+      resolve2({
+        status: null,
+        stdout: Buffer.alloc(0),
+        stderr: Buffer.alloc(0),
+        error: e,
+        timedOut: false,
+        truncated: false
+      });
+      return;
+    }
+    trackChild(child.pid);
+    let settled = false;
+    let timedOut = false;
+    let aborted = false;
+    let spawnError;
+    let timer = null;
+    let graceTimer = null;
+    const onAbort = () => {
+      aborted = true;
+      killAndSettle();
+    };
+    const finish = (status) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      if (graceTimer) clearTimeout(graceTimer);
+      if (child.pid !== void 0) liveChildren.delete(child.pid);
+      opts.signal?.removeEventListener("abort", onAbort);
+      const result = {
+        status,
+        stdout: out.done(),
+        stderr: err.done(),
+        timedOut,
+        truncated: out.over() || err.over()
+      };
+      if (aborted) result.aborted = true;
+      if (spawnError) result.error = spawnError;
+      resolve2(result);
+    };
+    const killAndSettle = () => {
+      killTree(child.pid);
+      if (settled || graceTimer) return;
+      graceTimer = setTimeout(() => {
+        child.stdout?.destroy();
+        child.stderr?.destroy();
+        finish(null);
+      }, KILL_GRACE_MS);
+    };
+    if (opts.timeoutMs !== void 0 && opts.timeoutMs > 0) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        killAndSettle();
+      }, opts.timeoutMs);
+    }
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+    child.stdout?.on("data", (c) => out.push(c));
+    child.stderr?.on("data", (c) => err.push(c));
+    child.on("error", (e) => {
+      spawnError = e;
+      if (child.pid === void 0) finish(null);
+    });
+    if (opts.input !== void 0 && child.stdin) {
+      child.stdin.on("error", () => {
+      });
+      child.stdin.end(opts.input);
+    }
+    child.on("close", (code) => finish(code));
+  });
+}
+
+// src/tools/shellRuntime.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var WINDOWS_SUFFIXES = [".exe", ".cmd", ".bat", ".com", ""];
+function pathApi(platform) {
+  return platform === "win32" ? path.win32 : path.posix;
+}
+function defaultFileExists(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function joinPath(platform, ...parts) {
+  return pathApi(platform).join(...parts);
+}
+function findExecutable(name, ctx) {
+  if (name.includes("/") || name.includes("\\")) {
+    return ctx.fileExists(name) ? name : null;
+  }
+  const suffixes = ctx.platform === "win32" ? WINDOWS_SUFFIXES : [""];
+  const delimiter = ctx.platform === "win32" ? ";" : ":";
+  const dirs = (ctx.env.PATH ?? "").split(delimiter).filter((d) => d.length > 0);
+  for (const dir of dirs) {
+    for (const suffix of suffixes) {
+      const candidate = joinPath(ctx.platform, dir, name + suffix);
+      if (ctx.fileExists(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+function kindFromBasename(base) {
+  const b = base.toLowerCase().replace(/\.(exe|cmd|bat|com)$/, "");
+  if (b === "busybox") return "busybox";
+  if (b === "powershell" || b === "pwsh") return "powershell";
+  if (b === "cmd") return "cmd";
+  return "sh";
+}
+function busyboxArgs(file, command) {
+  const base = (file ? path.win32.basename(file) : "busybox").toLowerCase().replace(/\.(exe|cmd|bat|com)$/, "");
+  return base === "busybox" ? ["sh", "-c", command] : ["-c", command];
+}
+function argsFor(kind, command) {
+  switch (kind) {
+    case "busybox":
+      return ["sh", "-c", command];
+    case "powershell":
+      return ["-NoProfile", "-NonInteractive", "-Command", command];
+    case "cmd":
+      return ["/d", "/s", "/c", command];
+    default:
+      return ["-c", command];
+  }
+}
+function makeSpec(kind, file, label) {
+  return {
+    kind,
+    file,
+    label,
+    buildArgs: (command) => kind === "busybox" ? busyboxArgs(file, command) : argsFor(kind, command)
+  };
+}
+function defaultLabelFor(kind) {
+  switch (kind) {
+    case "busybox":
+      return "busybox ash";
+    case "powershell":
+      return "PowerShell";
+    case "cmd":
+      return "cmd.exe";
+    case "default":
+      return "\u7CFB\u7EDF\u9ED8\u8BA4 shell";
+    default:
+      return "sh";
+  }
+}
+function findBusybox(ctx, execPath) {
+  const explicit = (ctx.env.ZQAGENT_BUSYBOX ?? "").trim();
+  if (explicit) return ctx.fileExists(explicit) ? explicit : null;
+  const exeDir = pathApi(ctx.platform).dirname(execPath);
+  const candidates = [
+    joinPath(ctx.platform, exeDir, "busybox.exe"),
+    joinPath(ctx.platform, exeDir, "sh.exe"),
+    joinPath(ctx.platform, exeDir, "bin", "busybox.exe"),
+    joinPath(ctx.platform, exeDir, "bin", "sh.exe")
+  ];
+  for (const candidate of candidates) {
+    if (ctx.fileExists(candidate)) return candidate;
+  }
+  return null;
+}
+function resolveRequested(requested, ctx, execPath) {
+  const lower = requested.toLowerCase();
+  if (lower === "cmd") {
+    const file = findExecutable("cmd", ctx) ?? ctx.env.ComSpec ?? ctx.env.COMSPEC ?? "cmd.exe";
+    return makeSpec("cmd", file, "cmd.exe");
+  }
+  if (lower === "powershell" || lower === "pwsh") {
+    const file = findExecutable(lower, ctx) ?? findExecutable("powershell", ctx) ?? `${lower}.exe`;
+    return makeSpec("powershell", file, "PowerShell");
+  }
+  if (lower === "busybox") {
+    const found = findBusybox(ctx, execPath) ?? findExecutable("busybox", ctx);
+    return makeSpec("busybox", found ?? requested, "busybox ash");
+  }
+  if (["sh", "bash", "dash", "zsh", "ash"].includes(lower)) {
+    return makeSpec("sh", findExecutable(lower, ctx) ?? lower, lower);
+  }
+  const base = pathApi(ctx.platform).basename(requested);
+  const kind = kindFromBasename(base);
+  return makeSpec(kind, requested, base || defaultLabelFor(kind));
+}
+function resolveShellSpec(opts = {}) {
+  const platform = opts.platform ?? process.platform;
+  const env = opts.env ?? process.env;
+  const execPath = opts.execPath ?? process.execPath;
+  const ctx = {
+    platform,
+    env,
+    fileExists: opts.fileExists ?? defaultFileExists
+  };
+  const requested = (env.ZQAGENT_SHELL ?? "").trim();
+  if (requested && requested.toLowerCase() !== "auto") {
+    return resolveRequested(requested, ctx, execPath);
+  }
+  if (platform !== "win32") {
+    return makeSpec("default", null, "/bin/sh");
+  }
+  const busybox = findBusybox(ctx, execPath);
+  if (busybox) return makeSpec("busybox", busybox, "busybox ash (POSIX)");
+  const bash = findExecutable("bash", ctx);
+  if (bash) return makeSpec("sh", bash, "bash (Git for Windows)");
+  const shell = findExecutable("pwsh", ctx) ?? findExecutable("powershell", ctx);
+  if (shell) return makeSpec("powershell", shell, "PowerShell");
+  return makeSpec("default", null, env.ComSpec ?? env.COMSPEC ?? "cmd.exe");
+}
+function wrapCommand(kind, command, platform = process.platform) {
+  if (kind === "powershell") {
+    return "$OutputEncoding = [Console]::OutputEncoding = [Text.Encoding]::UTF8; " + command + "\nif ($null -ne $LASTEXITCODE) { exit $LASTEXITCODE }";
+  }
+  if (kind === "cmd" || kind === "default" && platform === "win32") {
+    return `chcp 65001>nul & ${command}`;
+  }
+  return command;
+}
+function describeShell(spec, platform) {
+  if (spec.kind === "sh" || spec.kind === "busybox") {
+    return `\u5F53\u524D\u5E73\u53F0 ${platform}\uFF0Cshell=${spec.label}\uFF1A\u8BF7\u4F7F\u7528 POSIX \u98CE\u683C\u547D\u4EE4\u3002`;
+  }
+  if (spec.kind === "powershell") {
+    return `\u5F53\u524D\u5E73\u53F0 ${platform}\uFF0Cshell=PowerShell\uFF1Als/cat/rm/cp/mv/pwd \u7B49\u522B\u540D\u53EF\u7528\uFF0C\u4E5F\u53EF\u7528 cmdlet\uFF1B\u8DEF\u5F84\u5206\u9694\u7B26\u4E3A "\\"\u3002`;
+  }
+  if (spec.kind === "default" && platform !== "win32") {
+    return `\u5F53\u524D\u5E73\u53F0 ${platform}\uFF0Cshell=${spec.label}\uFF1A\u8BF7\u4F7F\u7528 POSIX \u98CE\u683C\u547D\u4EE4\u3002`;
+  }
+  return `\u5F53\u524D\u5E73\u53F0 ${platform}\uFF0Cshell=${spec.label}\uFF1A\u8BF7\u4F7F\u7528 Windows \u547D\u4EE4\uFF08dir/type/del/copy/move/findstr\uFF09\uFF0C\u591A\u6761\u547D\u4EE4\u7528 & \u6216 && \u8FDE\u63A5\uFF1B\u4E0D\u8981\u4F7F\u7528 ls/cat/rm/grep \u7B49 POSIX \u547D\u4EE4\u3002`;
+}
+function parseCdChain(command, opts = {}) {
+  const platform = opts.platform ?? process.platform;
+  const trimmed = command.trim();
+  const chain = /^([\s\S]*?)\s*&&\s*([\s\S]+)$/.exec(trimmed);
+  const head = (chain ? chain[1] : trimmed).trim();
+  const rest = chain ? chain[2].trim() : null;
+  const m = /^(?:cd|set-location|sl|pushd|push-location)\b\s*([\s\S]*)$/i.exec(head);
+  if (!m) return { target: null, rest: null };
+  let target = m[1].trim();
+  target = target.replace(/^-(?:path|literalpath)\s+/i, "");
+  if (platform === "win32") target = target.replace(/^\/d\s+/i, "");
+  target = target.replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1").trim();
+  if (!target || target === "-") return { target: null, rest: null };
+  return { target, rest };
+}
+
+// src/tools/shellBackground.ts
+var import_node_child_process3 = require("child_process");
+var DEFAULT_BUFFER_LIMIT = 64 * 1024;
+var RingBuffer = class {
+  constructor(limit = DEFAULT_BUFFER_LIMIT) {
+    this.limit = limit;
+  }
+  limit;
+  chunks = [];
+  size = 0;
+  add(chunk) {
+    if (!chunk) return;
+    this.chunks.push(chunk);
+    this.size += chunk.length;
+    while (this.size > this.limit && this.chunks.length > 1) {
+      this.size -= this.chunks.shift().length;
+    }
+    if (this.size > this.limit) {
+      const joined = this.chunks.join("");
+      this.chunks = [joined.slice(-this.limit)];
+      this.size = this.chunks[0].length;
+    }
+  }
+  get() {
+    const joined = this.chunks.join("");
+    return joined.length > this.limit ? joined.slice(-this.limit) : joined;
+  }
+};
+var ShellTaskManager = class {
+  tasks = /* @__PURE__ */ new Map();
+  seq = 0;
+  cleanupInstalled = false;
+  /** 启动一个后台任务，立即返回快照（不等退出） */
+  start(opts) {
+    this.installCleanup();
+    const id = `shell-${++this.seq}-${Date.now().toString(36)}`;
+    const child = (0, import_node_child_process3.spawn)(opts.file, opts.argv, {
+      cwd: opts.cwd,
+      env: opts.env,
+      detached: process.platform !== "win32",
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const task = {
+      id,
+      command: opts.command,
+      scope: opts.scope ?? null,
+      child,
+      stdout: new RingBuffer(),
+      stderr: new RingBuffer(),
+      status: "running",
+      exitCode: null,
+      signal: null,
+      startedAt: Date.now(),
+      endedAt: null
+    };
+    this.tasks.set(id, task);
+    child.stdout?.on("data", (d) => task.stdout.add(d.toString("utf-8")));
+    child.stderr?.on("data", (d) => task.stderr.add(d.toString("utf-8")));
+    child.on("error", (err) => task.stderr.add(`[spawn error] ${err.message}
+`));
+    child.on("exit", (code, signal) => {
+      task.exitCode = code;
+      task.signal = signal;
+      task.endedAt = Date.now();
+      if (task.status !== "killed") task.status = "exited";
+    });
+    child.unref();
+    return this.snapshot(task);
+  }
+  /** 读取任务输出与状态 */
+  output(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task) return { error: `\u672A\u77E5\u7684\u540E\u53F0\u4EFB\u52A1: ${taskId}` };
+    return this.snapshot(task);
+  }
+  /** 终止任务（进程树）并返回快照；传 scope 时只允许终止该归属下的任务 */
+  kill(taskId, scope) {
+    const task = this.tasks.get(taskId);
+    if (!task) return { error: `\u672A\u77E5\u7684\u540E\u53F0\u4EFB\u52A1: ${taskId}` };
+    if (scope !== void 0 && task.scope !== scope) {
+      return { error: `\u672A\u77E5\u7684\u540E\u53F0\u4EFB\u52A1: ${taskId}` };
+    }
+    if (task.status === "running") {
+      task.status = "killed";
+      task.endedAt = Date.now();
+      killTree(task.child.pid);
+    }
+    return this.snapshot(task);
+  }
+  /** 列出任务快照（调试/展示用）；传 scope 时只返回该归属下的任务 */
+  list(scope) {
+    const all = [...this.tasks.values()];
+    return (scope === void 0 ? all : all.filter((t) => t.scope === scope)).map(
+      (t) => this.snapshot(t)
+    );
+  }
+  /** 终止全部任务（进程退出时调用） */
+  disposeAll() {
+    for (const task of this.tasks.values()) {
+      if (task.status === "running") {
+        task.status = "killed";
+        killTree(task.child.pid);
+      }
+    }
+  }
+  snapshot(task) {
+    return {
+      task_id: task.id,
+      command: task.command,
+      status: task.status,
+      running: task.status === "running",
+      exit_code: task.exitCode,
+      signal: task.signal,
+      stdout: task.stdout.get(),
+      stderr: task.stderr.get(),
+      duration_ms: (task.endedAt ?? Date.now()) - task.startedAt
+    };
+  }
+  installCleanup() {
+    if (this.cleanupInstalled) return;
+    this.cleanupInstalled = true;
+    process.once("exit", () => this.disposeAll());
+  }
+};
+
+// src/tools/sandbox.ts
+var import_node_child_process4 = require("child_process");
+function sbplString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function buildMacProfile(writable) {
+  const rules = writable.map((p) => `  (subpath ${sbplString(p)})`).join("\n");
+  return [
+    "(version 1)",
+    "(allow default)",
+    "(deny file-write*)",
+    "(allow file-write*",
+    rules,
+    ")"
+  ].join("\n");
+}
+function buildBwrapArgs(writable, cwd) {
+  const args = ["--ro-bind", "/", "/", "--dev-bind", "/dev", "/dev"];
+  if (!writable.includes("/tmp")) args.push("--tmpfs", "/tmp");
+  for (const dir of writable) {
+    if (dir === "/dev" || dir === "/proc") continue;
+    args.push("--bind", dir, dir);
+  }
+  args.push("--chdir", cwd, "--die-with-parent");
+  return args;
+}
+function wrapWithSandbox(plan, invocation, ctx) {
+  if (!plan || !plan.enforced || !plan.bin) return invocation;
+  if (plan.backend === "sandbox-exec") {
+    return {
+      file: plan.bin,
+      argv: ["-p", buildMacProfile(plan.writable), invocation.file, ...invocation.argv]
+    };
+  }
+  return {
+    file: plan.bin,
+    argv: [...buildBwrapArgs(plan.writable, ctx.cwd), "--", invocation.file, ...invocation.argv]
+  };
+}
+function describeSandbox(plan) {
+  if (!plan) return "\u672A\u914D\u7F6E";
+  return plan.enforced ? plan.reason : `\u672A\u542F\u7528\uFF08${plan.reason}\uFF09`;
+}
+
+// src/tools/shell.ts
+var MAX_STDOUT = 1e4;
+var MAX_STDERR = 5e3;
+var MAX_BUFFER = 1024 * 1024 * 5;
+var shellSessions = /* @__PURE__ */ new Map();
+function shellKey(workspace, owner) {
+  const root = path2.resolve(workspace);
+  const o = String(owner ?? "").trim();
+  return o ? `${root}\0${o}` : root;
+}
+function sessionFor(workspace, owner) {
+  const key = shellKey(workspace, owner);
+  let s = shellSessions.get(key);
+  if (!s) {
+    s = { cwd: path2.resolve(workspace) };
+    shellSessions.set(key, s);
+  }
+  return s;
+}
+function resetShellSession(workspace, owner) {
+  shellSessions.delete(shellKey(workspace, owner));
+}
+function getShellCwd(workspace, owner) {
+  return sessionFor(workspace, owner).cwd;
+}
+function resolveInvocation(spec, prepared) {
+  if (spec.file !== null) {
+    return { file: spec.file, argv: spec.buildArgs(prepared) };
+  }
+  if (process.platform === "win32") {
+    const comspec = process.env.ComSpec ?? process.env.COMSPEC ?? "cmd.exe";
+    return { file: comspec, argv: ["/d", "/s", "/c", prepared] };
+  }
+  return { file: "/bin/sh", argv: ["-c", prepared] };
+}
+function shellEnv() {
+  return {
+    ...process.env,
+    GIT_TERMINAL_PROMPT: "0",
+    PYTHONUNBUFFERED: "1",
+    PYTHONUTF8: "1",
+    PYTHONIOENCODING: "utf-8"
+  };
+}
+function decodeOutput(buf) {
+  if (!buf || buf.length === 0) return "";
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(buf);
+  } catch {
+    for (const enc of ["gbk", "big5", "shift_jis", "latin1"]) {
+      try {
+        return new TextDecoder(enc).decode(buf);
+      } catch {
+      }
+    }
+    return buf.toString("latin1");
+  }
+}
+function makeRunShell(workspace, spec, tasks, scope, sandbox, sessionKey) {
+  const session = sessionFor(workspace, sessionKey);
+  return async function run_shell(args, ctx) {
+    const command = String(args.command ?? "");
+    const description = String(args.description ?? "").slice(0, 100);
+    const background = args.run_in_background === true;
+    const rawTimeout = Number(args.timeout_seconds ?? 120);
+    const timeoutSec = Number.isFinite(rawTimeout) ? rawTimeout : 120;
+    const timeout = Math.min(Math.max(timeoutSec, 1), 600) * 1e3;
+    if (!command.trim()) {
+      return { error: "\u547D\u4EE4\u4E0D\u80FD\u4E3A\u7A7A" };
+    }
+    const { target, rest } = parseCdChain(command);
+    let toRun = command;
+    if (target) {
+      try {
+        const resolved = path2.resolve(session.cwd, target);
+        if (fs2.existsSync(resolved) && fs2.statSync(resolved).isDirectory()) {
+          session.cwd = resolved;
+        }
+      } catch {
+      }
+      if (rest) toRun = rest;
+    }
+    const prepared = wrapCommand(spec.kind, toRun);
+    const { file, argv } = wrapWithSandbox(
+      sandbox,
+      resolveInvocation(spec, prepared),
+      { cwd: session.cwd }
+    );
+    const env = shellEnv();
+    if (background) {
+      const snap = tasks.start({ command, file, argv, cwd: session.cwd, env, scope });
+      return {
+        task_id: snap.task_id,
+        status: snap.status,
+        cwd: session.cwd,
+        note: "\u5DF2\u5728\u540E\u53F0\u542F\u52A8\u3002\u7528 shell_task_output \u67E5\u770B\u8F93\u51FA\uFF0Cshell_task_kill \u7EC8\u6B62\u3002"
+      };
+    }
+    const result = await execAsync(file, argv, {
+      cwd: session.cwd,
+      timeoutMs: timeout,
+      maxBuffer: MAX_BUFFER,
+      env,
+      signal: ctx?.signal
+    });
+    const stdout = decodeOutput(result.stdout).slice(-MAX_STDOUT);
+    const stderr = decodeOutput(result.stderr).slice(-MAX_STDERR);
+    if (result.aborted) {
+      return {
+        stdout,
+        stderr,
+        exit_code: result.status ?? 1,
+        cwd: session.cwd,
+        interrupted: true,
+        error: "\u547D\u4EE4\u5DF2\u88AB\u7528\u6237\u4E2D\u65AD"
+      };
+    }
+    if (result.error && !result.timedOut) {
+      const message = result.error.message;
+      return {
+        stdout,
+        stderr: stderr || message,
+        exit_code: 1,
+        cwd: session.cwd,
+        error: message.slice(0, 200)
+      };
+    }
+    return {
+      stdout,
+      stderr,
+      exit_code: result.status ?? 1,
+      cwd: session.cwd,
+      ...result.timedOut ? { timed_out: true, error: `\u547D\u4EE4\u8D85\u65F6\uFF08${timeoutSec}s\uFF09\u540E\u5DF2\u7EC8\u6B62` } : {}
+    };
+  };
+}
+var shellTasks = new ShellTaskManager();
+function listShellTasks(scope) {
+  return shellTasks.list(scope);
+}
+function killShellTask(taskId, scope) {
+  return shellTasks.kill(taskId, scope);
+}
+function registerShellTool(registry, workspace, scope, sandbox, sessionKey) {
+  const spec = resolveShellSpec();
+  const tasks = shellTasks;
+  const shell = makeRunShell(
+    workspace,
+    spec,
+    tasks,
+    scope ?? null,
+    sandbox ?? null,
+    sessionKey ?? null
+  );
+  registry.register(
+    (args, ctx) => shell(args, ctx),
+    { category: "shell", riskLevel: "high", capabilities: ["run_shell"], requiresApproval: true },
+    {
+      type: "function",
+      function: {
+        name: "run_shell",
+        description: `\u5728\u6301\u4E45\u5316 shell \u4F1A\u8BDD\u4E2D\u8FD0\u884C\u547D\u4EE4 (cwd \u548C\u73AF\u5883\u53D8\u91CF\u5728\u591A\u6B21\u8C03\u7528\u4E4B\u95F4\u4FDD\u6301)\u3002\u8F93\u51FA\u622A\u65AD\u5230\u6700\u540E\u90E8\u5206\uFF0Cstdout \u4E0E stderr \u90FD\u4F1A\u8FD4\u56DE\u3002\u4F20\u9012 description \u8BF4\u660E\u547D\u4EE4\u7528\u9014 (\u663E\u793A\u5728\u5BA1\u6279\u63D0\u793A\u4E2D)\uFF0C\u4F20\u9012 timeout_seconds \u63A7\u5236\u8D85\u65F6\u3002\u5BF9\u4E8E\u5F00\u53D1\u670D\u52A1\u5668 / watch \u7B49\u957F\u9A7B\u8FDB\u7A0B\uFF0C\u8BBE\u7F6E run_in_background=true\uFF0C\u968F\u540E\u7528 shell_task_output \u8F6E\u8BE2\u8F93\u51FA\u3001shell_task_kill \u7EC8\u6B62\u3002\u8FD0\u884C\u73AF\u5883\uFF1A${describeShell(spec, process.platform)}` + (sandbox?.enforced ? `\u6C99\u7BB1\uFF1A${describeSandbox(sandbox)}\uFF1B\u5DE5\u4F5C\u533A\u5916\u7684\u5199\u5165\u4F1A\u88AB\u7CFB\u7EDF\u62D2\u7EDD\u3002` : ""),
+        parameters: {
+          type: "object",
+          properties: {
+            command: { type: "string", description: "\u8981\u6267\u884C\u7684 shell \u547D\u4EE4" },
+            description: { type: "string", description: "\u547D\u4EE4\u7528\u9014\u7684\u7B80\u77ED\u63CF\u8FF0 (\u663E\u793A\u5728\u5BA1\u6279\u4E2D)" },
+            timeout_seconds: { type: "integer", description: "\u8D85\u65F6\u79D2\u6570 (\u9ED8\u8BA4 120\uFF0C\u6700\u5927 600)" },
+            run_in_background: {
+              type: "boolean",
+              description: "\u662F\u5426\u540E\u53F0\u8FD0\u884C (\u9ED8\u8BA4 false)\u3002\u9002\u5408\u5F00\u53D1\u670D\u52A1\u5668\u7B49\u957F\u9A7B\u8FDB\u7A0B\u3002"
+            }
+          },
+          required: ["command"]
+        }
+      }
+    }
+  );
+  registry.register(
+    (args) => tasks.output(String(args.task_id ?? "")),
+    { category: "shell", riskLevel: "low", capabilities: ["run_shell"], requiresApproval: false },
+    {
+      type: "function",
+      function: {
+        name: "shell_task_output",
+        description: "\u67E5\u770B run_shell(run_in_background=true) \u542F\u52A8\u7684\u540E\u53F0\u4EFB\u52A1\u7684\u7D2F\u8BA1\u8F93\u51FA\u4E0E\u72B6\u6001\u3002\u8FD4\u56DE status (running/exited/killed)\u3001exit_code\u3001stdout\u3001stderr\u3002",
+        parameters: {
+          type: "object",
+          properties: {
+            task_id: { type: "string", description: "run_shell \u8FD4\u56DE\u7684 task_id" }
+          },
+          required: ["task_id"]
+        }
+      }
+    }
+  );
+  registry.register(
+    (args) => tasks.kill(String(args.task_id ?? ""), scope ?? null),
+    { category: "shell", riskLevel: "medium", capabilities: ["run_shell"], requiresApproval: false },
+    {
+      type: "function",
+      function: {
+        name: "shell_task_kill",
+        description: "\u7EC8\u6B62\u540E\u53F0\u4EFB\u52A1\uFF08\u8FDE\u540C\u5176\u5B50\u8FDB\u7A0B\u6811\uFF09\u3002\u8FD4\u56DE\u4EFB\u52A1\u7684\u6700\u7EC8\u72B6\u6001\u3002",
+        parameters: {
+          type: "object",
+          properties: {
+            task_id: { type: "string", description: "run_shell \u8FD4\u56DE\u7684 task_id" }
+          },
+          required: ["task_id"]
+        }
+      }
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decodeOutput,
+  getShellCwd,
+  killShellTask,
+  listShellTasks,
+  registerShellTool,
+  resetShellSession
+});
+//# sourceMappingURL=shell.cjs.map