chainlesschain 0.162.176 → 0.162.178

package/src/lib/async-hook-supervisor.cjs

@@ -28,11 +28,10 @@
  *   - tree-reaping of every child on stopAll() / process 'exit', so a session
  *     never leaves an orphan hook process.
  *
- * `_deps.spawn` / `_deps.now` are injected so the whole supervisor is unit-
+ * Process runners and `_deps.now` are injected so the whole supervisor is unit-
  * testable with fake child processes (no real shell).
  */
 
-const cpDefault = require("node:child_process");
 const { tryParseDecision } = require("./hook-runner.cjs");
 
 const DEFAULT_TIMEOUT_MS = 60000;
@@ -52,8 +51,10 @@ class AsyncHookSupervisor {
         ? Number(opts.maxConcurrent)
         : DEFAULT_MAX_CONCURRENT;
     this._deps = {
-      spawn: opts.spawn || cpDefault.spawn,
-      spawnSync: opts.spawnSync || cpDefault.spawnSync,
+      run: opts.run || opts.spawn || null,
+      runSync: opts.runSync || opts.spawnSync || null,
+      killProcess: opts.killProcess || process.kill.bind(process),
+      platform: opts.platform || process.platform,
       now: opts.now || (() => Date.now()),
     };
     this._running = new Map(); // key -> { child, timer }
@@ -125,8 +126,12 @@ class AsyncHookSupervisor {
       return;
     }
     try {
-      if (process.platform === "win32") {
-        const r = this._deps.spawnSync(
+      if (this._deps.platform === "win32") {
+        // Snapshot before taskkill: a policy-restricted taskkill may terminate
+        // the shell and then fail on its descendants, orphaning them so a
+        // parent-PID query performed afterward can no longer find the tree.
+        const descendants = this._windowsDescendantPids(pid);
+        const r = this._deps.runSync(
           "taskkill",
           ["/PID", String(pid), "/T", "/F"],
           { windowsHide: true },
@@ -135,20 +140,27 @@ class AsyncHookSupervisor {
         // tree snapshot and termination. Repeat once so that race cannot
         // leave a short-lived hook grandchild orphaned.
         if (!r?.error && r?.status === 0) {
-          this._deps.spawnSync(
-            "taskkill",
-            ["/PID", String(pid), "/T", "/F"],
-            { windowsHide: true },
-          );
+          this._deps.runSync("taskkill", ["/PID", String(pid), "/T", "/F"], {
+            windowsHide: true,
+          });
         }
-        // If taskkill couldn't launch, fall back to a direct kill.
+        // Restricted runners can launch taskkill but still receive a non-zero
+        // access/policy result. Enumerate the tree while it is still alive,
+        // then terminate descendants leaf-first before killing the shell.
         if (r && (r.error || (r.status != null && r.status !== 0))) {
+          for (const descendant of descendants.reverse()) {
+            try {
+              this._deps.killProcess(descendant, "SIGKILL");
+            } catch {
+              /* already gone */
+            }
+          }
           child.kill(signal);
         }
       } else {
         // Negative pid → the whole process group (requires the detached spawn).
         try {
-          process.kill(-pid, signal);
+          this._deps.killProcess(-pid, signal);
         } catch {
           child.kill(signal);
         }
@@ -162,6 +174,102 @@ class AsyncHookSupervisor {
     }
   }
 
+  /**
+   * Snapshot a Windows process tree for the taskkill-denied fallback. Query the
+   * process table once instead of issuing a quoted WMIC `where` expression for
+   * every level: Node/cmd quoting can silently turn that expression into an
+   * invalid WMIC alias query. PowerShell/CIM covers systems where WMIC has been
+   * removed. Traversal is bounded + cycle-safe so corrupt data cannot stall
+   * session teardown.
+   */
+  _windowsDescendantPids(rootPid) {
+    if (this._deps.platform !== "win32") return [];
+    const root = Number(rootPid);
+    if (!Number.isInteger(root) || root <= 0) return [];
+    let output = "";
+    let shouldTryCim = false;
+    try {
+      const result = this._deps.runSync(
+        "wmic",
+        [
+          "path",
+          "Win32_Process",
+          "get",
+          "ParentProcessId,ProcessId",
+          "/format:csv",
+        ],
+        {
+          encoding: "utf8",
+          windowsHide: true,
+          timeout: 3000,
+        },
+      );
+      if (!result?.error && result?.status === 0) {
+        output = String(result.stdout || "");
+      } else if (result?.error?.code === "ENOENT") {
+        shouldTryCim = true;
+      }
+    } catch {
+      shouldTryCim = true;
+    }
+    if (!output && shouldTryCim) {
+      try {
+        const result = this._deps.runSync(
+          "powershell.exe",
+          [
+            "-NoProfile",
+            "-NonInteractive",
+            "-Command",
+            "Get-CimInstance Win32_Process | ForEach-Object { '{0},{1}' -f $_.ParentProcessId,$_.ProcessId }",
+          ],
+          {
+            encoding: "utf8",
+            windowsHide: true,
+            timeout: 3000,
+          },
+        );
+        if (!result?.error && result?.status === 0) {
+          output = String(result.stdout || "");
+        }
+      } catch {
+        return [];
+      }
+    }
+
+    const childrenByParent = new Map();
+    for (const line of output.split(/\r?\n/)) {
+      const fields = line.trim().split(",");
+      if (fields.length < 2) continue;
+      const parentPid = Number(fields.at(-2));
+      const childPid = Number(fields.at(-1));
+      if (
+        !Number.isInteger(parentPid) ||
+        parentPid < 0 ||
+        !Number.isInteger(childPid) ||
+        childPid <= 0
+      ) {
+        continue;
+      }
+      const children = childrenByParent.get(parentPid) || [];
+      children.push(childPid);
+      childrenByParent.set(parentPid, children);
+    }
+
+    const seen = new Set([root]);
+    const pending = [root];
+    const descendants = [];
+    while (pending.length > 0 && seen.size <= 256) {
+      const parentPid = pending.shift();
+      for (const childPid of childrenByParent.get(parentPid) || []) {
+        if (seen.has(childPid)) continue;
+        seen.add(childPid);
+        descendants.push(childPid);
+        pending.push(childPid);
+      }
+    }
+    return descendants;
+  }
+
   /** Install the process-exit reaper exactly once, only when a child exists. */
   _installExitHook() {
     if (this._exitHookInstalled) return;
@@ -257,22 +365,24 @@ class AsyncHookSupervisor {
         // POSIX: own process group so a timeout / stopAll can signal the whole
         // tree (shell + the real hook command), not just the shell wrapper.
         // No-op on Windows, where the tree is reaped via `taskkill /T` instead.
-        detached: process.platform !== "win32",
+        detached: this._deps.platform !== "win32",
         env: {
           ...process.env,
           CLAUDE_HOOK_EVENT: hook.event || payload.hook_event_name || "",
         },
       };
-      child = opts.broker && hook.origin === "plugin:hook"
-        ? opts.broker.spawn(hook.command, [], {
-            ...spawnOptions,
-            origin: hook.origin,
-            policy: "allow",
-            pluginId: hook.pluginId || null,
-            pluginVersion: hook.pluginVersion || null,
-            pluginSource: hook.pluginSource || null,
-          })
-        : this._deps.spawn(hook.command, spawnOptions);
+      if (typeof this._deps.run !== "function") {
+        throw new Error("async hook process runner unavailable");
+      }
+      child = this._deps.run(hook.command, {
+        ...spawnOptions,
+        origin: hook.origin || "async-hook:command",
+        policy: "allow",
+        scope: "async-hook",
+        pluginId: hook.pluginId || null,
+        pluginVersion: hook.pluginVersion || null,
+        pluginSource: hook.pluginSource || null,
+      });
     } catch (err) {
       this._record(hook, {
         ok: false,

package/src/lib/async-hook-supervisor.js

@@ -0,0 +1,47 @@
+import supervisor from "./async-hook-supervisor.cjs";
+import executionBroker from "./process-execution-broker/index.js";
+
+const brokerRunner = executionBroker.spawn.bind(executionBroker);
+const brokerSyncRunner = executionBroker.spawnSync.bind(executionBroker);
+
+export const _processDeps = {
+  run: brokerRunner,
+  runSync: brokerSyncRunner,
+};
+
+function runAsyncHook(command, options = {}) {
+  return _processDeps.run(command, [], {
+    ...options,
+    origin: options.origin || "async-hook:command",
+    policy: "allow",
+    scope: "async-hook",
+  });
+}
+
+function runAsyncHookSupervisorCommand(command, args, options = {}) {
+  return _processDeps.runSync(command, args, {
+    ...options,
+    origin: options.origin || "async-hook:supervisor",
+    policy: "allow",
+    scope: "async-hook",
+  });
+}
+
+export class AsyncHookSupervisor extends supervisor.AsyncHookSupervisor {
+  constructor(options = {}) {
+    super({
+      ...options,
+      run: options.run || options.spawn || runAsyncHook,
+      runSync:
+        options.runSync || options.spawnSync || runAsyncHookSupervisorCommand,
+    });
+  }
+}
+
+export const { DEFAULT_TIMEOUT_MS, DEFAULT_MAX_CONCURRENT } = supervisor;
+
+export default {
+  AsyncHookSupervisor,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_MAX_CONCURRENT,
+};

package/src/lib/background-agent-supervisor.js

@@ -1,4 +1,3 @@
-import { spawn, spawnSync } from "node:child_process";
 import {
   closeSync,
   existsSync,
@@ -21,6 +20,7 @@ import {
   finishAgentWorktree,
   validateAgentWorktree,
 } from "./agent-worktree.js";
+import executionBroker from "./process-execution-broker/index.js";
 
 export const DEFAULT_HEARTBEAT_INTERVAL_MS = 5000;
 export const DEFAULT_HEARTBEAT_STALE_MS = 120000;
@@ -42,6 +42,16 @@ export const PID_IDENTITY_TOLERANCE_MS = 60000;
 const START_TIME_CACHE_TTL_MS = 10000;
 const _startTimeCache = new Map();
 
+function runSupervisorCommand(file, args, options, origin) {
+  return _deps.spawnSync(file, args, {
+    ...options,
+    origin,
+    policy: "allow",
+    scope: "background-agent",
+    shell: false,
+  });
+}
+
 /** CIM_DATETIME (`20260711120000.500000+480`) → epoch ms, null when unparseable. */
 export function parseCimDateToMs(raw) {
   const m =
@@ -77,7 +87,7 @@ function defaultReadProcessStartTimeMs(pid) {
     // wmic first (fast, ~100-300ms); PowerShell CIM as fallback (wmic is
     // removed from recent Windows 11 builds).
     try {
-      const r = spawnSync(
+      const r = runSupervisorCommand(
         "wmic",
         [
           "process",
@@ -88,6 +98,7 @@ function defaultReadProcessStartTimeMs(pid) {
           "/value",
         ],
         { windowsHide: true, encoding: "utf8", timeout: 5000 },
+        "background-agent:process-start-time",
       );
       if (!r.error && r.status === 0) {
         const m = /CreationDate=([^\r\n]+)/.exec(r.stdout || "");
@@ -101,10 +112,11 @@ function defaultReadProcessStartTimeMs(pid) {
       const script =
         `$p = Get-CimInstance Win32_Process -Filter 'ProcessId=${target}' -ErrorAction SilentlyContinue; ` +
         "if ($p -and $p.CreationDate) { [DateTimeOffset]::new($p.CreationDate).ToUnixTimeMilliseconds() }";
-      const r = spawnSync(
+      const r = runSupervisorCommand(
         "powershell",
         ["-NoProfile", "-NonInteractive", "-Command", script],
         { windowsHide: true, encoding: "utf8", timeout: 10000 },
+        "background-agent:process-start-time",
       );
       if (!r.error && r.status === 0) {
         const n = Number(String(r.stdout || "").trim());
@@ -118,10 +130,15 @@ function defaultReadProcessStartTimeMs(pid) {
   // POSIX: `ps -o lstart=` gives an absolute start timestamp on Linux + macOS
   // (procps and BSD ps both support it; busybox ps does not → null → open).
   try {
-    const r = spawnSync("ps", ["-o", "lstart=", "-p", String(target)], {
-      encoding: "utf8",
-      timeout: 5000,
-    });
+    const r = runSupervisorCommand(
+      "ps",
+      ["-o", "lstart=", "-p", String(target)],
+      {
+        encoding: "utf8",
+        timeout: 5000,
+      },
+      "background-agent:process-start-time",
+    );
     if (!r.error && r.status === 0) {
       const t = Date.parse(String(r.stdout || "").trim());
       if (Number.isFinite(t) && t > 0) return t;
@@ -147,13 +164,14 @@ function defaultKillProcessTree(pid, signal = "SIGKILL") {
   if (target === process.pid) return false;
   try {
     if (process.platform === "win32") {
-      const r = _deps.spawnSync(
+      const r = runSupervisorCommand(
         "taskkill",
         ["/PID", String(target), "/T", "/F"],
         {
           windowsHide: true,
           encoding: "utf8",
         },
+        "background-agent:process-tree-kill",
       );
       return !r.error && r.status === 0;
     }
@@ -170,8 +188,8 @@ function defaultKillProcessTree(pid, signal = "SIGKILL") {
 }
 
 export const _deps = {
-  spawn,
-  spawnSync,
+  spawn: executionBroker.spawn.bind(executionBroker),
+  spawnSync: executionBroker.spawnSync.bind(executionBroker),
   // Single POSIX signal seam: every kill this module issues goes through here
   // so tests can stub it — a bare `process.kill` is NOT interceptable and a
   // fixture recording a live pid would eat a REAL signal (the shard-2/4
@@ -741,7 +759,7 @@ export function resumeBackgroundAgent(id, prompt, options = {}) {
 }
 
 /**
- * Fail fast on an unusable cwd. Without this, spawn() surfaces a bad cwd as
+ * Fail fast on an unusable cwd. Without this, process launch surfaces a bad cwd as
  * an ASYNC 'error' event on the detached child — which nothing listened to
  * (uncaught exception with no context) — and the pre-written state/job files
  * stayed behind as a phantom "running" session. Deleted, file-replaced, and
@@ -826,6 +844,10 @@ export function launchBackgroundAgent({
       detached: true,
       stdio: "ignore",
       windowsHide: true,
+      origin: "background-agent:worker",
+      policy: "allow",
+      scope: "background-agent",
+      shell: false,
     });
   } catch (error) {
     rmSync(jobFile, { force: true });
@@ -922,13 +944,14 @@ export function stopBackgroundAgent(id) {
     return { ...lost, stopped: false };
   }
   if (process.platform === "win32") {
-    const killed = _deps.spawnSync(
+    const killed = runSupervisorCommand(
       "taskkill",
       ["/PID", String(state.pid), "/T", "/F"],
       {
         windowsHide: true,
         encoding: "utf8",
       },
+      "background-agent:stop-tree",
     );
     if (killed.error || (killed.status !== 0 && isProcessAlive(state.pid))) {
       throw new Error(