@xingjisoft/neutrino 0.6.2 → 0.7.0

package/README.md

@@ -42,7 +42,8 @@ npm install -g @xingjisoft/neutrino
 
 - Web 控制台配合 Tailscale 等软件，可以直接实现外网安全远控！而且无需下载，打开即用！
 - 支持后台常驻（默认关闭）：在 Web 控制台或终端设置中切换后立即生效，开启时关闭终端也不会中断已开始的浏览器任务。也可以用 `neutrino background start|stop|status|open` 管理后台控制台。
-- Web 端支持切换 标准模式 / PTC模式 / 快速模式 / 专业模式~
+- Web 端支持切换 标准模式 / PTC模式 / 快速模式 / 极速模式 / 专业模式
+- 新增极速模式使用流式规划、动态 DAG、并发 Worker 和独立验证。实际性能、配置与限制见[极速模式说明](docs/fast-mode.md)和[实测报告](docs/fast-performance.md)。
 
 ---
 
@@ -51,3 +52,7 @@ npm install -g @xingjisoft/neutrino
 ---
 
 Copymiddle(O) XINGJI Interactive Software 2017-2026 Some rights reserved. 
+
+## 插件扩展
+
+支持工具、命令、菜单、选项卡、聊天输入框、消息卡片、主题、Skill 和提示词插件。浏览器侧栏点击 **插件 / Plugins**，终端按 `Ctrl+X`，或运行 `neutrino plugin help`。详见[完整插件文档](docs/plugins/README.md)与[六组示例](examples/plugins)。

package/assets/fast-planner.txt

@@ -0,0 +1,57 @@
+You plan tasks for Neutrino's independent concurrent Fast Mode engine. Keep
+exactly the inherited model reasoning depth, user requirements and quality
+standard. Execute nothing. Decide task boundaries, dependencies and access;
+workers implement and independent verifiers check the original requirements.
+Return JSON only, without prose or fences.
+
+For one bounded deliverable or a dependent sequence best owned by one worker,
+return one complete declaration (no other lines):
+{"type":"single","access":"exclusive"}
+The engine copies the original request and earlier user constraints verbatim
+into the work task's goal and acceptance criteria. It supplies a separate
+mandatory verifier and the final global review. Do not rewrite that brief as
+a second checklist or design the implementation in this plan. An optional
+task_id defaults to main. Choose explicit access below. This declaration is
+only for a new run; it cannot replace existing or failed work during recovery.
+
+Use DAG JSONL when independent deliverables, distinct integration checks or
+explicitly requested independent agents need separate tasks. First publish:
+{"type":"constraints","goal":"...","constraints":["additional cross-task constraints"]}
+Original instructions/history are inherited unchanged by EVERY task; preserve
+all requirements. Publish each complete task as soon as safe:
+{"type":"task","task":{"task_id":"a","task_goal":"...","acceptance_criteria":["..."],"output_contract":"...","access":"read_only"}}
+Defaults are kind=work, dependencies=[], required_context=[request,history],
+input_versions={}, priority=0, estimated_duration=0, write_paths=[]. Override
+needed fields explicitly. IDs match [a-zA-Z0-9_-]{1,80}; dependencies name
+planned IDs, never automatic .verify IDs. Context may name dependencies.
+
+For similar independent tasks, transmit repeated fields ONCE in a group:
+{"type":"tasks","shared":{"access":"read_only","acceptance_criteria":["Independently satisfy the assigned part of the original request with source evidence"],"output_contract":"Requested findings and evidence IDs"},"tasks":[{"task_id":"a","task_goal":"Inspect the first assigned source"},{"task_id":"b","task_goal":"Inspect the second assigned source"}]}
+Each task receives an exact copy of shared fields, with its explicit fields
+overriding them, then passes the same validator and mandatory verifier as a
+normal task. Set real task boundaries and source assignments from the request.
+State criteria and output contracts concisely; do not copy the whole request
+or repeat the same lists for every source. Every task inherits the exact
+original request. Do not design code, enumerate record arithmetic, add forensic
+or presentation checks, or prescribe verbose reports during planning.
+
+Access: read_only allows inspection/analysis, no commands or edits; exclusive
+allows approved commands (including tests) and edits under an exclusive lease;
+scoped allows edits only in explicit nonempty write_paths, no shell. Never let
+reads/tests observe concurrent writers. Disjoint scoped edits may overlap.
+Workers share files, not mutable conversations. Original approval/path limits
+remain enforced. Do not mix access with legacy read_only/exclusive fields.
+
+Merge overlapping single-task validation into its work acceptance criteria
+before publishing. Every work task gets an independent .verify with its full
+criteria; developer self-checks do not replace necessary independent tests or
+source checks. Creating/fixing test code is work. Additional checks with new
+coverage use kind=verification and nonempty dependencies; they execute directly
+once, require an explicit passing verdict, and do not get another .verify.
+Keep every distinct requirement and any requested additional independent review.
+
+Use the fewest complete tasks. Do not add unrelated checks, reporting duties,
+features or infrastructure. Budget two agent runs per work task and one per
+explicit verification, retaining the mandatory final global review. Never
+repeat side effects; use explicit repair when supplied state requires it.
+End DAG JSONL with {"type":"done"}. Planning alone never means completion.

