agent-sh 0.3.0 → 0.3.1

package/dist/extensions/tui-renderer.js

@@ -10,111 +10,190 @@
  * silently dropped. Alternative renderers (web UI, logging, minimal)
  * can subscribe to the same events.
  */
-import { MarkdownRenderer } from "../utils/markdown.js";
+import { highlight } from "cli-highlight";
+import { MarkdownRenderer, wrapLine } from "../utils/markdown.js";
+import { createFencedBlockTransform } from "../utils/stream-transform.js";
 import { palette as p } from "../utils/palette.js";
-import { renderToolCall, startSpinner, stopSpinner as stopToolSpinner, } from "../utils/tool-display.js";
+import { renderToolCall, createSpinner, renderSpinnerLine, } from "../utils/tool-display.js";
 import { renderDiff } from "../utils/diff-renderer.js";
 import { renderBoxFrame } from "../utils/box-frame.js";
 import { getSettings } from "../settings.js";
-export default function activate({ bus, getAcpClient }) {
-    let spinner = null;
-    let renderer = null;
-    let commandOutputBuffer = "";
-    let commandOutputLineCount = 0;
-    let commandOutputOverflow = 0;
-    let lastCommand = "";
-    let toolLineOpen = false; // true when tool header was written without \n
-    let hadToolCalls = false; // true after any tool call in current response
-    let currentToolKind; // kind of the currently executing tool
-    let isThinking = false;
-    let showThinkingText = false;
-    let spinnerStartTime = 0; // preserved across spinner restarts
-    let lastTruncatedDiff = null;
+import { StdoutWriter } from "../utils/output-writer.js";
+/** Encode a PNG buffer as a terminal inline image escape sequence. */
+function encodeImageForTerminal(data) {
+    const b64 = data.toString("base64");
+    if (process.env.TERM_PROGRAM === "iTerm.app" || process.env.TERM_PROGRAM === "WezTerm") {
+        return `\x1b]1337;File=inline=1;size=${data.length};preserveAspectRatio=1:${b64}\x07`;
+    }
+    if (process.env.KITTY_WINDOW_ID || process.env.TERM_PROGRAM === "ghostty") {
+        const chunks = [];
+        for (let i = 0; i < b64.length; i += 4096) {
+            const chunk = b64.slice(i, i + 4096);
+            const isLast = i + 4096 >= b64.length;
+            chunks.push(i === 0
+                ? `\x1b_Gf=100,t=d,a=T,m=${isLast ? 0 : 1};${chunk}\x1b\\`
+                : `\x1b_Gm=${isLast ? 0 : 1};${chunk}\x1b\\`);
+        }
+        return chunks.join("");
+    }
+    return null;
+}
+function createRenderState() {
+    return {
+        renderer: null,
+        hadToolCalls: false,
+        spinner: null,
+        spinnerLabel: "",
+        spinnerOpts: {},
+        spinnerInterval: null,
+        spinnerStartTime: 0,
+        lastCommand: "",
+        toolLineOpen: false,
+        currentToolKind: undefined,
+        commandOutputBuffer: "",
+        commandOutputLineCount: 0,
+        commandOutputOverflow: 0,
+        isThinking: false,
+        showThinkingText: false,
+        thinkingPending: false,
+        lastTruncatedDiff: null,
+    };
+}
+export default function activate(ctx) {
+    const { bus, getAcpClient, define } = ctx;
+    const writer = new StdoutWriter();
+    const s = createRenderState();
+    // ── Register fenced block transform (code blocks → ContentBlock) ──
+    // Nobody is special — tui-renderer uses the same primitive as any extension.
+    const fencedTransform = createFencedBlockTransform(bus, {
+        open: /^```(\w*)\s*$/,
+        close: /^```\s*$/,
+        transform(match, content) {
+            return { type: "code-block", language: match[1] || "", code: content };
+        },
+    });
     // ── Event subscriptions ─────────────────────────────────────
     bus.on("agent:query", (e) => {
-        spinnerStartTime = 0;
+        s.spinnerStartTime = 0;
         showUserQuery(e.query);
         startAgentResponse();
         startThinkingSpinner();
     });
     bus.on("agent:thinking-chunk", (e) => {
-        if (!isThinking) {
-            isThinking = true;
-            if (showThinkingText) {
+        s.thinkingPending = true;
+        if (!s.isThinking) {
+            s.isThinking = true;
+            if (s.showThinkingText) {
                 stopCurrentSpinner();
-                if (!renderer)
+                if (!s.renderer)
                     startAgentResponse();
-                renderer.writeLine(`${p.dim}Thinking (ctrl+t to collapse)${p.reset}`);
+                s.renderer.writeLine(`${p.dim}Thinking (ctrl+t to collapse)${p.reset}`);
+                drain();
             }
             else {
                 // Restart spinner with ctrl+t hint now that we know thinking is available
                 startThinkingSpinner();
             }
         }
-        if (showThinkingText && e.text) {
-            if (!renderer)
+        if (s.showThinkingText && e.text) {
+            s.thinkingPending = false;
+            if (!s.renderer)
                 startAgentResponse();
-            renderer.push(`${p.dim}${e.text}${p.reset}`);
-            flushOutput();
+            s.renderer.push(`${p.dim}${e.text}${p.reset}`);
+            drain();
+        }
+    });
+    bus.on("agent:response-chunk", (e) => {
+        if (e.blocks) {
+            // Inject spacing: append \n to text blocks that precede non-text blocks
+            const blocks = e.blocks;
+            for (let i = 0; i < blocks.length; i++) {
+                const block = blocks[i];
+                const next = blocks[i + 1];
+                if (block.type === "text" && next && next.type !== "text") {
+                    block.text += "\n";
+                }
+            }
+            for (const block of blocks) {
+                switch (block.type) {
+                    case "text":
+                        if (block.text)
+                            writeAgentText(block.text);
+                        break;
+                    case "code-block":
+                        writeCodeBlock(block.language, block.code);
+                        break;
+                    case "image":
+                        writeInlineImage(block.data);
+                        break;
+                    case "raw":
+                        flushForRaw();
+                        writer.write(block.escape);
+                        break;
+                }
+            }
+        }
+        else {
+            writeAgentText(e.text);
         }
     });
-    bus.on("agent:response-chunk", (e) => writeAgentText(e.text));
     bus.on("agent:response-done", () => {
-        isThinking = false;
+        s.isThinking = false;
         endAgentResponse();
     });
     bus.on("agent:tool-call", (e) => {
-        lastCommand = e.tool;
+        s.lastCommand = e.tool;
     });
     bus.on("agent:tool-started", (e) => {
+        fencedTransform.flush();
         stopCurrentSpinner();
-        currentToolKind = e.kind;
+        s.currentToolKind = e.kind;
         if (e.title === "user_shell") {
-            // Minimal annotation — PTY echo will show the output
             closeToolLine();
-            if (!renderer)
+            if (!s.renderer)
                 startAgentResponse();
-            renderer.flush();
+            s.renderer.flush();
             const cmd = e.rawInput?.command || "";
-            renderer.writeLine(`${p.dim}▶ user_shell: ${cmd}${p.reset}`);
-            hadToolCalls = true;
+            s.renderer.writeLine(`${p.dim}▶ user_shell: ${cmd}${p.reset}`);
+            drain();
+            s.hadToolCalls = true;
         }
         else {
-            showToolCall(e.title, lastCommand, e);
+            showToolCall(e.title, s.lastCommand, e);
         }
-        lastCommand = "";
+        s.lastCommand = "";
     });
     bus.on("agent:tool-completed", (e) => {
         showToolComplete(e.exitCode);
-        currentToolKind = undefined;
-        spinnerStartTime = 0;
+        s.currentToolKind = undefined;
+        s.spinnerStartTime = 0;
         startThinkingSpinner();
     });
     bus.on("agent:tool-output-chunk", (e) => writeCommandOutput(e.chunk));
     bus.on("agent:tool-output", () => flushCommandOutput());
     bus.on("agent:cancelled", () => {
-        isThinking = false;
+        s.isThinking = false;
         stopCurrentSpinner();
         showInfo("(cancelled)");
         endAgentResponse();
     });
     bus.on("agent:processing-done", () => {
-        isThinking = false;
+        s.isThinking = false;
         stopCurrentSpinner();
         endAgentResponse();
     });
     bus.on("agent:error", (e) => showError(e.message));
-    // Flush rendering state and show inline diff for file writes
     bus.on("permission:request", (e) => {
         stopCurrentSpinner();
         flushCommandOutput();
-        renderer?.flush();
+        if (s.renderer) {
+            s.renderer.flush();
+            drain();
+        }
         if (e.kind === "file-write" && e.metadata?.diff) {
             showFileDiff(e.title, e.metadata.diff);
         }
         else {
-            // Non-file permission (e.g. tool-call) — end response box
-            // so interactive extensions can render their own UI
             endAgentResponse();
         }
     });
@@ -127,39 +206,46 @@ export default function activate({ bus, getAcpClient }) {
     bus.on("ui:info", (e) => showInfo(e.message));
     bus.on("ui:error", (e) => showError(e.message));
     // ── Rendering functions ─────────────────────────────────────
-    function flushOutput() {
-        if (process.stdout.writable) {
-            try {
-                process.stdout.write("");
-            }
-            catch { }
+    function drain() {
+        if (!s.renderer)
+            return;
+        for (const line of s.renderer.drainLines()) {
+            writer.write(line + "\n");
         }
     }
     function startAgentResponse() {
-        renderer = new MarkdownRenderer();
-        hadToolCalls = false;
-        renderer.printTopBorder();
+        s.renderer = new MarkdownRenderer(writer.columns);
+        s.hadToolCalls = false;
+        s.renderer.printTopBorder();
+        drain();
+    }
+    function showCollapsedThinking() {
+        if (s.thinkingPending && !s.showThinkingText) {
+            if (!s.renderer)
+                startAgentResponse();
+            s.renderer.writeLine(`${p.muted}… thinking${p.reset}`);
+            s.thinkingPending = false;
+        }
     }
     function endAgentResponse() {
         closeToolLine();
-        if (renderer) {
-            renderer.flush();
-            renderer.printBottomBorder();
-            renderer = null;
+        stopCurrentSpinner();
+        if (s.renderer) {
+            s.renderer.flush();
+            s.renderer.printBottomBorder();
+            drain();
+            s.renderer = null;
         }
     }
     function showUserQuery(query) {
-        const termW = process.stdout.columns || 80;
-        const boxW = Math.min(84, termW);
-        const contentW = boxW - 4; // inside box padding
-        // Wrap long queries to fit within box
+        const boxW = Math.min(84, writer.columns);
+        const contentW = boxW - 4;
         const lines = [];
         for (const raw of query.split("\n")) {
             if (raw.length <= contentW) {
                 lines.push(`${p.accent}${raw}${p.reset}`);
             }
             else {
-                // Simple word wrap
                 let remaining = raw;
                 while (remaining.length > contentW) {
                     let breakAt = remaining.lastIndexOf(" ", contentW);
@@ -178,76 +264,126 @@ export default function activate({ bus, getAcpClient }) {
             borderColor: p.accent,
             title: `${p.accent}${p.bold}❯${p.reset}`,
         });
-        process.stdout.write("\n");
+        writer.write("\n");
         for (const line of framed) {
-            process.stdout.write(line + "\n");
+            writer.write(line + "\n");
         }
     }
     function writeAgentText(text) {
         closeToolLine();
-        const needsGap = hadToolCalls;
-        hadToolCalls = false;
-        if (isThinking) {
-            isThinking = false;
-            if (showThinkingText && renderer) {
-                renderer.flush();
-                const termW = process.stdout.columns || 80;
-                const w = Math.min(80, termW);
-                renderer.writeLine(`${p.dim}${"─".repeat(w)}${p.reset}`);
+        const needsGap = s.hadToolCalls;
+        s.hadToolCalls = false;
+        if (s.isThinking) {
+            s.isThinking = false;
+            if (s.showThinkingText && s.renderer) {
+                s.renderer.flush();
+                const w = Math.min(80, writer.columns);
+                s.renderer.writeLine(`${p.dim}${"─".repeat(w)}${p.reset}`);
+                drain();
             }
         }
+        showCollapsedThinking();
         stopCurrentSpinner();
-        if (!renderer)
+        if (!s.renderer)
             startAgentResponse();
         if (needsGap)
-            process.stdout.write("\n");
-        renderer.push(text);
-        flushOutput();
+            writer.write("\n");
+        s.renderer.push(text);
+        drain();
+    }
+    define("render:code-block", (language, code, width) => {
+        flushForRaw();
+        if (language) {
+            s.renderer.writeLine(`${p.dim}${language}${p.reset}`);
+        }
+        let highlighted;
+        if (!language) {
+            // No language specified — render as plain text to avoid false syntax detection
+            highlighted = code;
+        }
+        else {
+            try {
+                highlighted = highlight(code, { language });
+            }
+            catch {
+                highlighted = `${p.success}${code}${p.reset}`;
+            }
+        }
+        const contentWidth = Math.min(90, width - 2);
+        for (const line of highlighted.split("\n")) {
+            const indented = `  ${line}`;
+            const wrapped = wrapLine(indented, contentWidth);
+            for (const wl of wrapped) {
+                s.renderer.writeLine(wl);
+            }
+        }
+        drain();
+    });
+    function writeCodeBlock(language, code) {
+        ctx.call("render:code-block", language, code, writer.columns);
+    }
+    function flushForRaw() {
+        closeToolLine();
+        stopCurrentSpinner();
+        if (!s.renderer)
+            startAgentResponse();
+        s.renderer.flush();
+        drain();
+    }
+    define("render:image", (data) => {
+        flushForRaw();
+        const escape = encodeImageForTerminal(data);
+        if (escape) {
+            writer.write("  " + escape + "\n");
+        }
+    });
+    function writeInlineImage(data) {
+        ctx.call("render:image", data);
     }
     function showToolCall(title, command, extra) {
         closeToolLine();
         stopCurrentSpinner();
-        if (!renderer)
+        if (!s.renderer)
             startAgentResponse();
-        renderer.flush();
-        const termW = process.stdout.columns || 80;
+        showCollapsedThinking();
+        s.renderer.flush();
+        drain();
         const lines = renderToolCall({
             title,
             command: command || undefined,
             kind: extra?.kind,
             locations: extra?.locations,
             rawInput: extra?.rawInput,
-        }, termW);
-        // Write all lines except the last normally, write last without \n
+        }, writer.columns);
         for (let i = 0; i < lines.length - 1; i++) {
-            renderer.writeLine(lines[i]);
+            s.renderer.writeLine(lines[i]);
         }
+        drain();
         if (lines.length > 0) {
-            process.stdout.write(`  ${lines[lines.length - 1]}`);
-            toolLineOpen = true;
+            writer.write(`  ${lines[lines.length - 1]}`);
+            s.toolLineOpen = true;
         }
-        hadToolCalls = true;
-        // Reset output tracking for the new tool
-        commandOutputLineCount = 0;
-        commandOutputOverflow = 0;
+        s.hadToolCalls = true;
+        s.commandOutputLineCount = 0;
+        s.commandOutputOverflow = 0;
     }
     function showToolComplete(exitCode) {
-        if (!renderer)
+        if (!s.renderer)
             return;
         const mark = exitCode === null
             ? `${p.muted}(timed out)${p.reset}`
             : exitCode === 0
                 ? `${p.success}✓${p.reset}`
                 : `${p.error}✗ exit ${exitCode}${p.reset}`;
-        if (toolLineOpen && commandOutputLineCount === 0) {
-            // No output written — append mark on same line as tool header
-            process.stdout.write(` ${mark}\n`);
-            toolLineOpen = false;
+        if (s.toolLineOpen && s.commandOutputLineCount === 0) {
+            writer.write(` ${mark}\n`);
+            s.toolLineOpen = false;
         }
         else {
             closeToolLine();
             flushCommandOutput();
-            renderer.writeLine(`  ${mark}`);
+            s.renderer.writeLine(`  ${mark}`);
+            drain();
         }
     }
     function hasThinkingMode() {
@@ -255,69 +391,81 @@ export default function activate({ bus, getAcpClient }) {
         return !mode || mode.id !== "off";
     }
     function startThinkingSpinner() {
-        // Preserve start time if restarting (e.g. toggle), otherwise reset
-        if (!spinnerStartTime)
-            spinnerStartTime = Date.now();
+        if (!s.spinnerStartTime)
+            s.spinnerStartTime = Date.now();
         stopCurrentSpinner();
         const thinking = hasThinkingMode();
-        const label = thinking ? "Thinking" : "Working";
+        s.spinnerLabel = thinking ? "Thinking" : "Working";
         const hint = thinking
-            ? (showThinkingText ? "(ctrl+t to collapse)" : "(ctrl+t to expand)")
+            ? (s.showThinkingText ? "(ctrl+t to collapse)" : "(ctrl+t to expand)")
             : "";
-        spinner = startSpinner(label, { hint: hint || undefined, startTime: spinnerStartTime });
+        s.spinnerOpts = { hint: hint || undefined, startTime: s.spinnerStartTime };
+        s.spinner = createSpinner({ startTime: s.spinnerStartTime });
+        s.spinnerInterval = setInterval(() => {
+            if (s.spinner) {
+                const line = renderSpinnerLine(s.spinner, s.spinnerLabel, s.spinnerOpts);
+                writer.write(`\r  ${line}\x1b[K`);
+            }
+        }, 80);
     }
     function stopCurrentSpinner() {
-        if (spinner) {
-            stopToolSpinner(spinner);
-            spinner = null;
+        if (s.spinnerInterval) {
+            clearInterval(s.spinnerInterval);
+            s.spinnerInterval = null;
+        }
+        if (s.spinner) {
+            writer.write("\r\x1b[2K");
+            s.spinner = null;
         }
     }
     function closeToolLine() {
-        if (toolLineOpen) {
-            process.stdout.write("\n");
-            toolLineOpen = false;
+        if (s.toolLineOpen) {
+            writer.write("\n");
+            s.toolLineOpen = false;
         }
     }
     function writeCommandOutput(chunk) {
-        if (!renderer)
+        if (!s.renderer)
             return;
         closeToolLine();
-        const maxLines = currentToolKind === "read"
+        const maxLines = s.currentToolKind === "read"
             ? getSettings().readOutputMaxLines
             : getSettings().maxCommandOutputLines;
-        commandOutputBuffer += chunk;
-        const lines = commandOutputBuffer.split("\n");
-        commandOutputBuffer = lines.pop();
+        s.commandOutputBuffer += chunk;
+        const lines = s.commandOutputBuffer.split("\n");
+        s.commandOutputBuffer = lines.pop();
         for (const line of lines) {
-            if (commandOutputLineCount < maxLines) {
-                renderer.writeLine(`${p.dim}  ${line}${p.reset}`);
-                commandOutputLineCount++;
+            if (s.commandOutputLineCount < maxLines) {
+                s.renderer.writeLine(`${p.dim}  ${line}${p.reset}`);
+                s.commandOutputLineCount++;
             }
             else {
-                commandOutputOverflow++;
+                s.commandOutputOverflow++;
             }
         }
+        drain();
     }
     function flushCommandOutput() {
-        if (!renderer)
+        if (!s.renderer)
             return;
-        const maxLines = currentToolKind === "read"
+        const maxLines = s.currentToolKind === "read"
             ? getSettings().readOutputMaxLines
             : getSettings().maxCommandOutputLines;
-        if (commandOutputBuffer) {
-            if (commandOutputLineCount < maxLines) {
-                renderer.writeLine(`${p.dim}  ${commandOutputBuffer}${p.reset}`);
-                commandOutputLineCount++;
+        if (s.commandOutputBuffer) {
+            if (s.commandOutputLineCount < maxLines) {
+                s.renderer.writeLine(`${p.dim}  ${s.commandOutputBuffer}${p.reset}`);
+                s.commandOutputLineCount++;
             }
             else {
-                commandOutputOverflow++;
+                s.commandOutputOverflow++;
             }
-            commandOutputBuffer = "";
+            s.commandOutputBuffer = "";
         }
-        if (commandOutputOverflow > 0 && maxLines > 0) {
-            renderer.writeLine(`${p.dim}  … ${commandOutputOverflow} more lines${p.reset}`);
+        if (s.commandOutputOverflow > 0 && maxLines > 0) {
+            s.renderer.writeLine(`${p.dim}  … ${s.commandOutputOverflow} more lines${p.reset}`);
         }
-        commandOutputOverflow = 0;
+        s.commandOutputOverflow = 0;
+        drain();
     }
     function diffTitle(filePath, diff) {
         const stats = diff.isNewFile
@@ -328,8 +476,7 @@ export default function activate({ bus, getAcpClient }) {
     function showFileDiff(filePath, diff) {
         if (diff.isIdentical)
             return;
-        const termW = process.stdout.columns || 80;
-        const boxW = Math.min(84, termW);
+        const boxW = Math.min(84, writer.columns);
         const contentW = boxW - 4;
         const diffLines = renderDiff(diff, {
             width: contentW,
@@ -341,10 +488,10 @@ export default function activate({ bus, getAcpClient }) {
         const lastLine = diffLines[diffLines.length - 1] ?? "";
         const isTruncated = lastLine.includes("… ");
         if (isTruncated) {
-            lastTruncatedDiff = { filePath, diff, expanded: false };
+            s.lastTruncatedDiff = { filePath, diff, expanded: false };
         }
         else {
-            lastTruncatedDiff = null;
+            s.lastTruncatedDiff = null;
         }
         const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
         const footer = isTruncated
@@ -357,16 +504,17 @@ export default function activate({ bus, getAcpClient }) {
             title: diffTitle(filePath, diff),
             footer,
         });
-        if (!renderer)
+        if (!s.renderer)
             startAgentResponse();
         for (const line of framed) {
-            renderer.writeLine(line);
+            s.renderer.writeLine(line);
         }
+        drain();
     }
     function expandLastDiff() {
-        if (!lastTruncatedDiff)
+        if (!s.lastTruncatedDiff)
             return;
-        const entry = lastTruncatedDiff;
+        const entry = s.lastTruncatedDiff;
         entry.expanded = !entry.expanded;
         if (!entry.expanded) {
             showFileDiffCached(entry);
@@ -374,8 +522,7 @@ export default function activate({ bus, getAcpClient }) {
         }
         if (!entry.expandedLines) {
             const { filePath, diff } = entry;
-            const termW = process.stdout.columns || 80;
-            const boxW = Math.min(120, termW);
+            const boxW = Math.min(120, writer.columns);
             const contentW = boxW - 4;
             const diffLines = renderDiff(diff, {
                 width: contentW,
@@ -392,15 +539,14 @@ export default function activate({ bus, getAcpClient }) {
                 footer: [`  ${p.dim}ctrl+o to collapse${p.reset}`],
             });
         }
-        process.stdout.write("\n");
+        writer.write("\n");
         for (const line of entry.expandedLines) {
-            process.stdout.write(line + "\n");
+            writer.write(line + "\n");
         }
     }
     function showFileDiffCached(entry) {
         const { filePath, diff } = entry;
-        const termW = process.stdout.columns || 80;
-        const boxW = Math.min(84, termW);
+        const boxW = Math.min(84, writer.columns);
         const contentW = boxW - 4;
         const diffLines = renderDiff(diff, {
             width: contentW,
@@ -417,43 +563,41 @@ export default function activate({ bus, getAcpClient }) {
             title: diffTitle(filePath, diff),
             footer: [`  ${p.dim}ctrl+o to expand${p.reset}`],
         });
-        process.stdout.write("\n");
+        writer.write("\n");
         for (const line of framed) {
-            process.stdout.write(line + "\n");
+            writer.write(line + "\n");
         }
     }
     function toggleThinkingDisplay() {
-        showThinkingText = !showThinkingText;
-        // Update spinner hint to reflect new state, even if not actively thinking
-        if (spinner) {
+        s.showThinkingText = !s.showThinkingText;
+        if (s.spinner) {
             stopCurrentSpinner();
             startThinkingSpinner();
             return;
         }
-        if (!isThinking)
+        if (!s.isThinking)
             return;
-        if (showThinkingText) {
-            // Switch from spinner to streaming text
+        if (s.showThinkingText) {
             stopCurrentSpinner();
-            if (!renderer)
+            if (!s.renderer)
                 startAgentResponse();
-            renderer.writeLine(`${p.dim}Thinking (ctrl+t to collapse)${p.reset}`);
+            s.renderer.writeLine(`${p.dim}Thinking (ctrl+t to collapse)${p.reset}`);
+            drain();
         }
         else {
-            // Switch from streaming text to spinner
-            if (renderer) {
-                renderer.flush();
-                const termW = process.stdout.columns || 80;
-                const w = Math.min(80, termW);
-                renderer.writeLine(`${p.dim}${"─".repeat(w)}${p.reset}`);
+            if (s.renderer) {
+                s.renderer.flush();
+                const w = Math.min(80, writer.columns);
+                s.renderer.writeLine(`${p.dim}${"─".repeat(w)}${p.reset}`);
+                drain();
             }
             startThinkingSpinner();
         }
     }
     function showError(message) {
-        process.stdout.write(`\n${p.error}Error: ${message}${p.reset}\n`);
+        writer.write(`\n${p.error}Error: ${message}${p.reset}\n`);
     }
     function showInfo(message) {
-        process.stdout.write(`${p.muted}${message}${p.reset}\n`);
+        writer.write(`${p.muted}${message}${p.reset}\n`);
     }
 }