chainlesschain 0.162.193 → 0.162.198

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);
   });
 }

package/src/repl/prompt-interactions.js

@@ -21,6 +21,7 @@ import {
   readClipboardImageChip,
 } from "./clipboard-image.js";
 import { layoutTerminalText } from "./terminal-layout.js";
+import { SlashCommandRegistry } from "./slash-command-registry.js";
 
 function commandArgs(line, command) {
   const text = String(line || "");
@@ -80,6 +81,29 @@ export function registerPromptInteractionCommands(registry, controller) {
   return PROMPT_INTERACTION_SLASH_COMMANDS.map((command) => command.name);
 }
 
+/** Build one session-local controller + registry dispatcher for production. */
+export function createPromptInteractionSurface(options = {}) {
+  const controller =
+    options.controller || new PromptInteractionController(options);
+  const registry = options.registry || new SlashCommandRegistry();
+  const commandNames = new Set(
+    registerPromptInteractionCommands(registry, controller),
+  );
+  return {
+    controller,
+    registry,
+    commandNames,
+    async dispatchSlash(line) {
+      const text = String(line || "").trim();
+      const commandName = text.split(/\s+/, 1)[0];
+      if (!commandNames.has(commandName)) return { handled: false };
+      const command = registry.getCommand(commandName);
+      const args = text.slice(commandName.length).trim();
+      return command.handler(args);
+    },
+  };
+}
+
 export class PromptInteractionController {
   constructor(options = {}) {
     this.readline = options.readline || null;
@@ -96,6 +120,10 @@ export class PromptInteractionController {
       typeof options.getSessionId === "function"
         ? options.getSessionId
         : () => options.sessionId || null;
+    this.getSuggestionContext =
+      typeof options.getSuggestionContext === "function"
+        ? options.getSuggestionContext
+        : () => ({});
     this.screenReader = options.screenReader === true;
     this.getColumns =
       typeof options.getColumns === "function"
@@ -160,6 +188,22 @@ export class PromptInteractionController {
     this._print(`\n${renderPromptSuggestions(suggestions)}`, { refresh: true });
   }
 
+  _suggestionContext(overrides = {}) {
+    let live = {};
+    try {
+      const value = this.getSuggestionContext();
+      if (value && typeof value === "object") live = value;
+    } catch {
+      // Suggestion context is optional polish and cannot break prompt input.
+    }
+    return {
+      ...live,
+      ...overrides,
+      sessionId:
+        overrides.sessionId || live.sessionId || this.getSessionId() || null,
+    };
+  }
+
   diagnostics() {
     return {
       keybindingErrors: this.keybindingDiagnostics.slice(),
@@ -219,7 +263,7 @@ export class PromptInteractionController {
       const result = runPromptSuggestionsCommand(suggestionArgs, {
         controller: this.suggestions,
         persistEnabled: this.persistSuggestionEnabled,
-        context: optionsContext(this.getSessionId()),
+        context: this._suggestionContext(),
       });
       this._print(result.message, { error: !result.ok });
       return { handled: true, ...result };
@@ -321,10 +365,7 @@ export class PromptInteractionController {
   }
 
   scheduleSuggestions(context = {}) {
-    return this.suggestions.schedule({
-      ...context,
-      sessionId: context.sessionId || this.getSessionId(),
-    });
+    return this.suggestions.schedule(this._suggestionContext(context));
   }
 
   takeClipboardImageChips() {
@@ -339,6 +380,25 @@ export class PromptInteractionController {
   }
 }
 
-function optionsContext(sessionId) {
-  return { sessionId: sessionId || null };
+/**
+ * Merge host-provided clipboard image chips into a prepared user message.
+ * Only bounded data-image blocks produced by clipboard-image.js are accepted;
+ * a host cannot smuggle a remote URL into the model through this seam.
+ */
+export function mergeClipboardImageChips(content, chips = []) {
+  const accepted = (Array.isArray(chips) ? chips : []).filter(
+    (chip) =>
+      chip?.type === "image_url" &&
+      /^data:image\/(?:png|jpeg|gif|webp);base64,[A-Za-z0-9+/]+={0,2}$/u.test(
+        String(chip.image_url?.url || ""),
+      ),
+  );
+  if (!accepted.length) return { content, attached: 0 };
+  const parts = Array.isArray(content)
+    ? content.slice()
+    : String(content || "")
+      ? [{ type: "text", text: String(content) }]
+      : [];
+  parts.push(...accepted);
+  return { content: parts, attached: accepted.length };
 }

package/src/repl/slash-command-registry.js

@@ -4,7 +4,7 @@
  */
 
 import { formatBackgroundTasks } from "./tasks-status.js";
-import { runDoctorChecks } from "./doctor-status.js";
+import { buildDoctorChecks, renderDoctor } from "./doctor-status.js";
 
 export class SlashCommandRegistry {
   static _instance = null;
@@ -124,9 +124,8 @@ export class SlashCommandRegistry {
       [
         "/doctor",
         "Check system health",
-        async (args, { write }) => {
-          write("Running system diagnostics...");
-          await runDoctorChecks(write);
+        (args, { write, doctorInput = {} }) => {
+          write(renderDoctor(buildDoctorChecks(doctorInput)));
         },
       ],
       [