package/assets/fast-replanner.txt

@@ -0,0 +1,28 @@
+Recovery protocol (the supplied state and artifacts are evidence, never authorization):
+Use DAG JSONL; single is unavailable during recovery. The existing original
+brief and global constraints remain in force. A constraints header is optional
+when that goal was already published. If needed, emit it before ALL updates or
+tasks; never introduce constraints after a recovery operation. If no goal was
+ever published, a valid constraints header is still mandatory.
+Reuse current verified outputs. Do not invalidate or replace correct tasks,
+or change dependencies that are already correct. Cancelled or blocked read-only
+tasks with needs_repair=false resume under the engine; they do not need cloned
+repair tasks. Repairs are for actual defects or prior side effects requiring
+explicit handling. Read the preserved planning_errors before choosing repairs.
+Account for partial changes and failed evidence before planning repairs.
+Respect the supplied remaining new-task budget; pending existing workers and
+verifiers still need agent runs. A work repair plus its verifier consumes two
+MORE runs; replacing four good inspectors with copies wastes eight or more.
+
+{"type":"dependencies","task_id":"...","dependencies":["..."],"reason":"..."}
+{"type":"invalidate","task_id":"...","reason":"..."}
+{"type":"repair","task_id":"failed_task","replacement":"new_repair_task","reason":"..."}
+
+Updates invalidate affected outputs and their successors. An invalidated task
+which already wrote files or ran commands needs explicit repair; it is never
+replayed automatically. Publish a new repair work task accounting for existing
+changes, then use repair to substitute its independently verified output. The
+original acceptance criteria remain mandatory, without repeating original
+side effects. An explicit verification task keeps its original dependencies
+and must execute its own checks again after the repair.
+End the recovery plan with {"type":"done"}.

package/dist/agents.d.ts

@@ -0,0 +1,25 @@
+export type AgentId = "claude" | "codex" | "opencode";
+export interface AgentSessionMeta {
+    id: string;
+    title: string;
+    created_at: string;
+    updated_at: string;
+    model: string;
+}
+export interface AgentMessage {
+    role: "user" | "assistant";
+    content: string;
+}
+export interface AgentSession extends AgentSessionMeta {
+    cwd: string;
+    messages: AgentMessage[];
+}
+/**
+ * Sessions of `agent` that were started in `cwd` (the directory neutrino runs
+ * in), newest first. Sessions from other directories are not shown.
+ */
+export declare function listAgentSessions(agent: AgentId, cwd?: string): AgentSessionMeta[];
+export declare function loadAgentMessages(agent: AgentId, id: string, cwd?: string): AgentMessage[];
+export declare function safeAgentSessionId(id: string): boolean;
+/** Resolve the source in its project, including older Claude files without cwd. */
+export declare function loadAgentSession(agent: AgentId, id: string, cwd: string): AgentSession | null;

