@xingjisoft/neutrino 0.1.1 → 0.1.3

package/README.md

@@ -6,6 +6,10 @@ A CLI coding agent that lives in your terminal. Neutrino gives you an interactiv
 
 - **Interactive terminal UI** — logo screen, chat, model select, history, and settings screens.
 - **Full mouse support** — hover to highlight, click to select/open/position the cursor, wheel to scroll, right-click to go back (like OpenCode).
+- **Select & copy** — drag the mouse over any text (agent output, the input box, menus, …) to select it; releasing the button copies the selection to the clipboard (via OSC 52, with a native fallback).
+- **Paste-friendly input** — like OpenCode, a pasted block has its newlines turned into spaces so it stays one line, and only a manually typed `Enter` submits the message.
+- **Faithful log rendering** — text in the chat log keeps its indentation, blank lines and column alignment; when a long tool-output line wraps, continuation lines stay indented instead of snapping back to the left margin.
+- **Scrollable context log** — a vertical scrollbar is drawn on the right edge of the chat (and the agent-conversation viewer) whenever the conversation is taller than the view. Scroll with the wheel, `PgUp`/`PgDn` or `↑`/`↓`, or grab the scrollbar with the mouse and drag it like in a GUI.
 - **LLM providers** — ships with DeepSeek, OpenAI, and Anthropic presets; works with any OpenAI-compatible endpoint.
 - **Tool calling** — the agent can run shell commands, read files, write files, and list directories in your working directory.
 - **Streaming responses** — token-by-token output with pause/resume (`ESC ESC`).
@@ -47,14 +51,16 @@ Type a message on the start screen and press `Enter` to begin a new chat.
 
 | Keys | Action |
 | --- | --- |
-| `Enter` | Send message / confirm |
+| `Enter` | Send message / confirm (only a manually typed Enter sends) |
 | `←`/`→`, `↑`/`↓` | Move focus / navigate |
 | `Ctrl+E` | Open model config |
 | `Ctrl+B` | Back to menu (from chat) |
 | `Ctrl+L` | Clear conversation (from chat) |
 | `Esc Esc` | Pause / resume streaming |
+| `Esc` | Clear an active selection |
 | `PgUp` / `PgDn` | Scroll chat history |
-| `Ctrl+C` / `Ctrl+Q` | Quit |
+| `Ctrl+C` | Copy the selection, or quit if nothing is selected |
+| `Ctrl+Q` | Quit |
 
 ### Mouse
 
@@ -63,11 +69,15 @@ Type a message on the start screen and press `Enter` to begin a new chat.
 | Hover over an item | Highlight / select it in lists and menus |
 | Click an item | Select and confirm (open a screen, load a session, apply a setting…) |
 | Click the input box | Focus it and place the cursor at the clicked position |
+| Click and drag | Select text under the rectangle; releasing copies it to the clipboard |
 | Click the header (left of `ⓘ`) | Open the model selector |
 | Click `ⓘ` (chat header) | Toggle token usage stats |
+| Drag the scrollbar | Grab the thumb on the right edge of the chat/log and drag it to scroll |
 | Scroll wheel | Scroll the chat/log, or move through lists |
 | Right-click | Go back (like `Esc`) |
 
+The selection highlight is drawn over whatever is on screen, so it works uniformly on the chat log, the input box and every menu. Selected text is copied with trailing whitespace trimmed per line (shell-style), so it can be pasted straight back into a terminal.
+
 ## Configuration
 
 Settings are stored under `~/.neutrino/`:
@@ -101,10 +111,27 @@ The agent can call the following tools during a conversation:
 
 ```sh
 npm run build    # compile TypeScript to dist/
-node scripts/test-mouse.mjs    # verify mouse escape-sequence parsing
-node scripts/test-cursor.mjs   # verify click-to-position-cursor math
+npm test         # build, then run every test below
 ```
 
