@xingjisoft/neutrino 0.1.4 → 0.1.5

package/dist/agents.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { createRequire } from "node:module";
+import { claudeProjectKey, sameCwd } from "./cwd.js";
 const HOME = os.homedir();
 function parseJsonlLines(filePath) {
     let raw;
@@ -27,6 +28,37 @@ function parseJsonlLines(filePath) {
     }
     return out;
 }
+const HEAD_BYTES = 64 * 1024;
+/**
+ * Read at most `maxBytes` from the start of a file.
+ *
+ * Session transcripts can be several megabytes, but the working directory is
+ * always recorded up front, so scanning just the head keeps the history list
+ * fast when a project holds many sessions.
+ */
+function readHead(filePath, maxBytes = HEAD_BYTES) {
+    let fd = null;
+    try {
+        fd = fs.openSync(filePath, "r");
+        const len = Math.min(fs.fstatSync(fd).size, maxBytes);
+        if (len <= 0)
+            return "";
+        const buf = Buffer.alloc(len);
+        fs.readSync(fd, buf, 0, len, 0);
+        return buf.toString("utf-8");
+    }
+    catch {
+        return "";
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { }
+        }
+    }
+}
 function contentText(content) {
     if (typeof content === "string")
         return content;
@@ -78,9 +110,27 @@ function claudeTitle(lines) {
     }
     return "";
 }
