@xingjisoft/neutrino 0.3.0 → 0.4.1

package/dist/web/settings.js

@@ -1,28 +1,58 @@
-import { DEFAULT_CONFIG, INTENSITY_LEVELS, WEB_LANGUAGES, contextWindow, isContextWindow, loadConfig, loadModels, normalizeApprovalMode, normalizeWebLanguage, resolveModelSelection, saveConfig, saveModels, } from "../config.js";
+import { DEFAULT_CONFIG, INTENSITY_LEVELS, WEB_LANGUAGES, contextWindow, intensityForModel, isContextWindow, loadConfig, loadModels, modelContextWindow, modelContextWindowKey, modelIntensities, normalizeApprovalMode, normalizeIntensity, normalizeWebLanguage, resolveModelSelection, saveConfig, saveModels, } from "../config.js";
 import { hashWebPassword, validateWebPassword } from "./auth.js";
-/** Public settings use a whitelist: API keys and cached credentials stay on disk. */
-export function getWebSettings() {
-    const config = { ...DEFAULT_CONFIG, ...loadConfig() };
-    const providers = loadModels().providers.map((provider) => ({
+import { defaultProPreset, loadProModels, proMaxRecursionDepth, requireProPreset } from "../pro/config.js";
+/**
+ * Public settings use a whitelist: API keys and cached credentials stay on disk.
+ *
+ * `mode` selects the workspace. The Pro workspace has its own defaults,
+ * language, plan and reviewer settings; the login password and the approval
+ * policy are layered in from the shared config by loadConfig(), so the two
+ * pages cannot drift apart on those.
+ */
+export function getWebSettings(mode = "standard") {
+    const config = { ...DEFAULT_CONFIG, ...loadConfig(mode) };
+    const catalog = loadModels();
+    const providers = catalog.providers.map((provider) => ({
         name: provider.name,
-        models: provider.models.map((model) => ({ name: model.name, configured: Boolean(model.api_key?.trim()), context_window: contextWindow(model.context_window) })),
+        models: provider.models.map((model) => ({
+            name: model.name,
+            configured: Boolean(model.api_key?.trim()),
+            context_window: modelContextWindow(provider.name, model, mode),
+            // The browser only offers these, so it cannot submit a level the model
+            // does not declare. Missing field = every intensity.
+            intensities: modelIntensities(model),
+        })),
     }));
     const preferred = providers.find((p) => p.name === config.selected_provider);
     const provider = preferred ?? providers.find((p) => p.models.some((m) => m.configured)) ?? providers[0];
     const model = provider?.models.find((m) => m.name === config.selected_model) ??
         provider?.models.find((m) => m.configured) ?? provider?.models[0];
-    const intensity = String(config.selected_intensity ?? config.default_intensity);
+    const configuredModel = provider && model
+        ? catalog.providers.find((p) => p.name === provider.name)?.models.find((m) => m.name === model.name) ?? null
+        : null;
+    const intensity = intensityForModel(configuredModel, config.selected_intensity ?? config.default_intensity, config.default_intensity);
     return {
+        ...(mode === "pro" ? { pro: {
+                presets: loadProModels().tier.map((preset) => ({
+                    name: preset.name, chinese_name: preset.chinese_name,
+                    "model-setting": preset["model-setting"].map((setting) => ({
+                        type: setting.type, provider: setting.provider, model: setting.model,
+                        intensity: setting.intensity, context_window: setting.context_window,
+                    })),
+                })),
+                preset: defaultProPreset(),
+                max_recursion_depth: proMaxRecursionDepth(),
+            } } : {}),
         providers,
         intensities: INTENSITY_LEVELS,
         languages: WEB_LANGUAGES.map((value) => ({ value, label: value === "zh" ? "简体中文" : "English" })),
         selection: {
             provider: provider?.name ?? "",
             model: model?.name ?? "",
-            intensity: INTENSITY_LEVELS.includes(intensity) ? intensity : "High",
+            intensity,
         },
         settings: {
-            default_intensity: String(config.default_intensity),
+            default_intensity: intensityForModel(configuredModel, config.default_intensity, "High"),
             model_context_window: model?.context_window ?? contextWindow(undefined),
             approval_model: String(config.approval_model ?? ""),
             auto_approve_extreme_risk: config.auto_approve_extreme_risk === true,
@@ -31,27 +61,50 @@ export function getWebSettings() {
             plan_first: config.plan_first !== false,
             approval_mode: normalizeApprovalMode(config.approval_mode),
             web_console: config.web_console !== false,
+            web_lan: config.web_lan === true,
+            background: config.background === true,
         },
     };
 }
 /** Validate the complete patch before writing anything, preserving unrelated settings. */
-export function updateWebSettings(value) {
+export function updateWebSettings(value, mode = "standard") {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new Error("invalid settings body");
     const body = value;
     if (Object.keys(body).some((key) => key !== "selection" && key !== "settings"))
         throw new Error("unknown settings field");
-    const config = loadConfig();
+    const config = loadConfig(mode);
+    // Resolve the requested model first: its declared intensities decide which
+    // default level can be saved with this patch. Settings that do not touch a
+    // model stay editable even when the catalogue is empty.
+    const chosen = body.selection !== undefined ? resolveModelSelection(body.selection, false) : undefined;
+    let target = chosen ?? null;
+    const settingsTarget = () => {
+        target ??= resolveModelSelection(getWebSettings(mode).selection, false);
+        return target;
+    };
     if (body.settings !== undefined) {
         if (!body.settings || typeof body.settings !== "object" || Array.isArray(body.settings))
             throw new Error("invalid settings");
         const patch = body.settings;
         for (const [key, val] of Object.entries(patch)) {
-            if (key === "default_intensity") {
-                if (typeof val !== "string" || !INTENSITY_LEVELS.includes(val))
+            if (key === "pro_preset" && mode === "pro") {
+                config.pro_preset = requireProPreset(val);
+            }
+            else if (key === "pro_max_recursion_depth" && mode === "pro") {
+                if (typeof val !== "number" || !Number.isSafeInteger(val) || val < 1 || val > 100) {
+                    throw new Error("Pro recursion depth must be a whole number from 1 to 100");
+                }
+                config.pro_max_recursion_depth = val;
+            }
+            else if (key === "default_intensity") {
+                const level = normalizeIntensity(val);
+                if (!level)
                     throw new Error("invalid default intensity");
-                config.default_intensity = val;
-                config.selected_intensity = val;
+                if (!modelIntensities(settingsTarget().model).includes(level))
+                    throw new Error("this model does not support that thinking intensity");
+                config.default_intensity = level;
+                config.selected_intensity = level;
             }
             else if (key === "model_context_window") {
                 if (!isContextWindow(val))
@@ -93,6 +146,16 @@ export function updateWebSettings(value) {
                     throw new Error("web console must be a boolean");
                 config.web_console = val;
             }
+            else if (key === "web_lan") {
+                if (typeof val !== "boolean")
+                    throw new Error("LAN access must be a boolean");
+                config.web_lan = val;
+            }
+            else if (key === "background") {
+                if (typeof val !== "boolean")
+                    throw new Error("background residency must be a boolean");
+                config.background = val;
+            }
             else if (key === "web_password") {
                 validateWebPassword(val);
             }
@@ -101,8 +164,7 @@ export function updateWebSettings(value) {
             }
         }
     }
-    if (body.selection !== undefined) {
-        const chosen = resolveModelSelection(body.selection, false);
+    if (chosen) {
         config.selected_provider = chosen.provider;
         config.selected_model = chosen.model.name;
         config.selected_model_url = chosen.model.url;
@@ -116,12 +178,23 @@ export function updateWebSettings(value) {
         config.web_password_hash = hashWebPassword(password);
     const window = body.settings?.model_context_window;
     if (window !== undefined) {
-        const selection = body.selection ?? getWebSettings().selection;
-        const chosen = resolveModelSelection(selection, false);
-        const models = loadModels();
-        const model = models.providers.find((p) => p.name === chosen.provider).models.find((m) => m.name === chosen.model.name);
-        model.context_window = window;
-        saveModels(models);
+        const selected = settingsTarget();
+        if (mode === "pro") {
+            // Context capacity is part of a workspace's compression settings. Pro
+            // stores its own copy instead of editing the shared model catalog.
+            const current = config.model_context_windows;
+            const overrides = current && typeof current === "object" && !Array.isArray(current)
+                ? { ...current }
+                : {};
+            overrides[modelContextWindowKey(selected.provider, selected.model.name)] = window;
+            config.model_context_windows = overrides;
+        }
+        else {
+            const models = loadModels();
+            const model = models.providers.find((p) => p.name === selected.provider).models.find((m) => m.name === selected.model.name);
+            model.context_window = window;
+            saveModels(models);
+        }
     }
-    saveConfig(config);
+    saveConfig(config, mode);
 }

package/dist/web/terminalBridge.js

@@ -0,0 +1,250 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import http from "node:http";
+import { resolveModelSelection } from "../config.js";
+import { hub } from "./hub.js";
+function sendJson(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+    res.end(JSON.stringify(data));
+}
+function authorized(req, token) {
+    const provided = req.headers.authorization?.replace(/^Bearer /, "") ?? "";
+    const expected = Buffer.from(token);
+    const actual = Buffer.from(provided);
+    return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+async function readBody(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += bytes.length;
+        if (size > 1_000_000)
+            throw new Error("request too large");
+        chunks.push(bytes);
+    }
+    const value = JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("invalid request");
+    return value;
+}
+/** A private loopback bridge exposes only the terminal's live hub. */
+export async function startTerminalBridge() {
+    const token = randomBytes(32).toString("hex");
+    const server = http.createServer((req, res) => {
+        void (async () => {
+            if (!authorized(req, token)) {
+                sendJson(res, 401, { error: "terminal token required" });
+                return;
+            }
+            if (req.method === "GET" && req.url === "/snapshots") {
+                const snapshots = [];
+                for (const entry of hub.list()) {
+                    const snapshot = hub.snapshot(entry.key);
+                    if (snapshot)
+                        snapshots.push({ mode: hub.has(entry.key, "pro") ? "pro" : "standard", snapshot });
+                }
+                sendJson(res, 200, snapshots);
+                return;
+            }
+            if (req.method !== "POST" || req.url !== "/action") {
+                sendJson(res, 404, { error: "not found" });
+                return;
+            }
+            const input = await readBody(req);
+            const key = typeof input.key === "string" ? input.key : "";
+            const action = input.action;
+            const body = input.body && typeof input.body === "object" && !Array.isArray(input.body)
+                ? input.body : {};
+            if (!hub.has(key)) {
+                sendJson(res, 404, { error: "unknown live session" });
+                return;
+            }
+            if (action === "pause")
+                hub.pause(key);
+            else if (action === "resume")
+                hub.resume(key);
+            else if (action === "message") {
+                if (typeof body.text !== "string" || !body.text.trim())
+                    throw new Error("empty message");
+                hub.send(key, body.text);
+            }
+            else if (action === "approve") {
+                if (!hub.approve(key, body.approved === true)) {
+                    sendJson(res, 409, { error: "no approval is pending" });
+                    return;
+                }
+            }
+            else if (action === "approval-mode") {
+                if (body.mode !== "request" && body.mode !== "auto")
+                    throw new Error("mode must be request or auto");
+                if (!hub.setApprovalMode(key, body.mode)) {
+                    sendJson(res, 409, { error: "this session cannot change approval mode" });
+                    return;
+                }
+            }
+            else if (action === "model") {
+                const result = hub.configure(key, resolveModelSelection(body));
+                if (!result.ok) {
+                    sendJson(res, 409, { error: result.error });
+                    return;
+                }
+            }
+            else if (action === "pro-preset") {
+                if (typeof body.preset !== "string")
+                    throw new Error("invalid Pro preset");
+                const result = hub.setProPreset(key, body.preset);
+                if (!result.ok) {
+                    sendJson(res, 409, { error: result.error });
+                    return;
+                }
+            }
+            else if (action === "clear") {
+                if (!hub.clear(key)) {
+                    sendJson(res, 409, { error: "this session cannot be cleared" });
+                    return;
+                }
+            }
+            else {
+                sendJson(res, 400, { error: "this session is owned by the terminal UI" });
+                return;
+            }
+            sendJson(res, 200, {
+                ok: true, snapshot: hub.snapshot(key),
+                ...(action === "pause" ? { paused: true } : action === "resume" ? { paused: false } : {}),
+                ...(action === "approve" ? { approved: body.approved === true } : {}),
+            });
+        })().catch(error => {
+            if (!res.headersSent)
+                sendJson(res, 400, { error: error instanceof Error ? error.message : "invalid request" });
+            else
+                res.end();
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => { server.removeListener("error", reject); resolve(); });
+    });
+    server.unref();
+    const address = server.address();
+    if (!address || typeof address === "string")
+        throw new Error("could not open the terminal bridge");
+    return { url: `http://127.0.0.1:${address.port}`, token, close: () => { server.close(); } };
+}
+class RemoteTerminal {
+    bridge;
+    remoteKey;
+    mode;
+    current;
+    key = "";
+    constructor(bridge, remoteKey, mode, initial) {
+        this.bridge = bridge;
+        this.remoteKey = remoteKey;
+        this.mode = mode;
+        this.current = initial;
+        this.key = hub.register(this);
+    }
+    liveCwd() { return this.current.cwd; }
+    liveMeta() {
+        const { key: _key, cwd: _cwd, messages: _messages, streamingContent: _streaming, context: _context, plan: _plan, ...meta } = this.current;
+        return meta;
+    }
+    liveSnapshot(key) { return { ...this.current, key }; }
+    // The public server forwards actions through remoteAction, where failures can
+    // be returned to the browser rather than silently lost.
+    livePause() { }
+    liveResume() { }
+    liveSend(_text) { }
+    update(snapshot) {
+        this.current = snapshot;
+        hub.notify(this.key);
+    }
+    async remoteAction(action, body) {
+        try {
+            const response = await fetch(`${this.bridge.url}/action`, {
+                method: "POST", headers: { Authorization: `Bearer ${this.bridge.token}`, "Content-Type": "application/json" },
+                body: JSON.stringify({ key: this.remoteKey, action, body }), signal: AbortSignal.timeout(5000),
+            });
+            const data = await response.json();
+            if (data.snapshot) {
+                this.update(data.snapshot);
+                data.snapshot = this.liveSnapshot(this.key);
+            }
+            return { status: response.status, data };
+        }
+        catch {
+            return { status: 503, data: { error: "the terminal session is unavailable" } };
+        }
+    }
+    close() { hub.unregister(this.key); }
+}
+/** Mirror each attached terminal's live sessions into the Web service. */
+export class TerminalBridges {
+    entries = new Map();
+    timer = setInterval(() => { for (const owner of this.entries.keys())
+        void this.poll(owner); }, 250);
+    constructor() { this.timer.unref(); }
+    add(owner, bridge) {
+        this.remove(owner);
+        this.entries.set(owner, { bridge, sessions: new Map(), polling: false, failures: 0 });
+        void this.poll(owner);
+    }
+    remove(owner) {
+        const entry = this.entries.get(owner);
+        if (!entry)
+            return;
+        this.entries.delete(owner);
+        for (const session of entry.sessions.values())
+            session.close();
+    }
+    close() {
+        clearInterval(this.timer);
+        for (const owner of this.entries.keys())
+            this.remove(owner);
+    }
+    async poll(owner) {
+        const entry = this.entries.get(owner);
+        if (!entry || entry.polling)
+            return;
+        entry.polling = true;
+        try {
+            const response = await fetch(`${entry.bridge.url}/snapshots`, {
+                headers: { Authorization: `Bearer ${entry.bridge.token}` }, signal: AbortSignal.timeout(1500),
+            });
+            if (!response.ok)
+                throw new Error("terminal bridge failed");
+            const snapshots = await response.json();
+            if (!Array.isArray(snapshots) || this.entries.get(owner) !== entry)
+                return;
+            entry.failures = 0;
+            const live = new Set();
+            for (const { mode, snapshot } of snapshots) {
+                if (!snapshot || typeof snapshot.key !== "string" || (mode !== "standard" && mode !== "pro"))
+                    continue;
+                live.add(snapshot.key);
+                const session = entry.sessions.get(snapshot.key);
+                if (session)
+                    session.update(snapshot);
+                else
+                    entry.sessions.set(snapshot.key, new RemoteTerminal(entry.bridge, snapshot.key, mode, snapshot));
+            }
+            for (const [key, session] of entry.sessions) {
+                if (!live.has(key)) {
+                    session.close();
+                    entry.sessions.delete(key);
+                }
+            }
+        }
+        catch {
+            // Keep snapshots over brief disconnects, but never expose a dead terminal
+            // indefinitely if its process stays alive after the bridge fails.
+            if (++entry.failures >= 4) {
+                for (const session of entry.sessions.values())
+                    session.close();
+                entry.sessions.clear();
+            }
+        }
+        finally {
+            entry.polling = false;
+        }
+    }
+}

package/package.json

@@ -1,37 +1,37 @@
-{
-  "name": "@xingjisoft/neutrino",
-  "version": "0.3.0",
-  "description": "XINGJI Neutrino - a CLI coding agent in the terminal.",
-  "type": "module",
-  "license": "Apache-2.0",
-  "bin": {
-    "neutrino": "dist/bin.js"
-  },
-  "main": "dist/app.js",
-  "files": [
-    "dist",
-    "assets",
-    "web"
-  ],
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "npm run build && node scripts/test-paste.mjs && node scripts/test-mouse.mjs && node scripts/test-cursor.mjs && node scripts/test-selection.mjs && node scripts/test-drag-scroll.mjs && node scripts/test-selection-performance.mjs && node scripts/test-copy.mjs && node scripts/test-scrollbar.mjs && node scripts/test-render.mjs && node scripts/test-drift.mjs && node scripts/test-sanitize.mjs && node scripts/test-markdown.mjs && node scripts/test-wrap.mjs && node scripts/test-fetch.mjs && node scripts/test-compact.mjs && node scripts/test-history-fold.mjs && node scripts/test-web-history.mjs && node scripts/test-web-default.mjs && node scripts/test-turn-fold.mjs && node scripts/test-plan.mjs && node scripts/test-subagent.mjs && node scripts/test-web-settings.mjs && node scripts/test-web-markdown.mjs && node scripts/test-web-i18n.mjs && node scripts/test-web-workspaces.mjs && node scripts/test-tools.mjs && node scripts/test-approval.mjs && node scripts/test-approval-review.mjs && node scripts/test-approval-ui.mjs && node scripts/test-web-approval-details.mjs && node scripts/test-approval-mode.mjs && node scripts/test-approval-context.mjs && node scripts/test-settings-render.mjs && node scripts/test-approval-flow.mjs && node scripts/test-web.mjs && node scripts/test-web-settings-http.mjs && node scripts/test-web-auth.mjs && node scripts/test-web-auth-ui.mjs && node scripts/test-interrupt.mjs && node scripts/test-terminal-lifecycle.mjs && node scripts/test-persistence.mjs && node scripts/test-resilience.mjs && node scripts/test-approval-timeout.mjs && node scripts/test-approval-hardening.mjs && node scripts/test-approval-extreme.mjs && node scripts/test-approval-reason.mjs",
-    "prepare": "npm run build",
-    "web": "node dist/bin.js web"
-  },
-  "keywords": [
-    "cli",
-    "agent",
-    "ai",
-    "terminal",
-    "llm",
-    "coding"
-  ],
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "typescript": "^5.5.0"
-  }
-}
+{
+  "name": "@xingjisoft/neutrino",
+  "version": "0.4.1",
+  "description": "XINGJI Neutrino - a CLI coding agent in the terminal.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "bin": {
+    "neutrino": "dist/bin.js"
+  },
+  "main": "dist/app.js",
+  "files": [
+    "dist",
+    "assets",
+    "web"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node scripts/test-paste.mjs && node scripts/test-mouse.mjs && node scripts/test-cursor.mjs && node scripts/test-selection.mjs && node scripts/test-drag-scroll.mjs && node scripts/test-selection-performance.mjs && node scripts/test-copy.mjs && node scripts/test-scrollbar.mjs && node scripts/test-render.mjs && node scripts/test-drift.mjs && node scripts/test-sanitize.mjs && node scripts/test-markdown.mjs && node scripts/test-wrap.mjs && node scripts/test-fetch.mjs && node scripts/test-compact.mjs && node scripts/test-history-fold.mjs && node scripts/test-web-history.mjs && node scripts/test-session-migration.mjs && node scripts/test-web-session-migration.mjs && node scripts/test-web-default.mjs && node scripts/test-turn-fold.mjs && node scripts/test-long-turn.mjs && node scripts/test-plan.mjs && node scripts/test-subagent.mjs && node scripts/test-web-settings.mjs && node scripts/test-model-intensity.mjs && node scripts/test-background.mjs && node scripts/test-background-lifetime.mjs && node scripts/test-web-markdown.mjs && node scripts/test-web-i18n.mjs && node scripts/test-web-workspaces.mjs && node scripts/test-tools.mjs && node scripts/test-approval.mjs && node scripts/test-approval-review.mjs && node scripts/test-approval-ui.mjs && node scripts/test-web-approval-details.mjs && node scripts/test-approval-mode.mjs && node scripts/test-approval-context.mjs && node scripts/test-settings-render.mjs && node scripts/test-approval-flow.mjs && node scripts/test-web.mjs && node scripts/test-web-settings-http.mjs && node scripts/test-web-lan.mjs && node scripts/test-web-auth.mjs && node scripts/test-web-auth-ui.mjs && node scripts/test-web-pro.mjs && node scripts/test-pro-preflight.mjs && node scripts/test-pro-runtime.mjs && node scripts/test-pro-team.mjs && node scripts/test-pro-ui.mjs && node scripts/test-interrupt.mjs && node scripts/test-terminal-lifecycle.mjs && node scripts/test-persistence.mjs && node scripts/test-resilience.mjs && node scripts/test-approval-timeout.mjs && node scripts/test-approval-hardening.mjs && node scripts/test-approval-extreme.mjs && node scripts/test-approval-reason.mjs",
+    "prepare": "npm run build",
+    "web": "node dist/bin.js web"
+  },
+  "keywords": [
+    "cli",
+    "agent",
+    "ai",
+    "terminal",
+    "llm",
+    "coding"
+  ],
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.5.0"
+  }
+}