@xingjisoft/neutrino 0.3.0 → 0.4.0

package/dist/web/server.js

@@ -16,13 +16,14 @@ import http from "node:http";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { SESSION_DIR, deleteSession, listSessions, loadConfig, normalizeApprovalMode, resolveModelSelection, saveConfig, } from "../config.js";
+import { deleteSession, listSessions, loadConfig, normalizeApprovalMode, resolveModelSelection, saveConfig, sessionDir, } from "../config.js";
 import { getWebSettings, updateWebSettings } from "./settings.js";
 import { WebAuth } from "./auth.js";
 import { normalizeCwd, sameCwd } from "../cwd.js";
 import { hub } from "./hub.js";
 import { writeCrashLog } from "../terminal/restore.js";
-import { createWebSession, resumeSession } from "./session.js";
+import { createWebSession, proInitialSelection, resumeSession } from "./session.js";
+import { defaultProPreset, requireProPreset } from "../pro/config.js";
 import { listAgentSessions, loadAgentMessages } from "../agents.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // dist/web -> package root (mirrors the same trick used in config.ts).
@@ -43,6 +44,9 @@ function closeWebSession(key) {
 }
 /** Bind addresses that mean "every interface" rather than one host. */
 const WILDCARD_HOSTS = new Set(["0.0.0.0", "::", "[::]", ""]);
