@xingjisoft/neutrino 0.4.1 → 0.5.1

package/README.md

@@ -2,7 +2,7 @@
 
 ↓ 详细内容点这里 Learn More ↓
 
-[English](./README-en.md) | [简体中文](./README-en.md)
+[English](./README-en.md) | [简体中文](./README-zh.md)
 
 ## 什么是 Neutrino ？
 

package/dist/app.js

@@ -16,6 +16,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 { UpdatePromptScreen } from "./screens/updatePrompt.js";
 import { configureBackgroundService, readBackgroundStatus, isProcessAlive, runningBackground, startBackgroundService, stopBackgroundService, } from "./background.js";
 import { startTerminalBridge } from "./web/terminalBridge.js";
 const CURSOR_BLINK_MS = 530;
@@ -102,6 +103,10 @@ export class App {
     webPromptBackground = true;
     /** True while a click is bringing the Web console up, so double clicks are safe. */
     proOpening = false;
+    /** Same guard for the Web-mode button, which has its own click. */
+    webOpening = false;
+    /** An update offer that arrived before the start screen was mounted. */
+    pendingUpdate = null;
     constructor() {
         this.width = process.stdout.columns || 80;
         this.height = process.stdout.rows || 24;
@@ -340,6 +345,28 @@ export class App {
             this.proOpening = false;
         }
     }
+    /**
+     * Open the browser console's regular workspace, bringing the console up first
+     * when it is not running yet. Like openProMode it runs from a mouse handler:
+     * it never throws and never waits on the browser.
+     */
+    async openWebMode() {
+        if (this.webOpening)
+            return;
+        this.webOpening = true;
+        try {
+            const url = await this.ensureWebConsole();
+            openInBrowser(url);
+            this.showToast(`Opening Web console: ${url}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.showToast(`Web console failed: ${message}`, "top");
+        }
+        finally {
+            this.webOpening = false;
+        }
+    }
     async start() {
         // Installed before anything touches the terminal: from here on, a crash
         // restores mouse tracking, raw mode and the alternate screen instead of
@@ -371,6 +398,14 @@ export class App {
         this.resetMouse();
         this.state.selection = null;
         screen.onActivate();
+        // An offer made while the start screen was not mounted yet belongs on it,
+        // and the start screen is exactly what has just appeared.
+        if (screen instanceof StartScreen && this.pendingUpdate) {
+            const status = this.pendingUpdate;
+            this.pendingUpdate = null;
+            this.pushScreen(new UpdatePromptScreen(status));
+            return;
+        }
         this.render();
     }
     popScreen() {
@@ -975,6 +1010,26 @@ export class App {
         }
         this.pushScreen(screen);
     }
+    /**
+     * Offer a newer published release where a session starts.
+     *
+     * The registry answer arrives a moment after launch. If the user is already
+     * in a conversation by then, the notice is dropped rather than breaking into
+     * their work: the next start offers it again.
+     */
+    promptUpdate(status) {
+        if (this.screens.some((screen) => screen instanceof UpdatePromptScreen))
+            return;
+        if (this.top instanceof StartScreen) {
+            this.pushScreen(new UpdatePromptScreen(status));
+            return;
+        }
+        // No screen is mounted yet: the launch is still starting the Web console.
+        // Hold the offer until the start screen appears. Once the user has moved
+        // on to a conversation the offer is dropped instead of interrupting it.
+        if (this.screens.length === 0)
+            this.pendingUpdate = status;
+    }
     openModelConfig() {
         if (this.screens.some((s) => s instanceof ModelSelectScreen))
             return;

package/dist/bin.js

@@ -7,6 +7,8 @@ import { webUrls } from "./web/server.js";
 import { runningBackground, startBackgroundService, stopBackgroundService, } from "./background.js";
 import { runWebService } from "./web/service.js";
 import { openInBrowser } from "./browser.js";
+import { PRO_MODEL_FILE, PRO_MODELS_URL, syncProModels } from "./pro/config.js";
+import { checkForUpdate } from "./update.js";
 const DEFAULT_WEB_PORT = 8765;
 /** Binding here makes the UI reachable from every interface. */
 const WILDCARD_HOST = "0.0.0.0";
@@ -321,6 +323,21 @@ else {
         process.stderr.write("To serve the web UI without a terminal, run 'neutrino web --port <port>'.\n");
         process.exit(1);
     }
+    // The Pro presets are downloaded, not shipped, and kept in line with the
+    // official copy before any workspace can ask for a preset. A failure is not
+    // fatal: Pro mode reports the missing file (or keeps the local presets), and
+    // the next start tries again.
+    await syncProModels().then((result) => {
+        if (result.status === "updated") {
+            process.stderr.write(`neutrino: updated the Pro presets at ${PRO_MODEL_FILE} from ${PRO_MODELS_URL}\n`);
+        }
+    }).catch((error) => {
+        process.stderr.write(`neutrino: ${error instanceof Error ? error.message : String(error)}\n`);
+    });
+    // Ask the registry for the published version as early as possible, while the
+    // Web console is still starting: the first screen must not wait on the
+    // network. Offline is an ordinary state, hence no diagnostic here.
+    const updateCheck = checkForUpdate();
     const app = new App();
     const webPort = options.port ?? portFromEnv ?? DEFAULT_WEB_PORT;
     const saved = loadConfig();
@@ -342,5 +359,9 @@ else {
             process.stderr.write("The terminal UI will keep running. Pass --port <port> to use another port, or --no-web to skip the web UI.\n");
         }
     }
+    void updateCheck.then((status) => {
+        if (status.hasUpdate)
+            app.promptUpdate(status);
+    });
     await app.start();
 }

package/dist/pro/config.js

@@ -1,10 +1,16 @@
 import fs from "node:fs";
 import path from "node:path";
+import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { PRO_DIR, loadConfig } from "../config.js";
 /** Provider URLs and credentials stay in the shared, ordinary model catalogue. */
 export const PRO_MODEL_FILE = path.join(PRO_DIR, "model.json");
+/** Presets the user adds or rewrites themselves; a same-named preset here wins. */
+export const PRO_CUSTOM_MODEL_FILE = path.join(PRO_DIR, "model-custom.json");
+/** The official presets, fetched on first use: nothing is bundled with the package. */
+export const PRO_MODELS_URL = "https://ius.neutrino.xingjisoft.com/model.json";
 const ASSET_DIR = fileURLToPath(new URL("../../assets/pro/", import.meta.url));
+const DOWNLOAD_TIMEOUT_MS = 10_000;
 export const PRO_ROLES = [
     "main_model", "thinking_model", "front_output_model", "backend_output_model",
     "confirm_model", "genimage_model", "plan_model", "modeling_model",
@@ -15,29 +21,125 @@ export const PRO_ROLE_LABELS = {
     backend_output_model: "Backend", confirm_model: "Approval", genimage_model: "Image generation",
     plan_model: "Planning", modeling_model: "Modeling",
 };
-/** Copy the bundled template byte-for-byte, exclusively on first use. */
+let downloading = null;
+/**
+ * Make sure the Pro presets are on disk, downloading the official set the first
+ * time. A file the user already has is never touched here; a failed download
+ * leaves nothing behind, so the next start simply tries again.
+ */
 export function ensureProModels() {
     fs.mkdirSync(PRO_DIR, { recursive: true });
+    if (fs.existsSync(PRO_MODEL_FILE))
+        return Promise.resolve();
+    downloading ??= downloadProModels().finally(() => { downloading = null; });
+    return downloading;
+}
+async function downloadProModels() {
+    const body = await fetchProModels();
+    // An error page or a truncated reply must never become the user's presets.
+    parseProModels(body, "model.json", PRO_MODELS_URL);
     try {
-        fs.copyFileSync(path.join(ASSET_DIR, "model-template.json"), PRO_MODEL_FILE, fs.constants.COPYFILE_EXCL);
+        fs.writeFileSync(PRO_MODEL_FILE, body, { flag: "wx" });
     }
     catch (error) {
+        // Another process won the race and wrote the file first: that is fine.
         if (error.code !== "EEXIST")
             throw error;
     }
 }
-export function loadProModels() {
-    ensureProModels();
+/**
+ * Keep ~/.neutrino/pro/model.json in step with the official presets, which own
+ * that file: any difference is overwritten. Presets the user keeps for
+ * themselves belong in model-custom.json, so nothing personal is lost. When the
+ * official copy cannot be read, the local presets stay exactly as they are.
+ *
+ * Called once at start-up by both the terminal and the Web console.
+ */
+export async function syncProModels() {
+    const failure = `could not download the Pro model presets from ${PRO_MODELS_URL}`;
+    let body;
+    try {
+        body = await fetchProModels();
+    }
+    catch (error) {
+        // Offline, or the server is down: the local presets are still usable.
+        if (!fs.existsSync(PRO_MODEL_FILE))
+            throw error;
+        return { status: "kept", detail: error instanceof Error ? error.message : String(error) };
+    }
+    const remote = parseProModels(body, "model.json", PRO_MODELS_URL);
+    const present = fs.existsSync(PRO_MODEL_FILE);
+    if (remote.tier.length === 0) {
+        if (!present)
+            throw new Error(`${failure}: it contains no presets`);
+        return { status: "kept", detail: `${failure}: it contains no presets` };
+    }
+    // Only formatting differences are not a difference: the file keeps its shape.
+    // A local file that does not parse is replaced, so a hand edit cannot block Pro.
+    if (present && samePresets(readProModelsQuietly(), remote))
+        return { status: "unchanged" };
+    writeProModels(body);
+    return { status: "updated" };
+}
+async function fetchProModels() {
+    try {
+        const response = await fetch(PRO_MODELS_URL, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) });
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status}`);
+        return await response.text();
+    }
+    catch (error) {
+        throw new Error(`could not download the Pro model presets from ${PRO_MODELS_URL}: `
+            + `${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/** Write the official copy in one step, so no reader ever sees half a file. */
+function writeProModels(body) {
+    fs.mkdirSync(PRO_DIR, { recursive: true });
+    const temp = `${PRO_MODEL_FILE}.${process.pid}.tmp`;
+    try {
+        fs.writeFileSync(temp, body);
+        fs.renameSync(temp, PRO_MODEL_FILE);
+    }
+    catch (error) {
+        fs.rmSync(temp, { force: true });
+        throw error;
+    }
+}
+function readProModelsQuietly() {
+    try {
+        return readProModels(PRO_MODEL_FILE, "model.json");
+    }
+    catch {
+        return null;
+    }
+}
+function samePresets(left, right) {
+    return left !== null && canonicalJson(left) === canonicalJson(right);
+}
+/** Compare documents by content, so reformatting alone is never a difference. */
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value)
+            .filter(([, entry]) => entry !== undefined)
+            .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));
+        return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+}
+/** Parse and validate one presets document; each file has to be valid on its own. */
+function parseProModels(text, label, where) {
     let value;
     try {
-        value = JSON.parse(fs.readFileSync(PRO_MODEL_FILE, "utf8"));
+        value = JSON.parse(text);
     }
     catch {
-        throw new Error("Pro model.json is not valid JSON; fix ~/.neutrino/pro/model.json");
+        throw new Error(`Pro ${label} is not valid JSON; fix ${where}`);
     }
-    if (!value || typeof value !== "object" || !Array.isArray(value.tier) ||
-        value.tier.length === 0) {
-        throw new Error("Pro model.json must contain a nonempty tier array");
+    if (!value || typeof value !== "object" || !Array.isArray(value.tier)) {
+        throw new Error(`Pro ${label} must contain a tier array`);
     }
     const names = new Set();
     for (const preset of value.tier) {
@@ -59,6 +161,34 @@ export function loadProModels() {
     }
     return value;
 }
+function readProModels(file, label) {
+    return parseProModels(fs.readFileSync(file, "utf8"), label, `~/.neutrino/pro/${label}`);
+}
+export function loadProModels() {
+    if (!fs.existsSync(PRO_MODEL_FILE)) {
+        // The download is asynchronous, so it happens at start-up (see ensureProModels).
+        throw new Error(`Pro model.json is missing; it is downloaded from ${PRO_MODELS_URL} on first use`);
+    }
+    const { tier } = readProModels(PRO_MODEL_FILE, "model.json");
+    // Presets the user keeps in model-custom.json are merged in. Their place in the
+    // list is read as strength (the slider runs from weak to strong), so entries that
+    // are not official rungs lead it: a preset named after an official one edits that
+    // rung in place, every other one sits left of the graded presets.
+    if (fs.existsSync(PRO_CUSTOM_MODEL_FILE)) {
+        const own = [];
+        for (const preset of readProModels(PRO_CUSTOM_MODEL_FILE, "model-custom.json").tier) {
+            const index = tier.findIndex((entry) => entry.name === preset.name);
+            if (index === -1)
+                own.push(preset);
+            else
+                tier[index] = preset;
+        }
+        tier.unshift(...own);
+    }
+    if (tier.length === 0)
+        throw new Error("Pro model.json must contain a nonempty tier array");
+    return { tier };
+}
 export function requireProPreset(value) {
     if (typeof value !== "string" || !loadProModels().tier.some((preset) => preset.name === value)) {
         throw new Error("Unknown Pro preset");

package/dist/screens/start.js

@@ -2,7 +2,7 @@ import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
 import { loadLogo, loadVersion, loadConfig, saveConfig, normalizeApprovalMode } from "../config.js";
 import { drawHeader } from "../header.js";
-import { centerVertically, computeInputWindow, cursorFromColumn, drawHint, drawInputBox, drawTabButton, inRect, approvalToggle, drawApprovalToggle, drawProModeButton, proModeButton, } from "../ui.js";
+import { centerVertically, computeInputWindow, cursorFromColumn, drawHint, drawInputBox, drawTabButton, inRect, approvalToggle, drawApprovalToggle, drawHeaderButton, proModeButton, webModeButton, } from "../ui.js";
 const TABS = ["Model", "History", "Settings"];
 const LOGO = loadLogo();
 const FOCUS_COUNT = TABS.length + 2; // input box + 3 tabs + approval mode
@@ -31,6 +31,7 @@ export class StartScreen extends Screen {
     focusIdx = 0; // 0 = input box, 1..3 = tabs, 4 = approval mode
     hoverIdx = -1; // -1 = nothing, otherwise the control index
     proHover = false; // pointer is over the Pro-mode button
+    webHover = false; // pointer is over the Web-mode button
     lastHoverX = -1;
     lastHoverY = -1;
     showsCursor() {
@@ -138,12 +139,15 @@ export class StartScreen extends Screen {
             this.lastHoverX = ev.x;
             this.lastHoverY = ev.y;
             const pro = proModeButton(this.app.width, this.app.height);
+            const web = webModeButton(this.app.width, this.app.height);
             const proHover = pro !== null && inRect(ev.x, ev.y, pro);
+            const webHover = web !== null && inRect(ev.x, ev.y, web);
             const layout = this.layout();
             let hover = -1;
-            // While the pointer is over the Pro button no other control is hovered
-            // underneath it: the box is opaque, so its neighbours must not light up.
-            if (!proHover) {
+            // While the pointer is over one of the top-left buttons no other control
+            // is hovered underneath it: the boxes are opaque, so their neighbours
+            // must not light up.
+            if (!proHover && !webHover) {
                 if (inRect(ev.x, ev.y, approvalToggle(this.app.width, this.app.height - 4, this.approvalMode))) {
                     hover = FOCUS_COUNT - 1;
                 }
@@ -159,8 +163,9 @@ export class StartScreen extends Screen {
                     }
                 }
             }
-            if (proHover !== this.proHover || hover !== this.hoverIdx) {
+            if (proHover !== this.proHover || webHover !== this.webHover || hover !== this.hoverIdx) {
                 this.proHover = proHover;
+                this.webHover = webHover;
                 this.hoverIdx = hover;
                 this.app.render();
             }
@@ -172,13 +177,19 @@ export class StartScreen extends Screen {
                 return;
             if (ev.button === 2)
                 return; // right click: no-op on start screen
-            // The Pro button is a control of its own and is checked first: a left
-            // click anywhere in its box opens Pro mode instead of the control below.
+            // The top-left buttons are controls of their own and are checked first:
+            // a left click anywhere in a box opens its workspace instead of the
+            // control below.
             const pro = proModeButton(this.app.width, this.app.height);
             if (ev.button === 0 && pro && inRect(ev.x, ev.y, pro)) {
                 void this.app.openProMode();
                 return;
             }
+            const web = webModeButton(this.app.width, this.app.height);
+            if (ev.button === 0 && web && inRect(ev.x, ev.y, web)) {
+                void this.app.openWebMode();
+                return;
+            }
             if (ev.y >= 1 && inRect(ev.x, ev.y, approvalToggle(this.app.width, this.app.height - 4, this.approvalMode))) {
                 this.focusIdx = FOCUS_COUNT - 1;
                 this.toggleApproval();
@@ -224,8 +235,8 @@ export class StartScreen extends Screen {
         for (let y = inputY; y <= tabY + TAB_H; y++)
             if (y >= 0 && y < h)
                 rows.push(y);
-        // The Pro button sits directly below the status bar; repainting its rows
-        // makes it self-heal exactly like the input box and the tabs.
+        // The top-left buttons sit directly below the status bar; repainting their
+        // rows makes them self-heal exactly like the input box and the tabs.
         for (let y = 1; y <= 3; y++)
             if (y >= 0 && y < h)
                 rows.push(y);
@@ -259,8 +270,8 @@ export class StartScreen extends Screen {
     }
     /**
      * First content row. The centered block normally floats in the middle, but
-     * it must start below the Pro button when that button is visible: the box is
-     * opaque chrome and would otherwise clip the top of the logo.
+     * it must start below the top-left buttons when they are visible: the boxes
+     * are opaque chrome and would otherwise clip the top of the logo.
      */
     contentTop(height, contentH) {
         const top = centerVertically(height - 4, contentH);
@@ -353,8 +364,9 @@ export class StartScreen extends Screen {
             buf.centerText(versionY, `v${version}`, { fg: C.dim });
         }
         drawApprovalToggle(buf, approvalY, this.approvalMode, this.focusIdx === FOCUS_COUNT - 1 || this.hoverIdx === FOCUS_COUNT - 1);
-        // Painted last so its opaque footprint is never clipped by the decorative
-        // content above it. Its hit box uses the same top-left geometry.
-        drawProModeButton(buf, this.proHover);
+        // Painted last so their opaque footprints are never clipped by the
+        // decorative content drawn before them. Hit testing shares the geometry.
+        drawHeaderButton(buf, proModeButton(w, h), this.proHover);
+        drawHeaderButton(buf, webModeButton(w, h), this.webHover);
     }
 }

package/dist/screens/updatePrompt.js

@@ -0,0 +1,200 @@
+import { Screen } from "../terminal/screen.js";
+import { C } from "../colors.js";
+import { drawHeader } from "../header.js";
+import { drawHint, drawTabButton, inRect, wrapText } from "../ui.js";
+import { MANUAL_UPDATE_COMMAND, installUpdate } from "../update.js";
+const TITLE_ROW = 2;
+const META_ROW = 3;
+const BODY_TOP = 5;
+const BUTTON_H = 3;
+const BUTTON_X = 1;
+const BODY_X = 3;
+/**
+ * The "a newer Neutrino is published" notice.
+ *
+ * It is pushed over the start screen only, never over a conversation: the
+ * answer arrives a moment after launch, and stealing a chat the user has
+ * already opened would be worse than a missed notice.
+ *
+ * Confirming runs npm here, in this process; the running code is not replaced,
+ * so a successful update ends by telling the user to restart. A failed one
+ * shows the command to run by hand, because npm usually fails for a reason the
+ * user has to fix (permissions, a proxy, an offline machine).
+ */
+export class UpdatePromptScreen extends Screen {
+    phase = "prompt";
+    /** Why the install failed, or which version landed. */
+    detail = "";
+    selectedIdx = 0;
+    lastHoverX = -1;
+    lastHoverY = -1;
+    current;
+    latest;
+    constructor(status) {
+        super();
+        this.current = status.currentVersion;
+        this.latest = status.latestVersion;
+    }
+    /** The buttons drawn right now; a click always lands on one of these. */
+    buttons() {
+        if (this.phase === "prompt")
+            return ["Update now", "Later"];
+        if (this.phase === "installing")
+            return [];
+        return ["Close"];
+    }
+    buttonRow(index) {
+        const count = this.buttons().length;
+        const top = this.app.height - 1 - count * BUTTON_H;
+        return top + index * BUTTON_H;
+    }
+    /** Columns the body paragraphs may use before wrapping. */
+    bodyWidth() {
+        return Math.max(10, this.app.width - BODY_X * 2);
+    }
+    start() {
+        if (this.phase !== "prompt")
+            return;
+        this.phase = "installing";
+        this.selectedIdx = 0;
+        this.app.render();
+        void installUpdate().then((result) => {
+            this.phase = result.ok ? "updated" : "failed";
+            this.detail = result.ok
+                ? result.version || this.latest
+                : result.error || "npm did not report a reason.";
+            this.selectedIdx = 0;
+            this.app.render();
+        });
+    }
+    close() {
+        if (this.phase === "installing")
+            return;
+        this.app.popScreen();
+    }
+    activate(index) {
+        const label = this.buttons()[index];
+        if (!label)
+            return;
+        if (label === "Update now")
+            this.start();
+        else
+            this.close();
+    }
+    move(delta) {
+        const count = this.buttons().length;
+        if (count === 0)
+            return;
+        this.selectedIdx = (this.selectedIdx + delta + count) % count;
+        this.app.render();
+    }
+    onKey(key) {
+        if (key.name === "up")
+            this.move(-1);
+        else if (key.name === "down")
+            this.move(1);
+        else if (key.name === "return" || key.name === "enter")
+            this.activate(this.selectedIdx);
+        else if (key.name === "escape")
+            this.close();
+    }
+    onMouse(ev) {
+        const count = this.buttons().length;
+        const indexAt = (x, y) => {
+            for (let i = 0; i < count; i++) {
+                if (inRect(x, y, { x: BUTTON_X, y: this.buttonRow(i), w: this.app.width - 2, h: BUTTON_H }))
+                    return i;
+            }
+            return -1;
+        };
+        if (ev.type === "move") {
+            if (ev.x === this.lastHoverX && ev.y === this.lastHoverY)
+                return;
+            this.lastHoverX = ev.x;
+            this.lastHoverY = ev.y;
+            const hover = indexAt(ev.x, ev.y);
+            if (hover >= 0 && hover !== this.selectedIdx) {
+                this.selectedIdx = hover;
+                this.app.render();
+            }
+            return;
+        }
+        if (ev.type === "wheel") {
+            this.move(ev.dir === -1 ? -1 : 1);
+            return;
+        }
+        if (ev.type === "click") {
+            if (ev.button === 2) {
+                this.close();
+                return;
+            }
+            const index = indexAt(ev.x, ev.y);
+            if (index < 0)
+                return;
+            this.selectedIdx = index;
+            this.activate(index);
+        }
+    }
+    /** What the dialog says, in the order it is drawn. */
+    body() {
+        const normal = { fg: C.white };
+        const note = { fg: C.dim };
+        if (this.phase === "installing") {
+            return [
+                { text: `Installing Neutrino ${this.latest} with npm…`, style: normal },
+                { text: "This can take a minute. Neutrino keeps running while npm works.", style: note },
+            ];
+        }
+        if (this.phase === "updated") {
+            return [
+                { text: `Neutrino ${this.detail} was installed.`, style: { fg: C.green, bold: true } },
+                { text: "Restart Neutrino to run the new version: this terminal keeps the old one until it exits.", style: normal },
+            ];
+        }
+        if (this.phase === "failed") {
+            return [
+                { text: "The automatic update failed. Neutrino was not changed.", style: { fg: C.red, bold: true } },
+                { text: this.detail, style: normal },
+                { text: "Update by hand with:", style: note },
+                { text: MANUAL_UPDATE_COMMAND, style: { fg: C.accent, bold: true } },
+            ];
+        }
+        return [
+            { text: `Neutrino ${this.latest} is available.`, style: normal },
+            { text: "Update now installs it with npm. Restart Neutrino afterwards to use it.", style: note },
+        ];
+    }
+    render(buf) {
+        drawHeader(buf, this.app.state);
+        const h = buf.height;
+        const title = this.phase === "prompt" ? "Update available"
+            : this.phase === "installing" ? "Updating Neutrino"
+                : this.phase === "updated" ? "Update installed"
+                    : "Update failed";
+        buf.centerText(TITLE_ROW, title, { fg: C.accent, bold: true });
+        buf.centerText(META_ROW, `Running ${this.current} · Published ${this.latest}`, { fg: C.dim });
+        // Body paragraphs wrap to the terminal width so a narrow window still reads,
+        // and stop above the buttons so the two can never overlap.
+        const width = this.bodyWidth();
+        const bodyEnd = h - 1 - this.buttons().length * BUTTON_H;
+        let y = BODY_TOP;
+        for (const line of this.body()) {
+            for (const piece of wrapText(line.text, width)) {
+                if (y >= bodyEnd)
+                    break;
+                buf.writeText(BODY_X, y, piece, line.style);
+                y++;
+            }
+        }
+        const buttons = this.buttons();
+        for (let i = 0; i < buttons.length; i++) {
+            drawTabButton(buf, BUTTON_X, this.buttonRow(i), buf.width - BUTTON_X * 2, buttons[i], i === this.selectedIdx);
+        }
+        const hint = this.phase === "installing"
+            ? "npm is running; this screen closes when it finishes"
+            : buttons.length > 1
+                ? "↑/↓ select · Enter confirm · click to choose · Esc later"
+                : "Enter or Esc close";
+        drawHint(buf, h - 1, hint);
+    }
+}