chainlesschain 0.162.176 → 0.162.177

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(

package/src/lib/background-task-manager.js

@@ -1 +1,5 @@
-export { TaskStatus, BackgroundTaskManager } from "../harness/background-task-manager.js";
+export {
+  _deps,
+  TaskStatus,
+  BackgroundTaskManager,
+} from "../harness/background-task-manager.js";

package/src/lib/changelog.js

@@ -91,6 +91,41 @@ export function compareSemver(a, b) {
   return 0;
 }
 
+/**
+ * Whether a parsed changelog documents an exact CLI package version.
+ *
+ * A product block can cover more than one CLI release (notably the root
+ * `Unreleased` block), so check both its primary `cliVersion` and the complete
+ * `cliVersions` set. This is also the publish-time stale-artifact guard.
+ */
+export function hasCliVersion(releases, version) {
+  if (!version || !Array.isArray(releases)) return false;
+  return releases.some(
+    (release) =>
+      release?.cliVersion === version ||
+      (Array.isArray(release?.cliVersions) &&
+        release.cliVersions.includes(version)),
+  );
+}
+
+/** Highest exact CLI version documented by the parsed release list. */
+export function latestCliVersion(releases) {
+  if (!Array.isArray(releases)) return null;
+  const versions = releases.flatMap((release) => {
+    const covered = Array.isArray(release?.cliVersions)
+      ? release.cliVersions
+      : [];
+    return release?.cliVersion ? [...covered, release.cliVersion] : covered;
+  });
+  return versions.length === 0
+    ? null
+    : versions.reduce(
+        (latest, version) =>
+          compareSemver(version, latest) > 0 ? version : latest,
+        versions[0],
+      );
+}
+
 /**
  * Parse a raw CHANGELOG.md string into CLI-focused release entries.
  *
@@ -135,6 +170,28 @@ export function parseChangelog(md) {
     const sections = extractCliSections(block.lines, block.header);
     if (!sections) continue;
 
+    // The root changelog keeps multiple still-unreleased CLI versions as
+    // sibling `###` sections. Treating the whole `## [Unreleased]` block as
+    // one record collapses many CLI releases into a single entry and makes
+    // `-n 5` mean five product blocks instead of five CLI versions.
+    if (parsed.version.toLowerCase() === "unreleased") {
+      for (const section of sections) {
+        const sectionText = `${section.heading}\n${section.body}`;
+        const sectionVersions = extractCliVersions(sectionText);
+        if (!sectionVersions.primary) continue;
+        const dateMatch = sectionText.match(/\b(\d{4}-\d{2}-\d{2})\b/);
+        releases.push({
+          productVersion: null,
+          cliVersion: sectionVersions.primary,
+          cliVersions: sectionVersions.all.sort(compareSemver),
+          date: dateMatch ? dateMatch[1] : null,
+          title: "",
+          sections: [section],
+        });
+      }
+      continue;
+    }
+
     releases.push({
       productVersion: parsed.version,
       cliVersion: primary,

package/src/lib/chrome-connector.js

@@ -26,11 +26,11 @@
  * Chrome when done. This is the same trade Claude-Code's Chrome connector
  * makes.
  */
-import { spawn } from "child_process";
 import fs from "fs";
 import os from "os";
 import path from "path";
 import http from "http";
+import executionBroker from "./process-execution-broker/index.js";
 
 export const DEFAULT_CDP_PORT = 9222;
 
@@ -69,7 +69,7 @@ export const DEFAULT_DOM_CAP = 150000;
 
 const _deps = {
   fs,
-  spawn,
+  spawn: executionBroker.spawn.bind(executionBroker),
   homedir: () => os.homedir(),
   platform: () => process.platform,
   env: () => process.env,
@@ -215,6 +215,10 @@ export function launchChrome(opts = {}) {
       detached: true,
       stdio: "ignore",
       windowsHide: false,
+      origin: "chrome-connector:launch",
+      policy: "allow",
+      scope: "browser",
+      shell: false,
     });
     child.unref();
     return { ok: true, executable, args, pid: child.pid };

package/src/lib/claude-code-bridge.js

@@ -13,11 +13,14 @@
  *   ], { cwd: "/path/to/project" });
  */
 
-import { spawn, execSync } from "child_process";
 import { EventEmitter } from "events";
+import executionBroker from "./process-execution-broker/index.js";
 
 /* ---------- _deps injection (Vitest CJS mock pattern) ---------- */
-export const _deps = { spawn, execSync };
+export const _deps = {
+  spawn: executionBroker.spawn.bind(executionBroker),
+  execSync: executionBroker.execSync.bind(executionBroker),
+};
 
 // ─── Agent status constants ───────────────────────────────────────
 
