@livx.cc/agentx 0.99.77 → 0.99.79

package/dist/tools.shell.js

@@ -28,6 +28,19 @@ function redactSecrets(text) {
   return text.replace(SECRET_PAIR, (_m, head, quote, _val) => `${head}${quote}${REDACTED}`).replace(SECRET_TOKEN, REDACTED);
 }
 
+// src/hostPath.ts
+var currentPlatform = () => typeof process !== "undefined" && process.platform || "browser";
+var isWinPaths = (platform = currentPlatform()) => platform === "win32";
+function toVfsPath(p, platform = currentPlatform()) {
+  if (!isWinPaths(platform) || typeof p !== "string") return p;
+  let s = p.replace(/\\/g, "/");
+  s = s.replace(/^\/\/\?\/UNC\//i, "//").replace(/^\/\/\?\//, "");
+  const drive = /^([A-Za-z]):(?=\/|$)/.exec(s);
+  if (drive) return `/${drive[1].toLowerCase()}${s.slice(2) || "/"}`.replace(/\/+$/, "") || "/";
+  if (/^\/\/[^/]/.test(s)) return `/unc/${s.slice(2)}`;
+  return s;
+}
+
 // src/tools.structured.ts
 function ckAbort(signal) {
   if (signal?.aborted) throw new Error("aborted");
@@ -72,7 +85,7 @@ async function walkFiles(fs, dir, signal, out = [], st, depth = 0) {
 }
 function scanRoots(fs, path, opts) {
   const asked = path == null ? [] : (Array.isArray(path) ? path : [path]).map((p) => String(p)).filter(Boolean);
-  const roots = (asked.length ? asked : opts?.roots?.length ? opts.roots : [fsCwd(fs)]).map((r) => r.length > 1 && r.endsWith("/") ? r.slice(0, -1) : r);
+  const roots = (asked.length ? asked : opts?.roots?.length ? opts.roots : [fsCwd(fs)]).map((r) => toVfsPath(r)).map((r) => r.length > 1 && r.endsWith("/") ? r.slice(0, -1) : r);
   return [...new Set(roots)].filter((r, _i, all) => !all.some((other) => other !== r && r.startsWith(`${other}/`)));
 }
 function scanNote(states) {
@@ -866,21 +879,130 @@ var JobRegistry = class {
   }
 };
 
-// src/tools.shell.ts
-var log7 = forComponent("shell");
-var clean = (s) => truncateOutput(redactSecrets(s.replace(/\n+$/, "")));
-var DETACHED = { stdio: ["ignore", "pipe", "pipe"], detached: true };
-function killGroup(proc, signal) {
-  if (!proc?.pid) return false;
+// src/platform.ts
+import { spawnSync, execFile } from "child_process";
+import { statSync as statSync3 } from "fs";
+import * as np from "path";
+var IS_WIN = process.platform === "win32";
+var POSIX_SH = { bin: "/bin/sh", args: (c) => ["-c", c], label: "/bin/sh", kind: "sh" };
+function specFor(bin) {
+  const name = np.basename(bin).toLowerCase().replace(/\.exe$/, "");
+  if (name === "powershell" || name === "pwsh") {
+    const pre = "$ProgressPreference='SilentlyContinue';[Console]::OutputEncoding=[Text.Encoding]::UTF8;$OutputEncoding=[Text.Encoding]::UTF8;";
+    return {
+      bin,
+      kind: "powershell",
+      label: name === "pwsh" ? "PowerShell (pwsh)" : "Windows PowerShell",
+      args: (c) => ["-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-EncodedCommand", Buffer.from(pre + c, "utf16le").toString("base64")]
+    };
+  }
+  if (name === "cmd") return { bin, kind: "cmd", label: "cmd.exe", args: (c) => ["/d", "/s", "/c", `"${c}"`], spawnOptions: { windowsVerbatimArguments: true } };
+  return { bin, kind: "sh", label: /bash/.test(name) && /git/i.test(bin) ? "Git Bash" : name, args: (c) => ["-c", c] };
+}
+var isFile = (p) => {
   try {
-    process.kill(-proc.pid, signal);
-    return true;
+    return statSync3(p).isFile();
   } catch {
     return false;
   }
+};
+function findGitBash(env = process.env) {
+  const roots = [];
+  const git = findOnPath("git", env);
+  if (git) {
+    const dir = np.dirname(git);
+    const up = (p, n) => {
+      for (let i = 0; i < n; i++) p = np.dirname(p);
+      return p;
+    };
+    roots.push(/[\\/](mingw(32|64)|ucrt64|clang(32|64|arm64))[\\/]bin$/i.test(dir) ? up(dir, 2) : up(dir, 1));
+  }
+  for (const base of [env.ProgramFiles, env["ProgramFiles(x86)"], env.ProgramW6432, env.LOCALAPPDATA && np.join(env.LOCALAPPDATA, "Programs")])
+    if (base) roots.push(np.join(base, "Git"));
+  for (const r of roots) {
+    const b = np.join(r, "bin", "bash.exe");
+    if (isFile(b)) return b;
+  }
+  return void 0;
 }
+var _shell;
+function defaultShell() {
+  if (!IS_WIN) return POSIX_SH;
+  if (_shell) return _shell;
+  const override = process.env.AGENTX_SHELL;
+  if (override && (isFile(override) || findOnPath(override))) return _shell = specFor(isFile(override) ? override : findOnPath(override));
+  const bash = findGitBash();
+  if (bash) return _shell = specFor(bash);
+  const sysRoot = process.env.SystemRoot || "C:\\Windows";
+  const ps = np.join(sysRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  if (isFile(ps)) return _shell = specFor(ps);
+  return _shell = specFor(process.env.ComSpec || "cmd.exe");
+}
+function shellFor(shell) {
+  if (!IS_WIN) return shell ? { ...POSIX_SH, bin: shell } : POSIX_SH;
+  return shell && isFile(shell) ? specFor(shell) : defaultShell();
+}
+var DETACH_OPTIONS = IS_WIN ? { windowsHide: true } : { detached: true };
+function killTree(pid, signal) {
+  if (!pid) return false;
+  if (!IS_WIN) {
+    try {
+      process.kill(-pid, signal);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  try {
+    const r = spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true, stdio: "ignore", timeout: 1e4 });
+    return r.status === 0;
+  } catch {
+    return false;
+  }
+}
+async function winTreeCpuSeconds(root) {
+  const script = 'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId) $([uint64]$_.UserModeTime + [uint64]$_.KernelModeTime)" }';
+  const out = await new Promise((res, rej) => execFile(
+    "powershell.exe",
+    ["-NoProfile", "-NonInteractive", "-Command", script],
+    { timeout: 15e3, windowsHide: true },
+    (e, so) => e ? rej(e) : res(String(so))
+  ));
+  const rows = out.split(/\r?\n/).map((l) => l.trim().split(/\s+/)).filter((r) => r.length === 3).map(([pid, ppid, ticks]) => ({ pid: Number(pid), ppid: Number(ppid), sec: Number(ticks) / 1e7 }));
+  const inTree = new Set(rows.filter((r) => r.pid === root).map((r) => r.pid));
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (const r of rows) if (!inTree.has(r.pid) && inTree.has(r.ppid) && r.pid !== r.ppid) {
+      inTree.add(r.pid);
+      grew = true;
+    }
+  }
+  let total;
+  for (const r of rows) if (inTree.has(r.pid) && Number.isFinite(r.sec)) total = (total ?? 0) + r.sec;
+  return total;
+}
+function findOnPath(cmd, env = process.env) {
+  const exts = IS_WIN && !/\.[^\\/.]+$/.test(cmd) ? (env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
+  const cands = (base) => exts.map((e) => base + e);
+  if (/[\\/]/.test(cmd)) return cands(cmd).find(isFile);
+  const PATH = env.PATH ?? env.Path ?? "";
+  for (const dir of PATH.split(np.delimiter)) {
+    if (!dir) continue;
+    for (const p of cands(np.join(dir, cmd))) if (isFile(p)) return p;
+  }
+  return void 0;
+}
+
+// src/tools.shell.ts
+var log7 = forComponent("shell");
+var clean = (s) => truncateOutput(redactSecrets(s.replace(/\n+$/, "")));
+var DETACHED = { stdio: ["ignore", "pipe", "pipe"], ...DETACH_OPTIONS };
+function killGroup(proc, signal) {
+  return killTree(proc?.pid, signal);
+}
+var shellArgv = (sh, command) => ({ bin: sh.bin, args: sh.args(command), ...sh.spawnOptions ? { spawnOptions: sh.spawnOptions } : {} });
 async function spawnArgvFor(command, cwd, osSandbox) {
-  if (!osSandbox) return { bin: "/bin/sh", args: ["-c", command] };
+  if (!osSandbox) return shellArgv(defaultShell(), command);
   const opts = osSandbox === true ? {} : osSandbox;
   const wrapper = await findSandboxWrapper();
   const wrapped = wrapper ? sandboxArgv(command, cwd, opts, process.platform, process.env.TMPDIR) : null;
@@ -910,9 +1032,17 @@ function parsePsTime(t) {
   return Number(m[1] ?? 0) * 86400 + Number(m[2] ?? 0) * 3600 + Number(m[3]) * 60 + Number(m[4]);
 }
 async function psGroupCpuSeconds(pgid) {
+  if (IS_WIN) {
+    try {
+      return await winTreeCpuSeconds(pgid);
+    } catch (e) {
+      log7.debug(`cpu probe failed for ${pgid}: ${e}`);
+      return void 0;
+    }
+  }
   try {
-    const { execFile } = await import("child_process");
-    const out = await new Promise((res, rej) => execFile("ps", ["-A", "-o", "pid=,ppid=,pgid=,time="], { timeout: 5e3, env: { ...process.env, LC_ALL: "C" } }, (e, so) => e ? rej(e) : res(String(so))));
+    const { execFile: execFile2 } = await import("child_process");
+    const out = await new Promise((res, rej) => execFile2("ps", ["-A", "-o", "pid=,ppid=,pgid=,time="], { timeout: 5e3, env: { ...process.env, LC_ALL: "C" } }, (e, so) => e ? rej(e) : res(String(so))));
     return sumTreeCpu(out, pgid);
   } catch (e) {
     log7.debug(`ps cpu probe failed for group ${pgid}: ${e}`);
@@ -946,8 +1076,8 @@ var ShellJobRegistry = class {
     const h = this.track(command, { idleMs: 0 });
     try {
       const spawn = this.cfg.spawn ?? await nodeSpawn();
-      const argv = this.cfg.osSandbox ? await spawnArgvFor(command, this.cfg.cwd, this.cfg.osSandbox) : { bin: "/bin/sh", args: ["-c", command] };
-      this.attach(h, spawn(argv.bin, argv.args, { cwd: this.cfg.cwd, env: childEnv(this.cfg), ...DETACHED }));
+      const argv = this.cfg.osSandbox ? await spawnArgvFor(command, this.cfg.cwd, this.cfg.osSandbox) : shellArgv(defaultShell(), command);
+      this.attach(h, spawn(argv.bin, argv.args, { cwd: this.cfg.cwd, env: childEnv(this.cfg), ...DETACHED, ...argv.spawnOptions }));
     } catch (e) {
       h.chunk(`failed to spawn: ${e?.message ?? e}`);
       h.finish("error", void 0, e?.message ?? String(e));
@@ -1101,7 +1231,7 @@ function makeRealShellTool(options) {
       return { ...this, description: rebound.description, run: rebound.run, withCwd: rebound.withCwd };
     },
     get description() {
-      return "Run a shell command via /bin/sh in the working directory. Executes any installed binary \u2014 ls, cat, grep, git, bun, node, curl, scripts, etc. Returns combined stdout+stderr; non-zero exits are prefixed `[exit N]`. Runs non-interactively with no terminal (stdin is /dev/null): commands that prompt for input fail fast rather than hang \u2014 for privileged actions use a non-interactive flag (e.g. `sudo -n`), or ask the user to run the command themselves. " + (options.registry?.adopt ? `A command still running after ${defaultTimeoutMs}ms is NOT killed \u2014 it is handed to a background job and you get its id, so you can keep checking on it (\`[still running]\`). Pass \`timeoutMs\` (max ${maxTimeoutMs}) to wait longer in the foreground, and always bound network commands yourself (e.g. \`curl -m 10\`). ` : `Each command is killed after ${defaultTimeoutMs}ms (result \`[exit 124]\` with whatever output it produced) \u2014 pass \`timeoutMs\` (max ${maxTimeoutMs}) for a legitimately slower command, and always bound network commands yourself (e.g. \`curl -m 10\`). `) + backgroundDoc();
+      return `Run a shell command via ${shellFor(options.shell).label} in the working directory. ` + windowsShellNote(shellFor(options.shell)) + "Executes any installed binary \u2014 ls, cat, grep, git, bun, node, curl, scripts, etc. Returns combined stdout+stderr; non-zero exits are prefixed `[exit N]`. Runs non-interactively with no terminal (stdin is /dev/null): commands that prompt for input fail fast rather than hang \u2014 for privileged actions use a non-interactive flag (e.g. `sudo -n`), or ask the user to run the command themselves. " + (options.registry?.adopt ? `A command still running after ${defaultTimeoutMs}ms is NOT killed \u2014 it is handed to a background job and you get its id, so you can keep checking on it (\`[still running]\`). Pass \`timeoutMs\` (max ${maxTimeoutMs}) to wait longer in the foreground, and always bound network commands yourself (e.g. \`curl -m 10\`). ` : `Each command is killed after ${defaultTimeoutMs}ms (result \`[exit 124]\` with whatever output it produced) \u2014 pass \`timeoutMs\` (max ${maxTimeoutMs}) for a legitimately slower command, and always bound network commands yourself (e.g. \`curl -m 10\`). `) + backgroundDoc();
     },
     // Declared so transports above the agent loop can size their own deadline with headroom (see AgentTool.maxDurationMs).
     maxDurationMs: maxTimeoutMs,
@@ -1125,7 +1255,7 @@ function makeRealShellTool(options) {
         return `Started background job ${id}. Poll output with ShellOutput({id:"${id}"}), check ShellStatus({id:"${id}"}), stop with ShellKill({id:"${id}"}).`;
       }
       const spawn = options.spawn ?? await nodeSpawn();
-      let argv = { bin: options.shell || "/bin/sh", args: ["-c", cmd] };
+      let argv = shellArgv(shellFor(options.shell), cmd);
       if (options.osSandbox) {
         try {
           argv = await spawnArgvFor(cmd, options.cwd, options.osSandbox);
@@ -1170,12 +1300,13 @@ function makeRealShellTool(options) {
           };
           let proc;
           try {
-            proc = spawn(argv.bin, argv.args, { cwd: options.cwd, env: childEnv(options), signal: ctl.signal, ...DETACHED });
+            if (IS_WIN) ctl.signal.addEventListener("abort", () => killGroup(proc, "SIGKILL"), { once: true });
+            proc = spawn(argv.bin, argv.args, { cwd: options.cwd, env: childEnv(options), signal: ctl.signal, ...DETACHED, ...argv.spawnOptions });
           } catch (e) {
             return finish(`[exit 1] failed to spawn shell: ${e?.message ?? e}`);
           }
           if (ctl.signal.aborted) killGroup(proc, "SIGKILL");
-          else ctl.signal.addEventListener("abort", () => killGroup(proc, "SIGKILL"), { once: true });
+          else if (!IS_WIN) ctl.signal.addEventListener("abort", () => killGroup(proc, "SIGKILL"), { once: true });
           const registry = options.registry;
           if (registry?.adopt) {
             onDeadline = () => {
@@ -1220,6 +1351,12 @@ function makeRealShellTool(options) {
     }
   };
 }
+function windowsShellNote(sh) {
+  if (!IS_WIN) return "";
+  if (sh.kind === "sh") return "This is Windows: the shell is bash (POSIX syntax); drive paths are written /c/Users/\u2026 or C:/Users/\u2026, and Windows programs (.exe/.cmd) run directly. ";
+  if (sh.kind === "powershell") return "This is Windows and the shell is PowerShell \u2014 use PowerShell syntax (`;` not `&&`, `$env:VAR`, Get-ChildItem/Select-String), not bash. ";
+  return "This is Windows and the shell is cmd.exe \u2014 use cmd syntax (`&&`, `%VAR%`, dir/type/findstr), not bash. ";
+}
 function handoffFor(timeoutMs, id, body, notifies) {
   const head = `[still running] exceeded ${timeoutMs}ms, so it was handed to background job ${id} \u2014 NOT killed, it is still going (it is only stopped if it goes silent with no CPU activity for a long time, and then you are told why). Check on it with ShellOutput({id:"${id}"}) / ShellStatus({id:"${id}"}), stop it with ShellKill({id:"${id}"}). ` + (notifies ? "Its completion will be reported to you, so you may continue with other work meanwhile." : "Nothing will tell you when it finishes \u2014 poll it yourself before you rely on its result.");
   return body ? `${head}
@@ -1282,6 +1419,7 @@ export {
   makeShellJobTools,
   parsePsTime,
   psGroupCpuSeconds,
-  sumTreeCpu
+  sumTreeCpu,
+  windowsShellNote
 };
 //# sourceMappingURL=tools.shell.js.map