@xingjisoft/neutrino 0.3.0 → 0.4.1

package/dist/terminal/restore.js

@@ -89,17 +89,7 @@ export function writeCrashLog(kind, err) {
         return null;
     }
 }
-/**
- * Installs process-wide handlers that restore the terminal before the process
- * dies.
- *
- * Without this, any throw that escapes a timer, a stream callback or a floating
- * promise kills the process with raw mode still on and the alternate screen
- * still active. The visible result is a terminal that works but spews
- * `[<b>;<x>;<y>M` mouse reports at the shell prompt, because the shell now
- * receives the mouse events the TUI asked the terminal to send.
- */
-export function installCrashGuard() {
+export function installCrashGuard(options = {}) {
     if (installed)
         return;
     installed = true;
@@ -123,7 +113,8 @@ export function installCrashGuard() {
     });
     // These signals otherwise bypass Node's exit hook, including Ctrl+Break on
     // Windows. The app handles SIGINT as an interrupt and SIGTERM as a quit.
-    process.on("SIGHUP", () => process.exit(129));
+    if (!options.surviveHangup)
+        process.on("SIGHUP", () => process.exit(129));
     process.on("SIGBREAK", () => process.exit(149));
     const fatal = (kind, err) => {
         // Restore first: the terminal must be usable even if logging itself fails.

package/dist/tray.js

@@ -0,0 +1,138 @@
+/**
+ * Windows notification-area icon for the background Web console.
+ *
+ * Node cannot create a tray icon by itself, and the project deliberately has
+ * no native dependencies, so a tiny Windows PowerShell process hosts a
+ * `System.Windows.Forms.NotifyIcon`. It uses the same orbit badge as the
+ * regular console's top-left mark. Everything is best-effort: an unavailable
+ * icon must never stop the service.
+ */
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { BACKGROUND_LOG_FILE, backgroundLog } from "./background.js";
+import { NEUTRINO_DIR } from "./config.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = path.resolve(__dirname, "..");
+const ICON_FILE = path.join(PKG_ROOT, "assets", "neutrino.ico");
+/** Quote a value as a PowerShell single-quoted literal. */
+function psString(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+/** The icon itself. Only Windows has a notification area, and only it can run this. */
+export function startBackgroundTray(options) {
+    if (process.platform !== "win32")
+        return null;
+    if (process.env.NEUTRINO_NO_TRAY === "1")
+        return null;
+    if (!fs.existsSync(ICON_FILE)) {
+        backgroundLog(`tray icon not found at ${ICON_FILE}`);
+        return null;
+    }
+    // Separate files let an old icon close cleanly even if residency is turned
+    // back on before its PowerShell message loop has processed the shutdown.
+    const suffix = `${process.pid}-${randomBytes(8).toString("hex")}`;
+    const scriptFile = path.join(NEUTRINO_DIR, `tray-${suffix}.ps1`);
+    const closeFile = path.join(NEUTRINO_DIR, `tray-${suffix}.stop`);
+    const script = `
+$ErrorActionPreference = 'Continue'
+$scriptFile = ${psString(scriptFile)}
+$closeFile = ${psString(closeFile)}
+try {
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+$iconPath = ${psString(ICON_FILE)}
+$url = ${psString(options.url)}
+$stopUrl = ${psString(options.stopUrl)}
+$token = ${psString(options.token)}
+$parent = ${options.pid}
+$notify = New-Object System.Windows.Forms.NotifyIcon
+$notify.Icon = New-Object System.Drawing.Icon($iconPath)
+$notify.Text = 'Neutrino - background console'
+$notify.Visible = $true
+$menu = New-Object System.Windows.Forms.ContextMenuStrip
+$open = $menu.Items.Add('Open Neutrino console')
+$open.add_Click({ Start-Process -FilePath $url })
+$stop = $menu.Items.Add('Stop background service')
+$stop.add_Click({
+  try {
+    Invoke-RestMethod -Method Post -Uri $stopUrl -Headers @{ Authorization = "Bearer $token" } -TimeoutSec 5 | Out-Null
+  } catch {
+    Stop-Process -Id $parent -Force
+  }
+  $notify.Visible = $false
+  [System.Windows.Forms.Application]::Exit()
+})
+$menu.Items.Add((New-Object System.Windows.Forms.ToolStripSeparator)) | Out-Null
+$notify.ContextMenuStrip = $menu
+$notify.add_MouseClick({ param($sender, $eventArgs) if ($eventArgs.Button -eq [System.Windows.Forms.MouseButtons]::Left) { Start-Process -FilePath $url } })
+$notify.add_DoubleClick({ Start-Process -FilePath $url })
+$timer = New-Object System.Windows.Forms.Timer
+$timer.Interval = 250
+$timer.add_Tick({
+  if ((Test-Path -LiteralPath $closeFile) -or -not (Get-Process -Id $parent -ErrorAction SilentlyContinue)) {
+    $notify.Visible = $false
+    [System.Windows.Forms.Application]::Exit()
+  }
+})
+$timer.Start()
+[System.Windows.Forms.Application]::Run()
+} finally {
+  if ($notify) { $notify.Visible = $false; $notify.Dispose() }
+  Remove-Item -LiteralPath $closeFile, $scriptFile -Force -ErrorAction SilentlyContinue
+}
+`;
+    const cleanup = () => {
+        for (const file of [scriptFile, closeFile]) {
+            try {
+                fs.rmSync(file, { force: true });
+            }
+            catch { /* The helper also cleans up. */ }
+        }
+    };
+    try {
+        fs.mkdirSync(NEUTRINO_DIR, { recursive: true });
+        fs.writeFileSync(scriptFile, `\ufeff${script}`, { encoding: "utf-8", mode: 0o600 });
+        const logFd = fs.openSync(BACKGROUND_LOG_FILE, "a");
+        let child;
+        try {
+            child = spawn("powershell.exe", [
+                "-NoProfile", "-NonInteractive", "-STA", "-ExecutionPolicy", "Bypass", "-WindowStyle", "Hidden",
+                "-File", scriptFile,
+            ], 
+            // Not detached: on Windows a detached PowerShell exits before its
+            // message loop starts. The icon outlives the service on its own; its
+            // timer notices the parent pid disappearing and shuts it down.
+            { stdio: ["ignore", "ignore", logFd], windowsHide: true });
+        }
+        finally {
+            fs.closeSync(logFd);
+        }
+        let active = true;
+        child.once("error", (error) => { active = false; cleanup(); backgroundLog(`tray failed: ${error.message}`); });
+        child.once("exit", (code) => { active = false; cleanup(); backgroundLog(`tray exited (${code ?? "signal"})`); });
+        child.unref();
+        backgroundLog(`tray icon started (pid ${child.pid ?? "unknown"})`);
+        return { close: () => {
+                if (!active)
+                    return;
+                try {
+                    fs.writeFileSync(closeFile, "", { mode: 0o600 });
+                }
+                catch {
+                    try {
+                        child.kill();
+                    }
+                    catch { /* Already gone. */ }
+                }
+            } };
+    }
+    catch (error) {
+        cleanup();
+        backgroundLog(`tray failed: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}

package/dist/ui.js

@@ -293,6 +293,64 @@ export function drawTabButton(buf, x, y, w, label, selected, align = "center") {
         buf.writeText(lx, y + 1, label, { fg: C.dim });
     }
 }
+/** Label of the CLI entry point that opens the browser console's Pro workspace. */
+export const PRO_MODE_LABEL = "启用Pro模式";
+/**
+ * Geometry of the Pro-mode button: a small box in the top-left corner, directly
+ * below the status bar (row 0). Rendering and hit testing share it so a click
+ * always lands on the box that is drawn.
+ *
+ * Returns null when the terminal is too small to fit the box with a little
+ * breathing room around it. The height floor also keeps the start screen's
+ * centered block (which is pushed below the box) clear of the approval toggle
+ * on very short terminals, where the original layout is preserved instead.
+ */
+export function proModeButton(width, height) {
+    // One blank column at the very edge, then the border: "flush to the edge
+    // with a single space", as the start screen expects.
+    const x = 1;
+    const y = 1;
+    const h = 3;
+    // Two cells of padding, one inside each border.
+    const w = displayWidth(PRO_MODE_LABEL) + 4;
+    if (width < w + 4 || height < 22)
+        return null;
+    return { x, y, w, h, label: PRO_MODE_LABEL };
+}
+/**
+ * Draw the Pro-mode button. It is painted as opaque chrome so content behind it
+ * can never bleed through; the label row turns into the highlight background
+ * while the pointer is over it.
+ */
+export function drawProModeButton(buf, hovered = false) {
+    const button = proModeButton(buf.width, buf.height);
+    if (!button)
+        return;
+    const { x, y, w, h, label } = button;
+    if (w < 2 || h < 2)
+        return;
+    // Clear the footprint first: the button acts as an overlay over decorative
+    // content (the logo), which must not show through its interior.
+    buf.fillRect(x, y, w, h, { bg: C.black });
+    buf.drawBox(x, y, w, h, { fg: C.dim });
+    const innerX = x + 1;
+    const innerW = w - 2;
+    const labelY = y + Math.floor(h / 2);
+    if (hovered)
+        buf.fillRect(innerX, labelY, innerW, 1, { bg: C.highlightBg });
+    const text = truncateByWidth(label, innerW);
+    const textX = innerX + Math.max(0, Math.floor((innerW - displayWidth(text)) / 2));
+    const style = hovered
+        ? { fg: C.accent, bg: C.highlightBg, bold: true }
+        : { fg: C.accent, bold: true };
+    buf.writeText(textX, labelY, text, style);
+    // The button is chrome, not content: copying a selection across it must not
+    // drag its border or label into the clipboard.
+    for (let j = y; j < y + h; j++) {
+        for (let i = x; i < x + w; i++)
+            buf.markChrome(i, j);
+    }
+}
 export function centerVertically(totalHeight, contentHeight) {
     const top = Math.floor((totalHeight - contentHeight) / 2);
     return Math.max(1, top);

package/dist/web/hub.js

@@ -12,6 +12,7 @@
  * {@link LiveHub.notify}, which coalesces rapid-fire updates (one per streamed
  * token) and pushes a snapshot to any connected browser.
  */
+import { normalizeMode } from "../config.js";
 export function liveApprovalDetails(tool, args, risk, cwd) {
     return { tool, level: risk.level, arguments: args, cwd, summary: risk.summary, reasons: risk.reasons };
 }
@@ -32,6 +33,7 @@ class LiveHub {
             key,
             agent,
             cwd: agent.liveCwd(),
+            mode: normalizeMode(agent.mode),
             listeners: new Set(),
             timer: null,
             lastSent: "",
@@ -48,13 +50,24 @@ class LiveHub {
             clearTimeout(entry.timer);
         this.entries.delete(key);
     }
-    has(key) {
-        return this.entries.has(key);
+    /**
+     * Whether a key is live. With a mode, keys from the other workspace are
+     * treated as unknown: the Pro page must never reach a terminal session.
+     */
+    has(key, mode) {
+        const entry = this.entries.get(key);
+        return Boolean(entry) && (!mode || entry.mode === mode);
     }
-    /** All live sessions, newest registration last. */
-    list() {
+    remoteAction(key) {
+        const agent = this.entries.get(key)?.agent;
+        return agent?.remoteAction ? agent.remoteAction.bind(agent) : null;
+    }
+    /** All live sessions, newest registration last. Optionally one workspace only. */
+    list(mode) {
         const out = [];
         for (const entry of this.entries.values()) {
+            if (mode && entry.mode !== mode)
+                continue;
             out.push({ ...entry.agent.liveMeta(), key: entry.key, cwd: entry.cwd });
         }
         return out;
@@ -167,6 +180,15 @@ class LiveHub {
             this.notify(key);
         return result;
     }
+    setProPreset(key, preset) {
+        const entry = this.entries.get(key);
+        if (!entry?.agent.liveSetProPreset)
+            return { ok: false, error: "this session cannot change Pro presets" };
+        const result = entry.agent.liveSetProPreset(preset);
+        if (result.ok)
+            this.notify(key);
+        return result;
+    }
     setApprovalMode(key, mode) {
         const entry = this.entries.get(key);
         if (!entry?.agent.liveSetApprovalMode)