@@ -36,6 +39,19 @@ export const AGENT_STATUS = {
 // only thing _parseStreamJson needs — is at the end.
 export const MAX_AGENT_OUTPUT_BYTES = 32 * 1024 * 1024;
 
+function detectCliVersion(command) {
+  return _deps
+    .execSync(`${command} --version`, {
+      encoding: "utf-8",
+      timeout: 5000,
+      origin: `claude-code-bridge:detect-${command}`,
+      policy: "allow",
+      scope: "orchestrator",
+      shell: true,
+    })
+    .trim();
+}
+
 // ─── Detection ───────────────────────────────────────────────────
 
 /**
@@ -44,9 +60,7 @@ export const MAX_AGENT_OUTPUT_BYTES = 32 * 1024 * 1024;
  */
 export function detectClaudeCode() {
   try {
-    const version = _deps
-      .execSync("claude --version", { encoding: "utf-8", timeout: 5000 })
-      .trim();
+    const version = detectCliVersion("claude");
     return { found: true, version };
   } catch (_err) {
     return { found: false };
@@ -59,9 +73,7 @@ export function detectClaudeCode() {
  */
 export function detectCodex() {
   try {
-    const version = _deps
-      .execSync("codex --version", { encoding: "utf-8", timeout: 5000 })
-      .trim();
+    const version = detectCliVersion("codex");
     return { found: true, version };
   } catch (_err) {
     return { found: false };
@@ -152,6 +164,10 @@ export class ClaudeCodeAgent extends EventEmitter {
         cwd,
         env: { ...process.env },
         windowsHide: true,
+        origin: "claude-code-bridge:agent",
+        policy: "allow",
+        scope: "orchestrator",
+        shell: false,
       });
       this._proc = proc;
 

package/src/lib/cli-anything-bridge.js

@@ -8,13 +8,27 @@
  * that the existing 4-layer skill-loader picks up automatically.
  */
 
-import { execSync } from "child_process";
 import fs from "fs";
 import path from "path";
 import { getElectronUserDataDir } from "./paths.js";
+import executionBroker from "./process-execution-broker/index.js";
 
 /* ---------- _deps injection (Vitest CJS mock pattern) ---------- */
-export const _deps = { execSync, fs, path };
+export const _deps = {
+  execFileSync: executionBroker.execFileSync.bind(executionBroker),
+  fs,
+  path,
+};
+
+function execCliAnything(file, args, options, origin) {
+  return _deps.execFileSync(file, args, {
+    ...options,
+    origin,
+    policy: "allow",
+    scope: "cli-anything",
+    shell: false,
+  });
+}
 
 /* ----------------------------------------------------------------
  * Database helpers
@@ -55,13 +69,16 @@ export function detectPython() {
 
   for (const cmd of candidates) {
     try {
-      const ver = _deps
-        .execSync(`${cmd} --version`, {
+      const ver = execCliAnything(
+        cmd,
+        ["--version"],
+        {
           encoding: "utf-8",
           timeout: 10000,
           stdio: ["pipe", "pipe", "pipe"],
-        })
-        .trim();
+        },
+        "cli-anything:detect-python",
+      ).trim();
       const match = ver.match(/Python\s+([\d.]+)/i);
       if (match) {
         return { found: true, command: cmd, version: match[1] };
@@ -82,11 +99,16 @@ export function detectCliAnything() {
   if (!py.found) return { installed: false };
 
   try {
-    const out = _deps.execSync(`${py.command} -m pip show cli-anything`, {
-      encoding: "utf-8",
-      timeout: 15000,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
+    const out = execCliAnything(
+      py.command,
+      ["-m", "pip", "show", "cli-anything"],
+      {
+        encoding: "utf-8",
+        timeout: 15000,
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+      "cli-anything:detect-package",
+    );
     const verMatch = out.match(/Version:\s*([\d.]+)/i);
     return {
       installed: true,
@@ -102,11 +124,16 @@ export function detectCliAnything() {
  * Install CLI-Anything via pip.
  */
 export function installCliAnything(pythonCmd) {
-  _deps.execSync(`${pythonCmd} -m pip install cli-anything`, {
-    encoding: "utf-8",
-    timeout: 120000,
-    stdio: "inherit",
-  });
+  execCliAnything(
+    pythonCmd,
+    ["-m", "pip", "install", "cli-anything"],
+    {
+      encoding: "utf-8",
+      timeout: 120000,
+      stdio: "inherit",
+    },
+    "cli-anything:install",
+  );
 }
 
 /* ----------------------------------------------------------------
@@ -152,11 +179,16 @@ export function scanPathForTools() {
 export function parseToolHelp(command) {
   let helpText;
   try {
-    helpText = _deps.execSync(`${command} --help`, {
-      encoding: "utf-8",
-      timeout: 15000,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
+    helpText = execCliAnything(
+      command,
+      ["--help"],
+      {
+        encoding: "utf-8",
+        timeout: 15000,
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+      "cli-anything:tool-help",
+    );
   } catch (err) {
     const raw = err.stdout || err.stderr || "";
     helpText = typeof raw === "string" ? raw : raw.toString("utf-8");
@@ -252,19 +284,44 @@ Pass the subcommand and arguments as plain text input:
  */
 export function _generateHandlerJs(name, command) {
   return `"use strict";
-const { execSync } = require("child_process");
+const CLI_COMMAND = ${JSON.stringify(command)};
+
+function parseArgs(input) {
+  const args = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (const ch of input.trim()) {
+    if (ch === "'" && !inDouble) { inSingle = !inSingle; continue; }
+    if (ch === '"' && !inSingle) { inDouble = !inDouble; continue; }
+    if (/\\s/.test(ch) && !inSingle && !inDouble) {
+      if (current) { args.push(current); current = ""; }
+      continue;
+    }
+    current += ch;
+  }
+  if (inSingle || inDouble) return null;
+  if (current) args.push(current);
+  return args;
+}
 
 module.exports = {
   async execute(task, context) {
     const input = (task?.params?.input || task?.action || "").trim();
     if (!input) return { success: false, error: "No input provided" };
-    // Security: input is interpolated into a shell command, so reject shell
-    // metacharacters to prevent command injection from untrusted skill input.
+    // Keep the historical shell-character guard for generated-handler
+    // compatibility even though the Broker now receives literal argv.
     if (/[;&|\`$<>()\\n\\r]/.test(input)) {
       return { success: false, error: "Input contains unsafe shell characters; refused." };
     }
+    const args = parseArgs(input);
+    if (!args) return { success: false, error: "Input contains an unmatched quote; refused." };
+    const processBroker = context?.processBroker;
+    if (!processBroker || typeof processBroker.runFileSync !== "function") {
+      return { success: false, error: "Process Broker unavailable for skill execution." };
+    }
     try {
-      const output = execSync(\`${command} \${input}\`, {
+      const output = processBroker.runFileSync(CLI_COMMAND, args, {
         encoding: "utf-8",
         timeout: 60000,
         cwd: context?.projectRoot || process.cwd(),

package/src/lib/doctor-checkup.js

@@ -23,9 +23,9 @@ import {
   statSync,
   rmSync,
 } from "node:fs";
-import { execSync, spawnSync } from "node:child_process";
 import { join, basename } from "node:path";
 import { getHomeDir, getConfigPath } from "./paths.js";
+import executionBroker from "./process-execution-broker/index.js";
 import {
   languageIdForFile,
   resolveServer,
@@ -59,8 +59,8 @@ export const _deps = {
   readFileSync,
   statSync,
   rmSync,
-  execSync,
-  spawnSync,
+  execFileSync: (...args) => executionBroker.execFileSync(...args),
+  spawnSync: (...args) => executionBroker.spawnSync(...args),
   now: () => Date.now(),
 };
 
@@ -549,10 +549,14 @@ async function worktreeSection(opts, deps) {
   try {
     const inRepo = (() => {
       try {
-        deps.execSync("git rev-parse --is-inside-work-tree", {
+        deps.execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
           cwd,
           encoding: "utf-8",
           stdio: ["ignore", "pipe", "ignore"],
+          origin: "doctor:git-worktree",
+          policy: "allow",
+          scope: "diagnostics",
+          shell: false,
         });
         return true;
       } catch {
@@ -570,10 +574,14 @@ async function worktreeSection(opts, deps) {
       );
     } else {
       const out =
-        deps.execSync("git worktree prune --dry-run -v", {
+        deps.execFileSync("git", ["worktree", "prune", "--dry-run", "-v"], {
           cwd,
           encoding: "utf-8",
           stdio: ["ignore", "pipe", "ignore"],
+          origin: "doctor:git-worktree",
+          policy: "allow",
+          scope: "diagnostics",
+          shell: false,
         }) || "";
       const prunable = out.split("\n").filter((l) => l.trim()).length;
       if (prunable > 0) {
@@ -1138,10 +1146,14 @@ export async function runCheckupFixes(sections, opts = {}) {
           detail: `removed ${removed} file(s)`,
         });
       } else if (fix.id === "git-worktree-prune") {
-        deps.execSync("git worktree prune", {
+        deps.execFileSync("git", ["worktree", "prune"], {
           cwd: opts.cwd || process.cwd(),
           encoding: "utf-8",
           stdio: ["ignore", "pipe", "ignore"],
+          origin: "doctor:git-worktree-fix",
+          policy: "allow",
+          scope: "diagnostics",
+          shell: false,
         });
         results.push({
           id: fix.id,

package/src/lib/eval/tasks.js

@@ -11,7 +11,24 @@
 
 import fs from "fs";
 import path from "path";
-import { execFileSync } from "node:child_process";
+import executionBroker from "../process-execution-broker/index.js";
+
+export const _deps = {
+  execFileSync: (...args) => executionBroker.execFileSync(...args),
+};
+
+function runTaskCheck(dir, script, options = {}) {
+  return _deps.execFileSync(process.execPath, [script], {
+    cwd: dir,
+    timeout: 10000,
+    stdio: ["ignore", "pipe", "pipe"],
+    ...options,
+    origin: "eval:task-check",
+    policy: "allow",
+    scope: "eval",
+    shell: false,
+  });
+}
 
 function read(dir, rel) {
   try {
@@ -97,11 +114,8 @@ export const BUILTIN_TASKS = [
       // Objective check: it must parse AND print OK. Re-run in a child so we
       // score the actual behavior, not a heuristic on the source.
       try {
-        const out = execFileSync(process.execPath, ["bug.js"], {
-          cwd: dir,
+        const out = runTaskCheck(dir, "bug.js", {
           encoding: "utf8",
-          timeout: 10000,
-          stdio: ["ignore", "pipe", "pipe"], // capture stderr, don't inherit
         });
         return out.trim() === "OK"
           ? { pass: true, detail: "node bug.js prints OK" }
@@ -186,11 +200,8 @@ export const BUILTIN_TASKS = [
         };
       }
       try {
-        const out = execFileSync(process.execPath, ["run-checks.mjs"], {
-          cwd: dir,
+        const out = runTaskCheck(dir, "run-checks.mjs", {
           encoding: "utf8",
-          timeout: 10000,
-          stdio: ["ignore", "pipe", "pipe"],
         });
         return out.includes("ALL OK")
           ? { pass: true, detail: "test suite passes" }
@@ -243,11 +254,8 @@ export const BUILTIN_TASKS = [
       }
       // Behavior must be preserved: run main.js and check the output.
       try {
-        const out = execFileSync(process.execPath, ["main.js"], {
-          cwd: dir,
+        const out = runTaskCheck(dir, "main.js", {
           encoding: "utf8",
-          timeout: 10000,
-          stdio: ["ignore", "pipe", "pipe"],
         });
         return out.trim() === "6"
           ? { pass: true, detail: "renamed + behavior preserved" }
@@ -290,12 +298,7 @@ export const BUILTIN_TASKS = [
       if (read(dir, "verify.mjs") == null) {
         return { pass: false, detail: "verify.mjs not created" };
       }
-      const run = () =>
-        execFileSync(process.execPath, ["verify.mjs"], {
-          cwd: dir,
-          timeout: 10000,
-          stdio: ["ignore", "pipe", "pipe"],
-        });
+      const run = () => runTaskCheck(dir, "verify.mjs");
       // 1) The verifier must PASS against the correct implementation.
       try {
         run();
@@ -383,11 +386,8 @@ export const BUILTIN_TASKS = [
         };
       }
       try {
-        const out = execFileSync(process.execPath, ["app.mjs"], {
-          cwd: dir,
+        const out = runTaskCheck(dir, "app.mjs", {
           encoding: "utf8",
-          timeout: 10000,
-          stdio: ["ignore", "pipe", "pipe"],
         }).trim();
         return out === "Hello, Ada!\nHello, Bob!!!"
           ? { pass: true, detail: "signature migrated + callers updated" }
@@ -525,11 +525,8 @@ export const BUILTIN_TASKS = [
         };
       }
       try {
-        const out = execFileSync(process.execPath, ["build.mjs"], {
-          cwd: dir,
+        const out = runTaskCheck(dir, "build.mjs", {
           encoding: "utf8",
-          timeout: 10000,
-          stdio: ["ignore", "pipe", "pipe"],
         });
         return out.includes("BUILD OK")
           ? { pass: true, detail: "build links + passes" }
@@ -620,11 +617,8 @@ export const BUILTIN_TASKS = [
         return { pass: false, detail: "app.mjs does not use the new toTitle" };
       }
       try {
-        const out = execFileSync(process.execPath, ["run.mjs"], {
-          cwd: dir,
+        const out = runTaskCheck(dir, "run.mjs", {
           encoding: "utf8",
-          timeout: 10000,
-          stdio: ["ignore", "pipe", "pipe"],
         });
         return out.trim() === "OK"
           ? { pass: true, detail: "adapted to new API + manifest bumped" }