chainlesschain 0.162.188 → 0.162.193

package/src/lib/file-lines.js

@@ -0,0 +1,125 @@
+import { closeSync, fstatSync, openSync, readSync } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
+
+const DEFAULT_CHUNK_SIZE = 64 * 1024;
+
+function recordRead(ioMetrics, bytes) {
+  if (!ioMetrics || typeof ioMetrics !== "object") return;
+  ioMetrics.readCalls = Math.max(0, Number(ioMetrics.readCalls) || 0) + 1;
+  ioMetrics.bytesRead =
+    Math.max(0, Number(ioMetrics.bytesRead) || 0) + Math.max(0, bytes || 0);
+}
+
+/**
+ * Stream UTF-8 lines from a file without loading the whole file. The final
+ * unterminated fragment is yielded with `terminated:false`, which lets callers
+ * distinguish a crash tail from a normal record.
+ */
+export function* iterateFileLinesSync(
+  filePath,
+  {
+    chunkSize = DEFAULT_CHUNK_SIZE,
+    includeEmpty = false,
+    ioMetrics = null,
+  } = {},
+) {
+  const fd = openSync(filePath, "r");
+  const decoder = new StringDecoder("utf8");
+  const buffer = Buffer.allocUnsafe(Math.max(1024, chunkSize));
+  let pending = "";
+  let lineNo = 0;
+  try {
+    for (;;) {
+      const bytes = readSync(fd, buffer, 0, buffer.length, null);
+      if (bytes === 0) break;
+      recordRead(ioMetrics, bytes);
+      pending += decoder.write(buffer.subarray(0, bytes));
+      let newline;
+      while ((newline = pending.indexOf("\n")) >= 0) {
+        let line = pending.slice(0, newline);
+        if (line.endsWith("\r")) line = line.slice(0, -1);
+        pending = pending.slice(newline + 1);
+        lineNo += 1;
+        if (includeEmpty || line.length > 0) {
+          yield { line, lineNo, terminated: true };
+        }
+      }
+    }
+    pending += decoder.end();
+    if (pending.length > 0 || includeEmpty) {
+      lineNo += 1;
+      if (includeEmpty || pending.length > 0) {
+        yield { line: pending, lineNo, terminated: false };
+      }
+    }
+  } finally {
+    closeSync(fd);
+  }
+}
+
+/**
+ * Read UTF-8 lines newest-first using bounded memory. Lines are assembled as
+ * bytes before decoding so a multibyte character split across chunks remains
+ * intact. `terminated:false` marks only the physical tail fragment.
+ */
+export function* iterateFileLinesReverseSync(
+  filePath,
+  {
+    chunkSize = DEFAULT_CHUNK_SIZE,
+    includeEmpty = false,
+    ioMetrics = null,
+  } = {},
+) {
+  const fd = openSync(filePath, "r");
+  const size = fstatSync(fd).size;
+  let endsWithNewline = false;
+  if (size > 0) {
+    const last = Buffer.allocUnsafe(1);
+    const bytes = readSync(fd, last, 0, 1, size - 1);
+    recordRead(ioMetrics, bytes);
+    endsWithNewline = last[0] === 0x0a;
+  }
+  let position = size;
+  let carry = Buffer.alloc(0);
+  let isPhysicalTail = true;
+  try {
+    while (position > 0) {
+      const length = Math.min(Math.max(1024, chunkSize), position);
+      position -= length;
+      const chunk = Buffer.allocUnsafe(length);
+      const bytes = readSync(fd, chunk, 0, length, position);
+      recordRead(ioMetrics, bytes);
+      const combined = Buffer.concat([chunk, carry]);
+      let end = combined.length;
+      for (let index = combined.length - 1; index >= 0; index -= 1) {
+        if (combined[index] !== 0x0a) continue;
+        let bytes = combined.subarray(index + 1, end);
+        if (bytes.length > 0 && bytes[bytes.length - 1] === 0x0d) {
+          bytes = bytes.subarray(0, bytes.length - 1);
+        }
+        const line = bytes.toString("utf8");
+        const terminated = isPhysicalTail ? endsWithNewline : true;
+        // A file ending in "\n" produces one empty physical-tail slice. Skip
+        // it without changing the termination status of the real last line.
+        if (includeEmpty || line.length > 0) {
+          yield { line, terminated };
+          isPhysicalTail = false;
+        }
+        end = index;
+      }
+      carry = combined.subarray(0, end);
+    }
+    if (carry.length > 0 || includeEmpty) {
+      let bytes = carry;
+      if (bytes.length > 0 && bytes[bytes.length - 1] === 0x0d) {
+        bytes = bytes.subarray(0, bytes.length - 1);
+      }
+      const line = bytes.toString("utf8");
+      if (includeEmpty || line.length > 0) {
+        yield { line, terminated: !isPhysicalTail };
+      }
+    }
+  } finally {
+    closeSync(fd);
+  }
+}

