@xingjisoft/neutrino 0.1.3 → 0.1.5

package/dist/terminal/buffer.js

@@ -1,5 +1,6 @@
 import { C, EMPTY_STYLE } from "../colors.js";
 import { displayWidth, wcwidth } from "../width.js";
+import { isControlChar } from "../sanitize.js";
 const emptyCell = () => ({ ch: " ", style: { bg: C.black } });
 function normalize(style) {
     return style.bg ? style : { ...style, bg: C.black };
@@ -56,6 +57,12 @@ export class Buffer {
         row[x] = { ch: "", style: normalize(style) };
     }
     writeChar(x, y, ch, style) {
+        // A control character (ESC, TAB, CR, …) would be written verbatim by the
+        // renderer and interpreted by the terminal as a command. Neutralise it to a
+        // space, which matches the single-column width wcwidth() reports for it, so
+        // the layout stays exactly as the caller measured it.
+        if (isControlChar(ch))
+            ch = " ";
         if (cellWidth(ch) === 2) {
             if (x + 1 >= this.width) {
                 // No room for the tail: degrade to a space so the line never overflows
@@ -70,8 +77,6 @@ export class Buffer {
         this.overwriteCell(x, y, ch, style);
     }
     set(x, y, ch, style = EMPTY_STYLE) {
-        if (ch === "\r" || ch === "\n")
-            return;
         if (x < 0 || x >= this.width || y < 0 || y >= this.height)
             return;
         this.writeChar(x, y, ch, style);
@@ -81,8 +86,14 @@ export class Buffer {
             return;
         let col = x;
         for (const ch of text) {
+            // Measure the character as the caller will have measured it, *then*
+            // neutralise control codes, so the column bookkeeping stays identical to
+            // the wrapping done upstream (see sanitize.ts).
+            const ctrl = isControlChar(ch);
             const w = wcwidth(ch.codePointAt(0) ?? 0);
             if (w === 0) {
+                if (ctrl)
+                    continue; // zero-width control (NUL): drop it
                 // Combining mark: attach it to the glyph immediately to the left.
                 const px = col - 1;
                 if (px >= 0 && px < this.width && this.cells[y][px].ch !== "") {
@@ -96,7 +107,7 @@ export class Buffer {
                 col += w;
                 continue;
             }
-            this.writeChar(col, y, ch, style);
+            this.writeChar(col, y, ctrl ? " " : ch, style);
             col += w;
         }
     }
@@ -124,6 +135,16 @@ export class Buffer {
         }
         this.writeText(x, y + h - 1, bottom, style);
     }
+    /**
+     * Flag a cell as non-copyable chrome (e.g. a scrollbar). The flag lives on
+     * the cell and is cleared automatically whenever the cell is written again,
+     * since every frame starts from a fresh buffer.
+     */
+    markChrome(x, y) {
+        if (x < 0 || x >= this.width || y < 0 || y >= this.height)
+            return;
+        this.cells[y][x].chrome = true;
+    }
     clear() {
         for (let j = 0; j < this.height; j++) {
             const row = this.cells[j];

package/dist/terminal/input.js

@@ -54,9 +54,20 @@ export class InputReader {
         stdin.removeListener("data", this.dataHandler);
         if (this.escTimer)
             clearTimeout(this.escTimer);
-        if (stdin.isTTY)
-            stdin.setRawMode(false);
-        stdin.pause();
+        try {
+            if (stdin.isTTY)
+                stdin.setRawMode(false);
+        }
+        catch {
+            // The console already went away; leaving raw mode is best-effort here and
+            // failing must not abort the rest of the shutdown.
+        }
+        try {
+            stdin.pause();
+        }
+        catch {
+            // Same as above.
+        }
     }
     onData(chunk) {
         this.pending += this.decoder.decode(chunk, { stream: true });

package/dist/terminal/renderer.js

@@ -1,4 +1,6 @@
 import process from "node:process";
+import { restoreTerminalSync, markTuiActive } from "./restore.js";
+import { isControlChar } from "../sanitize.js";
 function styleKey(st) {
     let k = "";
     if (st.fg)
@@ -43,23 +45,71 @@ function rowSignature(row) {
 }
 export class Renderer {
     prevSig = [];
+    disposed = false;
     prevW = 0;
     prevH = 0;
     out = process.stdout;
+    /**
+     * The most recent frame and the rows that were force-repainted for it. Kept
+     * so `repaint()` can re-emit the exact same frame — without re-running the
+     * screen's (potentially expensive) render — to heal any drift the terminal
+     * introduced behind our back.
+     */
+    lastBuf = null;
+    lastForce = [];
     init() {
+        // Tell the crash guard the terminal is ours *before* touching it, so a
+        // crash that skips dispose() can still undo every switch below.
+        markTuiActive();
         this.write("\x1b[?1049h"); // alternate screen
         this.write("\x1b[?25l"); // hide cursor
         this.write("\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h\x1b[?1015h"); // mouse tracking (incl. any-event for hover)
         this.write("\x1b[?2004h"); // bracketed paste (so pastes can be told apart from typing)
     }
     dispose() {
-        this.write("\x1b[?2004l");
-        this.write("\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1015l");
-        this.write("\x1b[?25h");
-        this.write("\x1b[?1049l");
-        this.write("\x1b[0m");
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        // stdout.write may still be queued when App.quit calls process.exit.
+        // Use the same synchronous teardown as the crash/exit guard.
+        restoreTerminalSync();
     }
-    render(buf) {
+    /**
+     * @param forceRows rows to repaint unconditionally, even when their contents
+     *   are unchanged. Screens use this for persistent chrome (input box, hints)
+     *   so that terminal-side drift can never leave it stale (see
+     *   `Screen.alwaysRepaintRows`).
+     */
+    render(buf, forceRows = []) {
+        this.lastBuf = buf;
+        this.lastForce = forceRows;
+        this.draw(buf, forceRows);
+    }
+    /**
+     * Re-emit the last frame in full. Cheap (no screen re-render) and visually a
+     * no-op when nothing drifted, but it repairs rows the terminal moved on its
+     * own (resize reflow, stray scroll). Called periodically as a safety net.
+     */
+    repaint() {
+        if (!this.lastBuf)
+            return;
+        const all = [];
+        for (let y = 0; y < this.lastBuf.height; y++)
+            all.push(y);
+        this.draw(this.lastBuf, all);
+    }
+    /**
+     * Ring the terminal bell.
+     *
+     * Written straight to the stream rather than into a frame: BEL has no visual
+     * effect, so it cannot desync the diffed rows, and it must never end up in
+     * `lastBuf` where repaint() would replay it.
+     */
+    bell(times = 1) {
+        const count = Math.max(1, Math.trunc(times) || 1);
+        this.write("\x07".repeat(count));
+    }
+    draw(buf, forceRows) {
         const w = buf.width;
         const h = buf.height;
         if (w !== this.prevW || h !== this.prevH) {
@@ -67,11 +117,12 @@ export class Renderer {
             this.prevW = w;
             this.prevH = h;
         }
+        const force = forceRows.length ? new Set(forceRows) : null;
         let out = "";
         for (let y = 0; y < h; y++) {
             const row = buf.cells[y];
             const sig = rowSignature(row);
-            if (sig !== this.prevSig[y]) {
+            if (sig !== this.prevSig[y] || (force !== null && force.has(y))) {
                 out += this.renderRow(y, row);
                 this.prevSig[y] = sig;
             }
@@ -96,12 +147,24 @@ export class Renderer {
                 s += sgr(cell.style);
                 lastKey = sk;
             }
-            s += cell.ch;
+            // Final safety net: the byte stream is the one place a stray control
+            // character would be executed by the terminal (cursor moves, screen
+            // clears, …). The Buffer already neutralises them; this guarantees it
+            // even if a cell is ever populated by some other path.
+            s += isControlChar(cell.ch) ? " " : cell.ch;
         }
         s += "\x1b[0m";
         return s;
     }
     write(chunk) {
-        this.out.write(chunk);
+        if (this.disposed || this.out.destroyed || this.out.writableEnded)
+            return;
+        try {
+            this.out.write(chunk);
+        }
+        catch {
+            // A terminal that vanished (closed window, dying conhost) must not take
+            // the whole session down with it.
+        }
     }
 }

package/dist/terminal/restore.js

@@ -0,0 +1,147 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { flushSessionCheckpoints } from "../persistence.js";
+const NEUTRINO_DIR = path.join(os.homedir(), ".neutrino");
+/**
+ * Escape sequences that undo everything the TUI switches on.
+ *
+ * Mouse tracking is disabled before the alternate screen is left, and the
+ * cursor is restored before the screen swap, so the shell never inherits a
+ * half-configured terminal. Order matters: `?1049l` must come last or the
+ * remaining writes would land on the main screen.
+ */
+export const TUI_TEARDOWN = "\x1b[?2004l" + // bracketed paste off
+    "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1015l" + // mouse tracking off
+    "\x1b[?25h" + // cursor visible
+    "\x1b[0m" + // default attributes
+    "\x1b[?1049l"; // back to the main screen
+/** Whether a TUI has claimed the terminal and its state still needs undoing. */
+let active = false;
+let restored = false;
+let installed = false;
+/** Called once the renderer has entered the alternate screen and raw mode. */
+export function markTuiActive() {
+    // Unconditional: only the renderer calls this, and the renderer is only ever
+    // constructed once the app has decided it owns a real terminal.
+    active = true;
+    restored = false;
+}
+/**
+ * Puts the terminal back into a usable state, synchronously and at most once.
+ *
+ * Everything here has to work while the process is dying: no promises, no
+ * asynchronous writes, and every step individually guarded so one failure
+ * cannot skip the rest (a broken `setRawMode` must not leave the cursor
+ * hidden, for example).
+ */
+export function restoreTerminalSync() {
+    if (!active || restored)
+        return false;
+    let outputRestored = false;
+    let inputRestored = false;
+    try {
+        // fd 1 write is the only one guaranteed to be flushed by a dying process;
+        // `process.stdout.write` may queue the bytes and lose them at exit.
+        const bytes = Buffer.from(TUI_TEARDOWN);
+        let offset = 0;
+        while (offset < bytes.length) {
+            const written = fs.writeSync(1, bytes, offset, bytes.length - offset);
+            if (written === 0)
+                throw new Error("terminal write made no progress");
+            offset += written;
+        }
+        outputRestored = true;
+    }
+    catch {
+        try {
+            process.stdout.write(TUI_TEARDOWN);
+        }
+        catch {
+            // The terminal is gone; there is nothing left to restore.
+        }
+    }
+    try {
+        if (process.stdin.isTTY && process.stdin.isRaw)
+            process.stdin.setRawMode(false);
+        inputRestored = true;
+    }
+    catch {
+        // stdin already closed, or not a TTY we can reconfigure.
+    }
+    // A queued or failed write must not disarm the synchronous exit retry.
+    restored = outputRestored && inputRestored;
+    return restored;
+}
+/** Appends a crash entry to `~/.neutrino/crash.log` and returns the path. */
+export function writeCrashLog(kind, err) {
+    const detail = err instanceof Error ? (err.stack ?? `${err.name}: ${err.message}`) : String(err);
+    const entry = `[${new Date().toISOString()}] ${kind} pid=${process.pid}\n${detail}\n\n`;
+    try {
+        fs.mkdirSync(NEUTRINO_DIR, { recursive: true });
+        const file = path.join(NEUTRINO_DIR, "crash.log");
+        fs.appendFileSync(file, entry, "utf8");
+        return file;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Installs process-wide handlers that restore the terminal before the process
+ * dies.
+ *
+ * Without this, any throw that escapes a timer, a stream callback or a floating
+ * promise kills the process with raw mode still on and the alternate screen
+ * still active. The visible result is a terminal that works but spews
+ * `[<b>;<x>;<y>M` mouse reports at the shell prompt, because the shell now
+ * receives the mouse events the TUI asked the terminal to send.
+ */
+export function installCrashGuard() {
+    if (installed)
+        return;
+    installed = true;
+    let flushed = false;
+    const finalize = () => {
+        restoreTerminalSync();
+        if (flushed)
+            return true;
+        flushed = true;
+        return flushSessionCheckpoints();
+    };
+    process.on("exit", () => {
+        if (!finalize()) {
+            try {
+                fs.writeSync(2, "\nneutrino: some conversation changes could not be saved; check disk access and crash.log.\n");
+            }
+            catch {
+                // The crash log is the remaining record if stderr is unavailable.
+            }
+        }
+    });
+    // These signals otherwise bypass Node's exit hook, including Ctrl+Break on
+    // Windows. SIGINT/SIGTERM are handled by App.quit (or the web server).
+    process.on("SIGHUP", () => process.exit(129));
+    process.on("SIGBREAK", () => process.exit(149));
+    const fatal = (kind, err) => {
+        // Restore first: the terminal must be usable even if logging itself fails.
+        const saved = finalize();
+        const file = writeCrashLog(kind, err);
+        const detail = err instanceof Error ? (err.stack ?? `${err.name}: ${err.message}`) : String(err);
+        try {
+            const tail = file ? `\nFull log: ${file}` : "";
+            fs.writeSync(2, `\nneutrino stopped: ${kind}\n\n${detail}\n\n` +
+                (saved
+                    ? "Check history for the latest saved conversation snapshots."
+                    : "Some conversation changes could not be saved; check disk access and crash.log.") +
+                `${tail}\n`);
+        }
+        catch {
+            // stderr is gone too; the crash log is the only record.
+        }
+        process.exit(1);
+    };
+    process.on("uncaughtException", (err) => fatal("uncaught exception", err));
+    process.on("unhandledRejection", (err) => fatal("unhandled rejection", err));
+}

package/dist/terminal/screen.js

@@ -9,6 +9,21 @@ export class Screen {
     scrollbar() {
         return null;
     }
+    /**
+     * Rows this screen draws as persistent "chrome" (an input box, key hints, …)
+     * that must be repainted on *every* frame, even when their contents are
+     * unchanged.
+     *
+     * The renderer normally emits only rows whose cells changed, which is what
+     * keeps redraws cheap. But the terminal can shift its own contents behind our
+     * back — ConPTY reflowing the buffer mid-resize, a size-race repaint, a stray
+     * scroll — and a diffed row would then stay stale forever (the classic
+     * "input box swallowed by the log" artefact). Redrawing this small strip by
+     * absolute position every frame makes it self-healing.
+     */
+    alwaysRepaintRows() {
+        return [];
+    }
     /**
      * Handle a bracketed (or detected) paste. `text` already has its newlines
      * flattened to spaces, so it can be inserted as a single line. Screens that

package/dist/ui.js

@@ -1,5 +1,21 @@
 import { C } from "./colors.js";
 import { displayWidth, truncateByWidth, wcwidth } from "./width.js";
+/** One terminal row; shared geometry keeps rendering and hit testing aligned. */
+export function approvalToggle(width, y, mode) {
+    const label = mode === "auto" ? "[ Auto Approval ]" : "[ Request Approval ]";
+    const text = truncateByWidth(label, Math.max(0, width - 2));
+    return { x: Math.max(0, Math.floor((width - displayWidth(text)) / 2)), y, w: displayWidth(text), h: 1, text };
+}
+export function drawApprovalToggle(buf, y, mode, focused = false) {
+    if (y < 1 || y >= buf.height)
+        return;
+    const button = approvalToggle(buf.width, y, mode);
+    buf.writeText(button.x, y, button.text, {
+        fg: focused ? C.black : mode === "auto" ? C.green : C.accent,
+        bg: focused ? C.accent : C.highlightBg,
+        bold: true,
+    });
+}
 function chunkByWidth(text, width) {
     const chunks = [];
     let cur = "";
@@ -199,6 +215,9 @@ export function drawScrollbar(buf, x, top, bottom, total, viewport, offset, opts
     for (let i = 0; i < g.trackH; i++) {
         const isThumb = i >= g.thumbTop && i < g.thumbTop + g.thumbH;
         buf.set(x, top + i, isThumb ? "█" : "│", { fg: isThumb ? thumbColor : trackColor });
+        // The bar is chrome, not content: mark it so copying a selection never
+        // drags the scrollbar (or the padding before it) into the clipboard.
+        buf.markChrome(x, top + i);
     }
 }
 export function drawInputBox(buf, x, y, w, value, cursorPos, opts = {}) {

package/dist/web/auth.js

@@ -0,0 +1,82 @@
+import crypto from "node:crypto";
+import { promisify } from "node:util";
+import { loadConfig, saveConfig } from "../config.js";
+export const DEFAULT_WEB_PASSWORD = "114514";
+const COOKIE = "neutrino_session";
+const MAX_AGE = 365 * 24 * 60 * 60;
+const scrypt = promisify(crypto.scrypt);
+export function validateWebPassword(password) {
+    if (typeof password !== "string" || !password.trim() || password.length > 256) {
+        throw new Error("Password must contain 1–256 characters and cannot be blank.");
+    }
+}
+/** Only a salted password hash is persisted; settings never return it. */
+export function hashWebPassword(password) {
+    validateWebPassword(password);
+    const salt = crypto.randomBytes(16).toString("hex");
+    return `scrypt:${salt}:${crypto.scryptSync(password, salt, 64).toString("hex")}`;
+}
+function passwordHash() {
+    const config = loadConfig();
+    if (typeof config.web_password_hash === "string" && config.web_password_hash)
+        return config.web_password_hash;
+    const hash = hashWebPassword(DEFAULT_WEB_PASSWORD);
+    config.web_password_hash = hash;
+    saveConfig(config);
+    return hash;
+}
+function signature(value, hash) {
+    return crypto.createHmac("sha256", hash).update(value).digest("base64url");
+}
+function matches(a, b) {
+    const left = Buffer.from(a);
+    const right = Buffer.from(b);
+    return left.length === right.length && crypto.timingSafeEqual(left, right);
+}
+/** Signed cookies survive restarts, but a password change invalidates all of them. */
+export class WebAuth {
+    enabled;
+    constructor(enabled) {
+        this.enabled = enabled;
+        if (enabled)
+            passwordHash();
+    }
+    authenticated(req) {
+        if (!this.enabled)
+            return true;
+        const value = req.headers.cookie?.split(";").map(part => part.trim())
+            .find(part => part.startsWith(`${COOKIE}=`))?.slice(COOKIE.length + 1);
+        if (!value)
+            return false;
+        const [expires, nonce, mac, extra] = value.split(".");
+        if (extra !== undefined || !/^\d+$/.test(expires) || !nonce || !mac || Number(expires) <= Date.now())
+            return false;
+        return matches(mac, signature(`${expires}.${nonce}`, passwordHash()));
+    }
+    async login(password) {
+        if (!this.enabled)
+            return true;
+        try {
+            validateWebPassword(password);
+        }
+        catch {
+            return false;
+        }
+        const hash = passwordHash();
+        const [kind, salt, expected] = hash.split(":");
+        if (kind !== "scrypt" || !salt || !expected)
+            return false;
+        const derived = await scrypt(password, salt, 64);
+        // A concurrent settings change must not issue a session for the old password.
+        return hash === passwordHash() && matches(derived.toString("hex"), expected);
+    }
+    remember(res) {
+        if (!this.enabled)
+            return;
+        const value = `${Date.now() + MAX_AGE * 1000}.${crypto.randomBytes(24).toString("base64url")}`;
+        res.setHeader("Set-Cookie", `${COOKIE}=${value}.${signature(value, passwordHash())}; Path=/; HttpOnly; SameSite=Strict; Max-Age=${MAX_AGE}`);
+    }
+    forget(res) {
+        res.setHeader("Set-Cookie", `${COOKIE}=; Path=/; HttpOnly; SameSite=Strict; Max-Age=0`);
+    }
+}

package/dist/web/hub.js

@@ -0,0 +1,180 @@
+/**
+ * The live-session hub.
+ *
+ * The terminal UI is the source of truth for a conversation: while a
+ * {@link ../screens/chat.js ChatScreen} is open it owns the message list, the
+ * streaming buffer and the busy/paused flags. The web server, however, must be
+ * able to (a) show *every* conversation live and (b) drive the running one
+ * (pause, resume, send). This hub is the bridge between the two.
+ *
+ * A screen registers itself once it is activated and unregisters when it is
+ * popped. Every time the screen changes something meaningful it calls
+ * {@link LiveHub.notify}, which coalesces rapid-fire updates (one per streamed
+ * token) and pushes a snapshot to any connected browser.
+ */
+export function liveApprovalDetails(tool, args, risk, cwd) {
+    return { tool, level: risk.level, arguments: args, cwd, summary: risk.summary, reasons: risk.reasons };
+}
+// Streaming emits tokens very quickly; coalescing to ~12fps keeps the browser
+// smooth without serialising the whole conversation on every token.
+const FLUSH_MS = 80;
+class LiveHub {
+    entries = new Map();
+    seq = 0;
+    /** Register a screen. Returns the stable key used to address it over HTTP. */
+    register(agent) {
+        for (const entry of this.entries.values()) {
+            if (entry.agent === agent)
+                return entry.key;
+        }
+        const key = `L${++this.seq}`;
+        this.entries.set(key, {
+            key,
+            agent,
+            cwd: agent.liveCwd(),
+            listeners: new Set(),
+            timer: null,
+            lastSent: "",
+        });
+        return key;
+    }
+    unregister(key) {
+        if (!key)
+            return;
+        const entry = this.entries.get(key);
+        if (!entry)
+            return;
+        if (entry.timer)
+            clearTimeout(entry.timer);
+        this.entries.delete(key);
+    }
+    has(key) {
+        return this.entries.has(key);
+    }
+    /** All live sessions, newest registration last. */
+    list() {
+        const out = [];
+        for (const entry of this.entries.values()) {
+            out.push({ ...entry.agent.liveMeta(), key: entry.key, cwd: entry.cwd });
+        }
+        return out;
+    }
+    /** One-off snapshot, or null when the key is unknown. */
+    snapshot(key) {
+        const entry = this.entries.get(key);
+        return entry ? entry.agent.liveSnapshot(key) : null;
+    }
+    /**
+     * Subscribe to a live session. The current snapshot is delivered immediately
+     * so a freshly-connected browser never has to wait for the next change.
+     */
+    subscribe(key, fn) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return null;
+        entry.listeners.add(fn);
+        try {
+            fn(entry.agent.liveSnapshot(key));
+        }
+        catch {
+            // A broken listener must not break registration.
+        }
+        return () => {
+            entry.listeners.delete(fn);
+        };
+    }
+    /**
+     * Mark a session as changed. Snapshots are only produced when somebody is
+     * listening, and duplicate snapshots (e.g. a cursor blink) are dropped.
+     */
+    notify(key) {
+        if (!key)
+            return;
+        const entry = this.entries.get(key);
+        if (!entry || entry.listeners.size === 0 || entry.timer)
+            return;
+        entry.timer = setTimeout(() => {
+            entry.timer = null;
+            const live = this.entries.get(key);
+            if (live)
+                this.flush(live);
+        }, FLUSH_MS);
+        // Don't let a pending flush keep a shutting-down process alive.
+        entry.timer.unref?.();
+    }
+    flush(entry) {
+        if (entry.listeners.size === 0)
+            return;
+        let snapshot;
+        let data;
+        try {
+            snapshot = entry.agent.liveSnapshot(entry.key);
+            data = JSON.stringify(snapshot);
+        }
+        catch {
+            return;
+        }
+        if (data === entry.lastSent)
+            return;
+        entry.lastSent = data;
+        for (const fn of [...entry.listeners]) {
+            try {
+                fn(snapshot);
+            }
+            catch {
+                // Ignore a failing listener; others still get the update.
+            }
+        }
+    }
+    pause(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return false;
+        entry.agent.livePause();
+        this.notify(key);
+        return true;
+    }
+    resume(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return false;
+        entry.agent.liveResume();
+        this.notify(key);
+        return true;
+    }
+    send(key, text) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return false;
+        entry.agent.liveSend(text);
+        this.notify(key);
+        return true;
+    }
+    approve(key, approved) {
+        const entry = this.entries.get(key);
+        if (!entry || !entry.agent.liveApprove)
+            return false;
+        const handled = entry.agent.liveApprove(approved);
+        this.notify(key);
+        return handled;
+    }
+    configure(key, selection) {
+        const entry = this.entries.get(key);
+        if (!entry?.agent.liveConfigure)
+            return { ok: false, error: "this session cannot change models" };
+        const result = entry.agent.liveConfigure(selection);
+        if (result.ok)
+            this.notify(key);
+        return result;
+    }
+    setApprovalMode(key, mode) {
+        const entry = this.entries.get(key);
+        if (!entry?.agent.liveSetApprovalMode)
+            return false;
+        entry.agent.liveSetApprovalMode(mode);
+        this.notify(key);
+        return true;
+    }
+}
+/** Process-wide singleton shared by the TUI and the web server. */
+export const hub = new LiveHub();