+Individual tests:
+
+```sh
+node scripts/test-paste.mjs      # verify pasted newlines are flattened to spaces
+node scripts/test-mouse.mjs      # verify mouse escape-sequence parsing
+node scripts/test-cursor.mjs     # verify click-to-position-cursor math
+node scripts/test-selection.mjs  # verify selection highlighting & text extraction
+node scripts/test-scrollbar.mjs  # verify the conversation scrollbar size/position and drag maths
+node scripts/test-markdown.mjs   # verify markdown/table rendering (incl. ragged rows)
+node scripts/test-wrap.mjs       # verify indentation & spacing are preserved when wrapping
+node scripts/test-render.mjs     # fuzz the diff renderer + render the chat screen,
+                                 # asserting no stale/residual cells are left behind
+```
+
+### Rendering model
+
+The screen is drawn into a `Buffer` of cells which is diffed against the previous frame, so only changed rows are emitted. Rows are erased to the end of the line before being repainted, and the buffer keeps double-width glyphs consistent (writing over one half of a wide character blanks the other half). Together these guarantee that a repainted row can never leave a stale cell behind.
+
 ## License
 
 Apache-2.0. See [LICENSE](./LICENSE).

package/dist/app.js

@@ -4,12 +4,18 @@ import { InputReader } from "./terminal/input.js";
 import { Renderer } from "./terminal/renderer.js";
 import { defaultState } from "./state.js";
 import { loadConfig, saveConfig } from "./config.js";
+import { C } from "./colors.js";
+import { applySelection, selectionText } from "./selection.js";
+import { offsetFromThumbTop, scrollbarGeometry } from "./ui.js";
+import { copyToClipboard } from "./clipboard.js";
 import { ChatScreen } from "./screens/chat.js";
 import { HistoryScreen } from "./screens/history.js";
 import { AgentSelectScreen } from "./screens/agentSelect.js";
 import { ModelSelectScreen } from "./screens/modelSelect.js";
 import { SettingsScreen } from "./screens/settings.js";
 import { StartScreen } from "./screens/start.js";
