chainlesschain 0.162.175 → 0.162.177

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,
@@ -225,24 +282,32 @@ function extractCliSections(bodyLines, header) {
  *
  * @returns {{ source: string, releases: Array }}
  */
-export function loadChangelog() {
+export function loadChangelog({
+  fsApi = fs,
+  pathApi = path,
+  dirname = __dirname,
+} = {}) {
   const changelogCandidates = [
-    path.join(__dirname, "..", "..", "CHANGELOG.md"), // packages/cli/CHANGELOG.md
-    path.join(__dirname, "..", "..", "..", "..", "CHANGELOG.md"), // repo root
+    pathApi.join(dirname, "..", "..", "CHANGELOG.md"), // packages/cli/CHANGELOG.md
+    pathApi.join(dirname, "..", "..", "..", "..", "CHANGELOG.md"), // repo root
   ];
   for (const p of changelogCandidates) {
-    if (fs.existsSync(p)) {
-      return {
-        source: "CHANGELOG.md",
-        releases: parseChangelog(fs.readFileSync(p, "utf-8")),
-      };
+    if (fsApi.existsSync(p)) {
+      const releases = parseChangelog(fsApi.readFileSync(p, "utf-8"));
+      // A parent-level CHANGELOG can exist in a global Node.js installation
+      // (for example C:\\nvm4w\\nodejs\\CHANGELOG.md).  Do not treat an
+      // unrelated, successfully-read file with zero CLI releases as the
+      // authoritative source; continue to the bundled artifact instead.
+      if (releases.length > 0) {
+        return { source: "CHANGELOG.md", releases };
+      }
     }
   }
   // Installed npm package: CHANGELOG.md isn't shipped, use the bundled artifact.
-  const jsonPath = path.join(__dirname, "..", "data", "changelog.json");
-  if (fs.existsSync(jsonPath)) {
+  const jsonPath = pathApi.join(dirname, "..", "data", "changelog.json");
+  if (fsApi.existsSync(jsonPath)) {
     try {
-      const data = JSON.parse(fs.readFileSync(jsonPath, "utf-8"));
+      const data = JSON.parse(fsApi.readFileSync(jsonPath, "utf-8"));
       if (Array.isArray(data.releases)) return data;
     } catch {
       /* fall through to empty */

package/src/lib/channels/channel-manager.js

@@ -20,6 +20,7 @@ import {
   canApprove,
   describeAuthorityChain,
 } from "../agent-authority.js";
+import { EventRuntimeStore } from "../event-runtime-store.js";
 
 export const CHANNEL_KINDS = ["webhook", "telegram"];
 
@@ -120,6 +121,9 @@ export async function startChannels(specsInput, opts = {}) {
   const config = opts.config || {};
   const log = opts.log || ((msg) => logger.info(msg));
   const deps = opts.deps || {};
+  const eventRuntimeStore =
+    opts.eventRuntimeStore ||
+    (process.env.CC_EVENT_RUNTIME_DURABLE === "1" ? new EventRuntimeStore() : null);
   // Every inbound event is stamped with its channel authority (`steer`, never
   // `approve`) before the caller's handler sees it — so a channel message can
   // never be mistaken for a user approval no matter what it contains.
@@ -149,6 +153,7 @@ export async function startChannels(specsInput, opts = {}) {
           port: spec.arg ? Number(spec.arg) : cfg.port,
           onEvent,
           log,
+          eventRuntimeStore,
         });
         started.push({ kind: "webhook", describe: handle.describe, ...handle });
       } else if (spec.kind === "telegram") {
@@ -161,6 +166,7 @@ export async function startChannels(specsInput, opts = {}) {
           ...cfg,
           onEvent,
           log,
+          eventRuntimeStore,
         });
         started.push({
           kind: "telegram",

package/src/lib/channels/telegram-channel.js

@@ -13,6 +13,7 @@
 
 const POLL_TIMEOUT_S = 25;
 const ERROR_BACKOFF_MS = 5000;
+import { EventRuntimeProducer } from "../event-runtime-producer.js";
 
 export async function startTelegramChannel(options = {}) {
   const {
@@ -27,7 +28,11 @@ export async function startTelegramChannel(options = {}) {
     // failures) can never turn the loop into a microtask chain that starves
     // the event loop (timers, stop()) entirely.
     pollPauseMs = 50,
+    eventRuntimeStore = null,
   } = options;
+  const runtimeProducer = eventRuntimeStore
+    ? new EventRuntimeProducer({ store: eventRuntimeStore })
+    : null;
 
   if (!botToken) {
     throw new Error(
@@ -65,12 +70,17 @@ export async function startTelegramChannel(options = {}) {
           if (!chatId || !text) continue;
           if (!allowed.has(String(chatId))) continue; // fail closed
           try {
-            onEvent?.({
+            const event = {
               channel: "telegram",
               sender: String(chatId),
               text,
               meta: { updateId: update.update_id },
+            };
+            runtimeProducer?.publish(event, {
+              origin: "telegram",
+              id: `telegram:${update.update_id}`,
             });
+            onEvent?.(event);
           } catch {
             /* downstream owns its failures */
           }

package/src/lib/channels/webhook-channel.js

@@ -17,6 +17,7 @@
 
 import { createServer } from "node:http";
 import { randomBytes, timingSafeEqual } from "node:crypto";
+import { EventRuntimeProducer } from "../event-runtime-producer.js";
 
 const MAX_BODY_BYTES = 64 * 1024;
 
@@ -34,7 +35,11 @@ export async function startWebhookChannel(options = {}) {
     allowlist,
     onEvent,
     log = () => {},
+    eventRuntimeStore = null,
   } = options;
+  const runtimeProducer = eventRuntimeStore
+    ? new EventRuntimeProducer({ store: eventRuntimeStore })
+    : null;
 
   const isLoopback =
     host === "127.0.0.1" || host === "::1" || host === "localhost";
@@ -92,8 +97,7 @@ export async function startWebhookChannel(options = {}) {
           return respond(403, { error: "sender not in allowlist" });
         }
       }
-      try {
-        onEvent?.({
+      const event = {
           channel: "webhook",
           sender,
           text,
@@ -101,9 +105,17 @@ export async function startWebhookChannel(options = {}) {
             payload.meta && typeof payload.meta === "object"
               ? payload.meta
               : undefined,
+        };
+      try {
+        runtimeProducer?.publish(event, {
+          origin: "webhook",
+          id: payload.event_id || payload.eventId || null,
         });
+        onEvent?.(event);
       } catch {
-        /* the session queue owns downstream failures */
+        // A configured durable runtime is the recovery boundary. Refuse the
+        // request rather than acknowledging an event that was not persisted.
+        if (runtimeProducer) return respond(503, { error: "event persistence unavailable" });
       }
       respond(202, { ok: true });
     });

package/src/lib/checkpoint-store.js

@@ -18,9 +18,13 @@
  * is. When it is not, callers should fall back / report unavailable.
  */
 
-import { spawnSync } from "node:child_process";
 import { rmSync } from "node:fs";
 import path from "node:path";
+import executionBroker from "./process-execution-broker/index.js";
+
+export const _deps = {
+  spawnSync: (...args) => executionBroker.spawnSync(...args),
+};
 
 const REF_NS = "refs/cc-checkpoints";
 // Deterministic identity for shadow commits so `git commit-tree` never trips on
@@ -41,7 +45,11 @@ const CHECKPOINT_IDENTITY = Object.freeze({
  * @throws {Error} with git's stderr when the command fails
  */
 function git(args, { cwd, env, input } = {}) {
-  const res = spawnSync("git", args, {
+  const res = _deps.spawnSync("git", args, {
+    origin: "checkpoint:git",
+    scope: "checkpoint",
+    policy: "allow",
+    shell: false,
     cwd,
     input,
     encoding: "utf-8",

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/cloud/bundle.js

@@ -7,13 +7,23 @@
  * a repo.
  */
 
-import { execFileSync } from "node:child_process";
 import { writeFileSync, mkdtempSync } from "node:fs";
 import { readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { executionBroker } from "../process-execution-broker/index.js";
 
-export const _deps = { execFileSync };
+function brokerExecFileSync(file, args, options) {
+  return executionBroker.execFileSync(file, args, {
+    ...options,
+    origin: "cloud:git",
+    policy: "allow",
+    scope: "cloud",
+    shell: false,
+  });
+}
+
+export const _deps = { execFileSync: brokerExecFileSync };
 
 function git(args, cwd, deps = _deps) {
   return deps

package/src/lib/code-review.js

@@ -4,8 +4,37 @@
  * @module lib/code-review
  */
 
-import { execSync } from "child_process";
 import { logger } from "./logger.js";
+import { executionBroker } from "./process-execution-broker/index.js";
+
+export const _deps = {
+  execFileSync: (...args) => executionBroker.execFileSync(...args),
+};
+
+export function buildGitDiffArgs(
+  target = "--staged",
+  { nameOnly = false } = {},
+) {
+  const args = ["diff"];
+  if (nameOnly) args.push("--name-only");
+  if (target === "--staged" || target === "--cached") {
+    args.push(target);
+  } else {
+    args.push("--end-of-options", String(target), "--");
+  }
+  return args;
+}
+
+function gitDiff(target, options = {}) {
+  return _deps.execFileSync("git", buildGitDiffArgs(target, options), {
+    encoding: "utf8",
+    maxBuffer: 10 * 1024 * 1024,
+    origin: "review:git-diff",
+    policy: "allow",
+    scope: "review",
+    shell: false,
+  });
+}
 
 /**
  * Get git diff for review
@@ -14,10 +43,7 @@ import { logger } from "./logger.js";
  */
 export function getGitDiff(target = "--staged") {
   try {
-    return execSync(`git diff ${target}`, {
-      encoding: "utf8",
-      maxBuffer: 10 * 1024 * 1024,
-    });
+    return gitDiff(target);
   } catch (err) {
     logger.error(`Failed to get git diff: ${err.message}`);
     return "";
@@ -31,9 +57,7 @@ export function getGitDiff(target = "--staged") {
  */
 export function getChangedFiles(target = "--staged") {
   try {
-    const output = execSync(`git diff ${target} --name-only`, {
-      encoding: "utf8",
-    });
+    const output = gitDiff(target, { nameOnly: true });
     return output.trim().split("\n").filter(Boolean);
   } catch (err) {
     logger.error(`Failed to get changed files: ${err.message}`);

package/src/lib/computer-use/control-backend.js

@@ -7,16 +7,27 @@
  * project's U-Key/hardware posture.
  */
 
-import { spawnSync } from "node:child_process";
+import executionBroker from "../process-execution-broker/index.js";
 
-export const _deps = { spawnSync, platform: () => process.platform };
+export const _deps = {
+  spawnSync: (...args) => executionBroker.spawnSync(...args),
+  platform: () => process.platform,
+};
 
 /** Run a PowerShell script, returning { ok, stdout, stderr }. */
 function runPowerShell(script, deps = _deps) {
   const res = deps.spawnSync(
     "powershell.exe",
     ["-NoProfile", "-NonInteractive", "-Command", script],
-    { encoding: "utf-8", windowsHide: true, maxBuffer: 16 * 1024 * 1024 },
+    {
+      encoding: "utf-8",
+      windowsHide: true,
+      maxBuffer: 16 * 1024 * 1024,
+      origin: "computer-use:powershell",
+      scope: "computer-use",
+      policy: "allow",
+      shell: false,
+    },
   );
   if (res.error) return { ok: false, stdout: "", stderr: res.error.message };
   return {
@@ -140,6 +151,10 @@ export function createWindowsBackend(deps = _deps) {
           windowsHide: false,
           detached: true,
           stdio: "ignore",
+          origin: "computer-use:app-launch",
+          scope: "computer-use",
+          policy: "allow",
+          shell: false,
         });
         return res.error
           ? { ok: false, error: res.error.message }