@xingjisoft/neutrino 0.1.4 → 0.1.6

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. */

package/dist/config.js

@@ -2,12 +2,32 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import { sameCwd } from "./cwd.js";
+import { normalizeContext } from "./compact.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PKG_ROOT = path.resolve(__dirname, "..");
 export const NEUTRINO_DIR = path.join(os.homedir(), ".neutrino");
 export const MODEL_FILE = path.join(NEUTRINO_DIR, "model.json");
 export const SESSION_DIR = path.join(NEUTRINO_DIR, "session");
 export const CONFIG_FILE = path.join(NEUTRINO_DIR, "config.json");
+export const DEFAULT_CONTEXT_WINDOW = 1_000_000;
+export const CONTEXT_COMPRESSION_RATIO = 0.8;
+export const CONTEXT_WINDOW_OPTIONS = [32_000, 64_000, 128_000, 200_000, 256_000, 512_000, 1_000_000, 2_000_000, 4_000_000];
+export function isContextWindow(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+export function contextWindow(value) {
+    return isContextWindow(value) ? value : DEFAULT_CONTEXT_WINDOW;
+}
+/** Reload the exact provider/model so settings also apply to active chats. */
+export function modelContextWindow(provider, model) {
+    const saved = loadModels().providers.find((p) => p.name === provider)?.models.find((m) => m.name === model.name);
+    return contextWindow((saved ?? model).context_window);
+}
+export function contextCompressionThreshold(provider, model) {
+    return Math.max(1, Math.floor(modelContextWindow(provider, model) * CONTEXT_COMPRESSION_RATIO));
+}
 export const DEFAULT_MODELS = {
     providers: [
         {
@@ -36,9 +56,16 @@ export const DEFAULT_CONFIG = {
     language: "en",
     theme: "default",
     default_intensity: "High",
-    // Estimated prompt tokens above which the conversation is auto-compressed.
-    // 0 disables auto-compression.
-    context_compress_threshold: 32000,
+    // Default for new conversations; each conversation can override it.
+    approval_mode: "request",
+    // Delete-class commands need a human unless this and Auto Approval are on.
+    auto_approve_extreme_risk: false,
+    // Audible cue when a turn ends or an approval request is waiting.
+    sound_alerts: true,
+    // Model that reviews approval requests. Empty = same model as the chat.
+    approval_model: "",
+    // Initialized as a salted hash of the default Web password on first use.
+    web_password_hash: "",
 };
 export const INTENSITY_LEVELS = ["Low", "Medium", "High", "Max", "Ultra"];
 export const INTENSITY_PARAMS = {
@@ -48,32 +75,28 @@ export const INTENSITY_PARAMS = {
     Max: { temperature: 1.0, top_p: 1.0 },
     Ultra: { temperature: 1.5, top_p: 1.0 },
 };
-/**
- * Selectable auto-compression thresholds, in estimated prompt tokens.
- * `0` turns the feature off. Rendered as-is in the settings screen.
- */
-export const COMPRESS_THRESHOLD_OPTIONS = [
-    { value: 0, label: "Off" },
-    { value: 8000, label: "8K tokens" },
-    { value: 16000, label: "16K tokens" },
-    { value: 32000, label: "32K tokens" },
-    { value: 64000, label: "64K tokens" },
-    { value: 128000, label: "128K tokens" },
-];
+export function normalizeApprovalMode(value) {
+    // Config files are hand-edited: "Auto" or " autO " must not silently
+    // downgrade the conversation to a prompt on every tool call.
+    return typeof value === "string" && value.trim().toLowerCase() === "auto"
+        ? "auto"
+        : "request";
+}
 export function ensureDirs() {
     fs.mkdirSync(NEUTRINO_DIR, { recursive: true });
     fs.mkdirSync(SESSION_DIR, { recursive: true });
 }
 export function loadModels() {
-    ensureDirs();
-    if (!fs.existsSync(MODEL_FILE)) {
-        saveModels(DEFAULT_MODELS);
-        return DEFAULT_MODELS;
-    }
     try {
+        ensureDirs();
+        if (!fs.existsSync(MODEL_FILE)) {
+            saveModels(DEFAULT_MODELS);
+            return DEFAULT_MODELS;
+        }
         return JSON.parse(fs.readFileSync(MODEL_FILE, "utf-8"));
     }
     catch {
+        // Same reasoning as loadConfig: this sits on the approval path.
         return DEFAULT_MODELS;
     }
 }
@@ -82,15 +105,17 @@ export function saveModels(data) {
     fs.writeFileSync(MODEL_FILE, JSON.stringify(data, null, 2), "utf-8");
 }
 export function loadConfig() {
-    ensureDirs();
-    if (!fs.existsSync(CONFIG_FILE)) {
-        saveConfig(DEFAULT_CONFIG);
-        return { ...DEFAULT_CONFIG };
-    }
     try {
+        ensureDirs();
+        if (!fs.existsSync(CONFIG_FILE)) {
+            saveConfig(DEFAULT_CONFIG);
+            return { ...DEFAULT_CONFIG };
+        }
         return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
     }
     catch {
+        // The approval gate reads this on every tool call; a directory we cannot
+        // create or a file we cannot parse must fall back, not throw.
         return { ...DEFAULT_CONFIG };
     }
 }
@@ -98,6 +123,18 @@ export function saveConfig(data) {
     ensureDirs();
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), "utf-8");
 }
+/** Look a model up by name across every configured provider. */
+export function findModel(name) {
+    const wanted = name.trim();
+    if (!wanted)
+        return null;
+    for (const [provider, models] of Object.entries(getModelsByProvider())) {
+        const model = models.find((m) => m.name === wanted);
+        if (model)
+            return { provider, model };
+    }
+    return null;
+}
 export function getModelsByProvider() {
     const data = loadModels();
     const result = {};
@@ -106,10 +143,30 @@ export function getModelsByProvider() {
     }
     return result;
 }
-export function saveSession(messages, modelName, provider, intensity, cwd, sessionId, tokens) {
+/** Resolve a provider/model pair exactly, including when names repeat across providers. */
+export function resolveModelSelection(value, requireKey = true) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("invalid model selection");
+    const input = value;
+    if (typeof input.provider !== "string" || typeof input.model !== "string" ||
+        typeof input.intensity !== "string")
+        throw new Error("provider, model and intensity are required");
+    if (!INTENSITY_LEVELS.includes(input.intensity))
+        throw new Error("invalid thinking intensity");
+    const provider = loadModels().providers.find((p) => p.name === input.provider);
+    if (!provider)
+        throw new Error("unknown provider");
+    const model = provider.models.find((m) => m.name === input.model);
+    if (!model)
+        throw new Error("unknown model for this provider");
+    if (requireKey && !model.api_key?.trim())
+        throw new Error("this model has no API key configured");
+    return { provider: provider.name, model: { ...model }, intensity: input.intensity };
+}
+export function saveSession(messages, modelName, provider, intensity, cwd, sessionId, tokens, context, approvalMode) {
     ensureDirs();
     const now = new Date();
-    const id = sessionId ?? now.toISOString().replace(/[:.]/g, "-");
+    const id = sessionId ?? `${now.toISOString().replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
     const existing = sessionId ? loadSession(sessionId) : null;
     const created_at = existing ? existing.created_at : now.toISOString();
     let title = "";
@@ -130,9 +187,37 @@ export function saveSession(messages, modelName, provider, intensity, cwd, sessi
         title,
         messages,
         tokens,
+        approval_mode: normalizeApprovalMode(approvalMode ?? existing?.approval_mode),
     };
+    const validContext = normalizeContext(context, messages.filter((m) => m.role !== "system").length);
+    if (validContext)
+        session.context = validContext;
     const filePath = path.join(SESSION_DIR, `${id}.json`);
-    fs.writeFileSync(filePath, JSON.stringify(session, null, 2), "utf-8");
+    // Keep the last complete transcript intact if writing or replacing fails.
+    // The temporary file shares the destination directory so rename is atomic.
+    const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    const contents = JSON.stringify(session, null, 2);
+    let fd;
+    try {
+        fd = fs.openSync(tempPath, "wx", 0o600);
+        fs.writeFileSync(fd, contents, "utf-8");
+        fs.fsyncSync(fd);
+        fs.closeSync(fd);
+        fd = undefined;
+        fs.renameSync(tempPath, filePath);
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { /* Preserve the write error. */ }
+        }
+        try {
+            fs.rmSync(tempPath, { force: true });
+        }
+        catch { /* Best-effort cleanup. */ }
+    }
     return id;
 }
 export function loadSession(sessionId) {
@@ -186,6 +271,14 @@ export function listSessions() {
     sessions.sort((a, b) => (b.updated_at || b.created_at).localeCompare(a.updated_at || a.created_at));
     return sessions;
 }
+/**
+ * Sessions that were started in `cwd` (the directory neutrino runs in).
+ * The history menu is scoped to the current project so sessions started in
+ * other directories do not clutter it.
+ */
+export function listSessionsForCwd(cwd = process.cwd()) {
+    return listSessions().filter((s) => sameCwd(s.cwd, cwd));
+}
 function readAsset(...candidates) {
     for (const candidate of candidates) {
         try {

package/dist/cwd.js

@@ -0,0 +1,54 @@
+/**
+ * Helpers for deciding whether a stored session belongs to the directory the
+ * agent is currently running in.
+ *
+ * Every agent records the working directory in its own flavour — `C:\a\b`,
+ * `C:/a/b`, a trailing slash, a differently cased drive letter, or a WSL style
+ * `/mnt/c/a/b` — so the comparison has to be forgiving about the spelling and
+ * strict about the actual location.
+ */
+/** Reduce a directory path to a canonical form that can be compared for equality. */
+export function normalizeCwd(dir) {
+    let p = (dir ?? "").trim();
+    if (!p)
+        return "";
+    // The Windows long-path prefix ("\\?\C:\a") carries no meaning for us.
+    p = p.replace(/^\\\\\?\\/, "");
+    p = p.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+    let drive = "";
+    let rest = p;
+    const wslDrive = /^\/(?:mnt|cygdrive)\/([a-zA-Z])(\/.*)?$/.exec(p);
+    const winDrive = /^([a-zA-Z]):(\/.*)?$/.exec(p);
+    if (wslDrive) {
+        drive = wslDrive[1];
+        rest = wslDrive[2] ?? "/";
+    }
+    else if (winDrive) {
+        drive = winDrive[1];
+        rest = winDrive[2] ?? "/";
+    }
+    if (drive) {
+        if (rest.length > 1)
+            rest = rest.replace(/\/+$/, "");
+        // Drive paths are Windows paths, which are case-insensitive.
+        return `${drive.toLowerCase()}:${(rest || "/").toLowerCase()}`;
+    }
+    // POSIX paths are case-sensitive: only drop trailing separators.
+    return p.length > 1 ? p.replace(/\/+$/, "") : p;
+}
+/** True when both paths point at the same directory. Empty paths never match. */
+export function sameCwd(a, b) {
+    const na = normalizeCwd(a);
+    const nb = normalizeCwd(b);
+    return na !== "" && na === nb;
+}
+/**
+ * Claude Code names each project directory after the working directory with
+ * every non-alphanumeric character replaced by a dash. That lets us attribute
+ * transcripts that do not carry an explicit `cwd` field.
+ */
+export function claudeProjectKey(dir) {
+    return normalizeCwd(dir)
+        .replace(/[^a-zA-Z0-9]/g, "-")
+        .toLowerCase();
+}

package/dist/header.js

@@ -2,6 +2,14 @@ import { C } from "./colors.js";
 import { truncateByWidth } from "./width.js";
 export function drawHeader(buf, state) {
     const w = buf.width;
+    if (state.approval) {
+        // A tool call is waiting for an answer: the whole bar turns orange so it
+        // cannot be missed while the agent sits paused mid-turn.
+        const bg = C.orange;
+        buf.fillRect(0, 0, w, 1, { bg });
+        buf.centerText(0, "Request Approval", { fg: C.black, bg, bold: true });
+        return;
+    }
     if (state.isThinking) {
         // Flashing indicator: the whole bar alternates between highlighted and
         // dark while the agent is working, so the user always notices it.