@xingjisoft/neutrino 0.1.4 → 0.1.6

package/dist/terminal/renderer.js

@@ -1,4 +1,5 @@
 import process from "node:process";
+import { restoreTerminalSync, markTuiActive } from "./restore.js";
 import { isControlChar } from "../sanitize.js";
 function styleKey(st) {
     let k = "";
@@ -44,29 +45,44 @@ 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
+     * The most recent frame, kept so `repaint()` can re-emit it without re-running the
      * screen's (potentially expensive) render — to heal any drift the terminal
      * introduced behind our back.
      */
     lastBuf = null;
-    lastForce = [];
+    blocked = false;
+    pendingForce = new Set();
+    drainHandler = () => {
+        this.blocked = false;
+        const forceRows = [...this.pendingForce];
+        this.pendingForce.clear();
+        if (!this.disposed && this.lastBuf)
+            this.draw(this.lastBuf, forceRows);
+    };
     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)
+        this.write("\x1b[>4;2m\x1b[>1u"); // xterm/kitty modified keys, including Ctrl+Shift+C
     }
     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;
+        this.out.removeListener?.("drain", this.drainHandler);
+        this.pendingForce.clear();
+        // stdout.write may still be queued when App.quit calls process.exit.
+        // Use the same synchronous teardown as the crash/exit guard.
+        restoreTerminalSync();
     }
     /**
      * @param forceRows rows to repaint unconditionally, even when their contents
@@ -76,7 +92,6 @@ export class Renderer {
      */
     render(buf, forceRows = []) {
         this.lastBuf = buf;
-        this.lastForce = forceRows;
         this.draw(buf, forceRows);
     }
     /**
@@ -92,7 +107,25 @@ export class Renderer {
             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) {
+        if (this.disposed)
+            return;
+        if (this.blocked) {
+            for (const y of forceRows)
+                this.pendingForce.add(y);
+            return;
+        }
         const w = buf.width;
         const h = buf.height;
         if (w !== this.prevW || h !== this.prevH) {
@@ -110,8 +143,12 @@ export class Renderer {
                 this.prevSig[y] = sig;
             }
         }
-        if (out)
-            this.write(out);
+        if (out && !this.write(out) && typeof this.out.once === "function") {
+            // The stream already accepted this frame. Wait for it to drain, then
+            // diff straight to the latest frame instead of queueing old mouse moves.
+            this.blocked = true;
+            this.out.once("drain", this.drainHandler);
+        }
     }
     renderRow(y, row) {
         // Move to the row, reset attributes and erase the whole line first. The
@@ -140,6 +177,15 @@ export class Renderer {
         return s;
     }
     write(chunk) {
-        this.out.write(chunk);
+        if (this.disposed || this.out.destroyed || this.out.writableEnded)
+            return true;
+        try {
+            return this.out.write(chunk) !== false;
+        }
+        catch {
+            // A terminal that vanished (closed window, dying conhost) must not take
+            // the whole session down with it.
+            return true;
+        }
     }
 }

package/dist/terminal/restore.js

@@ -0,0 +1,148 @@
+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[<u\x1b[>4m" + // restore kitty keyboard flags and xterm modified keys
+    "\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. The app handles SIGINT as an interrupt and SIGTERM as a quit.
+    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/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 = "";

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