+const CURSOR_BLINK_MS = 530;
+const TOAST_MS = 1600;
 export class App {
     state = defaultState();
     width;
@@ -20,6 +26,21 @@ export class App {
     running = false;
     sizeTimer = null;
     blinkTimer = null;
+    cursorTimer = null;
+    toastTimer = null;
+    toast = "";
+    // Most recently rendered frame. Kept so a selection can be turned back into
+    // text without having to re-run the screen's render.
+    lastBuffer = null;
+    // Mouse selection bookkeeping. `pressed` is true between a left-button press
+    // and its release; `pressStart` is where the press landed, used as the anchor
+    // once the pointer starts moving (i.e. once it becomes a drag). A plain click
+    // never moves, so it is forwarded to the screen and leaves no selection.
+    pressed = false;
+    pressStart = null;
+    // Active scrollbar drag: how many rows below the thumb's top the press
+    // landed, so the thumb stays under the pointer as it moves.
+    barDrag = null;
     resizeHandler = () => this.onResize();
     constructor() {
         this.width = process.stdout.columns || 80;
@@ -72,11 +93,15 @@ export class App {
     pushScreen(screen) {
         screen.app = this;
         this.screens.push(screen);
+        this.resetMouse();
+        this.state.selection = null;
         screen.onActivate();
         this.render();
     }
     popScreen() {
         const screen = this.screens.pop();
+        this.resetMouse();
+        this.state.selection = null;
         screen?.onDeactivate();
         this.render();
     }
@@ -96,17 +121,78 @@ export class App {
             this.blinkTimer = null;
             this.state.blinkOn = false;
         }
+        // The text cursor blinks whenever the top screen shows one. The timer is
+        // only kept alive while needed so idle screens don't repaint needlessly.
+        this.updateCursorBlink();
         const buf = new Buffer(this.width, this.height);
         this.top?.render(buf);
+        this.lastBuffer = buf;
+        // The selection overlay is painted over the finished frame, so it works on
+        // every screen (chat log, input box, menus, …) without each having to know
+        // about selection at all.
+        if (this.state.selection)
+            applySelection(buf, this.state.selection);
+        this.drawToast(buf);
         this.renderer.render(buf);
     }
+    drawToast(buf) {
+        if (!this.toast)
+            return;
+        const y = buf.height - 1;
+        buf.fillRect(0, y, buf.width, 1, { bg: C.black });
+        buf.centerText(y, ` ${this.toast} `, { fg: C.black, bg: C.accent, bold: true });
+    }
+    updateCursorBlink() {
+        const want = this.top?.showsCursor() ?? false;
+        if (want && !this.cursorTimer) {
+            this.cursorTimer = setInterval(() => {
+                this.state.cursorOn = !this.state.cursorOn;
+                this.render();
+            }, CURSOR_BLINK_MS);
+        }
+        else if (!want && this.cursorTimer) {
+            clearInterval(this.cursorTimer);
+            this.cursorTimer = null;
+            this.state.cursorOn = true;
+        }
+    }
+    /** Reset the blink phase so the cursor is solid right after an interaction. */
+    wakeCursor() {
+        this.state.cursorOn = true;
+    }
     handleEvent(ev) {
+        if (ev.type === "paste") {
+            // Pasted text arrives with its newlines already flattened to spaces, so
+            // it is inserted into the input instead of being submitted.
+            this.resetMouse();
+            this.wakeCursor();
+            this.top?.onPaste(ev.text);
+            return;
+        }
         if (ev.type === "key") {
             const k = ev.key;
-            if (k.ctrl && (k.name === "c" || k.name === "q")) {
+            // Any keystroke ends a pending mouse gesture (in case a release was lost).
+            this.resetMouse();
+            if (k.ctrl && k.name === "q") {
                 this.quit();
                 return;
             }
+            if (k.ctrl && k.name === "c") {
+                // Ctrl+C copies the selection when there is one, otherwise it quits —
+                // the usual terminal convention.
+                if (this.state.selection) {
+                    this.copySelection();
+                    return;
+                }
+                this.quit();
+                return;
+            }
+            if (k.name === "escape" && this.state.selection) {
+                this.state.selection = null;
+                this.render();
+                return;
+            }
+            this.wakeCursor();
             if (k.ctrl && (k.name === "m" || k.name === "e")) {
                 this.openModelConfig();
                 return;
@@ -114,9 +200,118 @@ export class App {
             this.top?.onKey(k);
         }
         else {
-            this.top?.onMouse(ev.event);
+            this.handleMouse(ev.event);
         }
     }
+    handleMouse(ev) {
+        if (ev.type === "click") {
+            this.wakeCursor();
+            // A left-press on the scrollbar starts a thumb drag rather than a text
+            // selection or a click on the screen behind it.
+            if (ev.button === 0) {
+                const bar = this.top?.scrollbar();
+                if (bar && ev.x >= bar.x && ev.y >= bar.top && ev.y <= bar.bottom) {
+                    const g = scrollbarGeometry(bar.top, bar.bottom, bar.total, bar.viewport, bar.offset);
+                    let grab = ev.y - bar.top - g.thumbTop;
+                    if (grab < 0 || grab >= g.thumbH) {
+                        // Pressed the groove: centre the thumb under the pointer.
+                        grab = Math.floor(g.thumbH / 2);
+                        const thumbTop = Math.max(0, Math.min(ev.y - bar.top - grab, g.maxThumbTop));
+                        bar.scrollTo(offsetFromThumbTop(g, thumbTop));
+                    }
+                    this.barDrag = { grab };
+                    this.pressed = false;
+                    this.pressStart = null;
+                    if (this.state.selection)
+                        this.state.selection = null;
+                    this.render();
+                    return;
+                }
+            }
+            this.pressed = true;
+            this.pressStart = { x: ev.x, y: ev.y };
+            if (this.state.selection) {
+                this.state.selection = null;
+                this.render();
+            }
+            // Forward immediately so plain clicks (focus, tabs, header, …) keep
+            // working even in terminals that don't report button releases.
+            this.top?.onMouse(ev);
+            return;
+        }
+        if (ev.type === "move") {
+            if (this.barDrag) {
+                const bar = this.top?.scrollbar();
+                if (bar) {
+                    const g = scrollbarGeometry(bar.top, bar.bottom, bar.total, bar.viewport, bar.offset);
+                    const thumbTop = Math.max(0, Math.min(ev.y - bar.top - this.barDrag.grab, g.maxThumbTop));
+                    bar.scrollTo(offsetFromThumbTop(g, thumbTop));
+                }
+                return;
+            }
+            if (this.pressed && this.pressStart) {
+                const s = this.pressStart;
+                if (ev.x !== s.x || ev.y !== s.y) {
+                    // The pointer left the press cell, so this is a drag: grow/shrink the
+                    // selection instead of forwarding a hover to the screen.
+                    this.state.selection = { anchor: s, cursor: { x: ev.x, y: ev.y } };
+                    this.render();
+                }
+                return;
+            }
+            this.top?.onMouse(ev);
+            return;
+        }
+        if (ev.type === "release") {
+            const sel = this.state.selection;
+            this.pressed = false;
+            this.pressStart = null;
+            this.barDrag = null;
+            if (sel) {
+                if (this.lastBuffer) {
+                    const text = selectionText(this.lastBuffer, sel);
+                    if (text.trim().length > 0) {
+                        copyToClipboard(text);
+                        this.showToast(`Copied ${text.length} char${text.length === 1 ? "" : "s"}`);
+                        return;
+                    }
+                }
+                this.render();
+            }
+            return;
+        }
+        if (ev.type === "wheel") {
+            if (this.state.selection)
+                this.state.selection = null;
+            this.top?.onMouse(ev);
+        }
+    }
+    resetMouse() {
+        this.pressed = false;
+        this.pressStart = null;
+        this.barDrag = null;
+    }
+    copySelection() {
+        const sel = this.state.selection;
+        if (!sel || !this.lastBuffer)
+            return;
+        const text = selectionText(this.lastBuffer, sel);
+        if (text.trim().length === 0)
+            return;
+        copyToClipboard(text);
+        this.showToast(`Copied ${text.length} char${text.length === 1 ? "" : "s"}`);
+    }
+    showToast(text) {
+        this.toast = text;
+        if (this.toastTimer)
+            clearTimeout(this.toastTimer);
+        this.toastTimer = setTimeout(() => {
+            this.toastTimer = null;
+            this.toast = "";
+            this.render();
+        }, TOAST_MS);
+        this.render();
+    }
     setModelConfig(providerName, model, intensity) {
         this.state.selectedProvider = providerName;
         this.state.selectedModelName = model.name;
@@ -182,6 +377,14 @@ export class App {
             clearInterval(this.blinkTimer);
             this.blinkTimer = null;
         }
+        if (this.cursorTimer) {
+            clearInterval(this.cursorTimer);
+            this.cursorTimer = null;
+        }
+        if (this.toastTimer) {
+            clearTimeout(this.toastTimer);
+            this.toastTimer = null;
+        }
         this.input.stop();
         this.renderer.dispose();
         process.exit(0);

package/dist/clipboard.js

@@ -0,0 +1,113 @@
+import { Buffer } from "node:buffer";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+/**
+ * Copy `text` to the system clipboard.
+ *
+ * Two independent, best-effort strategies are used so the copy works across as
+ * many terminals as possible:
+ *
+ *   1. OSC 52 — a terminal escape sequence that asks the host terminal to put
+ *      the (base64-encoded) text on the clipboard. This is the only strategy
+ *      that also works over SSH, and is supported by Windows Terminal, iTerm2,
+ *      Kitty, WezTerm, Alacritty, …
+ *   2. A native helper process (`clip` / `pbcopy` / `wl-copy` / `xclip` / …),
+ *      as a fallback for terminals that ignore OSC 52.
+ *
+ * Both are best-effort: any failure is silently ignored.
+ */
+export function copyToClipboard(text) {
+    if (!text)
+        return;
+    copyViaOsc52(text);
+    copyViaNative(text);
+}
+function copyViaOsc52(text) {
+    try {
+        const payload = Buffer.from(text, "utf8").toString("base64");
+        // OSC 52 ; <selection> ; <base64> BEL
+        process.stdout.write(`\x1b]52;c;${payload}\x07`);
+    }
+    catch {
+        /* ignore */
+    }
+}
+function copyViaNative(text) {
+    if (process.platform === "win32") {
+        copyWindows(text);
+        return;
+    }
+    const candidates = process.platform === "darwin"
+        ? [["pbcopy", []]]
+        : process.env.WAYLAND_DISPLAY
+            ? [
+                ["wl-copy", []],
+                ["xclip", ["-selection", "clipboard"]],
+                ["xsel", ["--clipboard", "--input"]],
+            ]
+            : [
+                ["xclip", ["-selection", "clipboard"]],
+                ["xsel", ["--clipboard", "--input"]],
+                ["wl-copy", []],
+            ];
+    pipeToFirstAvailable(candidates, text);
+}
+/** Spawn the first available helper and pipe the text into it. */
+function pipeToFirstAvailable(candidates, text) {
+    let index = 0;
+    const tryNext = () => {
+        if (index >= candidates.length)
+            return;
+        const [cmd, args] = candidates[index++];
+        let child;
+        try {
+            child = spawn(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
+        }
+        catch {
+            tryNext();
+            return;
+        }
+        child.once("error", () => tryNext());
+        child.once("spawn", () => {
+            child.stdin?.end(text);
+        });
+        child.stdin?.on("error", () => {
+            /* the helper closed early — ignore */
+        });
+    };
+    tryNext();
+}
+/**
+ * Windows: `clip.exe` decodes its input using the console code page, which
+ * mangles non-ASCII text. Instead we drop the text in a temp file and let
+ * PowerShell read it back as UTF-8 via the Unicode-aware Set-Clipboard cmdlet.
+ */
+function copyWindows(text) {
+    let tmp = null;
+    try {
+        tmp = path.join(os.tmpdir(), `neutrino-clip-${process.pid}-${Date.now()}.txt`);
+        fs.writeFileSync(tmp, text, "utf8");
+        const script = `Set-Clipboard -Value ([IO.File]::ReadAllText(${psQuote(tmp)}, [Text.Encoding]::UTF8)); ` +
+            `Remove-Item -LiteralPath ${psQuote(tmp)} -ErrorAction SilentlyContinue`;
+        const child = spawn("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { stdio: "ignore", windowsHide: true });
+        child.once("error", () => {
+            if (tmp) {
+                try {
+                    fs.rmSync(tmp, { force: true });
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        });
+    }
+    catch {
+        /* ignore */
+    }
+}
+function psQuote(value) {
+    return "'" + value.replace(/'/g, "''") + "'";
+}

package/dist/colors.js

@@ -11,5 +11,8 @@ export const C = {
     green: [115, 218, 202],
     red: [247, 118, 142],
     codeBg: [27, 35, 49], // dark blue-grey used behind code blocks
+    selection: [56, 92, 138], // muted blue used to highlight selected text
+    scrollTrack: [45, 58, 62], // dim groove behind the scrollbar thumb
+    scrollThumb: [130, 142, 190], // draggable scrollbar thumb
 };
 export const EMPTY_STYLE = {};

package/dist/config.js

@@ -194,3 +194,22 @@ export function loadPrompt() {
     return (readAsset(path.join(PKG_ROOT, "assets", "prompt.txt"), path.join(PKG_ROOT, "prompt.txt")) ??
         "You are Neutrino, a helpful AI coding assistant.");
 }
+let cachedVersion = null;
+/**
+ * Read the CLI version straight from the package's `package.json` so the
+ * displayed version can never drift out of sync with the published package.
+ * The result is cached after the first successful read.
+ */
+export function loadVersion() {
+    if (cachedVersion !== null)
+        return cachedVersion;
+    try {
+        const raw = fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8");
+        const pkg = JSON.parse(raw);
+        cachedVersion = typeof pkg.version === "string" ? pkg.version : "";
+    }
+    catch {
+        cachedVersion = "";
+    }
+    return cachedVersion;
+}

package/dist/markdown.js

@@ -566,7 +566,7 @@ function renderTable(t, width) {
             for (let c = 0; c < nCols; c++) {
                 if (c === 0)
                     spans.push({ text: "│ ", style: borderStyle });
-                const cellLine = wrapped[c][li]?.spans ?? [];
+                const cellLine = wrapped[c]?.[li]?.spans ?? [];
                 for (const s of cellLine) {
                     spans.push(isHeader ? { ...s, style: { ...s.style, bold: true } } : s);
                 }

package/dist/screens/agentConversation.js

@@ -1,7 +1,7 @@
 import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
 import { drawHeader } from "../header.js";
-import { drawHint } from "../ui.js";
+import { drawHint, drawScrollbar } from "../ui.js";
 import { drawSpans, renderMarkdownText } from "../markdown.js";
 import { ellipsize } from "../width.js";
 export class AgentConversationScreen extends Screen {
@@ -9,6 +9,7 @@ export class AgentConversationScreen extends Screen {
     messages;
     scrollTop = 0;
     followBottom = true;
+    scrollbarGeom = null;
     constructor(title, messages) {
         super();
         this.title = title;
@@ -52,6 +53,25 @@ export class AgentConversationScreen extends Screen {
             this.app.popScreen();
         }
     }
+    scrollbar() {
+        const g = this.scrollbarGeom;
+        if (!g || g.total <= g.viewport)
+            return null;
+        return {
+            x: g.x,
+            top: g.top,
+            bottom: g.bottom,
+            total: g.total,
+            viewport: g.viewport,
+            offset: this.scrollTop,
+            scrollTo: (offset) => {
+                const maxScroll = Math.max(0, g.total - g.viewport);
+                this.scrollTop = Math.max(0, Math.min(offset, maxScroll));
+                this.followBottom = this.scrollTop >= maxScroll;
+                this.app.render();
+            },
+        };
+    }
     buildLines(width) {
         const lines = [];
         for (const m of this.messages) {
@@ -85,12 +105,19 @@ export class AgentConversationScreen extends Screen {
         }
         if (this.scrollTop < 0)
             this.scrollTop = 0;
+        // Expose the bar so the app can drag it (see the scrollbar() method).
+        this.scrollbarGeom =
+            lines.length > viewH
+                ? { x: w - 1, top: logTop, bottom: logBottom, total: lines.length, viewport: viewH }
+                : null;
         for (let y = logTop; y <= logBottom; y++) {
             const li = this.scrollTop + (y - logTop);
             if (li >= lines.length)
                 break;
             drawSpans(buf, 2, y, lines[li].spans, Math.max(4, w - 4));
         }
-        drawHint(buf, h - 1, "↑/↓ scroll  ·  wheel scroll  ·  right-click back  ·  Esc back");
+        // Scrollbar on the right edge, visible only when the log overflows.
+        drawScrollbar(buf, w - 1, logTop, logBottom, lines.length, viewH, this.scrollTop);
+        drawHint(buf, h - 1, "↑/↓ scroll  ·  wheel or drag the bar  ·  right-click back  ·  Esc back");
     }
 }

package/dist/screens/chat.js

@@ -2,7 +2,7 @@ import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
 import { loadPrompt, saveSession, } from "../config.js";
 import { drawHeader } from "../header.js";
-import { computeInputWindow, cursorFromColumn, drawInputBox, wrapText } from "../ui.js";
+import { computeInputWindow, cursorFromColumn, drawInputBox, drawScrollbar, wrapText } from "../ui.js";
 import { drawSpans, renderMarkdownText } from "../markdown.js";
 import { ellipsize, displayWidth } from "../width.js";
 import { LLMClient } from "../llm/client.js";
@@ -42,6 +42,7 @@ export class ChatScreen extends Screen {
     cursor = 0;
     scrollTop = 0;
     followBottom = true;
+    scrollbarGeom = null;
     lastEscTime = 0;
     initialized = false;
     constructor(initialMessage = "") {
@@ -78,6 +79,20 @@ export class ChatScreen extends Screen {
             this.app.render();
         }
     }
+    showsCursor() {
+        // The chat input is always focused; a cursor is drawn when it holds text.
+        return this.inputValue.length > 0;
+    }
+    onPaste(text) {
+        if (!text)
+            return;
+        if (this.showInfo)
+            this.showInfo = false;
+        this.inputValue =
+            this.inputValue.slice(0, this.cursor) + text + this.inputValue.slice(this.cursor);
+        this.cursor += text.length;
+        this.app.render();
+    }
     onKey(key) {
         if (this.showInfo) {
             this.showInfo = false;
@@ -233,6 +248,26 @@ export class ChatScreen extends Screen {
             this.app.render();
         }
     }
+    scrollbar() {
+        const g = this.scrollbarGeom;
+        if (!g || g.total <= g.viewport)
+            return null;
+        return {
+            x: g.x,
+            top: g.top,
+            bottom: g.bottom,
+            total: g.total,
+            viewport: g.viewport,
+            offset: this.scrollTop,
+            scrollTo: (offset) => {
+                const maxScroll = Math.max(0, g.total - g.viewport);
+                this.scrollTop = Math.max(0, Math.min(offset, maxScroll));
+                // Dragging to the very bottom resumes auto-following new output.
+                this.followBottom = this.scrollTop >= maxScroll;
+                this.app.render();
+            },
+        };
+    }
     togglePause() {
         if (!this.busy && !this.queued)
             return;
@@ -459,20 +494,30 @@ export class ChatScreen extends Screen {
         }
         if (this.scrollTop < 0)
             this.scrollTop = 0;
+        // Remember the bar's geometry so a drag on the last column can scroll the
+        // log (see the scrollbar() method).
+        this.scrollbarGeom =
+            lines.length > viewH
+                ? { x: w - 1, top: logTop, bottom: logBottom, total: lines.length, viewport: viewH }
+                : null;
         for (let y = logTop; y <= logBottom; y++) {
             const li = this.scrollTop + (y - logTop);
             if (li >= lines.length)
                 break;
             drawSpans(buf, 2, y, lines[li].spans, Math.max(4, w - 4));
         }
+        // A scrollbar on the right edge of the log, shown only when the
+        // conversation overflows the visible area.
+        drawScrollbar(buf, w - 1, logTop, logBottom, lines.length, viewH, this.scrollTop);
         const inW = Math.max(12, w - 2);
         drawInputBox(buf, 1, inputY, inW, this.inputValue, this.cursor, {
             active: true,
             dimmed: this.busy,
+            cursorOn: this.app.state.cursorOn,
             placeholder: "Type a message...",
         });
         const hintY = h - 1;
-        const hints = "Enter send  ·  ESC ESC pause  ·  Ctrl+B menu  ·  Ctrl+L clear";
+        const hints = "Enter send · ESC ESC pause · Ctrl+B menu · Ctrl+L clear · drag to copy";
         const hintW = displayWidth(hints);
         const hintX = Math.max(0, w - 1 - hintW);
         const pathAvail = Math.max(0, hintX - 2);