@xingjisoft/neutrino 0.2.1 → 0.4.0

package/dist/browser.js

@@ -0,0 +1,57 @@
+import { spawn } from "node:child_process";
+import process from "node:process";
+/**
+ * Where the browser console's Pro workspace lives, given the console's base
+ * URL.
+ *
+ * The base comes straight from the running server, but it is normalised here
+ * anyway: a trailing slash must not produce `//pro`, and a URL that already
+ * points at `/pro` must not become `/pro/pro`. A missing/blank base yields the
+ * path alone instead of throwing, so a half-configured console can still be
+ * reported instead of crashing the click that asked for it.
+ */
+export function proModeUrl(baseUrl) {
+    const base = String(baseUrl ?? "").trim().replace(/\/+$/, "");
+    if (/\/pro$/i.test(base))
+        return base;
+    return `${base}/pro`;
+}
+/**
+ * Open `url` in the user's default browser. Fire-and-forget: the child is
+ * detached, its stdio is ignored and it is unref'd so the terminal is never
+ * held open (or blocked) by the browser. Every failure is swallowed — opening
+ * a browser is best-effort and must never take the TUI down.
+ */
+export function openInBrowser(url) {
+    try {
+        let command;
+        let args;
+        if (process.platform === "win32") {
+            // `start` is a cmd built-in. The empty "" is the (required) window title,
+            // so a quoted URL is never mistaken for one.
+            command = "cmd";
+            args = ["/c", "start", "", url];
+        }
+        else if (process.platform === "darwin") {
+            command = "open";
+            args = [url];
+        }
+        else {
+            command = "xdg-open";
+            args = [url];
+        }
+        const child = spawn(command, args, {
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        // A missing opener (xdg-open is not installed everywhere) is reported
+        // asynchronously; without a listener that 'error' event would crash the
+        // whole process.
+        child.on("error", () => { });
+        child.unref();
+    }
+    catch {
+        // Best-effort only.
+    }
+}

package/dist/config.js

@@ -11,6 +11,36 @@ export const NEUTRINO_DIR = path.join(os.homedir(), ".neutrino");
 export const MODEL_FILE = path.join(NEUTRINO_DIR, "model.json");
 export const SESSION_DIR = path.join(NEUTRINO_DIR, "session");
 export const CONFIG_FILE = path.join(NEUTRINO_DIR, "config.json");
+/**
+ * The browser console has two workspaces: the regular one and the isolated
+ * "Pro" workspace served at `/pro`. Everything a workspace owns — transcripts,
+ * model defaults, plan/compaction settings, reviewer model and interface
+ * language — is stored per mode; only the credentials and the approval policy
+ * below are shared, because they protect or gate the whole process.
+ */
+export const MODES = ["standard", "pro"];
+export const PRO_DIR = path.join(NEUTRINO_DIR, "pro");
+export const PRO_CONFIG_FILE = path.join(PRO_DIR, "config.json");
+export const PRO_SESSION_DIR = path.join(PRO_DIR, "session");
+/**
+ * Settings that intentionally apply to both workspaces. The Web password, the
+ * approval policy and the console's interface are properties of this process,
+ * not of a conversation workspace.
+ */
+export const SHARED_CONFIG_KEYS = ["web_password_hash", "approval_mode", "auto_approve_extreme_risk", "web_lan"];
+export function normalizeMode(value) {
+    return typeof value === "string" && value.trim().toLowerCase() === "pro" ? "pro" : "standard";
+}
+export function configFile(mode = "standard") {
+    return mode === "pro" ? PRO_CONFIG_FILE : CONFIG_FILE;
+}
+export function sessionDir(mode = "standard") {
+    return mode === "pro" ? PRO_SESSION_DIR : SESSION_DIR;
+}
+/** Key used to remember a model's context capacity per workspace. */
+export function modelContextWindowKey(provider, modelName) {
+    return `${provider}/${modelName}`;
+}
 /**
  * Whether assistant messages must be sent back with a `reasoning_content`
  * field. DeepSeek's thinking mode requires one on *every* assistant message of
@@ -32,12 +62,26 @@ export function contextWindow(value) {
     return isContextWindow(value) ? value : DEFAULT_CONTEXT_WINDOW;
 }
 /** Reload the exact provider/model so settings also apply to active chats. */
-export function modelContextWindow(provider, model) {
+export function modelContextWindow(provider, model, mode = "standard") {
+    // The Pro workspace keeps its own context capacities: changing one there must
+    // not move the compression threshold of the regular workspace (and vice
+    // versa). The capacity is a per-workspace setting, not shared model metadata,
+    // so an unset Pro value starts from the documented default instead of
+    // inheriting whatever the regular workspace saved in model.json.
+    if (mode === "pro") {
+        const configured = loadConfig("pro").model_context_windows;
+        if (configured && typeof configured === "object" && !Array.isArray(configured)) {
+            const override = configured[modelContextWindowKey(provider, model.name)];
+            if (isContextWindow(override))
+                return override;
+        }
+        return contextWindow(undefined);
+    }
     const saved = loadModels().providers.find((p) => p.name === provider)?.models.find((m) => m.name === model.name);
     return contextWindow((saved ?? model).context_window);
 }
-export function contextCompressionThreshold(provider, model) {
-    return Math.max(1, Math.floor(modelContextWindow(provider, model) * CONTEXT_COMPRESSION_RATIO));
+export function contextCompressionThreshold(provider, model, mode = "standard") {
+    return Math.max(1, Math.floor(modelContextWindow(provider, model, mode) * CONTEXT_COMPRESSION_RATIO));
 }
 export const DEFAULT_MODELS = {
     providers: [
@@ -63,6 +107,12 @@ export const DEFAULT_MODELS = {
         },
     ],
 };
+/** Languages the browser console can render its own interface in. */
+export const WEB_LANGUAGES = ["en", "zh"];
+/** Unknown or missing values fall back to English rather than breaking the UI. */
+export function normalizeWebLanguage(value) {
+    return typeof value === "string" && value.trim().toLowerCase().startsWith("zh") ? "zh" : "en";
+}
 export const DEFAULT_CONFIG = {
     language: "en",
     theme: "default",
@@ -83,6 +133,12 @@ export const DEFAULT_CONFIG = {
     // Mount the browser UI alongside the terminal UI unless it is turned off
     // here or on the command line.
     web_console: true,
+    // Listen on every interface (the equivalent of --lan) instead of loopback.
+    // The listener belongs to the process, so both workspaces share this value.
+    web_lan: false,
+    // Working directories opened from the browser, newest first. They remain
+    // listed even when they hold no conversations yet.
+    web_workspaces: [],
     // Initialized as a salted hash of the default Web password on first use.
     web_password_hash: "",
 };
@@ -94,6 +150,54 @@ export const INTENSITY_PARAMS = {
     Max: { temperature: 1.0, top_p: 1.0 },
     Ultra: { temperature: 1.5, top_p: 1.0 },
 };
+/** Canonical spelling of a configured intensity name, or null when unknown. */
+export function normalizeIntensity(value) {
+    if (typeof value !== "string")
+        return null;
+    const wanted = value.trim().toLowerCase();
+    return INTENSITY_LEVELS.find((level) => level.toLowerCase() === wanted) ?? null;
+}
+/**
+ * The intensities a model accepts, in the canonical Low → Ultra order.
+ *
+ * An absent or empty list keeps the historical behaviour: every level is
+ * allowed. Unknown names are ignored rather than making the model unusable, so
+ * a typo in `model.json` falls back to the remaining valid entries (or to all
+ * levels when none is valid).
+ */
+export function modelIntensities(model) {
+    const raw = model?.intensity;
+    const entries = Array.isArray(raw) ? raw : typeof raw === "string" ? [raw] : [];
+    const allowed = new Set();
+    for (const entry of entries) {
+        const level = normalizeIntensity(entry);
+        if (level)
+            allowed.add(level);
+    }
+    if (allowed.size === 0)
+        return [...INTENSITY_LEVELS];
+    return INTENSITY_LEVELS.filter((level) => allowed.has(level));
+}
+/**
+ * Pick a usable intensity for a model. The preferred value wins when the model
+ * accepts it; otherwise the configured fallback, then High, then the first
+ * supported level. This is the one place stale UI state, a saved session or a
+ * hand-edited `config.json` is reconciled with the model's limits.
+ */
+export function intensityForModel(model, preferred, fallback) {
+    const allowed = modelIntensities(model);
+    for (const candidate of [preferred, fallback, "High"]) {
+        const level = normalizeIntensity(candidate);
+        if (level && allowed.includes(level))
+            return level;
+    }
+    return allowed[0] ?? "High";
+}
+/** Exact model lookup within a provider (names may repeat across providers). */
+export function findConfiguredModel(providerName, modelName) {
+    return loadModels().providers.find((provider) => provider.name === providerName)
+        ?.models.find((model) => model.name === modelName) ?? null;
+}
 export function normalizeApprovalMode(value) {
     // Config files are hand-edited: "Auto" or " autO " must not silently
     // downgrade the conversation to a prompt on every tool call.
@@ -101,9 +205,11 @@ export function normalizeApprovalMode(value) {
         ? "auto"
         : "request";
 }
-export function ensureDirs() {
+export function ensureDirs(mode = "standard") {
     fs.mkdirSync(NEUTRINO_DIR, { recursive: true });
-    fs.mkdirSync(SESSION_DIR, { recursive: true });
+    fs.mkdirSync(sessionDir(mode), { recursive: true });
+    if (mode === "pro")
+        fs.mkdirSync(PRO_DIR, { recursive: true });
 }
 export function loadModels() {
     try {
@@ -123,7 +229,26 @@ export function saveModels(data) {
     ensureDirs();
     fs.writeFileSync(MODEL_FILE, JSON.stringify(data, null, 2), "utf-8");
 }
-export function loadConfig() {
+/** Read a config file without creating it; null when missing or unreadable. */
+function readConfigFile(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function loadConfig(mode = "standard") {
+    if (mode === "pro") {
+        // Pro keeps its own file, with credentials/approval policy layered on top
+        // from the main config so those stay shared by construction.
+        const own = readConfigFile(PRO_CONFIG_FILE) ?? {};
+        const shared = readConfigFile(CONFIG_FILE) ?? DEFAULT_CONFIG;
+        const merged = { ...DEFAULT_CONFIG, ...own };
+        for (const key of SHARED_CONFIG_KEYS)
+            merged[key] = shared[key] ?? DEFAULT_CONFIG[key];
+        return merged;
+    }
     try {
         ensureDirs();
         if (!fs.existsSync(CONFIG_FILE)) {
@@ -138,8 +263,30 @@ export function loadConfig() {
         return { ...DEFAULT_CONFIG };
     }
 }
-export function saveConfig(data) {
-    ensureDirs();
+export function saveConfig(data, mode = "standard") {
+    ensureDirs(mode);
+    if (mode === "pro") {
+        fs.mkdirSync(PRO_DIR, { recursive: true });
+        const own = { ...data };
+        for (const key of SHARED_CONFIG_KEYS)
+            delete own[key];
+        fs.writeFileSync(PRO_CONFIG_FILE, JSON.stringify(own, null, 2), "utf-8");
+        // A Pro settings save that touched a shared key (password, approval policy)
+        // writes it back to the main config, where the terminal and both pages read it.
+        const shared = readConfigFile(CONFIG_FILE) ?? { ...DEFAULT_CONFIG };
+        let changed = false;
+        for (const key of SHARED_CONFIG_KEYS) {
+            if (data[key] === undefined)
+                continue;
+            if (JSON.stringify(data[key]) === JSON.stringify(shared[key]))
+                continue;
+            shared[key] = data[key];
+            changed = true;
+        }
+        if (changed)
+            fs.writeFileSync(CONFIG_FILE, JSON.stringify(shared, null, 2), "utf-8");
+        return;
+    }
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), "utf-8");
 }
 /** Look a model up by name across every configured provider. */
@@ -170,7 +317,8 @@ export function resolveModelSelection(value, requireKey = true) {
     if (typeof input.provider !== "string" || typeof input.model !== "string" ||
         typeof input.intensity !== "string")
         throw new Error("provider, model and intensity are required");
-    if (!INTENSITY_LEVELS.includes(input.intensity))
+    const intensity = normalizeIntensity(input.intensity);
+    if (!intensity)
         throw new Error("invalid thinking intensity");
     const provider = loadModels().providers.find((p) => p.name === input.provider);
     if (!provider)
@@ -178,15 +326,17 @@ export function resolveModelSelection(value, requireKey = true) {
     const model = provider.models.find((m) => m.name === input.model);
     if (!model)
         throw new Error("unknown model for this provider");
+    if (!modelIntensities(model).includes(intensity))
+        throw new Error("this model does not support that thinking intensity");
     if (requireKey && !model.api_key?.trim())
         throw new Error("this model has no API key configured");
-    return { provider: provider.name, model: { ...model }, intensity: input.intensity };
+    return { provider: provider.name, model: { ...model }, intensity };
 }
-export function saveSession(messages, modelName, provider, intensity, cwd, sessionId, tokens, context, approvalMode, plan) {
-    ensureDirs();
+export function saveSession(messages, modelName, provider, intensity, cwd, sessionId, tokens, context, approvalMode, plan, mode = "standard", proPreset) {
+    ensureDirs(mode);
     const now = new Date();
     const id = sessionId ?? `${now.toISOString().replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
-    const existing = sessionId ? loadSession(sessionId) : null;
+    const existing = sessionId ? loadSession(sessionId, mode) : null;
     const created_at = existing ? existing.created_at : now.toISOString();
     let title = "";
     for (const msg of messages) {
@@ -207,6 +357,8 @@ export function saveSession(messages, modelName, provider, intensity, cwd, sessi
         messages,
         tokens,
         approval_mode: normalizeApprovalMode(approvalMode ?? existing?.approval_mode),
+        ...(mode === "pro" && (proPreset ?? existing?.pro_preset)
+            ? { pro_preset: proPreset ?? existing?.pro_preset } : {}),
     };
     const validContext = normalizeContext(context, messages.filter((m) => m.role !== "system").length);
     if (validContext)
@@ -215,7 +367,7 @@ export function saveSession(messages, modelName, provider, intensity, cwd, sessi
     // how far it got, and a stopped plan is still the record of what was agreed.
     if (plan && plan.steps.length)
         session.plan = plan;
-    const filePath = path.join(SESSION_DIR, `${id}.json`);
+    const filePath = path.join(sessionDir(mode), `${id}.json`);
     // Keep the last complete transcript intact if writing or replacing fails.
     // The temporary file shares the destination directory so rename is atomic.
     const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
@@ -243,8 +395,8 @@ export function saveSession(messages, modelName, provider, intensity, cwd, sessi
     }
     return id;
 }
-export function loadSession(sessionId) {
-    const filePath = path.join(SESSION_DIR, `${sessionId}.json`);
+export function loadSession(sessionId, mode = "standard") {
+    const filePath = path.join(sessionDir(mode), `${sessionId}.json`);
     if (!fs.existsSync(filePath))
         return null;
     try {
@@ -254,27 +406,28 @@ export function loadSession(sessionId) {
         return null;
     }
 }
-export function deleteSession(sessionId) {
-    const filePath = path.join(SESSION_DIR, `${sessionId}.json`);
+export function deleteSession(sessionId, mode = "standard") {
+    const filePath = path.join(sessionDir(mode), `${sessionId}.json`);
     if (fs.existsSync(filePath)) {
         fs.unlinkSync(filePath);
         return true;
     }
     return false;
 }
-export function listSessions() {
-    ensureDirs();
+export function listSessions(mode = "standard") {
+    ensureDirs(mode);
     const sessions = [];
+    const dir = sessionDir(mode);
     let files = [];
     try {
-        files = fs.readdirSync(SESSION_DIR).filter((f) => f.endsWith(".json"));
+        files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
     }
     catch {
         return sessions;
     }
     for (const f of files) {
         try {
-            const data = JSON.parse(fs.readFileSync(path.join(SESSION_DIR, f), "utf-8"));
+            const data = JSON.parse(fs.readFileSync(path.join(dir, f), "utf-8"));
             sessions.push({
                 id: data.id ?? f.replace(/\.json$/, ""),
                 created_at: data.created_at ?? "",
@@ -299,8 +452,8 @@ export function listSessions() {
  * The history menu is scoped to the current project so sessions started in
  * other directories do not clutter it.
  */
-export function listSessionsForCwd(cwd = process.cwd()) {
-    return listSessions().filter((s) => sameCwd(s.cwd, cwd));
+export function listSessionsForCwd(cwd = process.cwd(), mode = "standard") {
+    return listSessions(mode).filter((s) => sameCwd(s.cwd, cwd));
 }
 function readAsset(...candidates) {
     for (const candidate of candidates) {
@@ -351,13 +504,13 @@ export function loadSubAgentPrompt() {
  * `NEUTRINO_PLAN=off` overrides both ways for a single run, the way the other
  * environment variables override the saved configuration.
  */
-export function planFirstEnabled() {
+export function planFirstEnabled(mode = "standard") {
     const override = String(process.env.NEUTRINO_PLAN ?? "").trim().toLowerCase();
     if (override === "off" || override === "0" || override === "false" || override === "no")
         return false;
     if (override === "on" || override === "1" || override === "true" || override === "yes")
         return true;
-    return loadConfig().plan_first !== false;
+    return loadConfig(mode).plan_first !== false;
 }
 let cachedVersion = null;
 /**

package/dist/index.js

@@ -1,5 +1,5 @@
 export { App } from "./app.js";
 export { defaultState } from "./state.js";
-export { INTENSITY_LEVELS, INTENSITY_PARAMS, DEFAULT_MODELS, loadModels, saveModels, loadConfig, saveConfig, listSessions, loadSession, deleteSession, saveSession, } from "./config.js";
+export { INTENSITY_LEVELS, INTENSITY_PARAMS, DEFAULT_MODELS, MODES, normalizeMode, normalizeIntensity, modelIntensities, intensityForModel, findConfiguredModel, loadModels, saveModels, loadConfig, saveConfig, listSessions, loadSession, deleteSession, saveSession, } from "./config.js";
 export { LLMClient } from "./llm/client.js";
 export { executeTool, getToolDefinitions } from "./llm/tools.js";

package/dist/llm/approval.js

@@ -511,9 +511,13 @@ export class ApprovalGate {
             // Resolved inside the try: an unresolvable reviewer model is a failed
             // vote (and therefore a denial), not an exception that aborts the call.
             const { model, provider, intensity } = this.options.reviewer();
-            const client = new LLMClient(model, provider, intensity);
+            const client = this.options.createReviewerClient?.() ?? new LLMClient(model, provider, intensity);
             const timeout = this.options.reviewTimeoutMs?.() ?? REVIEW_TIMEOUT_MS;
-            const raw = await withTimeout(client.complete(REVIEW_SYSTEM_PROMPT, prompt), timeout);
+            const rolePrompt = this.options.reviewerSystemPrompt?.();
+            const system = rolePrompt ? `${rolePrompt}\n\n${REVIEW_SYSTEM_PROMPT}` : REVIEW_SYSTEM_PROMPT;
+            const controller = new AbortController();
+            const raw = await withTimeout(client.complete(system, prompt, { signal: controller.signal, cancelled: this.options.cancelled }), timeout)
+                .finally(() => controller.abort());
             if (raw === null) {
                 // Fail closed: a reviewer that never answers must not stall the turn.
                 return {