@xingjisoft/neutrino 0.5.1 → 0.6.0

package/dist/updateWatch.js

@@ -0,0 +1,76 @@
+/**
+ * The periodic update check.
+ *
+ * A Web console can stay open for days, so the start-up lookup alone would
+ * never tell its windows about a release published afterwards. This module asks
+ * the registry again on a timer, in the process that serves those windows, and
+ * hands a release it has not seen before to whoever is listening: the console
+ * forwards it to every open browser (GET /api/update/events) and the first-open
+ * dialog reads the same answer.
+ */
+import { checkForUpdate, updateStatus } from "./update.js";
+/** How often the background service asks the registry again. */
+export const UPDATE_CHECK_INTERVAL_MS = 30 * 60 * 1000;
+const listeners = new Set();
+let running = null;
+/**
+ * Listen for a release the periodic check finds. Returns the unsubscribe
+ * function.
+ *
+ * Only news is announced: a version this process already knows — from the
+ * start-up lookup, the settings button or an earlier tick — is not sent again,
+ * so the dialogs cannot reopen every half hour for a release the user has
+ * already declined.
+ */
+export function subscribeUpdateAnnouncements(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+/**
+ * Start asking the registry every `intervalMs` (30 minutes by default).
+ *
+ * Idempotent, and the returned function stops the timer and leaves the module
+ * ready to start again. Checks run off the timer rather than at start-up: both
+ * the console and the terminal UI already look once when they start, and a
+ * second immediate lookup would only spend npm calls on the same answer.
+ */
+export function startUpdateWatch(options = {}) {
+    if (running)
+        return running;
+    const timer = setInterval(() => {
+        // The remembered answer is read before the lookup, because the lookup itself
+        // updates it: what matters is whether this check is what discovered the
+        // release.
+        const known = updateStatus().latestVersion;
+        // `refresh` is what makes a timer useful: without it checkForUpdate keeps
+        // returning the answer this process already has and would never see a new
+        // release.
+        void checkForUpdate({ refresh: true }).then((check) => {
+            try {
+                options.onCheck?.(check);
+            }
+            catch {
+                // A failing log must not stop the check that follows it.
+            }
+            if (!check.hasUpdate || check.latestVersion === known)
+                return;
+            for (const listener of [...listeners]) {
+                try {
+                    listener(check);
+                }
+                catch {
+                    // One broken window must not starve the others.
+                }
+            }
+        });
+    }, options.intervalMs ?? UPDATE_CHECK_INTERVAL_MS);
+    // A check in flight must never keep a shutting-down process alive.
+    timer.unref?.();
+    running = () => {
+        clearInterval(timer);
+        running = null;
+    };
+    return running;
+}

package/dist/web/hub.js

@@ -189,6 +189,15 @@ class LiveHub {
             this.notify(key);
         return result;
     }
+    setAgentMode(key, mode) {
+        const entry = this.entries.get(key);
+        if (!entry?.agent.liveSetAgentMode)
+            return { ok: false, error: "this session cannot change agent mode" };
+        const result = entry.agent.liveSetAgentMode(mode);
+        if (result.ok)
+            this.notify(key);
+        return result;
+    }
     setApprovalMode(key, mode) {
         const entry = this.entries.get(key);
         if (!entry?.agent.liveSetApprovalMode)

package/dist/web/server.js

@@ -17,7 +17,7 @@ import os from "node:os";
 import path from "node:path";
 import { timingSafeEqual } from "node:crypto";
 import { fileURLToPath } from "node:url";
-import { deleteSession, listSessions, loadConfig, normalizeApprovalMode, resolveModelSelection, saveConfig, sessionDir, } from "../config.js";
+import { deleteSession, listSessions, loadConfig, normalizeApprovalMode, isAgentMode, resolveModelSelection, saveConfig, sessionDir, } from "../config.js";
 import { getWebSettings, updateWebSettings } from "./settings.js";
 import { isSeenIdentity, loadSeen, updateSeen, SEEN_LIMIT } from "./clientState.js";
 import { WebAuth } from "./auth.js";
@@ -29,7 +29,8 @@ import { defaultProPreset, ensureProModels, requireProPreset } from "../pro/conf
 import { listAgentSessions, loadAgentMessages, loadAgentSession, safeAgentSessionId } from "../agents.js";
 import { migrateAgentSession, SessionMigrationError } from "../migration.js";
 import { runningBackground } from "../background.js";
-import { MANUAL_UPDATE_COMMAND, installUpdate, updateStatus } from "../update.js";
+import { MANUAL_UPDATE_COMMAND, checkForUpdate, installUpdate, updateStatus } from "../update.js";
+import { subscribeUpdateAnnouncements } from "../updateWatch.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // dist/web -> package root (mirrors the same trick used in config.ts).
 const PKG_ROOT = path.resolve(__dirname, "..", "..");
@@ -537,18 +538,20 @@ function serveStatic(res, pathname) {
         sendText(res, 403, "Forbidden");
         return;
     }
-    fs.stat(filePath, (err, stat) => {
-        if (err || !stat.isFile()) {
+    // Send an immutable snapshot: the length and body must agree even while
+    // the development checkout changes or a filesystem stream adapter retries.
+    fs.readFile(filePath, (err, contents) => {
+        if (err) {
             sendText(res, 404, "Not found");
             return;
         }
         const type = MIME_TYPES[path.extname(filePath).toLowerCase()] ?? "application/octet-stream";
         res.writeHead(200, {
             "Content-Type": type,
-            "Content-Length": stat.size,
+            "Content-Length": contents.length,
             "Cache-Control": "no-cache",
         });
-        fs.createReadStream(filePath).pipe(res);
+        res.end(contents);
     });
 }
 function streamLive(key, req, res) {
@@ -604,7 +607,88 @@ function streamLive(key, req, res) {
     // Without this, a client reset during a write is an uncaught 'error' event.
     res.on("error", cleanup);
 }
-async function handleApi(req, res, url, auth, mode, pathname, binding) {
+/**
+ * The windows watching for update announcements. The console owns one of these
+ * so closing it can end those streams: a browser reconnects an EventSource by
+ * itself, so an open tab would otherwise keep `close` waiting for a socket that
+ * will never go quiet on its own.
+ */
+function createUpdateStreams() {
+    const open = new Set();
+    return {
+        add(res) {
+            open.add(res);
+        },
+        remove(res) {
+            open.delete(res);
+        },
+        closeAll() {
+            for (const res of [...open]) {
+                open.delete(res);
+                try {
+                    res.end();
+                }
+                catch { /* the window is already gone */ }
+            }
+        },
+    };
+}
+/**
+ * The periodic check's findings, as an event stream. A window that opens after
+ * a release was already found still has to learn about it, so the answer this
+ * process holds goes out first: the same status /api/settings hands the
+ * first-open dialog, with the same fields the manual check returns.
+ *
+ * Both workspaces read it. An update belongs to the process, not to a
+ * conversation, so a Pro tab and a standard tab are told about the same release.
+ */
+function streamUpdateEvents(req, res, streams) {
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream; charset=utf-8",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no",
+    });
+    // Same guard as streamLive: a browser that closed or reloaded the tab leaves
+    // a socket writes fail on, and an unhandled 'error' event would stop the process.
+    const write = (chunk) => {
+        if (res.destroyed || res.writableEnded)
+            return false;
+        try {
+            res.write(chunk);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const send = (status, error = "") => {
+        write(`event: update\ndata: ${JSON.stringify({
+            has_update: status.hasUpdate,
+            current_version: status.currentVersion,
+            latest_version: status.latestVersion,
+            error,
+        })}\n\n`);
+    };
+    write("retry: 2000\n\n");
+    send(updateStatus());
+    streams.add(res);
+    const unsubscribe = subscribeUpdateAnnouncements((check) => send(check, check.error ?? ""));
+    const keepAlive = setInterval(() => {
+        if (!write(": ping\n\n"))
+            cleanup();
+    }, 25_000);
+    keepAlive.unref?.();
+    function cleanup() {
+        clearInterval(keepAlive);
+        unsubscribe();
+        streams.remove(res);
+    }
+    req.on("close", cleanup);
+    req.on("error", cleanup);
+    res.on("error", cleanup);
+}
+async function handleApi(req, res, url, auth, mode, pathname, binding, updates) {
     if (!pathname.startsWith("/api/"))
         return false;
     // The Pro presets are not bundled either: the first Pro request makes sure they
@@ -748,6 +832,39 @@ async function handleApi(req, res, url, auth, mode, pathname, binding) {
         }
         return true;
     }
+    // The 30-minute background check announces a release here, so a window that
+    // stays open learns about it without reloading. Both workspaces open it.
+    if (req.method === "GET" && pathname === "/api/update/events") {
+        streamUpdateEvents(req, res, updates);
+        return true;
+    }
+    // The settings page's "Check for updates" button. Start-up reads the registry
+    // once and the Web console is served from that answer, so a manual check has
+    // to ask again; otherwise the button would keep showing whatever was true
+    // when the process started. Like the install below it runs npm on this
+    // machine, so it sits behind the login cookie and the same-origin check.
+    //
+    // The answer is a status, not an HTTP failure: an unreachable registry leaves
+    // `error` set on a 200 response, which is what the browser shows next to the
+    // button. A failure also changes nothing — the last good answer stays.
+    if (pathname === "/api/update/check") {
+        if (req.method !== "POST") {
+            sendJson(res, 405, { error: "method not allowed" });
+            return true;
+        }
+        if (!isSameOrigin(req)) {
+            sendJson(res, 403, { error: "cross-origin request rejected" });
+            return true;
+        }
+        const check = await checkForUpdate({ refresh: true });
+        sendJson(res, 200, {
+            has_update: check.hasUpdate,
+            current_version: check.currentVersion,
+            latest_version: check.latestVersion,
+            error: check.error ?? "",
+        });
+        return true;
+    }
     // The update prompt's confirm button: npm runs on this machine, so the route
     // sits behind the login cookie and the same-origin check like every other
     // mutation, and only a release the registry announced can be installed.
@@ -924,7 +1041,10 @@ async function handleApi(req, res, url, auth, mode, pathname, binding) {
                 }
                 approvalMode = normalizeApprovalMode(input.approval_mode);
             }
-            const session = createWebSession(cwd, selection, approvalMode, mode, preset);
+            if (input.agent_mode !== undefined && (!isAgentMode(input.agent_mode) || (mode === "pro" && input.agent_mode !== "standard"))) {
+                throw new ApiError(400, "invalid agent mode", "invalid agent mode");
+            }
+            const session = createWebSession(cwd, selection, approvalMode, mode, preset, input.agent_mode);
             const key = session.start();
             webSessions.set(key, session);
             recordWorkspace(cwd, mode);
@@ -1064,6 +1184,7 @@ async function handleApi(req, res, url, auth, mode, pathname, binding) {
         }
         let selection;
         let preset;
+        let agentMode;
         try {
             const body = await readJsonBody(req);
             if (!body || typeof body !== "object" || Array.isArray(body))
@@ -1074,6 +1195,12 @@ async function handleApi(req, res, url, auth, mode, pathname, binding) {
             const requestedPreset = body.pro_preset;
             if (requestedPreset !== undefined && mode === "pro")
                 preset = requireProPreset(requestedPreset);
+            const requestedMode = body.agent_mode;
+            if (requestedMode !== undefined) {
+                if (!isAgentMode(requestedMode) || (mode === "pro" && requestedMode !== "standard"))
+                    throw new Error("invalid agent mode");
+                agentMode = requestedMode;
+            }
         }
         catch (err) {
             sendJson(res, 400, { error: err instanceof Error ? err.message : "invalid model selection" });
@@ -1083,6 +1210,22 @@ async function handleApi(req, res, url, auth, mode, pathname, binding) {
         const existing = hub.list(mode).find((entry) => entry.sessionId === id);
         if (existing) {
             const remote = hub.remoteAction(existing.key);
+            if (agentMode !== undefined && mode !== "pro") {
+                if (remote) {
+                    const result = await remote("agent-mode", { mode: agentMode });
+                    if (result.status !== 200) {
+                        sendJson(res, result.status, result.data);
+                        return true;
+                    }
+                }
+                else {
+                    const changed = hub.setAgentMode(existing.key, agentMode);
+                    if (!changed.ok) {
+                        sendJson(res, 409, { error: changed.error });
+                        return true;
+                    }
+                }
+            }
             if (remote && preset !== undefined) {
                 const result = await remote("pro-preset", { preset });
                 if (result.status !== 200) {
@@ -1121,6 +1264,8 @@ async function handleApi(req, res, url, auth, mode, pathname, binding) {
         }
         if (preset !== undefined)
             data.pro_preset = preset;
+        if (agentMode !== undefined)
+            data.agent_mode = agentMode;
         const requested = selection ? {
             provider: selection.provider, model: selection.model.name, intensity: selection.intensity,
         } : undefined;
@@ -1146,7 +1291,7 @@ async function handleApi(req, res, url, auth, mode, pathname, binding) {
         streamLive(key, req, res);
         return true;
     }
-    const liveMatch = /^\/api\/live\/([^/]+)(?:\/(pause|resume|message|approve|close|model|pro-preset|approval-mode|clear))?$/.exec(pathname);
+    const liveMatch = /^\/api\/live\/([^/]+)(?:\/(pause|resume|message|approve|close|model|pro-preset|approval-mode|agent-mode|clear))?$/.exec(pathname);
     if (liveMatch) {
         const key = decodeURIComponent(liveMatch[1]);
         const action = liveMatch[2];
@@ -1175,7 +1320,7 @@ async function handleApi(req, res, url, auth, mode, pathname, binding) {
                     return true;
                 }
                 try {
-                    const body = ["approve", "approval-mode", "message", "model", "pro-preset"].includes(action)
+                    const body = ["approve", "approval-mode", "agent-mode", "message", "model", "pro-preset"].includes(action)
                         ? await readJsonBody(req) : {};
                     const result = await remote(action, body);
                     sendJson(res, result.status, result.data);
@@ -1204,6 +1349,25 @@ async function handleApi(req, res, url, auth, mode, pathname, binding) {
                 }
                 return true;
             }
+            if (action === "agent-mode") {
+                try {
+                    const body = await readJsonBody(req);
+                    const value = body?.mode;
+                    if (!isAgentMode(value) || mode === "pro") {
+                        sendJson(res, 400, { error: "invalid agent mode" });
+                        return true;
+                    }
+                    const changed = hub.setAgentMode(key, value);
+                    if (!changed.ok)
+                        sendJson(res, 409, { error: changed.error });
+                    else
+                        sendJson(res, 200, { ok: true, snapshot: hub.snapshot(key) });
+                }
+                catch (error) {
+                    sendJson(res, 400, { error: error instanceof Error ? error.message : "invalid agent mode" });
+                }
+                return true;
+            }
             if (action === "approval-mode") {
                 let body;
                 try {
@@ -1308,7 +1472,7 @@ async function handleApi(req, res, url, auth, mode, pathname, binding) {
     sendJson(res, 404, { error: "not found" });
     return true;
 }
-async function handleRequest(req, res, auth, binding) {
+async function handleRequest(req, res, auth, binding, updates) {
     let url;
     try {
         url = new URL(req.url ?? "/", "http://localhost");
@@ -1341,7 +1505,7 @@ async function handleRequest(req, res, auth, binding) {
         mode = "pro";
         apiPathname = pathname.slice("/pro".length);
     }
-    if (await handleApi(req, res, url, auth, mode, apiPathname, binding))
+    if (await handleApi(req, res, url, auth, mode, apiPathname, binding, updates))
         return;
     if (mode === "pro") {
         // Nothing else lives under /pro but the page and its API.
@@ -1371,8 +1535,11 @@ export async function startWebServer(options) {
         service: options.backgroundService,
         updateSettings: (body, mode) => updateSettings(body, mode),
     };
+    // Every window watching for an update belongs to this console, not the module,
+    // so a second embedded server (a test, an embedding) keeps its own set.
+    const updates = createUpdateStreams();
     const server = http.createServer((req, res) => {
-        handleRequest(req, res, auth, binding).catch((err) => {
+        handleRequest(req, res, auth, binding, updates).catch((err) => {
             if (!res.headersSent) {
                 sendJson(res, 500, { error: err instanceof Error ? err.message : "internal error" });
             }
@@ -1513,6 +1680,9 @@ export async function startWebServer(options) {
         setHost: (next) => rebind(next),
         close: () => new Promise((resolve) => {
             closed = true;
+            // These streams never end on their own, so they are closed explicitly;
+            // otherwise server.close() would wait for a window that stays open.
+            updates.closeAll();
             for (const key of [...webSessions.keys()])
                 closeWebSession(key);
             if (!server.listening) {

package/dist/web/service.js

@@ -5,6 +5,7 @@ import { loadConfig, saveConfig } from "../config.js";
 import { startBackgroundTray } from "../tray.js";
 import { PRO_MODELS_URL, syncProModels } from "../pro/config.js";
 import { checkForUpdate, UPDATE_PACKAGE } from "../update.js";
+import { startUpdateWatch } from "../updateWatch.js";
 import { hub } from "./hub.js";
 import { startWebServer } from "./server.js";
 import { TerminalBridges } from "./terminalBridge.js";
@@ -18,6 +19,7 @@ export async function runWebService(options) {
     let handle = null;
     let tray = null;
     let monitor = null;
+    let stopUpdateWatch = null;
     let stopping = false;
     const bridges = new TerminalBridges();
     const status = () => {
@@ -44,6 +46,8 @@ export async function runWebService(options) {
         stopping = true;
         if (monitor)
             clearInterval(monitor);
+        stopUpdateWatch?.();
+        stopUpdateWatch = null;
         tray?.close();
         bridges.close();
         backgroundLog(`stopping pid=${process.pid}`);
@@ -131,6 +135,24 @@ export async function runWebService(options) {
     }
     backgroundLog(`started pid=${process.pid} on ${handle.url} (residency ${resident ? "on" : "off"})`);
     syncTray();
+    // The start-up lookup above is one answer; a console that stays open needs
+    // more than that. Every 30 minutes the registry is asked again and a release
+    // it has not seen before is announced to every open window
+    // (GET /api/update/events), which is the same status the first-open dialog
+    // reads, so both ways of telling the user come from one source.
+    let loggedUpdate = "";
+    stopUpdateWatch = startUpdateWatch({
+        onCheck: (result) => {
+            // Log a change, not the same answer every half hour.
+            const line = result.hasUpdate
+                ? `${UPDATE_PACKAGE} ${result.latestVersion} is available (running ${result.currentVersion})`
+                : result.error ? `update check: ${result.error}` : "";
+            if (!line || line === loggedUpdate)
+                return;
+            loggedUpdate = line;
+            backgroundLog(line);
+        },
+    });
     // No helper processes: polling pids must remain invisible on Windows. An
     // orphaned, non-resident console lets an in-flight browser turn finish before
     // exiting, so disabling residency also cannot throw away running work.