chainlesschain 0.162.176 → 0.162.178

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/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,7 +13,6 @@
  * 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";
@@ -22,7 +21,9 @@ 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 {
   /**
@@ -88,10 +89,11 @@ export class LSPClient extends EventEmitter {
       shell: false,
       windowsHide: true,
       windowsVerbatimArguments: spawnSpec.windowsVerbatimArguments,
+      origin: this.origin || "lsp:server",
+      policy: "allow",
+      scope: "lsp",
       ...(this.origin
         ? {
-            origin: this.origin,
-            policy: "allow",
             pluginId: this.pluginId,
             pluginVersion: this.pluginVersion,
             pluginSource: this.pluginSource,

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

package/src/lib/operation-fingerprint.js

@@ -244,10 +244,11 @@ export function resolveOperationApproval(pending, resolution, opts = {}) {
  * fs/RNG — so it is fully unit-testable and serializable alongside a session.
  */
 export class OperationApprovalRegistry {
-  constructor({ clock } = {}) {
+  constructor({ clock, store = null } = {}) {
     this._byFingerprint = new Map(); // fingerprint -> pending record
     this._activeByLogicalKey = new Map(); // logical key -> active fingerprint
     this._clock = typeof clock === "function" ? clock : null;
+    this._store = store;
   }
 
   _now() {
@@ -260,10 +261,40 @@ export class OperationApprovalRegistry {
    * can resolve.
    * @returns {{fingerprint:string, shortId:string, summary:string}}
    */
-  issue(desc = {}) {
+  issue(desc = {}, opts = {}) {
     const fingerprint = computeOperationFingerprint(desc);
     const logicalKey = operationDescriptorKey(desc);
 
+    if (this._store) {
+      const card = this._store.issueRequest({
+        requestId: opts.requestId,
+        descriptor: desc,
+        binding: opts.binding,
+        now: opts.now !== undefined ? opts.now : this._now(),
+      });
+      this._byFingerprint.set(card.fingerprint, {
+        fingerprint: card.fingerprint,
+        logicalKey,
+        requestId: card.requestId,
+        binding: opts.binding,
+        sessionId: desc.session ?? null,
+        revision: card.revision,
+        status: card.status,
+      });
+      this._activeByLogicalKey.set(logicalKey, card.fingerprint);
+      return card;
+    }
+
+    // Reissuing the exact same card must never reset a resolved record.
+    const exact = this._byFingerprint.get(fingerprint);
+    if (exact) {
+      return {
+        fingerprint,
+        shortId: shortOperationId(fingerprint),
+        summary: summarizeOperation(desc),
+      };
+    }
+
     const priorFp = this._activeByLogicalKey.get(logicalKey);
     if (priorFp && priorFp !== fingerprint) {
       const prior = this._byFingerprint.get(priorFp);
@@ -296,6 +327,37 @@ export class OperationApprovalRegistry {
    * @returns {{ok:boolean, reason:(string|null)}}
    */
   resolve(fingerprint, opts = {}) {
+    if (this._store) {
+      const cached = this._byFingerprint.get(fingerprint);
+      const requestId = opts.requestId ?? cached?.requestId;
+      if (!requestId) {
+        return { ok: false, approved: false, reason: "unknown" };
+      }
+      try {
+        const verdict = this._store.resolveRequest(requestId, {
+          fingerprint: opts.fingerprint,
+          binding: opts.binding,
+          sessionId: opts.sessionId,
+          decision: opts.decision,
+          authority: opts.authority,
+          expectedRevision: opts.expectedRevision,
+          now: opts.now !== undefined ? opts.now : this._now(),
+        });
+        if (verdict.ok && cached) {
+          cached.status = verdict.approved ? "resolved" : "rejected";
+          cached.revision = verdict.revision;
+        }
+        return verdict;
+      } catch (error) {
+        return {
+          ok: false,
+          approved: false,
+          reason: "state-unavailable",
+          errorCode: error?.code || "CC_APPROVAL_STATE_UNKNOWN",
+        };
+      }
+    }
+
     const pending = this._byFingerprint.get(fingerprint);
     if (!pending) return { ok: false, reason: "unknown" };
     const now = opts.now !== undefined ? intOrNull(opts.now) : this._now();
@@ -304,9 +366,52 @@ export class OperationApprovalRegistry {
     return verdict;
   }
 
+  /**
+   * Persist a timeout/close transition. It can only reduce authority.
+   */
+  cancel(fingerprint, opts = {}) {
+    if (this._store) {
+      const cached = this._byFingerprint.get(fingerprint);
+      const requestId = opts.requestId ?? cached?.requestId;
+      if (!requestId) {
+        return { ok: false, approved: false, reason: "unknown" };
+      }
+      try {
+        const verdict = this._store.cancelRequest(requestId, {
+          expectedRevision: opts.expectedRevision ?? cached?.revision,
+          reason: opts.reason,
+          now: opts.now !== undefined ? opts.now : this._now(),
+        });
+        if (verdict.ok && cached) {
+          cached.status =
+            verdict.reason === "expired" ? "expired" : "cancelled";
+          cached.revision = verdict.revision;
+        }
+        return verdict;
+      } catch (error) {
+        return {
+          ok: false,
+          approved: false,
+          reason: "state-unavailable",
+          errorCode: error?.code || "CC_APPROVAL_STATE_UNKNOWN",
+        };
+      }
+    }
+
+    const pending = this._byFingerprint.get(fingerprint);
+    if (!pending) return { ok: false, reason: "unknown" };
+    if (pending.resolved) return { ok: false, reason: "duplicate" };
+    pending.resolved = true;
+    return { ok: true, approved: false, reason: opts.reason || "cancelled" };
+  }
+
   /** A read-only view of a pending card (or null). */
   get(fingerprint) {
     const p = this._byFingerprint.get(fingerprint);
+    if (this._store && p?.requestId) {
+      const durable = this._store.getRequest(p.requestId);
+      return durable ? { ...durable } : null;
+    }
     return p ? { ...p } : null;
   }
 }

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/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/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/pdh-dedicated-batch-collectors.js

@@ -0,0 +1,124 @@
+const DEDICATED_COLLECTOR_METHODS = Object.freeze({
+  "social-bilibili": "bilibiliAdbSync",
+  "social-weibo": "weiboAdbSync",
+  "social-douyin": "douyinAdbSync",
+  "social-xiaohongshu": "xhsAdbSync",
+  "social-toutiao": "toutiaoAdbSync",
+  "social-kuaishou": "kuaishouAdbSync",
+});
+
+function emptyFailureReport(report, error) {
+  return {
+    adapter: report?.adapter || "unknown",
+    status: "error",
+    rawCount: 0,
+    archivedRawCount: 0,
+    archiveFailureCount: 0,
+    entityCounts: {
+      events: 0,
+      persons: 0,
+      places: 0,
+      items: 0,
+      topics: 0,
+    },
+    invalidCount: 0,
+    kgTripleCount: 0,
+    ragDocCount: 0,
+    durationMs: 0,
+    error,
+    watermark: null,
+    watermarkDeferred: false,
+    checkpointCommitted: false,
+    pageBudget: null,
+    nextPageBudget: null,
+    scanDeferredCount: 0,
+    watermarkLookbackMs: 0,
+    collectionSinceWatermark: null,
+    attemptCount: 0,
+    retryCount: 0,
+    totalRetryDelayMs: 0,
+    retryExhausted: false,
+    retryAfterMs: null,
+    rateLimitReason: null,
+    rateLimitRemainingMinute: null,
+    rateLimitRemainingDay: null,
+    sourceRequestCount: 0,
+    sourceRequestThrottleMs: 0,
+    sourceRequestRateLimitRemainingMinute: null,
+    sourceRequestRateLimitRemainingDay: null,
+  };
+}
+
+function emit(hub, event) {
+  const listener = hub?.registry?.onSyncEvent;
+  if (typeof listener !== "function") return;
+  try {
+    listener(event);
+  } catch (_error) {
+    // Collection results must not depend on a progress listener.
+  }
+}
+
+/**
+ * Replace Registry `DEDICATED_COLLECTOR_REQUIRED` skips with host-level ADB
+ * collector results. The Registry stays host-agnostic; CLI/WS shells own the
+ * cookie extraction, signing bridges, and rooted-device collectors.
+ */
+export async function runDedicatedBatchCollectors(hub, reports) {
+  if (!Array.isArray(reports)) return reports;
+  const resolved = [...reports];
+
+  for (let index = 0; index < resolved.length; index += 1) {
+    const skipped = resolved[index];
+    if (
+      skipped?.status !== "skipped" ||
+      skipped?.skipReason !== "DEDICATED_COLLECTOR_REQUIRED"
+    ) {
+      continue;
+    }
+
+    const methodName = DEDICATED_COLLECTOR_METHODS[skipped.adapter];
+    const collect = methodName && hub?.[methodName];
+    if (typeof collect !== "function") continue;
+
+    emit(hub, {
+      kind: "sync.batch.dedicated.start",
+      adapter: skipped.adapter,
+      phase: "collecting",
+    });
+
+    let result;
+    try {
+      result = await collect.call(hub, {});
+    } catch (error) {
+      result = {
+        ok: false,
+        reason: "COLLECTOR_THREW",
+        message: error?.message || String(error),
+      };
+    }
+
+    if (result?.ok === true && result.report?.status === "ok") {
+      resolved[index] = result.report;
+    } else {
+      const reason = result?.reason || "DEDICATED_COLLECTOR_FAILED";
+      const message =
+        result?.message ||
+        result?.report?.error ||
+        "dedicated collector returned no successful SyncReport";
+      resolved[index] = emptyFailureReport(skipped, `${reason}: ${message}`);
+    }
+
+    emit(hub, {
+      kind: "sync.batch.dedicated.done",
+      adapter: skipped.adapter,
+      phase: resolved[index].status,
+      status: resolved[index].status,
+      error: resolved[index].error || null,
+    });
+  }
+
+  return resolved;
+}
+
+export { DEDICATED_COLLECTOR_METHODS };