-function listClaude() {
+const CWD_FIELD_RE = /"cwd"\s*:\s*("(?:[^"\\]|\\.)*")/;
+/** Working directory recorded in a Claude Code transcript ("" when unknown). */
+function claudeSessionCwd(filePath) {
+    const m = CWD_FIELD_RE.exec(readHead(filePath));
+    if (!m)
+        return "";
+    try {
+        const v = JSON.parse(m[1]);
+        return typeof v === "string" ? v : "";
+    }
+    catch {
+        return "";
+    }
+}
+function listClaude(cwd) {
     const metas = [];
+    const wantKey = claudeProjectKey(cwd);
     for (const dir of claudeProjectDirs()) {
+        // Claude names each project dir after its cwd, so the dir name still tells
+        // us the directory when a transcript predates the `cwd` field.
+        const dirKey = path.basename(dir).toLowerCase();
         let files;
         try {
             files = fs.readdirSync(dir);
@@ -99,6 +149,10 @@ function listClaude() {
             catch {
                 continue;
             }
+            // History is scoped to the current project: skip other directories.
+            const sessionCwd = claudeSessionCwd(fp);
+            if (sessionCwd ? !sameCwd(sessionCwd, cwd) : dirKey !== wantKey)
+                continue;
             const id = f.slice(0, -".jsonl".length);
             const title = cleanTitle(claudeTitle(parseJsonlLines(fp)) || id.slice(0, 8));
             metas.push({
@@ -216,11 +270,41 @@ function codexMessageText(payload) {
         .join("")
         .trim();
 }
-function listCodex() {
+/** Working directory recorded in a Codex rollout file ("" when unknown). */
+function codexSessionCwd(filePath) {
+    let fallback = "";
+    for (const line of readHead(filePath).split("\n")) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        let o;
+        try {
+            o = JSON.parse(t);
+        }
+        catch {
+            continue;
+        }
+        const payload = o.payload;
+        const c = typeof payload?.cwd === "string" ? payload.cwd : typeof o.cwd === "string" ? o.cwd : "";
+        if (!c)
+            continue;
+        // session_meta is authoritative; other records (turn_context) only serve
+        // as a fallback for older rollouts.
+        if (o.type === "session_meta")
+            return c;
+        if (!fallback)
+            fallback = c;
+    }
+    return fallback;
+}
+function listCodex(cwd) {
     const index = codexIndex();
     const files = codexRolloutFiles();
     const metas = [];
     for (const [id, fp] of files) {
+        // History is scoped to the current project: skip other directories.
+        if (!sameCwd(codexSessionCwd(fp), cwd))
+            continue;
         const info = index.get(id);
         let title = info?.title ?? "";
         let updated = info?.updated_at ?? "";
@@ -320,15 +404,28 @@ function opencodeModelName(modelJson) {
         return "";
     }
 }
-function listOpencode() {
+function listOpencode(cwd) {
     const db = opencodeDbHandle();
     if (!db)
         return [];
-    try {
-        const rows = db
-            .prepare("SELECT id, title, agent, model, time_created, time_updated FROM session ORDER BY time_updated DESC")
-            .all();
-        return rows.map((r) => ({
+    // Current schemas store the project directory on the session row; older ones
+    // keep it on the related project row. Try both, newest schema first.
+    const queries = [
+        "SELECT id, title, agent, model, time_created, time_updated, directory AS dir FROM session ORDER BY time_updated DESC",
+        "SELECT s.id AS id, s.title AS title, s.agent AS agent, s.model AS model, s.time_created AS time_created, s.time_updated AS time_updated, p.worktree AS dir FROM session s LEFT JOIN project p ON p.id = s.project_id ORDER BY s.time_updated DESC",
+    ];
+    for (const sql of queries) {
+        let rows;
+        try {
+            rows = db.prepare(sql).all();
+        }
+        catch {
+            continue; // this schema has no project path column, try the next query
+        }
+        // History is scoped to the current project: skip other directories.
+        return rows
+            .filter((r) => sameCwd(typeof r.dir === "string" ? r.dir : "", cwd))
+            .map((r) => ({
             id: String(r.id ?? ""),
             title: cleanTitle(typeof r.title === "string" ? r.title : "").slice(0, 80),
             created_at: iso(r.time_created),
@@ -336,9 +433,7 @@ function listOpencode() {
             model: opencodeModelName(r.model) || (typeof r.agent === "string" ? r.agent : ""),
         }));
     }
-    catch {
-        return [];
-    }
+    return [];
 }
 function loadOpencode(id) {
     const db = opencodeDbHandle();
@@ -380,12 +475,16 @@ function loadOpencode(id) {
     }
 }
 // ---------------- Public API ----------------
-export function listAgentSessions(agent) {
+/**
+ * Sessions of `agent` that were started in `cwd` (the directory neutrino runs
+ * in), newest first. Sessions from other directories are not shown.
+ */
+export function listAgentSessions(agent, cwd = process.cwd()) {
     if (agent === "claude")
-        return listClaude();
+        return listClaude(cwd);
     if (agent === "codex")
-        return listCodex();
-    return listOpencode();
+        return listCodex(cwd);
+    return listOpencode(cwd);
 }
 export function loadAgentMessages(agent, id) {
     if (agent === "claude")

package/dist/app.js

@@ -2,6 +2,7 @@ import process from "node:process";
 import { Buffer } from "./terminal/buffer.js";
 import { InputReader } from "./terminal/input.js";
 import { Renderer } from "./terminal/renderer.js";
+import { installCrashGuard, writeCrashLog } from "./terminal/restore.js";
 import { defaultState } from "./state.js";
 import { loadConfig, saveConfig } from "./config.js";
 import { C } from "./colors.js";
@@ -14,6 +15,7 @@ import { AgentSelectScreen } from "./screens/agentSelect.js";
 import { ModelSelectScreen } from "./screens/modelSelect.js";
 import { SettingsScreen } from "./screens/settings.js";
 import { StartScreen } from "./screens/start.js";
+import { startWebServer } from "./web/server.js";
 const CURSOR_BLINK_MS = 530;
 const TOAST_MS = 1600;
 // How often the whole frame is re-emitted as a safety net, so terminal-side
@@ -34,6 +36,9 @@ export class App {
     toastTimer = null;
     repaintTimer = null;
     toast = "";
+    // Consecutive failed renders. A screen that cannot draw itself is fatal;
+    // a single bad frame is not.
+    renderFailures = 0;
     // 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;
@@ -47,6 +52,7 @@ export class App {
     // landed, so the thumb stays under the pointer as it moves.
     barDrag = null;
     resizeHandler = () => this.onResize();
+    webHandle = null;
     constructor() {
         this.width = process.stdout.columns || 80;
         this.height = process.stdout.rows || 24;
@@ -76,7 +82,21 @@ export class App {
         this.state.selectedModelApiKey = String(config.selected_model_api_key ?? this.state.selectedModelApiKey);
         this.state.selectedModelStreaming = Boolean(config.selected_model_streaming ?? true);
     }
+    /**
+     * Mount the browser UI on the given port. Safe to call once; subsequent calls
+     * return the already-running server.
+     */
+    async enableWeb(port, host, auth = true) {
+        if (this.webHandle)
+            return this.webHandle;
+        this.webHandle = await startWebServer({ port, host, auth });
+        return this.webHandle;
+    }
     async start() {
+        // Installed before anything touches the terminal: from here on, a crash
+        // restores mouse tracking, raw mode and the alternate screen instead of
+        // handing the shell a terminal that types mouse reports.
+        installCrashGuard();
         this.renderer.init();
         this.input.start((ev) => this.handleEvent(ev));
         process.stdout.on("resize", this.resizeHandler);
@@ -112,6 +132,29 @@ export class App {
         this.render();
     }
     render() {
+        try {
+            this.renderFrame();
+            this.renderFailures = 0;
+        }
+        catch (err) {
+            // Rendering runs from timers and stream callbacks too, so an escaping
+            // throw here is equally fatal.
+            this.renderFailures++;
+            if (this.renderFailures === 1)
+                this.noteInternalError("render", err);
+            // A screen that cannot be drawn at all means there is no UI left; stop
+            // instead of spinning on a broken frame every 60 ms.
+            if (this.renderFailures > 30)
+                this.quit(1);
+        }
+    }
+    noteInternalError(kind, err) {
+        const file = writeCrashLog(kind, err);
+        const detail = err instanceof Error ? err.message : String(err);
+        const where = file ? ` - details in ${file}` : "";
+        this.showToast(`internal error (${kind}): ${detail}${where}`);
+    }
+    renderFrame() {
         // Start/stop the "thinking" blink animation. While the agent is thinking,
         // a timer toggles the blink phase and re-renders so the top status bar
         // flashes to draw the user's attention.
@@ -167,6 +210,16 @@ export class App {
         this.state.cursorOn = true;
     }
     handleEvent(ev) {
+        try {
+            this.dispatchEvent(ev);
+        }
+        catch (err) {
+            // This runs inside a stdin 'data' callback, where a throw is an uncaught
+            // exception that would kill the app mid-keystroke.
+            this.noteInternalError("input handler", err);
+        }
+    }
+    dispatchEvent(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.
@@ -316,6 +369,24 @@ export class App {
         copyToClipboard(text);
         this.showToast(`Copied ${text.length} char${text.length === 1 ? "" : "s"}`);
     }
+    // Public so screens can surface transient status (e.g. "reviewing 3/3").
+    /**
+     * Audible cue for something the user is waiting on.
+     *
+     * Silent when `sound_alerts` is off, so the bell stays a preference rather
+     * than unavoidable noise. A pending approval rings twice: it is the one event
+     * that actually blocks the agent, and a single blip is easy to miss.
+     */
+    bell(kind = "turn") {
+        try {
+            if (loadConfig().sound_alerts === false)
+                return;
+        }
+        catch {
+            // A config we cannot read must not swallow the cue.
+        }
+        this.renderer.bell(kind === "approval" ? 2 : 1);
+    }
     showToast(text) {
         this.toast = text;
         if (this.toastTimer)
@@ -344,16 +415,20 @@ export class App {
         saveConfig(config);
     }
     startNewChat(text) {
+        this.restoreSelection();
         this.pushScreen(new ChatScreen(text));
     }
     loadSession(data) {
         const screen = new ChatScreen("");
         screen.sessionId = data.id;
         screen.loadedMessages = data.messages ?? [];
+        screen.loadedCwd = data.cwd ?? null;
         screen.loadedProvider = data.provider || null;
         screen.loadedModel = data.model || null;
         screen.loadedIntensity = data.intensity || null;
         screen.loadedTokens = data.tokens ?? null;
+        screen.loadedContext = data.context ?? null;
+        screen.loadedApprovalMode = data.approval_mode ?? null;
         if (data.provider)
             this.state.selectedProvider = data.provider;
         if (data.model)
@@ -382,7 +457,7 @@ export class App {
             return;
         this.pushScreen(new SettingsScreen());
     }
-    quit() {
+    quit(exitCode = 0) {
         if (this.running)
             return;
         this.running = true;
@@ -404,8 +479,15 @@ export class App {
             clearTimeout(this.toastTimer);
             this.toastTimer = null;
         }
-        this.input.stop();
+        // Disable mouse reporting before input returns to cooked/echo mode.
         this.renderer.dispose();
-        process.exit(0);
+        try {
+            this.input.stop();
+        }
+        catch {
+            // Terminal restoration has already run, even if stdin is unusable.
+        }
+        void this.webHandle?.close();
+        process.exit(exitCode);
     }
 }

package/dist/bin.js

@@ -1,9 +1,181 @@
 #!/usr/bin/env node
 import process from "node:process";
 import { App } from "./app.js";
-if (!process.stdout.isTTY || !process.stdin.isTTY) {
-    process.stderr.write("neutrino requires an interactive terminal.\n");
-    process.exit(1);
+import { installCrashGuard } from "./terminal/restore.js";
+import { startWebServer } from "./web/server.js";
+const DEFAULT_WEB_PORT = 8765;
+/** Binding here makes the UI reachable from every interface. */
+const WILDCARD_HOST = "0.0.0.0";
+function parsePort(raw) {
+    if (!raw)
+        throw new Error("missing port number");
+    if (!/^\d+$/.test(raw))
+        throw new Error(`invalid port "${raw}"`);
+    const port = Number(raw);
+    if (port < 0 || port > 65535)
+        throw new Error(`port out of range: ${raw}`);
+    return port;
+}
+function envPort() {
+    const raw = process.env.NEUTRINO_WEB_PORT;
+    if (!raw)
+        return null;
+    try {
+        return parsePort(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function printHelp() {
+    process.stdout.write(`Neutrino
+
+Usage:
+  neutrino                     Start the terminal UI.
+  neutrino --web-port <port>   Start the terminal UI and mount the web UI.
+  neutrino web [--port <port>] Start only the web UI (serves saved history).
+
+Options:
+  -p, --port <port>   Web server port (web mode). Default: ${DEFAULT_WEB_PORT}
+      --host <host>   Interface to bind. Default: 127.0.0.1
+      --lan           Short for --host ${WILDCARD_HOST}: reachable from other
+                      devices on your LAN or VPN.
+      --no-auth       Serve without password login.
+      --web-port <n>  Also mount the web UI while the TUI runs.
+  -h, --help          Show this help.
+
+Environment:
+  NEUTRINO_WEB_PORT   Same as --web-port for the TUI, or the port in web mode.
+  NEUTRINO_WEB_HOST   Same as --host.
+
+The web UI can read every saved conversation and drive an agent with shell
+access, so it binds to loopback by default. Log in with the permanent password
+(default: 114514). Change it in Settings. --no-auth disables password login.
+`);
+}
+/** Read the value that follows a flag, so `--host` alone is an error. */
+function requireValue(argv, index, flag) {
+    const value = argv[index];
+    if (value === undefined || value.trim() === "") {
+        throw new Error(`missing value for ${flag}`);
+    }
+    return value;
+}
+function parseArgs(argv) {
+    const options = { mode: "tui", port: null, lan: false, noAuth: false };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "web") {
+            options.mode = "web";
+        }
+        else if (arg === "--port" || arg === "-p") {
+            options.port = parsePort(argv[++i]);
+        }
+        else if (arg.startsWith("--port=")) {
+            options.port = parsePort(arg.slice("--port=".length));
+        }
+        else if (arg === "--web-port") {
+            options.port = parsePort(argv[++i]);
+        }
+        else if (arg.startsWith("--web-port=")) {
+            options.port = parsePort(arg.slice("--web-port=".length));
+        }
+        else if (arg === "--host") {
+            options.host = requireValue(argv, ++i, "--host");
+        }
+        else if (arg.startsWith("--host=")) {
+            options.host = arg.slice("--host=".length);
+        }
+        else if (arg === "--lan") {
+            options.lan = true;
+        }
+        else if (arg === "--no-auth") {
+            options.noAuth = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            printHelp();
+            process.exit(0);
+        }
+        else {
+            throw new Error(`unknown argument "${arg}"`);
+        }
+    }
+    if (options.lan && options.host) {
+        throw new Error("use either --lan or --host, not both");
+    }
+    return options;
+}
+/** Print every address a client can open, plus what it takes to open one. */
+function reportAccess(handle) {
+    process.stdout.write(`Neutrino web UI listening on ${handle.host}:${handle.port}\n`);
+    const multiple = handle.urls.length > 1;
+    process.stdout.write(multiple ? "Open the address that matches your device:\n" : "Open:\n");
+    for (const url of handle.urls)
+        process.stdout.write(`  ${url}\n`);
+    const wildcard = handle.host === "0.0.0.0" || handle.host === "::";
+    if (wildcard && !handle.urls.some((url) => !url.includes("//127.0.0.1:"))) {
+        // Bound to every interface, yet nothing outside this machine is reachable:
+        // usually Wi-Fi is off, the VPN is down, or the only adapters left are
+        // virtual ones we deliberately hide.
+        process.stdout.write("note: no reachable network address found, so only this machine can connect.\n");
+    }
+    if (handle.authRequired) {
+        process.stdout.write("Sign in with your permanent Web password (default: 114514). Change it in Settings.\n");
+    }
+    else {
+        process.stdout.write("Password login is disabled.\n");
+    }
+}
+let options;
+try {
+    options = parseArgs(process.argv.slice(2));
+}
+catch (err) {
+    process.stderr.write(`neutrino: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.stderr.write("Run 'neutrino --help' for usage.\n");
+    process.exit(2);
+}
+// Installed before either mode starts: a crash must leave a usable terminal
+// (TUI) and a log line (both), never a shell flooded with mouse reports.
+installCrashGuard();
+const host = options.lan ? WILDCARD_HOST : options.host || process.env.NEUTRINO_WEB_HOST || undefined;
+const auth = !options.noAuth;
+if (options.mode === "web") {
+    // Headless: serve the saved history (and any live sessions in this process,
+    // which for a standalone server is none).
+    const port = options.port ?? envPort() ?? DEFAULT_WEB_PORT;
+    try {
+        const handle = await startWebServer({ port, host, auth });
+        reportAccess(handle);
+        process.stdout.write("Serving saved conversations. Press Ctrl+C to stop.\n");
+        const shutdown = () => {
+            handle.close().finally(() => process.exit(0));
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+    }
+    catch (err) {
+        process.stderr.write(`neutrino: failed to start web server: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(1);
+    }
+}
+else {
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+        process.stderr.write("neutrino requires an interactive terminal.\n");
+        process.stderr.write("To serve the web UI without a terminal, run 'neutrino web --port <port>'.\n");
+        process.exit(1);
+    }
+    const app = new App();
+    const webPort = options.port ?? envPort();
+    if (webPort !== null) {
+        try {
+            const handle = await app.enableWeb(webPort, host, auth);
+            reportAccess(handle);
+        }
+        catch (err) {
+            process.stderr.write(`neutrino: failed to start web server: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+    }
+    await app.start();
 }
-const app = new App();
-await app.start();

package/dist/colors.js

@@ -8,6 +8,8 @@ export const C = {
     toolHeader: [153, 217, 234], // cyan
     amber: [224, 175, 104], // #E0AF68
     white: [226, 232, 240],
+    orange: [255, 158, 61], // #FF9E3D approval highlight
+    orangeBg: [61, 36, 14], // #3D240E dim orange behind approval cards
     green: [115, 218, 202],
     red: [247, 118, 142],
     codeBg: [27, 35, 49], // dark blue-grey used behind code blocks

package/dist/compact.js

@@ -6,6 +6,25 @@
  * part into a plain transcript. The actual "ask the model to summarise" step
  * lives in `LLMClient.summarize`, so this module stays trivially unit-testable.
  */
+/** Ignore stale/corrupt metadata rather than hiding any original messages. */
+export function normalizeContext(value, messageCount) {
+    if (!value || typeof value !== "object")
+        return null;
+    const context = value;
+    if (typeof context.end !== "number" || !Number.isInteger(context.end) ||
+        context.end <= 0 || context.end > messageCount ||
+        typeof context.summary !== "string" || !context.summary.trim())
+        return null;
+    return { end: context.end, summary: context.summary };
+}
+/** Derive a bounded model history while leaving the complete transcript intact. */
+export function modelHistory(messages, context) {
+    const original = messages.filter((message) => message.role !== "system");
+    const valid = normalizeContext(context, original.length);
+    return valid
+        ? [{ role: "summary", content: valid.summary }, ...original.slice(valid.end)]
+        : original;
+}
 /** How many trailing messages are always kept verbatim when compressing. */
 export const COMPACT_KEEP = 4;
 /** Per-message character budget fed to the summariser, to bound its own input. */