chainlesschain 0.162.175 → 0.162.177

package/src/lib/lsp/__tests__/benchmark.test.js

@@ -8,6 +8,7 @@ import { describe, it, expect } from "vitest";
 import {
   percentile,
   summarize,
+  sampleRssDefault,
   sumSubtreeRss,
   sumSubtreeRssFromWmicCsv,
 } from "../benchmark.js";
@@ -86,3 +87,63 @@ describe("sumSubtreeRssFromWmicCsv", () => {
     expect(sumSubtreeRssFromWmicCsv("garbage\r\n", 100)).toBeNull();
   });
 });
+
+describe("sampleRssDefault", () => {
+  it("routes the POSIX process snapshot through the Broker contract", async () => {
+    const calls = [];
+    const execFileSync = (...args) => {
+      calls.push(args);
+      return "100 1 1024\n200 100 512\n400 1 9999\n";
+    };
+
+    await expect(
+      sampleRssDefault(100, { execFileSync, platform: "linux" }),
+    ).resolves.toBe(2);
+    expect(calls).toEqual([
+      [
+        "ps",
+        ["-o", "pid=,ppid=,rss="],
+        expect.objectContaining({
+          origin: "lsp:benchmark-rss",
+          policy: "allow",
+          scope: "lsp",
+          shell: false,
+        }),
+      ],
+    ]);
+  });
+
+  it("routes the Windows process snapshot through literal argv", async () => {
+    const calls = [];
+    const execFileSync = (...args) => {
+      calls.push(args);
+      return [
+        "Node,ParentProcessId,ProcessId,WorkingSetSize",
+        "HOST,1,100,1048576",
+        "HOST,100,200,1048576",
+      ].join("\r\n");
+    };
+
+    await expect(
+      sampleRssDefault(100, { execFileSync, platform: "win32" }),
+    ).resolves.toBe(2);
+    expect(calls).toEqual([
+      [
+        "wmic",
+        [
+          "process",
+          "get",
+          "ProcessId,ParentProcessId,WorkingSetSize",
+          "/format:csv",
+        ],
+        expect.objectContaining({
+          origin: "lsp:benchmark-rss",
+          policy: "allow",
+          scope: "lsp",
+          shell: false,
+          windowsHide: true,
+        }),
+      ],
+    ]);
+  });
+});

package/src/lib/lsp/__tests__/lsp-client.test.js

@@ -87,7 +87,12 @@ describe("LSPClient handshake", () => {
     expect(_deps.spawn).toHaveBeenCalledWith(
       "fake-lsp",
       ["--stdio"],
-      expect.objectContaining({ shell: false }),
+      expect.objectContaining({
+        origin: "lsp:server",
+        policy: "allow",
+        scope: "lsp",
+        shell: false,
+      }),
     );
   });
 

package/src/lib/lsp/__tests__/lsp-server-registry.test.js

@@ -109,6 +109,24 @@ describe("plugin server registration", () => {
     expect(s).toMatchObject({ id: "zls" });
   });
 
