chainlesschain 0.162.197 → 0.162.200

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?.();
 }

package/src/repl/chat-repl.js

@@ -52,6 +52,8 @@ import {
   appendTokenUsage,
   appendEvent,
 } from "../harness/jsonl-session-store.js";
+import { installPipeSafety } from "../runtime/pipe-safety.js";
+import { installOutputBackpressure } from "../runtime/output-backpressure.js";
 
 const SLASH_COMMANDS = {
   "/exit": "Exit the chat",
@@ -96,6 +98,8 @@ export async function startChatRepl(options = {}) {
   const apiKey = options.apiKey || null;
 
   const messages = [];
+  const stdout = options.stdout || process.stdout;
+  const stderr = options.stderr || process.stderr;
 
   // Phase J — attach chat REPL to a JSONL session so token_usage is recorded
   // and `cc session usage` / `usage.*` WS routes show real numbers.
@@ -112,12 +116,42 @@ export async function startChatRepl(options = {}) {
     }
   }
 
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: chalk.green("you> "),
-    terminal: true,
+  let rl = null;
+  let closing = false;
+  let cleanupStarted = false;
+  let outputFailure = null;
+  const requestOutputClose = (error) => {
+    if (error && !outputFailure) outputFailure = error;
+    if (error) process.exitCode = error.code === "EPIPE" ? 0 : 1;
+    if (closing) return;
+    closing = true;
+    rl?.close?.();
+  };
+  const outputFlow = installOutputBackpressure({
+    stdout,
+    stderr,
+    maxQueuedBytes: options.outputBackpressureMaxBytes,
+    onFailure: requestOutputClose,
   });
+  const disposePipeSafety = installPipeSafety([stdout, stderr], () =>
+    requestOutputClose(
+      Object.assign(new Error("chat REPL output pipe closed"), {
+        code: "EPIPE",
+      }),
+    ),
+  );
+  try {
+    rl = readline.createInterface({
+      input: options.input || process.stdin,
+      output: stdout,
+      prompt: chalk.green("you> "),
+      terminal: true,
+    });
+  } catch (error) {
+    disposePipeSafety();
+    outputFlow.restore();
+    throw error;
+  }
 
   logger.log(chalk.bold("\nChainlessChain AI Chat"));
   logger.log(chalk.gray(`Model: ${model}  Provider: ${provider}`));
@@ -127,6 +161,11 @@ export async function startChatRepl(options = {}) {
   rl.prompt();
 
   rl.on("line", async (input) => {
+    try {
+      await outputFlow.wait();
+    } catch {
+      return;
+    }
     const trimmed = input.trim();
 
     if (!trimmed) {
@@ -225,11 +264,14 @@ export async function startChatRepl(options = {}) {
     messages.push({ role: "user", content: userContent });
 
     // Stream the response
-    process.stdout.write(chalk.blue("ai>  "));
+    stdout.write(chalk.blue("ai>  "));
 
     try {
       let response;
-      const onToken = (token) => process.stdout.write(token);
+      const onToken = (token) => {
+        const accepted = stdout.write(token);
+        return accepted === false ? outputFlow.wait() : undefined;
+      };
       let capturedUsage = null;
       const onUsage = (u) => {
         capturedUsage = u;
@@ -246,7 +288,7 @@ export async function startChatRepl(options = {}) {
         const timeoutIn =
           timeoutMs > ms ? Math.round((timeoutMs - ms) / 1000) : 0;
         const suffix = timeoutIn > 0 ? ` · will time out in ${timeoutIn}s` : "";
-        process.stderr.write(
+        stderr.write(
           `\x1b[2m  ⏳ waiting for API response (silent ${silent}s)${suffix}…\x1b[0m\n`,
         );
       };
@@ -310,7 +352,7 @@ export async function startChatRepl(options = {}) {
         );
       }
 
-      process.stdout.write("\n\n");
+      stdout.write("\n\n");
       messages.push({ role: "assistant", content: response });
 
       if (sessionId) {
@@ -331,14 +373,37 @@ export async function startChatRepl(options = {}) {
         }
       }
     } catch (err) {
-      process.stdout.write("\n");
+      if (err?.isOutputBackpressureFailure === true) return;
+      stdout.write("\n");
       logger.error(`Error: ${err.message}`);
     }
 
+    try {
+      await outputFlow.wait();
+    } catch {
+      return;
+    }
     rl.prompt();
   });
 
-  rl.on("close", () => {
-    process.exit(0);
+  rl.on("close", async () => {
+    if (cleanupStarted) return;
+    cleanupStarted = true;
+    closing = true;
+    if (!outputFailure) {
+      try {
+        await outputFlow.wait();
+      } catch (error) {
+        outputFailure ||= error;
+      }
+    }
+    const exitCode = outputFailure
+      ? outputFailure.code === "EPIPE"
+        ? 0
+        : 1
+      : 0;
+    disposePipeSafety();
+    outputFlow.restore();
+    process.exit(exitCode);
   });
 }