package/src/lib/headless-config-command.js

@@ -16,6 +16,7 @@ import {
   renderConfigGet,
   renderConfigSet,
   renderConfigSummary,
+  isSecretConfigKey,
 } from "../repl/config-summary.js";
 
 /** Does this headless prompt start with the `/config` slash command? */
@@ -48,11 +49,21 @@ export function runConfigDirective(prompt, deps = {}) {
     };
   }
   if (cmd.action === "set") {
-    cm.setConfigValue(cmd.key, cmd.value);
-    return {
-      text: renderConfigSet(cmd.key, cm.getConfigValue(cmd.key)),
-      isError: false,
-    };
+    if (isSecretConfigKey(cmd.key)) {
+      return {
+        text: `/config: ${cmd.key} is secret; use cc config set-secret ${cmd.key}`,
+        isError: true,
+      };
+    }
+    try {
+      cm.setConfigValue(cmd.key, cmd.value);
+      return {
+        text: renderConfigSet(cmd.key, cm.getConfigValue(cmd.key)),
+        isError: false,
+      };
+    } catch (error) {
+      return { text: `/config: ${error.message}`, isError: true };
+    }
   }
   // show
   return {

package/src/lib/hook-runner.cjs

@@ -164,9 +164,20 @@ function tryParseDecision(stdout) {
     if (firstLine && firstLine[0] === "{") obj = tryJson(firstLine);
   }
   if (obj === undefined || obj === null || typeof obj !== "object") return null;
+  if (Array.isArray(obj)) {
+    return {
+      decision: HOOK_DECISIONS.CONTINUE,
+      reason: "hook decision payload must be a JSON object",
+      unsupportedDecision: true,
+    };
+  }
   // PreToolUse-specific permission decision
   const hso = obj.hookSpecificOutput;
-  if (hso && hso.permissionDecision) {
+  if (
+    hso &&
+    typeof hso === "object" &&
+    Object.prototype.hasOwnProperty.call(hso, "permissionDecision")
+  ) {
     const pd = String(hso.permissionDecision).toLowerCase();
     const decision =
       pd === "deny"
@@ -176,10 +187,17 @@ function tryParseDecision(stdout) {
           : pd === "allow"
             ? HOOK_DECISIONS.ALLOW
             : HOOK_DECISIONS.CONTINUE;
-    return { decision, reason: hso.permissionDecisionReason || null };
+    const supported = pd === "deny" || pd === "ask" || pd === "allow";
+    return {
+      decision,
+      reason: supported
+        ? hso.permissionDecisionReason || null
+        : `unsupported hook permissionDecision: ${pd || "<empty>"}`,
+      ...(supported ? {} : { unsupportedDecision: true }),
+    };
   }
   // Generic decision field
-  if (obj.decision) {
+  if (Object.prototype.hasOwnProperty.call(obj, "decision")) {
     const d = String(obj.decision).toLowerCase();
     const decision =
       d === "block" || d === "deny"
@@ -189,15 +207,37 @@ function tryParseDecision(stdout) {
           : d === "ask"
             ? HOOK_DECISIONS.ASK
             : HOOK_DECISIONS.CONTINUE;
-    return { decision, reason: obj.reason || null };
-  }
-  // continue:false → stop/block
-  if (obj.continue === false) {
+    const supported =
+      d === "block" ||
+      d === "deny" ||
+      d === "approve" ||
+      d === "allow" ||
+      d === "ask" ||
+      d === "continue";
     return {
-      decision: HOOK_DECISIONS.BLOCK,
-      reason: obj.stopReason || obj.reason || "hook requested stop",
+      decision,
+      reason: supported
+        ? obj.reason || null
+        : `unsupported hook decision: ${d || "<empty>"}`,
+      ...(supported ? {} : { unsupportedDecision: true }),
     };
   }
+  // continue:false → stop/block
+  if (Object.prototype.hasOwnProperty.call(obj, "continue")) {
+    if (obj.continue === false) {
+      return {
+        decision: HOOK_DECISIONS.BLOCK,
+        reason: obj.stopReason || obj.reason || "hook requested stop",
+      };
+    }
+    if (obj.continue !== true) {
+      return {
+        decision: HOOK_DECISIONS.CONTINUE,
+        reason: "hook continue field must be boolean",
+        unsupportedDecision: true,
+      };
+    }
+  }
   return {
     decision: HOOK_DECISIONS.CONTINUE,
     reason: null,
@@ -205,6 +245,42 @@ function tryParseDecision(stdout) {
   };
 }
 
+/**
+ * Upgrade an execution/protocol failure to a blocking authority decision.
+ * Direct command-hook calls and observe/Post aggregation retain their historic
+ * fail-open behavior; runHooks callers opt in with `{ failClosed: true }`.
+ * Keeping this conversion at the aggregation boundary also preserves the
+ * underlying nonBlockingError/breaker/protocol flags for audit telemetry.
+ */
+function failClosedAuthorityResult(result) {
+  const supportedDecision =
+    result && Object.values(HOOK_DECISIONS).includes(result.decision);
+  const authorityFailure =
+    !supportedDecision ||
+    result.nonBlockingError === true ||
+    result.breakerOpen === true ||
+    result.malformedDecision === true ||
+    result.unsupportedDecision === true;
+
+  if (!authorityFailure || result?.decision === HOOK_DECISIONS.BLOCK) {
+    return result;
+  }
+
+  const detail =
+    result?.reason ||
+    result?.error ||
+    (!supportedDecision
+      ? "hook returned an invalid decision result"
+      : "hook authority evaluation failed");
+  return {
+    ...(result || {}),
+    decision: HOOK_DECISIONS.BLOCK,
+    reason: `authority-bearing hook failed closed: ${detail}`,
+    authorityFailure: true,
+    originalDecision: supportedDecision ? result.decision : null,
+  };
+}
+
 /**
  * Run one command hook. `input` is JSON-serialized to the hook's stdin.
  *
@@ -676,6 +752,12 @@ async function _runCommandHookInnerAsync(command, input = {}, opts = {}) {
  * This closes the safety gap where an earlier hook's `ask` masks a LATER hook's
  * `block` (the short-circuit path returns `ask` and never runs the blocker).
  * Claude-Code parity: all matching hooks contribute to the merged decision.
+ *
+ * `opts.failClosed: true` (or its semantic alias `authorityBearing: true`)
+ * marks an authority-bearing decision path. It implies strict merge and
+ * upgrades spawn/timeout/breaker/protocol failures to BLOCK. The default
+ * remains fail-open for observe/Post hooks.
+ *
  * spawnSync is synchronous so execution is sequential — but the MERGE is
  * order-independent, so the outcome matches a parallel run.
  *
@@ -684,25 +766,32 @@ async function _runCommandHookInnerAsync(command, input = {}, opts = {}) {
 function runHooks(commandHooks, input = {}, opts = {}) {
   const results = [];
   const hooks = commandHooks || [];
+  const failClosed = opts.failClosed === true || opts.authorityBearing === true;
   const runOne = (h) => {
-    const sandboxPolicy = resolveHookSandboxPolicy(h, opts);
-    return runCommandHook(h.command, input, {
-      ...opts,
-      ...(sandboxPolicy ? { sandboxPolicy } : {}),
-      broker: opts.broker,
-      origin: h.origin,
-      pluginId: h.pluginId,
-      pluginVersion: h.pluginVersion,
-      pluginSource: h.pluginSource,
-      timeout: h.timeout != null ? h.timeout * 1000 : opts.timeout,
-      environmentAllowlist: h.environmentAllowlist || h.envAllowlist,
-      // per-hook shell selection (P1 #8): `{ "type":"command", "command":…,
-      // "shell":"powershell" }` in the settings hook entry
-      shell: h.shell != null ? h.shell : opts.shell,
-    });
+    try {
+      const sandboxPolicy = resolveHookSandboxPolicy(h, opts);
+      const result = runCommandHook(h.command, input, {
+        ...opts,
+        ...(sandboxPolicy ? { sandboxPolicy } : {}),
+        broker: opts.broker,
+        origin: h.origin,
+        pluginId: h.pluginId,
+        pluginVersion: h.pluginVersion,
+        pluginSource: h.pluginSource,
+        timeout: h.timeout != null ? h.timeout * 1000 : opts.timeout,
+        environmentAllowlist: h.environmentAllowlist || h.envAllowlist,
+        // per-hook shell selection (P1 #8): `{ "type":"command", "command":…,
+        // "shell":"powershell" }` in the settings hook entry
+        shell: h.shell != null ? h.shell : opts.shell,
+      });
+      return failClosed ? failClosedAuthorityResult(result) : result;
+    } catch (error) {
+      if (!failClosed) throw error;
+      return failClosedAuthorityResult(hookSpawnFailure(error));
+    }
   };
 
-  if (opts.mergeStrict) {
+  if (opts.mergeStrict || failClosed) {
     const decisions = [];
     for (const h of hooks) {
       const r = runOne(h);
@@ -752,21 +841,33 @@ function runHooks(commandHooks, input = {}, opts = {}) {
  */
 async function runHooksParallel(commandHooks, input = {}, opts = {}) {
   const hooks = commandHooks || [];
+  const failClosed = opts.failClosed === true || opts.authorityBearing === true;
   const settled = await Promise.all(
     hooks.map((h) => {
-      const sandboxPolicy = resolveHookSandboxPolicy(h, opts);
-      return runCommandHookAsync(h.command, input, {
-        ...opts,
-        ...(sandboxPolicy ? { sandboxPolicy } : {}),
-        broker: opts.broker,
-        origin: h.origin,
-        pluginId: h.pluginId,
-        pluginVersion: h.pluginVersion,
-        pluginSource: h.pluginSource,
-        timeout: h.timeout != null ? h.timeout * 1000 : opts.timeout,
-        environmentAllowlist: h.environmentAllowlist || h.envAllowlist,
-        shell: h.shell != null ? h.shell : opts.shell,
-      }).then((r) => ({ h, r }));
+      try {
+        const sandboxPolicy = resolveHookSandboxPolicy(h, opts);
+        return runCommandHookAsync(h.command, input, {
+          ...opts,
+          ...(sandboxPolicy ? { sandboxPolicy } : {}),
+          broker: opts.broker,
+          origin: h.origin,
+          pluginId: h.pluginId,
+          pluginVersion: h.pluginVersion,
+          pluginSource: h.pluginSource,
+          timeout: h.timeout != null ? h.timeout * 1000 : opts.timeout,
+          environmentAllowlist: h.environmentAllowlist || h.envAllowlist,
+          shell: h.shell != null ? h.shell : opts.shell,
+        }).then((r) => ({
+          h,
+          r: failClosed ? failClosedAuthorityResult(r) : r,
+        }));
+      } catch (error) {
+        if (!failClosed) throw error;
+        return Promise.resolve({
+          h,
+          r: failClosedAuthorityResult(hookSpawnFailure(error)),
+        });
+      }
     }),
   );
   const results = settled.map(({ h, r }) => ({ command: h.command, ...r }));

package/src/lib/hooks-v2-workspace-context.js

@@ -232,6 +232,16 @@ export function currentHostHooksV2WorkspaceBinding() {
   return verifyWorkspaceRecord(trustedWorkspaceStorage.getStore());
 }
 
+/** Resolve only the exact opaque binding object issued by this host process. */
+export function resolveHostHooksV2WorkspaceBinding(binding) {
+  if (!binding || typeof binding !== "object") return null;
+  const bindingId = binding.bindingId;
+  if (typeof bindingId !== "string") return null;
+  const record = registeredHostWorkspaces.get(bindingId);
+  if (!record || record.binding !== binding) return null;
+  return verifyWorkspaceRecord(record);
+}
+
 /**
  * Resolve an opaque durable binding only against roots registered by the
  * current host process. No persisted or event-supplied path is accepted.