@cruxy/cli 0.14.0 → 0.16.0

package/dist/tools/shell/run-command.js

@@ -1,9 +1,13 @@
-import { spawn } from "node:child_process";
 import { z } from "zod";
+import { runGatedShell } from "./exec.js";
 /**
  * Run an arbitrary shell command in the project root. The highest-risk tool we
  * ship: it is gated on `ctx.approve` (a denial runs nothing) and bounded by a
  * timeout that kills the whole process tree plus a cap on captured output.
+ *
+ * Gate + execution live in the shared {@link runGatedShell} (also used by the
+ * C.19 hook runner — the single, un-bypassable shell path); this tool only maps
+ * the structured result back onto its `ToolResult` framing.
  */
 export const runCommandTool = {
     name: "run_command",
@@ -14,129 +18,35 @@ export const runCommandTool = {
             .describe("The shell command to run (executed via the system shell)."),
     }),
     async execute(input, ctx) {
-        // Approve BEFORE anything runs; a denial executes nothing. A thrown
-        // CRUXY_E_APPROVAL_REQUIRED (non-interactive) propagates — do not catch.
-        const decision = await ctx.requestApproval({
-            kind: "shell",
-            command: input.command,
-        });
-        if (!decision.allow) {
+        // A thrown CRUXY_E_APPROVAL_REQUIRED (non-interactive) / sandbox coded error
+        // propagates from runGatedShell — do not catch (fail loud).
+        const outcome = await runGatedShell(input.command, ctx);
+        if (!outcome.approved) {
             return {
                 ok: false,
-                error: decision.feedback ?? "command denied by the user",
+                error: outcome.rejection ?? "command denied by the user",
             };
         }
-        // Substrate is chosen SOLELY by ctx.sandbox: present → run in the box (C.16),
-        // never on the host; absent → host, unchanged. There is no fallback path — a
-        // sandbox that can't run throws a coded error (see runSandboxed) rather than
-        // silently reaching runBounded.
-        return ctx.sandbox
-            ? runSandboxed(input.command, ctx)
-            : runBounded(input.command, ctx);
+        return mapExecResult(outcome.exec, ctx);
     },
 };
 /**
- * Run inside the sandbox and map the neutral ExecResult onto the IDENTICAL
- * ToolResult the host path produces — same "exit code N" framing, same
- * truncation note, same timeout message — so the tool is substrate-agnostic.
- * A container-start / image failure throws a coded CruxyError from
- * `sandbox.exec` and propagates; we deliberately do not catch it (fail loud).
+ * Map a {@link ShellExecResult} onto the tool's `ToolResult` — the same "exit
+ * code N" framing, truncation note, and timeout / spawn-error messages as
+ * before the shared-path refactor. `exitCode ?? signal ?? "unknown"` reproduces
+ * both the sandbox (`exitCode ?? "unknown"`, signal always null) and host
+ * (`code ?? signal ?? "unknown"`) framings from the original tool.
  */
-function runSandboxed(command, ctx) {
+function mapExecResult(r, ctx) {
     const { timeoutMs, maxOutputBytes } = ctx.config.shell;
-    return ctx
-        .sandbox.exec(command, {
-        cwd: ctx.cwd,
-        timeoutMs,
-        maxOutputBytes,
-        capture: "head",
-    })
-        .then((result) => {
-        if (result.timedOut) {
-            return { ok: false, error: `timed out after ${timeoutMs}ms` };
-        }
-        const exit = result.exitCode ?? "unknown";
-        let output = `exit code ${exit}\n${result.output}`;
-        if (result.outputTruncated) {
-            output += `\n… [output truncated at ${maxOutputBytes} bytes]`;
-        }
-        return { ok: true, output };
-    });
-}
-/** Spawn the command, capture bounded output, and enforce the timeout. */
-function runBounded(command, ctx) {
-    const { timeoutMs, maxOutputBytes } = ctx.config.shell;
-    return new Promise((resolve) => {
-        // `detached` makes the child its own process-group leader so the whole tree
-        // (the shell plus anything it spawns) can be killed on timeout.
-        const child = spawn(command, {
-            shell: true,
-            cwd: ctx.cwd,
-            detached: true,
-        });
-        const chunks = [];
-        let captured = 0;
-        let truncated = false;
-        const capture = (buf) => {
-            if (truncated)
-                return;
-            const room = maxOutputBytes - captured;
-            if (buf.length <= room) {
-                chunks.push(buf);
-                captured += buf.length;
-            }
-            else {
-                if (room > 0) {
-                    chunks.push(buf.subarray(0, room));
-                    captured += room;
-                }
-                truncated = true;
-            }
-        };
-        child.stdout?.on("data", capture);
-        child.stderr?.on("data", capture);
-        // A single guard so the timeout-kill and the natural close can't both fire.
-        let settled = false;
-        const timer = setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
-            killTree(child.pid);
-            resolve({ ok: false, error: `timed out after ${timeoutMs}ms` });
-        }, timeoutMs);
-        child.on("error", (err) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            resolve({ ok: false, error: err.message });
-        });
-        child.on("close", (code, signal) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            const exit = code ?? signal ?? "unknown";
-            let output = `exit code ${exit}\n${Buffer.concat(chunks).toString("utf8")}`;
-            if (truncated) {
-                output += `\n… [output truncated at ${maxOutputBytes} bytes]`;
-            }
-            resolve({ ok: true, output });
-        });
-    });
-}
-/**
- * Kill the command's entire process group. POSIX-specific (negative pid targets
- * the group); fine on our darwin/linux targets. Swallows errors — the process
- * may already be gone.
- */
-function killTree(pid) {
-    if (pid === undefined)
-        return;
-    try {
-        process.kill(-pid, "SIGKILL");
-    }
-    catch {
-        // Already exited, or no group — nothing to kill.
+    if (r.timedOut)
+        return { ok: false, error: `timed out after ${timeoutMs}ms` };
+    if (r.spawnError !== undefined)
+        return { ok: false, error: r.spawnError };
+    const exit = r.exitCode ?? r.signal ?? "unknown";
+    let output = `exit code ${exit}\n${r.output}`;
+    if (r.truncated) {
+        output += `\n… [output truncated at ${maxOutputBytes} bytes]`;
     }
+    return { ok: true, output };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cruxy/cli",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "an agentic coding CLI",
   "type": "module",
   "bin": {