@xingjisoft/neutrino 0.3.0 → 0.4.1

package/dist/web/server.js

@@ -15,15 +15,19 @@ import fs from "node:fs";
 import http from "node:http";
 import os from "node:os";
 import path from "node:path";
+import { timingSafeEqual } from "node:crypto";
 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 { listAgentSessions, loadAgentMessages } from "../agents.js";
+import { createWebSession, proInitialSelection, resumeSession, WebSession } from "./session.js";
+import { defaultProPreset, requireProPreset } from "../pro/config.js";
+import { listAgentSessions, loadAgentMessages, loadAgentSession, safeAgentSessionId } from "../agents.js";
+import { migrateAgentSession, SessionMigrationError } from "../migration.js";
+import { runningBackground } from "../background.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, "..", "..");
@@ -43,6 +47,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 +57,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 +117,48 @@ 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 validTerminalBridge(bridge, ownerPid) {
+    if (!bridge || typeof bridge !== "object" || Array.isArray(bridge) || typeof ownerPid !== "number")
+        return false;
+    const info = bridge;
+    if (typeof info.url !== "string" || typeof info.token !== "string" || !/^[a-f0-9]{64}$/.test(info.token))
+        return false;
+    try {
+        const url = new URL(info.url);
+        return url.protocol === "http:" && url.hostname === "127.0.0.1" && Boolean(url.port)
+            && url.pathname === "/" && !url.username && !url.password && !url.search && !url.hash;
+    }
+    catch {
+        return false;
+    }
+}
+function settingsPayload(mode, binding) {
+    const payload = getWebSettings(mode);
+    const lan = isWildcardHost(binding.host);
+    const { urls } = webUrls(binding.host, binding.port);
+    const background = binding.service?.status?.() ?? runningBackground();
+    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:")) : [],
+            // The background service is a process, not a workspace: both pages report
+            // the same state. The prompt is never shown once the setting is on.
+            background: background?.pid === process.pid ? background.resident : payload.settings.background,
+            background_running: background?.resident === true,
+            background_url: background?.url ?? "",
+            background_prompt: binding.prompt.pending && payload.settings.background !== true,
+        },
+    };
+}
 const MIME_TYPES = {
     ".html": "text/html; charset=utf-8",
     ".css": "text/css; charset=utf-8",
@@ -120,11 +180,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"));
@@ -158,7 +219,6 @@ function sendApiError(res, error) {
 }
 const MAX_RECENT_WORKSPACES = 12;
 const AGENT_IDS = new Set(["claude", "codex", "opencode"]);
-const AGENT_SESSION_ID_RE = /^[A-Za-z0-9._-]{1,200}$/;
 /** Expand `~` and require an absolute path; used by every folder route. */
 function absolutePath(raw) {
     if (typeof raw !== "string" || !raw.trim()) {
@@ -242,12 +302,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 +321,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 +340,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.
@@ -318,13 +378,10 @@ function createFolder(raw) {
 function isAgentId(value) {
     return AGENT_IDS.has(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)
@@ -448,6 +505,16 @@ function isSameOrigin(req) {
         return false;
     }
 }
+/** Constant-time comparison of the service's management token. */
+function hasServiceToken(req, token) {
+    const header = String(req.headers.authorization ?? "");
+    const prefix = "Bearer ";
+    if (!header.startsWith(prefix))
+        return false;
+    const supplied = Buffer.from(header.slice(prefix.length));
+    const expected = Buffer.from(token);
+    return supplied.length === expected.length && timingSafeEqual(supplied, expected);
+}
 function serveStatic(res, pathname) {
     let rel = pathname === "/" ? "/index.html" : pathname;
     try {
@@ -530,8 +597,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") {
@@ -541,6 +607,59 @@ async function handleApi(req, res, url, auth) {
         res.end();
         return true;
     }
+    // Management endpoints of the detached service. They are called by the CLI
+    // and the tray icon, which have the token from ~/.neutrino/background.json
+    // but not necessarily a browser login cookie.
+    if (["/api/background/ping", "/api/background/stop", "/api/background/configure"].includes(pathname)) {
+        if (req.method !== "GET" && req.method !== "POST") {
+            sendJson(res, 405, { error: "method not allowed" });
+            return true;
+        }
+        if (!binding.service) {
+            sendJson(res, 404, { error: "this console is not running in the background" });
+            return true;
+        }
+        if (!hasServiceToken(req, binding.service.token)) {
+            sendJson(res, 401, { error: "background service token required" });
+            return true;
+        }
+        if (pathname.endsWith("/ping")) {
+            sendJson(res, 200, { ok: true, pid: process.pid, url: webUrls(binding.host, binding.port).url });
+            return true;
+        }
+        if (pathname.endsWith("/configure")) {
+            if (req.method !== "POST") {
+                sendJson(res, 405, { error: "method not allowed" });
+                return true;
+            }
+            if (!binding.service.configure) {
+                sendJson(res, 409, { error: "Restart the console to update background residency." });
+                return true;
+            }
+            try {
+                const body = await readJsonBody(req, 4096);
+                if (!body || typeof body !== "object" || Array.isArray(body)
+                    || Object.keys(body).some(key => key !== "resident" && key !== "ownerPid" && key !== "bridge")
+                    || (body.resident !== undefined && typeof body.resident !== "boolean")
+                    || (body.ownerPid !== undefined && (!Number.isSafeInteger(body.ownerPid) || body.ownerPid <= 0))
+                    || (body.bridge !== undefined && !validTerminalBridge(body.bridge, body.ownerPid))) {
+                    throw new Error("invalid background settings");
+                }
+                const updated = binding.service.configure(body);
+                if (updated.resident)
+                    binding.prompt.pending = false;
+                sendJson(res, 200, updated);
+            }
+            catch (error) {
+                sendJson(res, 400, { error: error instanceof Error ? error.message : "invalid background settings" });
+            }
+            return true;
+        }
+        sendJson(res, 200, { ok: true, stopping: true });
+        // Let the response reach the caller before the socket closes.
+        setImmediate(() => binding.service?.onStop());
+        return true;
+    }
     if (pathname === "/api/auth/login" || pathname === "/api/auth/logout") {
         if (req.method !== "POST") {
             sendJson(res, 405, { error: "method not allowed" });
@@ -575,9 +694,24 @@ async function handleApi(req, res, url, auth) {
         sendJson(res, 401, { error: "Password login required." });
         return true;
     }
+    // The first browser to see the background-residency prompt consumes it for
+    // this console run, whether it accepted or dismissed it.
+    if (pathname === "/api/background/dismiss") {
+        if (req.method !== "POST") {
+            sendJson(res, 405, { error: "method not allowed" });
+        }
+        else if (!isSameOrigin(req)) {
+            sendJson(res, 403, { error: "cross-origin request rejected" });
+        }
+        else {
+            binding.prompt.pending = false;
+            sendJson(res, 200, { ok: true });
+        }
+        return true;
+    }
     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)) {
@@ -586,11 +720,11 @@ async function handleApi(req, res, url, auth) {
             }
             try {
                 const body = await readJsonBody(req);
-                updateWebSettings(body);
+                await binding.updateSettings(body, mode);
                 if (body.settings?.web_password !== undefined) {
                     auth.remember(res);
                 }
-                sendJson(res, 200, getWebSettings());
+                sendJson(res, 200, settingsPayload(mode, binding));
             }
             catch (err) {
                 sendJson(res, err?.code ? 500 : 400, {
@@ -604,15 +738,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 +754,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 +766,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 +828,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 +839,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,18 +861,18 @@ 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;
         }
         sendJson(res, 200, { ok: true, deleted: true });
         return true;
     }
-    // Read-only history recorded by other agents (Claude Code, Codex, OpenCode).
+    // History recorded by other agents (Claude Code, Codex, OpenCode).
     const agentSessionsMatch = /^\/api\/agents\/([^/]+)\/sessions$/.exec(pathname);
     if (req.method === "GET" && agentSessionsMatch) {
         const agent = decodeURIComponent(agentSessionsMatch[1]);
@@ -761,7 +896,59 @@ async function handleApi(req, res, url, auth) {
             sendJson(res, 400, { error: "invalid session id" });
             return true;
         }
-        sendJson(res, 200, { agent, id, messages: loadAgentMessages(agent, id) });
+        const cwd = url.searchParams.get("cwd");
+        if (cwd) {
+            const source = loadAgentSession(agent, id, cwd);
+            if (!source) {
+                sendJson(res, 404, { error: "session not found in this working directory" });
+                return true;
+            }
+            sendJson(res, 200, { ...source, agent });
+        }
+        else {
+            sendJson(res, 200, { agent, id, messages: loadAgentMessages(agent, id) });
+        }
+        return true;
+    }
+    const migrateMatch = /^\/api\/agents\/([^/]+)\/sessions\/([^/]+)\/migrate$/.exec(pathname);
+    if (migrateMatch) {
+        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 agent = decodeURIComponent(migrateMatch[1]);
+        const id = decodeURIComponent(migrateMatch[2]);
+        if (!isAgentId(agent) || !safeAgentSessionId(id)) {
+            sendJson(res, 400, { error: !isAgentId(agent) ? "unknown agent" : "invalid session id" });
+            return true;
+        }
+        try {
+            const body = await readJsonBody(req);
+            if (!body || typeof body !== "object" || Array.isArray(body))
+                throw new Error("invalid JSON body");
+            const input = body;
+            const cwd = existingDirectory(input.cwd ?? process.cwd());
+            const preset = mode === "pro" ? requireProPreset(input.pro_preset ?? defaultProPreset()) : undefined;
+            const selection = mode === "pro" ? proInitialSelection(preset)
+                : resolveModelSelection(input.selection ?? getWebSettings(mode).selection, false);
+            const migrated = migrateAgentSession(agent, id, cwd, {
+                provider: selection.provider, model: selection.model.name, intensity: selection.intensity,
+            }, mode, preset);
+            const session = new WebSession(migrated, selection.model, mode);
+            const key = session.start();
+            webSessions.set(key, session);
+            sendJson(res, 201, { ok: true, id: migrated.id, key, cwd, snapshot: hub.snapshot(key) });
+        }
+        catch (err) {
+            if (err instanceof SessionMigrationError)
+                sendJson(res, err.status, { error: err.message });
+            else
+                sendApiError(res, err);
+        }
         return true;
     }
     const sessionMatch = /^\/api\/session\/([^/]+)$/.exec(pathname);
@@ -771,7 +958,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,22 +978,48 @@ 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 (selection) {
+            const remote = hub.remoteAction(existing.key);
+            if (remote && preset !== undefined) {
+                const result = await remote("pro-preset", { preset });
+                if (result.status !== 200) {
+                    sendJson(res, result.status, result.data);
+                    return true;
+                }
+            }
+            else if (remote && selection) {
+                const result = await remote("model", { provider: selection.provider, model: selection.model.name, intensity: selection.intensity });
+                if (result.status !== 200) {
+                    sendJson(res, result.status, result.data);
+                    return true;
+                }
+            }
+            if (!remote && preset !== undefined) {
+                const changed = hub.setProPreset(existing.key, preset);
+                if (!changed.ok) {
+                    sendJson(res, 409, { error: changed.error });
+                    return true;
+                }
+            }
+            if (!remote && selection) {
                 const changed = hub.configure(existing.key, selection);
                 if (!changed.ok) {
                     sendJson(res, 409, { error: changed.error });
@@ -816,15 +1029,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 +1051,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 +1079,46 @@ 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;
             }
+            const remote = hub.remoteAction(key);
+            if (remote) {
+                if (action === "close") {
+                    sendJson(res, 400, { error: "this session is owned by the terminal UI" });
+                    return true;
+                }
+                try {
+                    const body = ["approve", "approval-mode", "message", "model", "pro-preset"].includes(action)
+                        ? await readJsonBody(req) : {};
+                    const result = await remote(action, body);
+                    sendJson(res, result.status, result.data);
+                }
+                catch (error) {
+                    sendJson(res, 400, { error: error instanceof Error ? error.message : "invalid request" });
+                }
+                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 +1223,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 +1232,62 @@ 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),
+        prompt: { pending: options.backgroundPrompt === true },
+        service: options.backgroundService,
+        updateSettings: (body, mode) => updateSettings(body, mode),
+    };
     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 +1296,162 @@ 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;
+        options.onAddressChange?.();
+    };
+    // 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;
+    }
+    // Serialize saves from both workspaces so a failed switch cannot roll back
+    // another tab's successful change.
+    let settingsChanges = Promise.resolve();
+    function updateSettings(body, mode) {
+        const task = settingsChanges.then(async () => {
+            const previous = loadConfig(mode);
+            const wasHost = binding.host;
+            try {
+                updateWebSettings(body, mode);
+                const patch = body?.settings;
+                const desiredHost = patch && Object.prototype.hasOwnProperty.call(patch, "web_lan")
+                    ? patch.web_lan === true ? WILDCARD_HOST : LOOPBACK_HOST
+                    : binding.host;
+                if (desiredHost !== binding.host)
+                    await binding.setHost(desiredHost);
+                if (patch && Object.prototype.hasOwnProperty.call(patch, "background")) {
+                    if (!binding.service?.configure) {
+                        throw new Error("Background residency could not be applied. Restart the console and try again.");
+                    }
+                    binding.service.configure({ resident: patch.background === true });
+                    if (patch.background === true)
+                        binding.prompt.pending = false;
+                }
+            }
+            catch (error) {
+                // A failed lifetime or address change must not look saved or active.
+                if (binding.host !== wasHost) {
+                    try {
+                        await binding.setHost(wasHost);
+                    }
+                    catch { /* Report the original failure. */ }
+                }
+                const config = loadConfig(mode);
+                config.web_lan = previous.web_lan;
+                config.background = previous.background;
+                try {
+                    saveConfig(config, mode);
+                }
+                catch { /* Report the original failure. */ }
+                throw error;
+            }
+        });
+        settingsChanges = 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;
 }