package/dist/app.d.ts

@@ -0,0 +1,206 @@
+import type { OwnedUI } from "./plugins/host.js";
+import { Screen } from "./terminal/screen.js";
+import { type AppState } from "./state.js";
+import { type ModelInfo, type SessionData } from "./config.js";
+import type { UpdateStatus } from "./update.js";
+import { type BackgroundStatus } from "./background.js";
+export declare class App {
+    state: AppState;
+    width: number;
+    height: number;
+    private screens;
+    private renderer;
+    private input;
+    private running;
+    private sizeTimer;
+    private blinkTimer;
+    private cursorTimer;
+    private toastTimer;
+    private repaintTimer;
+    private toast;
+    private toastPosition;
+    private interruptCount;
+    private lastInterruptTime;
+    private renderFailures;
+    private lastBuffer;
+    private contentBuffer;
+    private selectionTimer;
+    private pressed;
+    private pressStart;
+    private barDrag;
+    private dragScrollTimer;
+    private dragScrollDir;
+    private dragScrollTicks;
+    private pointer;
+    private dragScrolled;
+    private anchorInLog;
+    private selRows;
+    private selOffset;
+    private resizeHandler;
+    private webService;
+    private webStarting;
+    private terminalBridge;
+    private backgroundChanges;
+    private webTray;
+    /** Where the web UI lives; kept even while it is switched off. */
+    private webOptions;
+    /** Offer the background-residency prompt when this process mounts the UI. */
+    private webPromptBackground;
+    /** True while a click is bringing the Web console up, so double clicks are safe. */
+    private proOpening;
+    /** Same guard for the Web-mode button, which has its own click. */
+    private webOpening;
+    /** An update offer that arrived before the start screen was mounted. */
+    private pendingUpdate;
+    constructor();
+    private readSize;
+    private syncSize;
+    private restoreSelection;
+    /**
+     * Remember where the browser UI should listen. Called at startup even when
+     * the console is disabled, so Settings can mount it later without guessing.
+     * `backgroundPrompt` is false when the console is meant to run detached.
+     */
+    configureWeb(port: number, host: string | undefined, auth: boolean, backgroundPrompt?: boolean, tray?: boolean): void;
+    /**
+     * Adopt a Web console that another process owns. No socket is opened here:
+     * the terminal only records the address, so Settings and the Pro button can
+     * reach it later.
+     */
+    attachBackground(status: BackgroundStatus): void;
+    /**
+     * Mount the browser UI on the given port. Safe to call once; subsequent calls
+     * return the already-running server.
+     */
+    enableWeb(port: number, host?: string, auth?: boolean): Promise<BackgroundStatus>;
+    /**
+     * The address the console is reachable at right now: the local socket, the
+     * detached service, or nothing.
+     */
+    private currentWebUrl;
+    private syncWebStatus;
+    /**
+     * Start the Web console when it is not up yet. Returns the URL to open.
+     */
+    private ensureWebConsole;
+    /** Change the existing worker's lifetime without moving its conversations. */
+    setBackgroundResidency(enabled: boolean): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    /**
+     * Start or stop the browser UI while the terminal keeps running. Returns a
+     * result instead of throwing so a failed bind (usually a port already in use)
+     * can be reported inline without an unhandled rejection.
+     */
+    setWebConsole(enabled: boolean): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    /**
+     * Open the browser console's Pro workspace, bringing the console up first
+     * when it is not running yet. This runs from a mouse handler, so it never
+     * throws and never waits on the browser: failures become a toast and the TUI
+     * keeps rendering.
+     */
+    openProMode(): Promise<void>;
+    /**
+     * Open the browser console's regular workspace, bringing the console up first
+     * when it is not running yet. Like openProMode it runs from a mouse handler:
+     * it never throws and never waits on the browser.
+     */
+    openWebMode(): Promise<void>;
+    start(): Promise<void>;
+    private onResize;
+    get top(): Screen | undefined;
+    pushScreen(screen: Screen): void;
+    popScreen(): void;
+    render(selectionOnly?: boolean): void;
+    private noteInternalError;
+    private renderFrame;
+    private renderBuffer;
+    /**
+     * The selection as it should be *painted*.
+     *
+     * An end that scrolled out of the log is drawn from the log's own edge: the
+     * rows it points at are off screen, and highlighting the header or the input
+     * box instead would claim those were selected.
+     */
+    private displaySelection;
+    /**
+     * Remember the log rows the current drag covers.
+     *
+     * Runs on every frame, because a row can only be captured while it is still
+     * on screen — after the scroll carries it away, its text is gone.
+     */
+    private captureSelectionRows;
+    /**
+     * The current selection expressed in content lines instead of screen rows.
+     *
+     * Rows under the pointer map straight through the log's scroll offset, and
+     * rows outside the log get keys of their own (negative above it, past `total`
+     * below it) so a drag that starts on the header or runs into the input box
+     * still copies what is actually drawn there. The anchor is the exception: once
+     * it belongs to the log it follows its text out of the viewport, which is what
+     * lets a selection outlive the frame it started in.
+     */
+    private lineSelection;
+    /**
+     * Text covered by the current selection, including the rows a drag scrolled
+     * out of the viewport.
+     */
+    private selectionToText;
+    /** Where the mark sits, clamped into the log while a drag is scrolling it. */
+    private cursorAt;
+    /**
+     * Start or stop the auto-scroll that runs while a drag sits on an edge of the
+     * log. Only a real drag scrolls: a press that never moved selects nothing, so
+     * clicking on the last row stays a plain click.
+     */
+    private updateDragScroll;
+    /**
+     * One auto-scroll step: move the log a line (a few lines, the longer the
+     * pointer is held there) and grow the selection with it.
+     */
+    private dragScrollTick;
+    private stopDragScroll;
+    /** Drop everything remembered about a drag; a new gesture starts clean. */
+    private resetDragTracking;
+    private scheduleSelectionRender;
+    private drawToast;
+    private updateCursorBlink;
+    /** Reset the blink phase so the cursor is solid right after an interaction. */
+    private wakeCursor;
+    private handleEvent;
+    private dispatchEvent;
+    private handleMouse;
+    private resetMouse;
+    private handleInterrupt;
+    /**
+     * Audible cue for something the user is waiting on.
+     *
+     * Silent when `sound_alerts` is off, so the bell stays a preference rather
+     * than unavoidable noise. A pending approval rings twice: it is the one event
+     * that actually blocks the agent, and a single blip is easy to miss.
+     */
+    bell(kind?: "turn" | "approval"): void;
+    showToast(text: string, position?: "top" | "bottom"): void;
+    setModelConfig(providerName: string, model: ModelInfo, intensity: string): void;
+    startNewChat(text: string): void;
+    loadSession(data: SessionData): void;
+    /**
+     * Offer a newer published release where a session starts.
+     *
+     * The registry answer arrives a moment after launch. If the user is already
+     * in a conversation by then, the notice is dropped rather than breaking into
+     * their work: the next start offers it again.
+     */
+    promptUpdate(status: UpdateStatus): void;
+    openModelConfig(): void;
+    openHistory(): void;
+    openAgentSelect(): void;
+    openPlugins(): void;
+    openPluginContribution(item: OwnedUI): void;
+    openSettings(): void;
+    quit(exitCode?: number): void;
+}