+  it("returns plugin provenance for Broker-enforced servers", () => {
+    registerLanguageServer({
+      languageId: "kotlin",
+      command: "kotlin-lsp",
+      pluginId: "p-kotlin",
+      pluginVersion: "1.2.3",
+      pluginSource: "/plugins/kotlin/.lsp.json",
+    });
+    const isWin = process.platform === "win32";
+    existsFor([path.join("/proj", "node_modules", ".bin", isWin ? "kotlin-lsp.cmd" : "kotlin-lsp")]);
+    expect(resolveServer("kotlin", "/proj")).toMatchObject({
+      origin: "plugin:lsp",
+      pluginId: "p-kotlin",
+      pluginVersion: "1.2.3",
+      pluginSource: "/plugins/kotlin/.lsp.json",
+    });
+  });
+
   it("rejects an incomplete registration", () => {
     expect(() => registerLanguageServer({ languageId: "x" })).toThrow(
       /requires/,

package/src/lib/lsp/benchmark.js

@@ -12,11 +12,13 @@
  */
 
 import { CodeIntelligence } from "./code-intelligence.js";
+import executionBroker from "../process-execution-broker/index.js";
 
 /** now() in fractional milliseconds — injectable for deterministic tests. */
 export const _deps = {
   now: () => Number(process.hrtime.bigint() / 1000n) / 1000,
   sampleRss: sampleRssDefault,
+  execFileSync: (...args) => executionBroker.execFileSync(...args),
 };
 
 /** p-th percentile (0..100) of an UNSORTED sample via linear interpolation. */
@@ -167,10 +169,12 @@ async function captureServerInfo(ci) {
  * lies. We sum the whole subtree. Returns null if it can't be read (never throws
  * — memory is a bonus metric, not load-bearing).
  */
-async function sampleRssDefault(pid) {
-  const { execFileSync } = await import("child_process");
+export async function sampleRssDefault(
+  pid,
+  { execFileSync = _deps.execFileSync, platform = process.platform } = {},
+) {
   try {
-    if (process.platform === "win32") {
+    if (platform === "win32") {
       // One snapshot of every process → parent map → sum the subtree at `pid`.
       const csv = execFileSync(
         "wmic",
@@ -180,7 +184,15 @@ async function sampleRssDefault(pid) {
           "ProcessId,ParentProcessId,WorkingSetSize",
           "/format:csv",
         ],
-        { encoding: "utf8", windowsHide: true, maxBuffer: 16 * 1024 * 1024 },
+        {
+          encoding: "utf8",
+          windowsHide: true,
+          maxBuffer: 16 * 1024 * 1024,
+          origin: "lsp:benchmark-rss",
+          policy: "allow",
+          scope: "lsp",
+          shell: false,
+        },
       );
       const bytes = sumSubtreeRssFromWmicCsv(csv, pid);
       return bytes != null ? Math.round(bytes / (1024 * 1024)) : null;
@@ -188,6 +200,10 @@ async function sampleRssDefault(pid) {
     // POSIX: not wrapped, so the pid is the real server. Sum pid + children.
     const out = execFileSync("ps", ["-o", "pid=,ppid=,rss="], {
       encoding: "utf8",
+      origin: "lsp:benchmark-rss",
+      policy: "allow",
+      scope: "lsp",
+      shell: false,
     });
     const rows = out
       .trim()

package/src/lib/lsp/lsp-client.js

@@ -13,15 +13,17 @@
  * does not intercept this file). Nothing here is language-specific.
  */
 
-import { spawn as nodeSpawn } from "child_process";
 import { EventEmitter } from "events";
 import { encodeMessage, MessageBuffer } from "./jsonrpc-stream.js";
+import { executionBroker } from "../process-execution-broker/index.js";
 
 const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
 const DEFAULT_INIT_TIMEOUT_MS = 30_000;
 
 // Injectable so unit tests can supply a fake child process.
-export const _deps = { spawn: nodeSpawn };
+export const _deps = {
+  spawn: (...args) => executionBroker.spawn(...args),
+};
 
 export class LSPClient extends EventEmitter {
   /**
@@ -41,6 +43,10 @@ export class LSPClient extends EventEmitter {
     this.env = opts.env || {};
     this.requestTimeoutMs = opts.requestTimeoutMs || DEFAULT_REQUEST_TIMEOUT_MS;
     this.capabilitiesOverride = opts.capabilities || null;
+    this.origin = opts.origin || null;
+    this.pluginId = opts.pluginId || null;
+    this.pluginVersion = opts.pluginVersion || null;
+    this.pluginSource = opts.pluginSource || null;
 
     this._child = null;
     this._buffer = new MessageBuffer();
@@ -73,13 +79,26 @@ export class LSPClient extends EventEmitter {
     // fix, so buildSpawnCommand rewrites them to an explicit `cmd.exe /d /s /c`
     // invocation with verbatim args — still no shell, still injection-safe.
     const spawnSpec = buildSpawnCommand(this.command, this.args);
-    this._child = _deps.spawn(spawnSpec.file, spawnSpec.args, {
+    const spawnFn = String(this.origin || "").startsWith("plugin:")
+      ? executionBroker.spawn.bind(executionBroker)
+      : _deps.spawn;
+    this._child = spawnFn(spawnSpec.file, spawnSpec.args, {
       cwd: this.rootPath,
       env: { ...process.env, ...this.env },
       stdio: ["pipe", "pipe", "pipe"],
       shell: false,
       windowsHide: true,
       windowsVerbatimArguments: spawnSpec.windowsVerbatimArguments,
+      origin: this.origin || "lsp:server",
+      policy: "allow",
+      scope: "lsp",
+      ...(this.origin
+        ? {
+            pluginId: this.pluginId,
+            pluginVersion: this.pluginVersion,
+            pluginSource: this.pluginSource,
+          }
+        : {}),
     });
 
     this._child.on("error", (err) => {

package/src/lib/lsp/lsp-manager.js

@@ -239,6 +239,10 @@ export class LSPManager {
       command: resolved.command,
       args: resolved.args,
       rootPath: projectRoot,
+      origin: resolved.origin,
+      pluginId: resolved.pluginId,
+      pluginVersion: resolved.pluginVersion,
+      pluginSource: resolved.pluginSource,
     });
     // Collect pushed diagnostics keyed by document, tracking publish count/time
     // so callers can wait for the project to load (first publish) and settle

package/src/lib/lsp/lsp-server-registry.js

@@ -14,11 +14,9 @@
 
 import fs from "fs";
 import path from "path";
-import { execFileSync } from "child_process";
 
 export const _deps = {
   existsSync: fs.existsSync,
-  execFileSync,
 };
 
 // Extension → LSP languageId. Kept small and explicit; unknown extensions get
@@ -95,6 +93,9 @@ export function registerLanguageServer(def) {
     bins: [def.command],
     argsFor: () => (Array.isArray(def.args) ? def.args : []),
     fromPlugin: true,
+    pluginId: def.pluginId || null,
+    pluginVersion: def.pluginVersion || null,
+    pluginSource: def.pluginSource || null,
   };
   const existing = pluginServers.get(def.languageId) || [];
   // De-dupe by server id so re-registering the same server (e.g. a reload)
@@ -147,6 +148,14 @@ export function resolveServer(languageId, projectRoot) {
           id: def.id,
           command,
           args: def.argsFor(bin),
+          ...(def.fromPlugin
+            ? {
+                origin: "plugin:lsp",
+                pluginId: def.pluginId,
+                pluginVersion: def.pluginVersion,
+                pluginSource: def.pluginSource,
+              }
+            : {}),
         };
       }
     }

package/src/lib/mcp-oauth.js

@@ -25,7 +25,7 @@ import pathDefault from "node:path";
 import { homedir as homedirDefault } from "node:os";
 import crypto from "node:crypto";
 import http from "node:http";
-import { spawn } from "node:child_process";
+import { executionBroker } from "./process-execution-broker/index.js";
 
 export const _deps = {
   fetch: (...a) => globalThis.fetch(...a),
@@ -35,7 +35,13 @@ export const _deps = {
   sha256: (s) => crypto.createHash("sha256").update(s).digest(),
   createServer: (h) => http.createServer(h),
   openBrowser: defaultOpenBrowser,
-  spawn: (...a) => spawn(...a),
+  spawn: (command, args, options) =>
+    executionBroker.spawn(command, args, {
+      ...options,
+      origin: "mcp:oauth-browser",
+      policy: "allow",
+      scope: "oauth",
+    }),
   now: () => Date.now(),
   // Backoff sleep seam (tests override with a no-op so the retry doesn't wait).
   sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),

package/src/lib/npm-invocation.js

@@ -0,0 +1,29 @@
+import path from "node:path";
+
+/**
+ * Resolve npm without asking a shell to interpret the platform shim.
+ *
+ * Windows npm installations expose `npm.cmd`, but Node cannot execute a CMD
+ * shim with `shell:false` (`spawnSync npm.cmd EINVAL`). The shim delegates to
+ * the npm CLI located beside node.exe, so invoke that JavaScript entrypoint
+ * through the current Node executable instead.
+ */
+export function resolveNpmInvocation({
+  platform = process.platform,
+  execPath = process.execPath,
+} = {}) {
+  if (platform !== "win32") {
+    return { command: "npm", prefixArgs: [] };
+  }
+
+  const npmCliPath = path.win32.join(
+    path.win32.dirname(execPath),
+    "node_modules",
+    "npm",
+    "bin",
+    "npm-cli.js",
+  );
+  return { command: execPath, prefixArgs: [npmCliPath] };
+}
+
+export default resolveNpmInvocation;

package/src/lib/orchestrator.js

@@ -22,15 +22,17 @@
  */
 
 import { EventEmitter } from "events";
-import { execSync } from "child_process";
 import crypto from "crypto";
 import { AgentRouter } from "./agent-router.js";
 import { NotificationManager } from "./notifiers/index.js";
 import { createChatFn } from "./cowork-adapter.js";
 import { firstBalancedJson } from "./json-schema-output.js";
+import executionBroker from "./process-execution-broker/index.js";
 
 /* ---------- _deps injection (Vitest CJS mock pattern) ---------- */
-export const _deps = { execSync };
+export const _deps = {
+  execSync: (...args) => executionBroker.execSync(...args),
+};
 
 // ─── Task statuses ────────────────────────────────────────────────
 export const TASK_STATUS = {
@@ -389,6 +391,10 @@ export class Orchestrator extends EventEmitter {
         // re-dispatch). Give CI output generous headroom.
         maxBuffer: 64 * 1024 * 1024,
         stdio: "pipe",
+        origin: "orchestrator:ci",
+        policy: "allow",
+        scope: "orchestrator",
+        shell: true,
       });
       return {
         pass: true,

package/src/lib/packer/pack-update-applier.js

@@ -27,7 +27,11 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { spawn } from "node:child_process";
+import executionBroker from "../process-execution-broker/index.js";
+
+export const _deps = {
+  spawn: (...args) => executionBroker.spawn(...args),
+};
 
 /**
  * @param {object} ctx
@@ -55,7 +59,7 @@ export async function scheduleReplace(ctx) {
     dryRun = false,
     platform = process.platform === "win32" ? "win32" : "posix",
     parentPid = process.pid,
-    spawnImpl = spawn,
+    spawnImpl = _deps.spawn,
   } = ctx;
 
   if (!newExePath || typeof newExePath !== "string") {
@@ -92,6 +96,10 @@ export async function scheduleReplace(ctx) {
     // Detach so the sidecar survives our process exit. `windowsHide: true`
     // keeps the cmd window from flashing — the replace itself is silent.
     const child = spawnImpl("cmd.exe", ["/c", sidecarPath], {
+      origin: "packer:update-sidecar",
+      scope: "pack-update",
+      policy: "allow",
+      shell: false,
       detached: true,
       stdio: "ignore",
       windowsHide: true,
@@ -123,6 +131,10 @@ export async function scheduleReplace(ctx) {
 
   if (restart) {
     const child = spawnImpl(targetExePath, process.argv.slice(2), {
+      origin: "packer:update-restart",
+      scope: "pack-update",
+      policy: "allow",
+      shell: false,
       detached: true,
       stdio: "ignore",
     });

package/src/lib/packer/pkg-runner.js

@@ -14,8 +14,12 @@
 import fs from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
-import { spawnSync } from "node:child_process";
 import { PackError, EXIT } from "./errors.js";
+import executionBroker from "../process-execution-broker/index.js";
+
+export const _deps = {
+  spawnSync: (...args) => executionBroker.spawnSync(...args),
+};
 
 /**
  * @param {object} ctx
@@ -47,12 +51,19 @@ export function runPkg(ctx) {
   ];
 
   log(`  [pkg] Running: ${pkgBin.runtime} ${args.join(" ")}`);
-  const res = spawnSync(pkgBin.runtime, args, {
+  const res = _deps.spawnSync(pkgBin.runtime, args, {
+    origin: "packer:pkg",
+    scope: "pack",
+    policy: "allow",
+    shell: false,
     cwd: path.dirname(pkgConfigFile),
     stdio: "inherit",
     windowsHide: true,
   });
 
+  if (res.error) {
+    throw new PackError(`Failed to start pkg: ${res.error.message}`, EXIT.PKG);
+  }
   if (res.status !== 0) {
     throw new PackError(
       `pkg exited with code ${res.status}. See output above for details.`,

package/src/lib/packer/precheck.js

@@ -5,9 +5,13 @@
 
 import fs from "node:fs";
 import path from "node:path";
-import { execSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { PackError, EXIT } from "./errors.js";
+import executionBroker from "../process-execution-broker/index.js";
+
+export const _deps = {
+  execFileSync: (...args) => executionBroker.execFileSync(...args),
+};
 
 const WINDOWS_RESERVED = new Set([
   "CON",
@@ -139,22 +143,35 @@ export function precheck(ctx) {
   let gitCommit = null;
   let dirty = false;
   let repoRoot = null;
+  const gitOptions = (cwd) => ({
+    origin: "packer:precheck-git",
+    scope: "pack",
+    policy: "allow",
+    shell: false,
+    cwd,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"],
+  });
   try {
-    repoRoot = execSync("git rev-parse --show-toplevel", {
-      cwd: projectRoot,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    gitCommit = execSync("git rev-parse --short HEAD", {
-      cwd: repoRoot,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    const status = execSync("git status --porcelain", {
-      cwd: repoRoot,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-    });
+    repoRoot = _deps
+      .execFileSync(
+        "git",
+        ["rev-parse", "--show-toplevel"],
+        gitOptions(projectRoot),
+      )
+      .trim();
+    gitCommit = _deps
+      .execFileSync(
+        "git",
+        ["rev-parse", "--short", "HEAD"],
+        gitOptions(repoRoot),
+      )
+      .trim();
+    const status = _deps.execFileSync(
+      "git",
+      ["status", "--porcelain"],
+      gitOptions(repoRoot),
+    );
     dirty = status.trim().length > 0;
   } catch (_e) {
     // Not a git repo — fine, leave the metadata null

package/src/lib/packer/smoke-runner.js

@@ -19,11 +19,15 @@
  * Called from `runPack()` as Phase 8 when `cliOpts.smokeTest !== false`.
  */
 
-import { spawn } from "node:child_process";
 import { createConnection } from "node:net";
 import http from "node:http";
 import path from "node:path";
 import { PackError, EXIT } from "./errors.js";
+import executionBroker from "../process-execution-broker/index.js";
+
+export const _deps = {
+  spawn: (...args) => executionBroker.spawn(...args),
+};
 
 const DEFAULT_BOOT_TIMEOUT_MS = 45_000;
 const DEFAULT_PROBE_TIMEOUT_MS = 5_000;
@@ -80,7 +84,10 @@ export async function smokeTestExe(ctx) {
   // artifacts are always .exe so this only kicks in during tests that use
   // a shim — kept here so the smoke-runner is self-testable.
   const needsShell = /\.(cmd|bat|sh)$/i.test(exePath);
-  const child = spawn(exePath, ["ui", "--no-open"], {
+  const child = _deps.spawn(exePath, ["ui", "--no-open"], {
+    origin: "packer:smoke-launch",
+    scope: "pack",
+    policy: "allow",
     env,
     stdio: ["ignore", "pipe", "pipe"],
     windowsHide: true,
@@ -116,9 +123,15 @@ export async function smokeTestExe(ctx) {
         // unrelated process tree that inherited the number (on CI: another
         // vitest worker or a test's helper child).
         if (child.exitCode !== null || child.signalCode !== null) return;
-        spawn("taskkill", ["/F", "/T", "/PID", String(child.pid)], {
-          stdio: "ignore",
-        }).unref();
+        _deps
+          .spawn("taskkill", ["/F", "/T", "/PID", String(child.pid)], {
+            origin: "packer:smoke-taskkill",
+            scope: "pack",
+            policy: "allow",
+            shell: false,
+            stdio: "ignore",
+          })
+          .unref();
       } else if (child.pid) {
         // Negative pid → the whole process group from the detached spawn above,
         // so a shell:true wrapper's exec'd/forked `node` grandchild dies too

package/src/lib/packer/web-panel-builder.js

@@ -10,8 +10,12 @@
 
 import fs from "node:fs";
 import path from "node:path";
-import { spawnSync } from "node:child_process";
 import { PackError, EXIT } from "./errors.js";
+import executionBroker from "../process-execution-broker/index.js";
+
+export const _deps = {
+  spawnSync: (...args) => executionBroker.spawnSync(...args),
+};
 
 /**
  * @param {object} ctx
@@ -50,11 +54,21 @@ export function ensureWebPanel(ctx) {
   if (needsBuild) {
     log("  [web-panel] Building Vue panel via 'npm run build:web-panel'...");
     const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
-    const res = spawnSync(npmCmd, ["run", "build:web-panel"], {
+    const res = _deps.spawnSync(npmCmd, ["run", "build:web-panel"], {
+      origin: "packer:web-panel-build",
+      scope: "pack",
+      policy: "allow",
+      shell: false,
       cwd: cliRoot,
       stdio: "inherit",
       windowsHide: true,
     });
+    if (res.error) {
+      throw new PackError(
+        `Failed to start 'npm run build:web-panel': ${res.error.message}`,
+        EXIT.WEB_PANEL,
+      );
+    }
     if (res.status !== 0) {
       throw new PackError(
         `'npm run build:web-panel' exited with code ${res.status}`,

package/src/lib/paths.js

@@ -5,7 +5,7 @@ import { CONFIG_DIR_NAME } from "../constants.js";
 import { getPlatform } from "./platform.js";
 
 export function getHomeDir() {
-  return join(homedir(), CONFIG_DIR_NAME);
+  return process.env.CHAINLESSCHAIN_HOME || join(homedir(), CONFIG_DIR_NAME);
 }
 
 export function getBinDir() {

package/src/lib/permission-rules.cjs

@@ -61,7 +61,7 @@ const TOOL_GROUPS = Object.freeze({
   grep: ["search_files"],
   glob: ["search_files"],
   write: ["write_file"],
-  edit: ["edit_file", "edit_file_hashed"],
+  edit: ["edit_file", "edit_file_hashed", "delete_file", "move_file"],
   webfetch: ["web_fetch"],
   websearch: ["web_search"],
   task: ["spawn_sub_agent"],
@@ -82,6 +82,8 @@ const PATH_TOOLS = new Set([
   "write_file",
   "edit_file",
   "edit_file_hashed",
+  "delete_file",
+  "move_file",
 ]);
 /** Tools whose match target is a URL. */
 const URL_TOOLS = new Set(["web_fetch"]);
@@ -354,6 +356,8 @@ const SUGGEST_UMBRELLA = Object.freeze({
   write_file: "Write",
   edit_file: "Edit",
   edit_file_hashed: "Edit",
+  delete_file: "Edit",
+  move_file: "Edit",
   web_fetch: "WebFetch",
   web_search: "WebSearch",
   spawn_sub_agent: "Task",