chainlesschain 0.162.197 → 0.162.198

package/src/repl/agent-repl.js

@@ -25,6 +25,7 @@ import path from "path";
 import { randomUUID } from "node:crypto";
 import { isPromise, isProxy } from "node:util/types";
 import { logger } from "../lib/logger.js";
+import { issueMcpStdioExecutionAuthority } from "../lib/mcp-stdio-execution-authority.js";
 import { getPlanModeManager, PlanState } from "../lib/plan-mode.js";
 import { createVimState, feedNormalKey } from "../lib/repl-vim.js";
 import {
@@ -126,6 +127,7 @@ import { expandFileRefsAsync } from "../runtime/file-ref-expander.js";
 import { prepareVisionTurn, resolveVisionLlm } from "../lib/image-input.js";
 import { composeSystemPrompt } from "../runtime/system-prompt.js";
 import { installPipeSafety } from "../runtime/pipe-safety.js";
+import { installOutputBackpressure } from "../runtime/output-backpressure.js";
 import {
   makeFallbackChatFn,
   normalizeFallbackModels,
@@ -323,6 +325,9 @@ async function executeTool(name, args) {
  * unit-testable via the `options._coreLoop` injection seam.
  */
 export async function agentLoop(messages, options) {
+  const writeOut =
+    options.writeOut || ((text) => process.stdout.write(String(text)));
+  const waitForOutput = options.waitForOutput;
   // Resume-degenerate role merge (Claude Code 2.1.187 parity), gated by the
   // one-shot `mergeRoles` flag so it fires only on the first model call after
   // resuming a session whose prior run produced no assistant response. Collapse
@@ -343,7 +348,7 @@ export async function agentLoop(messages, options) {
   const onProviderFallback =
     options.onProviderFallback ||
     ((info) =>
-      process.stdout.write(
+      writeOut(
         chalk.yellow(
           `\n  ⚠️  ${info.message || `已从 "${info.from}" 切换到 "${info.to}"`}\n`,
         ),
@@ -380,7 +385,7 @@ export async function agentLoop(messages, options) {
         event.type === "managed-checkpoint-error" || event.coverage === "none"
           ? chalk.yellow
           : chalk.gray;
-      process.stdout.write(render(`${managedCheckpointLine}\n`));
+      writeOut(render(`${managedCheckpointLine}\n`));
     } else if (event.type === "checkpoint") {
       // Remember which file snapshot lines up with the live conversation so
       // `/rewind <n>` can restore code + conversation together (Claude-Code
@@ -393,7 +398,7 @@ export async function agentLoop(messages, options) {
           tool: event.tool,
         });
       }
-      process.stdout.write(
+      writeOut(
         chalk.gray(`  ⎌ checkpoint ${event.id} (before ${event.tool})\n`),
       );
     } else if (event.type === "tool-executing") {
@@ -402,7 +407,7 @@ export async function agentLoop(messages, options) {
         args: event.args,
         startedAt: options.now ? options.now() : Date.now(),
       };
-      process.stdout.write(
+      writeOut(
         chalk.gray(
           `  [${event.tool}] ${formatToolArgs(event.tool, event.args)}\n`,
         ),
@@ -438,9 +443,7 @@ export async function agentLoop(messages, options) {
         }
       }
       if (event.error || event.result?.error) {
-        process.stdout.write(
-          chalk.red(`  Error: ${event.error || event.result?.error}\n`),
-        );
+        writeOut(chalk.red(`  Error: ${event.error || event.result?.error}\n`));
         // Record policy denials (not plain tool failures) into the caller's
         // denial log for review via `/permissions denials` (Claude-Code 2.1.193
         // recent denials). Caller passes the session log (mirrors checkpointMarks)
@@ -477,13 +480,13 @@ export async function agentLoop(messages, options) {
           const sid = options?.sessionId;
           const policy = approval.policy || "strict";
           if (sid && policy === "strict") {
-            process.stdout.write(
+            writeOut(
               chalk.yellow(
                 `  Hint: relax policy with  cc session policy ${sid} --set trusted\n`,
               ),
             );
           } else if (sid) {
-            process.stdout.write(
+            writeOut(
               chalk.yellow(
                 `  Hint: per-session policy is "${policy}" — see  cc session policy ${sid}\n`,
               ),
@@ -491,26 +494,26 @@ export async function agentLoop(messages, options) {
           }
         }
       } else if (event.result?.success) {
-        process.stdout.write(chalk.green(`  Done\n`));
+        writeOut(chalk.green(`  Done\n`));
       }
     } else if (event.type === "thinking") {
       // Intermediate-step reasoning (before a tool call) — dimmed, inline.
       if (process.env.CC_REPL_THINKING !== "0" && event.text) {
-        process.stdout.write(
+        writeOut(
           "\n" + chalk.dim("💭 " + event.text.replace(/\n/g, "\n   ")) + "\n",
         );
       }
     } else if (event.type === "token-usage") {
       usageEvents.push(event);
     } else if (event.type === "iteration-warning") {
-      process.stdout.write(chalk.yellow(`\n  ${event.message}\n`));
+      writeOut(chalk.yellow(`\n  ${event.message}\n`));
     } else if (event.type === "iteration-budget-exhausted") {
-      process.stdout.write(
-        chalk.red(`\n  [Budget Exhausted] ${event.budget}\n`),
-      );
+      writeOut(chalk.red(`\n  [Budget Exhausted] ${event.budget}\n`));
     } else if (event.type === "response-complete") {
+      await waitForOutput?.();
       return { content: event.content, usageEvents, thinking: event.thinking };
     }
+    await waitForOutput?.();
   }
   return { content: "", usageEvents };
 }
@@ -1934,7 +1937,12 @@ export function createReplMcpHostRuntimeManager(dependencies = {}) {
     }
 
     const sink = persistLedger
-      ? createLedgerSink(sessionId, { appendEvent: appendLedgerEvent })
+      ? createLedgerSink(
+          sessionId,
+          appendLedgerEvent === appendAuthorityEvent
+            ? { recovery }
+            : { appendEvent: appendLedgerEvent },
+        )
       : null;
     const sharedController =
       !verifiedRecovery && current?.sessionId === sessionId
@@ -2068,27 +2076,93 @@ export async function startAgentRepl(options = {}) {
 }
 
 async function startAgentReplInWorkspace(options = {}, startupAdmission) {
+  let failureHandler = null;
+  let disposePipeSafety = null;
+  const flow = installOutputBackpressure({
+    stdout: process.stdout,
+    stderr: process.stderr,
+    maxQueuedBytes: options.outputBackpressureMaxBytes,
+    onFailure: (error) => failureHandler?.(error),
+  });
+  let restored = false;
+  const outputScope = {
+    flow,
+    setFailureHandler(handler) {
+      failureHandler = handler;
+    },
+    setPipeDisposer(disposer) {
+      disposePipeSafety = disposer;
+    },
+    restore() {
+      if (restored) return;
+      restored = true;
+      disposePipeSafety?.();
+      flow.restore();
+    },
+  };
+  try {
+    return await startAgentReplInWorkspaceOwned(
+      options,
+      startupAdmission,
+      outputScope,
+    );
+  } catch (error) {
+    outputScope.restore();
+    throw error;
+  }
+}
+
+async function startAgentReplInWorkspaceOwned(
+  options = {},
+  startupAdmission,
+  outputScope,
+) {
   // EPIPE guard: if the REPL's stdout is piped and the consumer closes (e.g.
   // `cc agent | head`), the async stream `error` would otherwise crash the
   // process. Route a broken pipe into the REPL's own graceful shutdown (the
   // rl "close" handler — MCP disconnect, kill background tasks) when the
-  // interface exists, else exit cleanly. `_replClosing` makes it fire once so a
-  // cleanup write that also EPIPEs can't loop. `_replRl` is set when rl is built.
+  // interface and its close handler exist. `_replClosing` makes it fire once so
+  // a cleanup write that also EPIPEs can't loop. An early EPIPE remains pending
+  // until the close handler is attached; it never skips directly to exit.
   let _replRl = null;
   let _replClosing = false;
-  installPipeSafety(undefined, () => {
+  let _replCloseReady = false;
+  let _replCleanupStarted = false;
+  let _turnAbort = null;
+  let _replOutputFailure = null;
+  const _requestReplOutputClose = (error) => {
+    if (error && !_replOutputFailure) _replOutputFailure = error;
+    if (error) {
+      process.exitCode = error.code === "EPIPE" ? 0 : 1;
+      _turnAbort?.abort(error);
+    }
     if (_replClosing) return;
     _replClosing = true;
-    if (_replRl) {
+    if (_replRl && _replCloseReady) {
       try {
-        _replRl.close(); // triggers the graceful "close" cleanup → process.exit
-        return;
+        _replRl.close(); // triggers the graceful "close" cleanup
       } catch {
-        /* fall through to a bare exit */
+        // The close handler owns shutdown. Leaving exitCode set allows the
+        // event loop to drain without bypassing the teardown lifecycle.
       }
     }
-    process.exit(0);
-  });
+  };
+  const _replOutputFlow = outputScope.flow;
+  outputScope.setFailureHandler(_requestReplOutputClose);
+  const _disposeReplPipeSafety = installPipeSafety(undefined, () =>
+    _requestReplOutputClose(
+      Object.assign(new Error("REPL output pipe closed"), { code: "EPIPE" }),
+    ),
+  );
+  outputScope.setPipeDisposer(_disposeReplPipeSafety);
+  const _waitForReplOutput = async () => {
+    try {
+      await _replOutputFlow.wait();
+      return true;
+    } catch {
+      return false;
+    }
+  };
   const { useJsonl, candidate: _startupJsonlResume } = startupAdmission;
   let model = options.model || "qwen2.5:7b";
   let provider = options.provider || "ollama";
@@ -2988,7 +3062,15 @@ async function startAgentReplInWorkspace(options = {}, startupAdmission) {
             let connected = 0;
             for (const [name, cfg] of serverEntries) {
               try {
-                await _bundleMcpClient.connect(name, cfg);
+                const authorizedConfig = { ...cfg };
+                authorizedConfig.mcpStdioExecutionAuthority =
+                  issueMcpStdioExecutionAuthority({
+                    serverName: name,
+                    config: authorizedConfig,
+                    approvalKind: "explicit-config",
+                    approvalSource: `agent-bundle:${path.resolve(options.bundlePath)}`,
+                  });
+                await _bundleMcpClient.connect(name, authorizedConfig);
                 connected += 1;
               } catch (mcpErr) {
                 logger.log(
@@ -3868,7 +3950,7 @@ async function startAgentReplInWorkspace(options = {}, startupAdmission) {
   // seam (throwIfAborted at each iteration); partial conversation is kept.
   // Idle Esc presses (no active turn) are ignored, and escape-prefixed key
   // sequences (arrows etc.) never reach here as bare "escape".
-  let _turnAbort = null;
+  _turnAbort = null;
   let _lastIdleEscAt = 0;
   let _replKeypressHandler = null;
   if (process.stdin.isTTY) {
@@ -4089,7 +4171,9 @@ async function startAgentReplInWorkspace(options = {}, startupAdmission) {
         });
         // Custom command wins; otherwise the built-in context-usage render.
         if (_slCfg) {
-          return _sl.renderStatusLine(_slCfg, context, { cwd: process.cwd() });
+          return _sl.renderStatusLine(_slCfg, context, {
+            cwd: process.cwd(),
+          });
         }
         const line = _sl.renderDefaultStatusLine(context);
         return line && line.trim() ? line : null;
@@ -4423,7 +4507,7 @@ async function startAgentReplInWorkspace(options = {}, startupAdmission) {
         `  ${chalk.cyan("/add-dir")}    Add an extra working root (/add-dir <dir>; no arg lists roots)`,
       );
       logger.log(
-        `  ${chalk.cyan("/reload-skills")} Re-scan skill layers without restarting`,
+        `  ${chalk.cyan("/reload-skills")} Revoke process Skill grants and re-scan layers`,
       );
       logger.log(
         `  ${chalk.cyan("/reload-plugins")} Re-scan installed plugins after add/trust/upgrade`,
@@ -5283,7 +5367,11 @@ async function startAgentReplInWorkspace(options = {}, startupAdmission) {
               dispatchAsyncHooks(
                 _settingsHooks,
                 "CwdChanged",
-                { old_cwd: oldCwd, cwd: newCwd, session_id: sessionId || null },
+                {
+                  old_cwd: oldCwd,
+                  cwd: newCwd,
+                  session_id: sessionId || null,
+                },
                 { cwd: newCwd, supervisor: _asyncHookSupervisor },
               );
             } catch {
@@ -5847,6 +5935,11 @@ async function startAgentReplInWorkspace(options = {}, startupAdmission) {
     // layers (incl. .claude/skills) without restarting the session.
     if (trimmed === "/reload-skills") {
       try {
+        _replSkillLoader.revokeExecutionAuthorizations?.({
+          message:
+            "Skill execution authorization was revoked by /reload-skills",
+          reasonCode: "reload-skills",
+        });
         _replSkillLoader.clearCache();
         const n = _replSkillLoader.loadAll().length;
         _replBaseSystem = _buildReplBaseSystem();
@@ -5856,7 +5949,7 @@ async function startAgentReplInWorkspace(options = {}, startupAdmission) {
         _persistReplContextSources();
         logger.log(
           chalk.green(
-            `✔ skills reloaded — ${n} available (${_replSkillLoader.getLayerPaths().length} layers re-scanned)`,
+            `✔ Skill grants revoked and skills reloaded — ${n} available (${_replSkillLoader.getLayerPaths().length} layers re-scanned)`,
           ),
         );
       } catch (err) {
@@ -6069,7 +6162,9 @@ async function startAgentReplInWorkspace(options = {}, startupAdmission) {
             logger.log(chalk.gray(l));
         } else {
           // set — createReplGoal throws on a malformed spec (caught below).
-          _sessionGoal = rg.createReplGoal(cmd.spec, { now: () => Date.now() });
+          _sessionGoal = rg.createReplGoal(cmd.spec, {
+            now: () => Date.now(),
+          });
           for (const l of rg.renderGoalStart(_sessionGoal))
             logger.log(chalk.cyan(l));
         }
@@ -7679,22 +7774,29 @@ async function startAgentReplInWorkspace(options = {}, startupAdmission) {
       // reasoning dimmed before it. Skipped (left undefined) in replay mode.
       let _liveStreamed = false;
       let _liveThinkStarted = false;
+      const _settleLiveWrite = (blocked) =>
+        blocked ? _replOutputFlow.wait() : undefined;
       const liveOpts = _streamLive
         ? {
             onToken: (t) => {
               // Separate the answer from the dimmed reasoning above it (once).
-              if (!_liveStreamed && _liveThinkStarted)
-                process.stdout.write("\n");
+              let blocked = false;
+              if (!_liveStreamed && _liveThinkStarted) {
+                blocked = process.stdout.write("\n") === false;
+              }
               _liveStreamed = true;
-              process.stdout.write(t);
+              blocked = process.stdout.write(t) === false || blocked;
+              return _settleLiveWrite(blocked);
             },
             onThinking: (t) => {
               if (process.env.CC_REPL_THINKING === "0") return;
+              let blocked = false;
               if (!_liveThinkStarted) {
                 process.stdout.write(chalk.dim("💭 "));
                 _liveThinkStarted = true;
               }
-              process.stdout.write(chalk.dim(t));
+              blocked = process.stdout.write(chalk.dim(t)) === false || blocked;
+              return _settleLiveWrite(blocked);
             },
           }
         : {};
@@ -7726,7 +7828,9 @@ async function startAgentReplInWorkspace(options = {}, startupAdmission) {
       if (_settingsHooks && !_asyncHookSupervisor) {
         const { AsyncHookSupervisor } =
           await import("../lib/async-hook-supervisor.js");
-        _asyncHookSupervisor = new AsyncHookSupervisor({ persistStats: true });
+        _asyncHookSupervisor = new AsyncHookSupervisor({
+          persistStats: true,
+        });
       }
       const activeMcpRuntime = _activateMcpHostRuntime();
       const activeRawMcpClient = activeMcpRuntime.rawClient || undefined;
@@ -7736,6 +7840,7 @@ async function startAgentReplInWorkspace(options = {}, startupAdmission) {
         thinking: reasoning,
       } = await agentLoop(messages, {
         ...liveOpts,
+        waitForOutput: _replOutputFlow.wait,
         mergeRoles: _mergeRolesThisTurn,
         // Visible auto-retry feedback (Claude-Code 2.1.181): when the model's
         // streaming call hits a transient connection drop and retries, tell the
@@ -8170,6 +8275,7 @@ async function startAgentReplInWorkspace(options = {}, startupAdmission) {
   };
 
   rl.on("line", async (input) => {
+    if (!(await _waitForReplOutput())) return;
     if (_processingLine) {
       const concurrentBtw = _slashCommandsDisabled
         ? null
@@ -8193,10 +8299,12 @@ async function startAgentReplInWorkspace(options = {}, startupAdmission) {
     _processingLine = true;
     try {
       await handleLine(input);
+      if (!(await _waitForReplOutput())) return;
       while (_pendingLines.length) {
         const next = _pendingLines.shift();
         logger.log(chalk.cyan(`▶ running queued input: ${next}`));
         await handleLine(next);
+        if (!(await _waitForReplOutput())) return;
       }
     } finally {
       _processingLine = false;
@@ -8204,6 +8312,9 @@ async function startAgentReplInWorkspace(options = {}, startupAdmission) {
   });
 
   rl.on("close", async () => {
+    if (_replCleanupStarted) return;
+    _replCleanupStarted = true;
+    _replClosing = true;
     _promptInteractions.dispose();
     if (process.stdin.isTTY) {
       if (_replKeypressHandler) {
@@ -8391,6 +8502,31 @@ async function startAgentReplInWorkspace(options = {}, startupAdmission) {
     } catch (_e) {
       // Non-critical
     }
-    process.exit(0);
+    if (!_replOutputFailure) {
+      try {
+        await _replOutputFlow.wait();
+      } catch (error) {
+        _replOutputFailure ||= error;
+      }
+    }
+    const outputExitCode = _replOutputFailure
+      ? _replOutputFailure.code === "EPIPE"
+        ? 0
+        : 1
+      : 0;
+    outputScope.restore();
+    process.exit(outputExitCode);
   });
+  _replCloseReady = true;
+  if (_replClosing) {
+    // stdout may have broken before readline and its cleanup handler were fully
+    // initialized. Close only now so the complete async teardown runs.
+    queueMicrotask(() => {
+      try {
+        rl.close();
+      } catch {
+        process.exitCode = 0;
+      }
+    });
+  }
 }

package/src/repl/bg-dashboard.js

@@ -20,6 +20,8 @@
 
 import chalk from "chalk";
 import { phaseGroupKey } from "../lib/background-agent-phase.js";
+import { installPipeSafety } from "../runtime/pipe-safety.js";
+import { installOutputBackpressure } from "../runtime/output-backpressure.js";
 
 export const GROUP_ORDER = [
   "needs-input",
@@ -171,31 +173,52 @@ const ALT_EXIT = `${ESC}[?25h${ESC}[?1049l`;
 const CLEAR = `${ESC}[2J${ESC}[H`;
 
 /** Default terminal IO — swapped for a fake in tests. */
-export function defaultDashboardIo() {
+export function defaultDashboardIo({
+  input = process.stdin,
+  stdout = process.stdout,
+  stderr = process.stderr,
+} = {}) {
+  let failure = null;
+  const recordFailure = (error) => {
+    failure ||= error;
+    process.exitCode = error?.code === "EPIPE" ? 0 : 1;
+  };
+  const outputFlow = installOutputBackpressure({
+    stdout,
+    stderr,
+    onFailure: recordFailure,
+  });
+  const disposePipeSafety = installPipeSafety([stdout, stderr], () =>
+    recordFailure(
+      Object.assign(new Error("dashboard output pipe closed"), {
+        code: "EPIPE",
+      }),
+    ),
+  );
   return {
-    isTTY: Boolean(process.stdout.isTTY && process.stdin.isTTY),
-    write: (s) => process.stdout.write(s),
-    enterAlt: () => process.stdout.write(ALT_ENTER),
-    exitAlt: () => process.stdout.write(ALT_EXIT),
-    clear: () => process.stdout.write(CLEAR),
+    isTTY: Boolean(stdout.isTTY && input.isTTY),
+    write: (s) => stdout.write(s),
+    enterAlt: () => stdout.write(ALT_ENTER),
+    exitAlt: () => stdout.write(ALT_EXIT),
+    clear: () => stdout.write(CLEAR),
     setRaw: (on) => {
-      if (process.stdin.isTTY && process.stdin.setRawMode) {
-        process.stdin.setRawMode(on);
+      if (input.isTTY && input.setRawMode) {
+        input.setRawMode(on);
       }
     },
     async listenKeys(onKey) {
       const readline = await import("node:readline");
-      readline.emitKeypressEvents(process.stdin);
-      process.stdin.resume();
+      readline.emitKeypressEvents(input);
+      input.resume();
       const handler = (str, key) => onKey(str, key || {});
-      process.stdin.on("keypress", handler);
-      return () => process.stdin.off("keypress", handler);
+      input.on("keypress", handler);
+      return () => input.off("keypress", handler);
     },
     async promptLine(question) {
       const readline = await import("node:readline");
       const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
+        input,
+        output: stdout,
       });
       try {
         return await new Promise((resolve) => rl.question(question, resolve));
@@ -203,6 +226,15 @@ export function defaultDashboardIo() {
         rl.close();
       }
     },
+    async wait() {
+      if (failure) throw failure;
+      await outputFlow.wait();
+      if (failure) throw failure;
+    },
+    dispose() {
+      disposePipeSafety();
+      outputFlow.restore();
+    },
   };
 }
 
@@ -224,23 +256,36 @@ export async function runBgDashboard(deps = {}) {
   let filterIndex = 0;
   let peek = null;
   let message = "";
+  let outputFailed = false;
+  let finishDashboard = () => {};
+  let renderChain = Promise.resolve();
   let model = buildDashboardModel(listAgents(), {
     filter: FILTERS[filterIndex],
     now: now(),
   });
 
   const render = () => {
-    model = buildDashboardModel(listAgents(), {
-      filter: FILTERS[filterIndex],
-      now: now(),
-    });
-    if (selected >= model.flat.length)
-      selected = Math.max(0, model.flat.length - 1);
-    if (peek && !model.flat.some((s) => s.id === peek.id)) peek = null;
-    io.clear();
-    io.write(
-      renderDashboard(model, { selectedIndex: selected, peek, message }) + "\n",
-    );
+    renderChain = renderChain
+      .then(async () => {
+        model = buildDashboardModel(listAgents(), {
+          filter: FILTERS[filterIndex],
+          now: now(),
+        });
+        if (selected >= model.flat.length)
+          selected = Math.max(0, model.flat.length - 1);
+        if (peek && !model.flat.some((s) => s.id === peek.id)) peek = null;
+        io.clear();
+        io.write(
+          renderDashboard(model, { selectedIndex: selected, peek, message }) +
+            "\n",
+        );
+        await io.wait?.();
+      })
+      .catch(() => {
+        outputFailed = true;
+        finishDashboard();
+      });
+    return renderChain;
   };
 
   const selectedSession = () => model.flat[selected] || null;
@@ -259,13 +304,15 @@ export async function runBgDashboard(deps = {}) {
 
   io.enterAlt();
   io.setRaw(true);
-  const timer = setInterval(render, refreshMs);
+  const timer = setInterval(() => void render(), refreshMs);
   timer.unref?.();
-  render();
+  await render();
 
   let stopListening = () => {};
   await new Promise((resolve) => {
     const finish = () => resolve();
+    finishDashboard = finish;
+    if (outputFailed) finish();
     const onKey = async (str, key) => {
       const name = key?.name || str;
       const ctrlC = key?.ctrl && key.name === "c";
@@ -342,7 +389,7 @@ export async function runBgDashboard(deps = {}) {
       } catch (err) {
         message = `error: ${err.message}`;
       }
-      render();
+      await render();
     };
     io.listenKeys(onKey).then((stop) => {
       stopListening = stop || (() => {});
@@ -353,4 +400,10 @@ export async function runBgDashboard(deps = {}) {
   stopListening();
   io.setRaw(false);
   io.exitAlt();
+  try {
+    await io.wait?.();
+  } catch {
+    // The output owner already classified the exit code.
+  }
+  io.dispose?.();
 }