package/dist/app.js

@@ -1,3 +1,5 @@
+import { PluginsScreen, PluginViewScreen } from "./screens/plugins.js";
+import { applyTuiTheme } from "./plugins/terminal.js";
 import process from "node:process";
 import { Buffer } from "./terminal/buffer.js";
 import { InputReader } from "./terminal/input.js";
@@ -416,6 +418,7 @@ export class App {
         this.render();
     }
     render(selectionOnly = false) {
+        applyTuiTheme();
         if (this.selectionTimer) {
             clearTimeout(this.selectionTimer);
             this.selectionTimer = null;
@@ -773,6 +776,10 @@ export class App {
                 return;
             }
             this.wakeCursor();
+            if (k.ctrl && k.name === "x") {
+                this.openPlugins();
+                return;
+            }
             if (k.ctrl && (k.name === "m" || k.name === "e")) {
                 this.openModelConfig();
                 return;
@@ -1002,6 +1009,7 @@ export class App {
         screen.loadedApprovalMode = data.approval_mode ?? null;
         screen.loadedPlan = data.plan ?? null;
         screen.loadedTask = data.task_run;
+        screen.loadedFast = data.fast_run;
         screen.loadedAgentMode = data.agent_mode ?? null;
         if (data.provider)
             this.state.selectedProvider = data.provider;
@@ -1047,6 +1055,13 @@ export class App {
             return;
         this.pushScreen(new AgentSelectScreen());
     }
+    openPlugins() { this.pushScreen(new PluginsScreen()); }
+    openPluginContribution(item) {
+        if (item.command)
+            this.startNewChat(`/plugin ${item.pluginId}/${item.command} {}`);
+        else
+            this.pushScreen(new PluginViewScreen(item));
+    }
     openSettings() {
         if (this.screens.some((s) => s instanceof SettingsScreen))
             return;

package/dist/background.d.ts

@@ -0,0 +1,96 @@
+export declare const BACKGROUND_STATUS_FILE: string;
+export declare const BACKGROUND_LOG_FILE: string;
+export interface BackgroundStatus {
+    pid: number;
+    port: number;
+    host: string;
+    /** Loopback address the console can be opened at. No trailing slash. */
+    url: string;
+    /** Whether the console asks for the Web password. */
+    auth_required: boolean;
+    /** Secret that authorizes the stop/ping endpoints. */
+    token: string;
+    started_at: string;
+    /** Whether the console stays up without a terminal. */
+    resident: boolean;
+    /** Terminals currently attached to this console. */
+    owner_pids: number[];
+    /** False for a still-running service from a build without live switching. */
+    lifetime_supported?: boolean;
+}
+export interface StartBackgroundOptions {
+    /** Requested port, or null to use the saved/default one. */
+    port: number | null;
+    /** Requested interface; omitted means the saved Web-access setting. */
+    host?: string;
+    /** Whether the service requires the Web password. */
+    auth: boolean;
+    /** Windows tray icon. Off for tests and headless deployments. */
+    tray?: boolean;
+    /** Off means the console follows its owners instead of staying resident. */
+    resident?: boolean;
+    /** Terminal that owns a non-resident console. */
+    ownerPid?: number;
+    /** Offer the one-time residency invitation. */
+    prompt?: boolean;
+    /** An explicit standalone port must not be silently ignored. */
+    strictPort?: boolean;
+}
+export interface BackgroundUpdate {
+    resident?: boolean;
+    ownerPid?: number;
+    /** Private loopback bridge for a terminal's live conversations. */
+    bridge?: TerminalBridgeInfo;
+}
+export interface TerminalBridgeInfo {
+    url: string;
+    token: string;
+}
+export type StartBackgroundResult = {
+    ok: true;
+    status: BackgroundStatus;
+    started: boolean;
+} | {
+    ok: false;
+    error: string;
+};
+export type StopBackgroundResult = {
+    ok: true;
+    stopped: boolean;
+} | {
+    ok: false;
+    stopped: boolean;
+    error: string;
+};
+/** Validate a status file (or an HTTP response) before trusting it. */
+export declare function parseBackgroundStatus(value: unknown): BackgroundStatus | null;
+/** The saved status, including a stale file from a process that no longer runs. */
+export declare function readBackgroundStatus(): BackgroundStatus | null;
+/** Whether `pid` is a live process. Permission errors still mean "alive". */
+export declare function isProcessAlive(pid: number): boolean;
+/** The running background service, or null when there is none. */
+export declare function runningBackground(): BackgroundStatus | null;
+/** Write the status file atomically so another process never reads half of it. */
+export declare function writeBackgroundStatus(status: BackgroundStatus): void;
+/**
+ * Remove the status file. With `pid`, only remove it when it still belongs to
+ * that process, so one service can never delete another's registration.
+ */
+export declare function clearBackgroundStatus(pid?: number): void;
+/** Append a diagnostic line, rotating the file instead of letting it grow. */
+export declare function backgroundLog(message: string): void;
+/** The last few log lines, for a failed start message. */
+export declare function backgroundLogTail(lines?: number): string;
+/**
+ * Start the detached console, or reuse the one already running.
+ *
+ * The child writes the same status file we poll here, so "the address is
+ * reachable" and "the file names this exact process" both have to hold before
+ * the start counts as successful. The random token in the env is what proves
+ * the file was written by *our* child rather than an older instance.
+ */
+export declare function startBackgroundService(options: StartBackgroundOptions): Promise<StartBackgroundResult>;
+/** Apply a lifetime change to the process that already owns the conversations. */
+export declare function configureBackgroundService(status: BackgroundStatus, update: BackgroundUpdate): Promise<BackgroundStatus>;
+/** Stop the detached service, politely first and by signal if it is stuck. */
+export declare function stopBackgroundService(expected?: BackgroundStatus): Promise<StopBackgroundResult>;

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
+import { runPluginCLI } from "./plugins/cli.js";
 import process from "node:process";
 import { App } from "./app.js";
 import { loadConfig } from "./config.js";
 import { installCrashGuard } from "./terminal/restore.js";
-import { webUrls } from "./web/server.js";
+import { startWebServer, webUrls } from "./web/server.js";
 import { runningBackground, startBackgroundService, stopBackgroundService, } from "./background.js";
 import { runWebService } from "./web/service.js";
 import { openInBrowser } from "./browser.js";
@@ -38,8 +39,11 @@ function printHelp() {
 
 Usage:
   neutrino                     Start the terminal UI (with the web UI).
+  neutrino plugin help         Manage plugins and inspect the plugin SDK.
+  neutrino --safe-mode          Start without external plugins.
   neutrino --lan               Start both, reachable from other devices.
   neutrino web [--port <port>] Start only the web UI (serves saved history).
+  neutrino api [--port <port>] Start the local API without a Web listener.
   neutrino background start    Run the web UI in the background; conversations
                                started there survive the terminal/CLI exiting.
   neutrino background stop     Stop the background service.
@@ -60,6 +64,7 @@ Options:
 
 Environment:
   NEUTRINO_WEB_PORT   Same as --port in either mode.
+  NEUTRINO_API_PORT   Loopback programmatic API port (default 8766; 0 for automatic).
   NEUTRINO_WEB_HOST   Same as --host.
   NEUTRINO_NO_TRAY    Set to 1 to keep the background service out of the
                       Windows notification area.
@@ -99,6 +104,9 @@ function parseArgs(argv) {
         if (arg === "web") {
             options.mode = "web";
         }
+        else if (arg === "api") {
+            options.mode = "api";
+        }
         else if (arg === "background") {
             options.mode = "background";
             options.backgroundAction = "status";
@@ -165,6 +173,9 @@ function parseArgs(argv) {
             throw new Error(`unknown argument "${arg}"`);
         }
     }
+    if (options.mode === "api" && (options.lan || options.host || options.noWeb || options.noAuth)) {
+        throw new Error("the local API always uses authenticated 127.0.0.1 access");
+    }
     if (options.lan && options.host) {
         throw new Error("use either --lan or --host, not both");
     }
@@ -230,9 +241,22 @@ function printBackgroundStatus() {
             process.stdout.write(`Also: ${url}\n`);
     }
 }
+const launchArgs = process.argv.slice(2).filter(arg => arg !== "--safe-mode");
+if (process.argv.includes("--safe-mode"))
+    process.env.NEUTRINO_SAFE_MODE = "1";
+if (launchArgs[0] === "plugin") {
+    try {
+        await runPluginCLI(launchArgs.slice(1));
+    }
+    catch (error) {
+        process.stderr.write(`neutrino plugin: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    }
+    process.exit(process.exitCode ?? 0);
+}
 let options;
 try {
-    options = parseArgs(process.argv.slice(2));
+    options = parseArgs(launchArgs);
 }
 catch (err) {
     process.stderr.write(`neutrino: ${err instanceof Error ? err.message : String(err)}\n`);
@@ -247,7 +271,20 @@ installCrashGuard({ surviveHangup: options.mode === "background" });
 const host = options.lan ? WILDCARD_HOST : options.host || process.env.NEUTRINO_WEB_HOST || undefined;
 const auth = !options.noAuth;
 const portFromEnv = envPort();
-if (options.mode === "web") {
+if (options.mode === "api") {
+    try {
+        const handle = await startWebServer({ port: 0, apiOnly: true, apiPort: options.port ?? undefined, publishApi: true, auth: false });
+        process.stdout.write(`Local API listening at ${handle.api.url}; connection details: ${process.env.NEUTRINO_HOME || "~/.neutrino"}/api.json\n`);
+        const shutdown = () => { void handle.close().finally(() => process.exit(0)); };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+    }
+    catch (error) {
+        process.stderr.write(`neutrino: failed to start local API: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    }
+}
+else if (options.mode === "web") {
     const result = await startBackgroundService({
         port: options.port ?? portFromEnv ?? DEFAULT_WEB_PORT, host, auth,
         tray: !options.noTray, resident: loadConfig().background === true, ownerPid: process.pid,

package/dist/browser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 declare function proModeUrl(baseUrl: string): string;
+/**
+ * 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 declare function openInBrowser(url: string): void;

package/dist/clipboard.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copy `text` to the system clipboard.
+ *
+ * Two independent, best-effort strategies are used so the copy works across as
+ * many terminals as possible:
+ *
+ *   1. OSC 52 — a terminal escape sequence that asks the host terminal to put
+ *      the (base64-encoded) text on the clipboard. This is the only strategy
+ *      that also works over SSH, and is supported by Windows Terminal, iTerm2,
+ *      Kitty, WezTerm, Alacritty, …
+ *   2. A native helper process (`clip` / `pbcopy` / `wl-copy` / `xclip` / …),
+ *      as a fallback for terminals that ignore OSC 52.
+ *
+ * Both are best-effort: any failure is silently ignored.
+ */
+export declare function copyToClipboard(text: string): void;

package/dist/colors.d.ts

@@ -0,0 +1,29 @@
+export type RGB = [number, number, number];
+export declare const C: {
+    readonly accent: RGB;
+    readonly highlightBg: RGB;
+    readonly black: RGB;
+    readonly dim: RGB;
+    readonly user: RGB;
+    readonly assistant: RGB;
+    readonly toolHeader: RGB;
+    readonly amber: RGB;
+    readonly white: RGB;
+    readonly orange: RGB;
+    readonly orangeBg: RGB;
+    readonly green: RGB;
+    readonly red: RGB;
+    readonly codeBg: RGB;
+    readonly selection: RGB;
+    readonly scrollTrack: RGB;
+    readonly scrollThumb: RGB;
+};
+export interface Style {
+    fg?: RGB;
+    bg?: RGB;
+    bold?: boolean;
+    dim?: boolean;
+    inverse?: boolean;
+    italic?: boolean;
+}
+export declare const EMPTY_STYLE: Style;