+/** The two interfaces the Web access switch moves between. */
+const LOOPBACK_HOST = "127.0.0.1";
+const WILDCARD_HOST = "0.0.0.0";
 /** True when `host` only accepts connections from this machine. */
 export function isLoopbackHost(host) {
     const h = host.trim().toLowerCase().replace(/^\[|\]$/g, "");
@@ -50,6 +54,17 @@ export function isLoopbackHost(host) {
         return false;
     return h === "localhost" || h === "::1" || h.startsWith("127.");
 }
+/** True when `host` listens on every interface, i.e. what --lan selects. */
+export function isWildcardHost(host) {
+    return WILDCARD_HOSTS.has(host.trim().toLowerCase().replace(/^\[|\]$/g, ""));
+}
+/**
+ * The interface a fresh listener uses when the command line did not pick one.
+ * The saved Web access switch behaves exactly like `--lan`.
+ */
+function defaultWebHost() {
+    return loadConfig().web_lan === true ? WILDCARD_HOST : LOOPBACK_HOST;
+}
 /**
  * Adapters that only ever talk to this machine: hypervisor host-only switches,
  * container bridges and loopback variants. Listing them would bury the address
@@ -99,6 +114,26 @@ export function webUrls(host, port) {
         urls: hosts.map((h) => `http://${h}:${port}/`),
     };
 }
+/**
+ * Settings plus the live socket. The `web_lan` switch reports and changes what
+ * is listening right now, so a run started with --lan shows as on even though
+ * nothing was saved yet.
+ */
+function settingsPayload(mode, binding) {
+    const payload = getWebSettings(mode);
+    const lan = isWildcardHost(binding.host);
+    const { urls } = webUrls(binding.host, binding.port);
+    return {
+        ...payload,
+        settings: {
+            ...payload.settings,
+            web_lan: lan,
+            web_host: binding.host,
+            // Addresses another device can open; empty unless every interface is bound.
+            web_urls: lan ? urls.filter((url) => !url.includes("//127.0.0.1:")) : [],
+        },
+    };
+}
 const MIME_TYPES = {
     ".html": "text/html; charset=utf-8",
     ".css": "text/css; charset=utf-8",
@@ -120,11 +155,12 @@ const SESSION_ID_RE = /^[A-Za-z0-9._-]{1,200}$/;
 function isSafeSessionId(id) {
     return SESSION_ID_RE.test(id) && id !== "." && id !== ".." && !id.includes("..");
 }
-function loadSessionSafe(id) {
+function loadSessionSafe(id, mode = "standard") {
     if (!isSafeSessionId(id))
         return null;
-    const filePath = path.join(SESSION_DIR, `${id}.json`);
-    if (path.dirname(filePath) !== SESSION_DIR)
+    const dir = sessionDir(mode);
+    const filePath = path.join(dir, `${id}.json`);
+    if (path.dirname(filePath) !== dir)
         return null;
     try {
         return JSON.parse(fs.readFileSync(filePath, "utf-8"));
@@ -242,12 +278,12 @@ function readFolder(raw) {
     };
 }
 /** Recent working directories: explicitly opened ones first, then saved-session folders. */
-function recentWorkspacePaths() {
-    const config = loadConfig();
+function recentWorkspacePaths(mode = "standard") {
+    const config = loadConfig(mode);
     const stored = Array.isArray(config.web_workspaces)
         ? config.web_workspaces.filter((entry) => typeof entry === "string" && entry.trim() !== "")
         : [];
-    const saved = listSessions().map((session) => session.cwd).filter(Boolean);
+    const saved = listSessions(mode).map((session) => session.cwd).filter(Boolean);
     const seen = new Set();
     const out = [];
     for (const dir of [...stored, ...saved, process.cwd()]) {
@@ -261,9 +297,9 @@ function recentWorkspacePaths() {
     }
     return out;
 }
-function workspaceList() {
-    const sessions = listSessions();
-    return recentWorkspacePaths().map((dir) => {
+function workspaceList(mode = "standard") {
+    const sessions = listSessions(mode);
+    return recentWorkspacePaths(mode).map((dir) => {
         let exists = false;
         try {
             exists = fs.statSync(dir).isDirectory();
@@ -280,15 +316,15 @@ function workspaceList() {
     });
 }
 /** Best-effort persistence: failing to remember a folder must not fail the conversation. */
-function recordWorkspace(dir) {
+function recordWorkspace(dir, mode = "standard") {
     try {
-        const config = loadConfig();
+        const config = loadConfig(mode);
         const stored = Array.isArray(config.web_workspaces)
             ? config.web_workspaces.filter((entry) => typeof entry === "string")
             : [];
         config.web_workspaces = [dir, ...stored.filter((entry) => !sameCwd(entry, dir))]
             .slice(0, MAX_RECENT_WORKSPACES);
-        saveConfig(config);
+        saveConfig(config, mode);
     }
     catch {
         // The picked folder still works for this conversation.
@@ -321,10 +357,10 @@ function isAgentId(value) {
 function safeAgentSessionId(id) {
     return AGENT_SESSION_ID_RE.test(id) && !id.includes("..") && id !== "." && id !== "..";
 }
-/** Build the sidebar payload: every session grouped by working directory. */
-function buildOverview() {
-    const sessions = listSessions();
-    const lives = hub.list();
+/** Build the sidebar payload: the selected workspace's sessions grouped by directory. */
+function buildOverview(mode = "standard") {
+    const sessions = listSessions(mode);
+    const lives = hub.list(mode);
     const liveBySession = new Map();
     for (const live of lives) {
         if (live.sessionId)
@@ -530,8 +566,7 @@ 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) {
-    const { pathname } = url;
+async function handleApi(req, res, url, auth, mode, pathname, binding) {
     if (!pathname.startsWith("/api/"))
         return false;
     if (req.method === "OPTIONS") {
@@ -577,22 +612,46 @@ async function handleApi(req, res, url, auth) {
     }
     if (pathname === "/api/settings") {
         if (req.method === "GET") {
-            sendJson(res, 200, getWebSettings());
+            sendJson(res, 200, settingsPayload(mode, binding));
         }
         else if (req.method === "POST") {
             if (!isSameOrigin(req)) {
                 sendJson(res, 403, { error: "cross-origin request rejected" });
                 return true;
             }
+            const wasLan = loadConfig(mode).web_lan === true;
             try {
                 const body = await readJsonBody(req);
-                updateWebSettings(body);
+                updateWebSettings(body, mode);
+                // `web_lan` is both a saved preference and a live switch: apply it to
+                // the socket now so the console starts or stops answering on the LAN
+                // without a restart. Other settings never move the listener, and an
+                // explicit --host still decides the interface until this is changed.
+                const patch = body?.settings;
+                const desired = patch && Object.prototype.hasOwnProperty.call(patch, "web_lan")
+                    ? patch.web_lan === true
+                    : isWildcardHost(binding.host);
+                if (desired !== isWildcardHost(binding.host)) {
+                    await binding.setHost(desired ? WILDCARD_HOST : LOOPBACK_HOST);
+                }
                 if (body.settings?.web_password !== undefined) {
                     auth.remember(res);
                 }
-                sendJson(res, 200, getWebSettings());
+                sendJson(res, 200, settingsPayload(mode, binding));
             }
             catch (err) {
+                // A switch that could not bind must not pretend the socket moved:
+                // restore the saved preference so the file matches what is running.
+                if ((loadConfig(mode).web_lan === true) !== wasLan) {
+                    try {
+                        const config = loadConfig(mode);
+                        config.web_lan = wasLan;
+                        saveConfig(config, mode);
+                    }
+                    catch {
+                        // Reporting the original failure matters more than the rollback.
+                    }
+                }
                 sendJson(res, err?.code ? 500 : 400, {
                     error: err instanceof Error ? err.message : "invalid settings",
                 });
@@ -604,15 +663,15 @@ async function handleApi(req, res, url, auth) {
         return true;
     }
     if (req.method === "GET" && pathname === "/api/health") {
-        sendJson(res, 200, { ok: true, live: hub.list().length });
+        sendJson(res, 200, { ok: true, live: hub.list(mode).length });
         return true;
     }
     if (req.method === "GET" && pathname === "/api/overview") {
-        sendJson(res, 200, buildOverview());
+        sendJson(res, 200, buildOverview(mode));
         return true;
     }
     if (req.method === "GET" && pathname === "/api/sessions") {
-        sendJson(res, 200, { sessions: listSessions() });
+        sendJson(res, 200, { sessions: listSessions(mode) });
         return true;
     }
     if (pathname === "/api/workspaces") {
@@ -620,7 +679,7 @@ async function handleApi(req, res, url, auth) {
             sendJson(res, 200, {
                 cwd: process.cwd(),
                 home: os.homedir(),
-                workspaces: workspaceList(),
+                workspaces: workspaceList(mode),
             });
             return true;
         }
@@ -632,8 +691,8 @@ async function handleApi(req, res, url, auth) {
             try {
                 const body = await readJsonBody(req);
                 const dir = existingDirectory(body?.path);
-                recordWorkspace(dir);
-                sendJson(res, 200, { ok: true, path: dir, workspaces: workspaceList() });
+                recordWorkspace(dir, mode);
+                sendJson(res, 200, { ok: true, path: dir, workspaces: workspaceList(mode) });
             }
             catch (err) {
                 sendApiError(res, err);
@@ -694,9 +753,10 @@ async function handleApi(req, res, url, auth) {
             const input = body;
             const cwd = existingDirectory(input.cwd ?? process.cwd());
             const requested = input.selection === undefined
-                ? getWebSettings().selection
+                ? getWebSettings(mode).selection
                 : input.selection;
-            const selection = resolveModelSelection(requested, false);
+            const preset = mode === "pro" ? requireProPreset(input.pro_preset ?? defaultProPreset()) : undefined;
+            const selection = mode === "pro" ? proInitialSelection(preset) : resolveModelSelection(requested, false);
             let approvalMode;
             if (input.approval_mode !== undefined) {
                 if (input.approval_mode !== "request" && input.approval_mode !== "auto") {
@@ -704,10 +764,10 @@ async function handleApi(req, res, url, auth) {
                 }
                 approvalMode = normalizeApprovalMode(input.approval_mode);
             }
-            const session = createWebSession(cwd, selection, approvalMode);
+            const session = createWebSession(cwd, selection, approvalMode, mode, preset);
             const key = session.start();
             webSessions.set(key, session);
-            recordWorkspace(cwd);
+            recordWorkspace(cwd, mode);
             sendJson(res, 200, { ok: true, key, cwd, snapshot: hub.snapshot(key) });
         }
         catch (err) {
@@ -726,11 +786,11 @@ async function handleApi(req, res, url, auth) {
             sendJson(res, 400, { error: "invalid session id" });
             return true;
         }
-        if (hub.list().some((entry) => entry.sessionId === id)) {
+        if (hub.list(mode).some((entry) => entry.sessionId === id)) {
             sendJson(res, 409, { error: "cannot delete a running conversation" });
             return true;
         }
-        if (!deleteSession(id)) {
+        if (!deleteSession(id, mode)) {
             sendJson(res, 404, { error: "session not found" });
             return true;
         }
@@ -771,7 +831,7 @@ async function handleApi(req, res, url, auth) {
             sendJson(res, 400, { error: "invalid session id" });
             return true;
         }
-        const data = loadSessionSafe(id);
+        const data = loadSessionSafe(id, mode);
         if (!data) {
             sendJson(res, 404, { error: "session not found" });
             return true;
@@ -791,21 +851,32 @@ async function handleApi(req, res, url, auth) {
             return true;
         }
         let selection;
+        let preset;
         try {
             const body = await readJsonBody(req);
             if (!body || typeof body !== "object" || Array.isArray(body))
                 throw new Error("invalid JSON body");
             const requested = body.selection;
-            if (requested !== undefined)
+            if (requested !== undefined && mode !== "pro")
                 selection = resolveModelSelection(requested);
+            const requestedPreset = body.pro_preset;
+            if (requestedPreset !== undefined && mode === "pro")
+                preset = requireProPreset(requestedPreset);
         }
         catch (err) {
             sendJson(res, 400, { error: err instanceof Error ? err.message : "invalid model selection" });
             return true;
         }
         // Already running (TUI or another tab)? Attach instead of duplicating.
-        const existing = hub.list().find((entry) => entry.sessionId === id);
+        const existing = hub.list(mode).find((entry) => entry.sessionId === id);
         if (existing) {
+            if (preset !== undefined) {
+                const changed = hub.setProPreset(existing.key, preset);
+                if (!changed.ok) {
+                    sendJson(res, 409, { error: changed.error });
+                    return true;
+                }
+            }
             if (selection) {
                 const changed = hub.configure(existing.key, selection);
                 if (!changed.ok) {
@@ -816,15 +887,17 @@ async function handleApi(req, res, url, auth) {
             sendJson(res, 200, { key: existing.key, attached: true });
             return true;
         }
-        const data = loadSessionSafe(id);
+        const data = loadSessionSafe(id, mode);
         if (!data) {
             sendJson(res, 404, { error: "session not found" });
             return true;
         }
+        if (preset !== undefined)
+            data.pro_preset = preset;
         const requested = selection ? {
             provider: selection.provider, model: selection.model.name, intensity: selection.intensity,
         } : undefined;
-        const outcome = resumeSession(data, requested);
+        const outcome = resumeSession(data, requested, mode);
         if (!outcome.ok) {
             sendJson(res, 400, { error: outcome.error });
             return true;
@@ -836,15 +909,22 @@ async function handleApi(req, res, url, auth) {
     }
     const streamMatch = /^\/api\/live\/([^/]+)\/stream$/.exec(pathname);
     if (req.method === "GET" && streamMatch) {
-        streamLive(decodeURIComponent(streamMatch[1]), req, res);
+        const key = decodeURIComponent(streamMatch[1]);
+        // A Pro tab must never observe (or be handed) a session from the other
+        // workspace just because it guessed the key.
+        if (!hub.has(key, mode)) {
+            sendJson(res, 404, { error: "unknown live session" });
+            return true;
+        }
+        streamLive(key, req, res);
         return true;
     }
-    const liveMatch = /^\/api\/live\/([^/]+)(?:\/(pause|resume|message|approve|close|model|approval-mode|clear))?$/.exec(pathname);
+    const liveMatch = /^\/api\/live\/([^/]+)(?:\/(pause|resume|message|approve|close|model|pro-preset|approval-mode|clear))?$/.exec(pathname);
     if (liveMatch) {
         const key = decodeURIComponent(liveMatch[1]);
         const action = liveMatch[2];
         if (req.method === "GET" && !action) {
-            const snapshot = hub.snapshot(key);
+            const snapshot = hub.has(key, mode) ? hub.snapshot(key) : null;
             if (!snapshot) {
                 sendJson(res, 404, { error: "unknown live session" });
                 return true;
@@ -857,10 +937,29 @@ async function handleApi(req, res, url, auth) {
                 sendJson(res, 403, { error: "cross-origin request rejected" });
                 return true;
             }
-            if (!hub.has(key)) {
+            if (!hub.has(key, mode)) {
                 sendJson(res, 404, { error: "unknown live session" });
                 return true;
             }
+            if (action === "pro-preset") {
+                if (mode !== "pro") {
+                    sendJson(res, 404, { error: "Pro presets are only available in Pro mode" });
+                    return true;
+                }
+                try {
+                    const body = await readJsonBody(req);
+                    const preset = requireProPreset(body?.preset);
+                    const changed = hub.setProPreset(key, preset);
+                    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 Pro preset" });
+                }
+                return true;
+            }
             if (action === "approval-mode") {
                 let body;
                 try {
@@ -965,7 +1064,7 @@ async function handleApi(req, res, url, auth) {
     sendJson(res, 404, { error: "not found" });
     return true;
 }
-async function handleRequest(req, res, auth) {
+async function handleRequest(req, res, auth, binding) {
     let url;
     try {
         url = new URL(req.url ?? "/", "http://localhost");
@@ -974,20 +1073,59 @@ async function handleRequest(req, res, auth) {
         sendText(res, 400, "Bad request");
         return;
     }
-    if (await handleApi(req, res, url, auth))
+    // The Pro workspace is the same single-page app at /pro, talking to an
+    // isolated API under /pro/api. Static assets stay at the root (the app uses
+    // root-absolute URLs), so only the page route and the API prefix are special.
+    const pathname = url.pathname;
+    if (pathname === "/pro" || pathname === "/pro/") {
+        if (req.method !== "GET" && req.method !== "HEAD") {
+            sendText(res, 405, "Method not allowed");
+            return;
+        }
+        if (pathname === "/pro/") {
+            // Canonical URL without the trailing slash keeps relative links rooted.
+            res.writeHead(308, { Location: `/pro${url.search}` });
+            res.end();
+            return;
+        }
+        serveStatic(res, "/index.html");
+        return;
+    }
+    let mode = "standard";
+    let apiPathname = pathname;
+    if (pathname.startsWith("/pro/api/")) {
+        mode = "pro";
+        apiPathname = pathname.slice("/pro".length);
+    }
+    if (await handleApi(req, res, url, auth, mode, apiPathname, binding))
         return;
+    if (mode === "pro") {
+        // Nothing else lives under /pro but the page and its API.
+        sendText(res, 404, "Not found");
+        return;
+    }
     if (req.method !== "GET" && req.method !== "HEAD") {
         sendText(res, 405, "Method not allowed");
         return;
     }
-    serveStatic(res, url.pathname);
+    serveStatic(res, pathname);
 }
 /** Start the web UI. Resolves once the socket is actually listening. */
 export async function startWebServer(options) {
-    const host = options.host ?? "127.0.0.1";
     const auth = new WebAuth(options.auth !== false);
+    // An explicit --host/--lan wins for this run; otherwise the saved Web access
+    // switch is applied exactly as if `--lan` had been passed.
+    let host = options.host?.trim() || defaultWebHost();
+    let port = options.port;
+    let closed = false;
+    // The settings page reads and changes this binding while the process runs.
+    const binding = {
+        host,
+        port,
+        setHost: (next) => rebind(next),
+    };
     const server = http.createServer((req, res) => {
-        handleRequest(req, res, auth).catch((err) => {
+        handleRequest(req, res, auth, binding).catch((err) => {
             if (!res.headersSent) {
                 sendJson(res, 500, { error: err instanceof Error ? err.message : "internal error" });
             }
@@ -996,41 +1134,116 @@ export async function startWebServer(options) {
             }
         });
     });
-    await new Promise((resolve, reject) => {
+    /** Wait for the socket to actually listen, or for it to fail. */
+    const listen = (onHost) => new Promise((resolve, reject) => {
         const onError = (err) => {
             server.removeListener("listening", onListening);
             reject(err);
         };
         const onListening = () => {
             server.removeListener("error", onError);
-            // Once listening, the server must tolerate connection-level failures
-            // (resets, EMFILE, half-open sockets) without the process dying. An
-            // 'error' event with no listener is fatal in Node.
-            server.on("error", (err) => {
-                writeCrashLog("web server", err);
-            });
-            server.on("clientError", (_err, socket) => {
-                if (socket.writable)
-                    socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
-                socket.destroy();
-            });
             resolve();
         };
         server.once("error", onError);
         server.once("listening", onListening);
-        server.listen(options.port, host);
+        server.listen(port, onHost);
     });
-    const address = server.address();
-    const port = typeof address === "object" && address ? address.port : options.port;
-    return {
+    /** A just-closed port can need a moment to reappear: retry only that race. */
+    async function listenRetry(onHost) {
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                await listen(onHost);
+                return;
+            }
+            catch (err) {
+                if (err.code !== "EADDRINUSE" || attempt >= 20)
+                    throw err;
+                await new Promise((done) => setTimeout(done, 10));
+            }
+        }
+    }
+    const syncAddress = () => {
+        const address = webUrls(host, port);
+        binding.host = host;
+        binding.port = port;
+        handle.host = host;
+        handle.port = port;
+        handle.url = address.url;
+        handle.urls = address.urls;
+    };
+    // Two tabs saving at once must not interleave close/listen on one socket.
+    let switches = Promise.resolve();
+    function rebind(next) {
+        const target = next.trim() || LOOPBACK_HOST;
+        const task = switches.then(async () => {
+            if (closed)
+                throw new Error("the Web console is shutting down");
+            if (target === host && server.listening)
+                return;
+            // `close` ends acceptance, not the connections already accepted. The
+            // listener is released immediately, which is all the switch needs, so a
+            // streaming turn and the tab that asked for the change stay connected.
+            if (server.listening)
+                server.close();
+            try {
+                await listenRetry(target);
+            }
+            catch (err) {
+                // Put the console back where it was rather than leaving it dark.
+                if (!closed) {
+                    try {
+                        await listenRetry(host);
+                    }
+                    catch {
+                        // The settings response still reports the original failure.
+                    }
+                }
+                throw err;
+            }
+            // A concurrent shutdown wins: never resurrect a console being closed.
+            if (closed) {
+                server.close();
+                throw new Error("the Web Console is shutting down");
+            }
+            host = target;
+            syncAddress();
+        });
+        switches = task.catch(() => undefined);
+        return task;
+    }
+    const handle = {
         host,
         port,
         authRequired: auth.enabled,
-        ...webUrls(host, port),
+        url: "",
+        urls: [],
+        setHost: (next) => rebind(next),
         close: () => new Promise((resolve) => {
+            closed = true;
             for (const key of [...webSessions.keys()])
                 closeWebSession(key);
+            if (!server.listening) {
+                resolve();
+                return;
+            }
             server.close(() => resolve());
         }),
     };
+    await listenRetry(host);
+    // Port 0 means "let the OS pick": remember the real one for every URL.
+    const address = server.address();
+    port = typeof address === "object" && address ? address.port : options.port;
+    syncAddress();
+    // Once listening, the server must tolerate connection-level failures
+    // (resets, EMFILE, half-open sockets) without the process dying: an 'error'
+    // event with no listener is fatal in Node.
+    server.on("error", (err) => {
+        writeCrashLog("web server", err);
+    });
+    server.on("clientError", (_err, socket) => {
+        if (socket.writable)
+            socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+        socket.destroy();
+    });
+    return handle;
 }