@xingjisoft/neutrino 0.4.0 → 0.5.0

package/dist/ui.js

@@ -295,35 +295,51 @@ export function drawTabButton(buf, x, y, w, label, selected, align = "center") {
 }
 /** Label of the CLI entry point that opens the browser console's Pro workspace. */
 export const PRO_MODE_LABEL = "启用Pro模式";
+/** Label of the CLI entry point that opens the browser console itself. */
+export const WEB_MODE_LABEL = "打开Web端";
 /**
- * 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.
+ * Geometry of a box in the top-left corner, directly below the status bar
+ * (row 0), starting at column `x`. 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.
+ * breathing room to its right. The height floor also keeps the start screen's
+ * centered block (which is pushed below the boxes) clear of the approval
+ * toggle on very short terminals, where the original layout is preserved.
  */
-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;
+function headerButton(width, height, x, label) {
     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)
+    const w = displayWidth(label) + 4;
+    if (width < x + w + 3 || height < 22)
+        return null;
+    return { x, y, w, h, label };
+}
+/**
+ * The Pro-mode button: flush to the left edge with a single blank column, as
+ * the start screen expects.
+ */
+export function proModeButton(width, height) {
+    return headerButton(width, height, 1, PRO_MODE_LABEL);
+}
+/**
+ * The Web-mode button: glued to the right border of the Pro-mode button so the
+ * two read as one row of entry points. It starts where the Pro box ends, which
+ * also means it is hidden together with it on terminals too small for the row.
+ */
+export function webModeButton(width, height) {
+    const pro = proModeButton(width, height);
+    if (!pro)
         return null;
-    return { x, y, w, h, label: PRO_MODE_LABEL };
+    return headerButton(width, height, pro.x + pro.w, WEB_MODE_LABEL);
 }
 /**
- * Draw the Pro-mode button. It is painted as opaque chrome so content behind it
+ * Draw one top-left 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);
+export function drawHeaderButton(buf, button, hovered = false) {
     if (!button)
         return;
     const { x, y, w, h, label } = button;

package/dist/update.js

@@ -0,0 +1,213 @@
+import { spawn } from "node:child_process";
+import process from "node:process";
+import { loadVersion } from "./config.js";
+/** The published package whose registry version decides whether an update exists. */
+export const UPDATE_PACKAGE = "@xingjisoft/neutrino";
+/** What a user can run by hand when the automatic update fails. */
+export const MANUAL_UPDATE_COMMAND = `npm install -g ${UPDATE_PACKAGE}`;
+const LOOKUP_TIMEOUT_MS = 20_000;
+const INSTALL_TIMEOUT_MS = 300_000;
+let published = "";
+let pending = null;
+let installing = null;
+/**
+ * The last known answer, for the terminal screen and the Web console payload.
+ * Reading this never touches the network: the lookup runs once per process (see
+ * checkForUpdate) and costs nothing afterwards.
+ */
+export function updateStatus() {
+    const currentVersion = loadVersion();
+    return {
+        currentVersion,
+        latestVersion: published,
+        hasUpdate: isNewerVersion(published, currentVersion),
+    };
+}
+/**
+ * Ask npm which version is published and remember it. This never rejects: an
+ * offline machine, a missing npm or a registry hiccup only means "no update to
+ * announce", which is what the next start is for. Concurrent callers share the
+ * one lookup, and a successful answer is kept for the rest of the process so
+ * the terminal and the Web console cannot disagree.
+ */
+export function checkForUpdate() {
+    if (published)
+        return Promise.resolve(updateStatus());
+    pending ??= lookupLatestVersion()
+        .then((version) => {
+        published = version;
+        return updateStatus();
+    })
+        .catch((error) => ({
+        ...updateStatus(),
+        error: error instanceof Error ? error.message : String(error),
+    }))
+        .finally(() => { pending = null; });
+    return pending;
+}
+/**
+ * Install the latest published release with npm.
+ *
+ * The terminal and both Web workspaces can ask for this, so requests share one
+ * install instead of running npm twice over the same files. It never rejects:
+ * whoever asked gets a result and, on failure, the command to run by hand.
+ *
+ * The version this process runs is not replaced — the running code stays on
+ * disk until the user restarts — so callers must tell the user to restart.
+ */
+export function installUpdate() {
+    installing ??= runNpm(["install", "-g", UPDATE_PACKAGE], INSTALL_TIMEOUT_MS)
+        .then((run) => npmResult(run, `install -g ${UPDATE_PACKAGE}`))
+        .catch((error) => ({
+        ok: false,
+        version: updateStatus().latestVersion,
+        error: error instanceof Error ? error.message : String(error),
+    }))
+        .finally(() => { installing = null; });
+    return installing;
+}
+/** `npm view <package> version`, with a deadline so a hung npm cannot hold a start-up. */
+async function lookupLatestVersion() {
+    const run = await runNpm(["view", UPDATE_PACKAGE, "version"], LOOKUP_TIMEOUT_MS);
+    const version = firstVersionLine(run.stdout);
+    if (version)
+        return version;
+    throw new Error(npmFailure(run, `view ${UPDATE_PACKAGE} version`));
+}
+/** Turn one finished npm run into the answer callers see. */
+function npmResult(run, what) {
+    const version = updateStatus().latestVersion;
+    return run.code === 0
+        ? { ok: true, version }
+        : { ok: false, version, error: npmFailure(run, what) };
+}
+/** The last line npm printed is the one that says what went wrong. */
+function npmFailure(run, what) {
+    const reason = run.stderr.trim().split("\n").pop()?.trim();
+    return `npm ${what} failed${run.code === null ? " (timed out)" : run.code === 0 ? "" : ` with code ${run.code}`}`
+        + (reason ? `: ${reason}` : "");
+}
+/**
+ * Run npm and collect a bounded amount of output. Rejects only when npm cannot
+ * be started at all or does not finish in time; a failing npm resolves with its
+ * exit code so the caller decides what it means.
+ */
+function runNpm(args, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let child;
+        try {
+            // On Windows npm is a .cmd shim, which Node only starts through a shell;
+            // the command is built from fixed literals, so nothing needs quoting.
+            const windows = process.platform === "win32";
+            child = spawn(windows ? process.env.ComSpec || "cmd.exe" : "npm", windows ? ["/d", "/s", "/c", `npm ${args.join(" ")}`] : args, { stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+        }
+        catch (error) {
+            reject(new Error(`could not run npm: ${error instanceof Error ? error.message : String(error)}`));
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const finish = (error, run) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (error)
+                reject(error);
+            else
+                resolve(run);
+        };
+        const timer = setTimeout(() => {
+            // Stop waiting on a hung npm: its output is discarded either way.
+            child.kill();
+            finish(new Error(`npm ${args.join(" ")} timed out after ${timeoutMs / 1000}s`));
+        }, timeoutMs);
+        timer.unref();
+        child.stdout?.setEncoding("utf8");
+        child.stderr?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => {
+            if (stdout.length < 8192)
+                stdout += chunk;
+        });
+        child.stderr?.on("data", (chunk) => {
+            if (stderr.length < 8192)
+                stderr += chunk;
+        });
+        // A missing npm is reported asynchronously; without this listener the
+        // 'error' event would crash the whole process.
+        child.on("error", (error) => finish(new Error(`could not run npm: ${error.message}`)));
+        child.on("close", (code) => finish(null, { code, stdout, stderr }));
+    });
+}
+/** npm prints the version alone, but warnings on stdout must not be mistaken for one. */
+function firstVersionLine(text) {
+    for (const line of text.split(/\r?\n/)) {
+        const value = line.trim();
+        if (/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.+-]+)?$/.test(value))
+            return value;
+    }
+    return "";
+}
+function parseVersion(value) {
+    const text = value.trim().replace(/^v/i, "").split("+")[0];
+    if (!text)
+        return null;
+    const dash = text.indexOf("-");
+    const core = (dash === -1 ? text : text.slice(0, dash)).split(".");
+    if (!core.length || core.some((part) => !/^\d+$/.test(part)))
+        return null;
+    const prerelease = dash === -1 ? null : text.slice(dash + 1).split(".");
+    if (prerelease && prerelease.some((part) => part === ""))
+        return null;
+    return { core: core.map(Number), prerelease };
+}
+/**
+ * Semantic-version order: returns 1 when `left` is newer, -1 when older and 0
+ * when they are the same release. A version that cannot be parsed compares as
+ * equal, so a malformed registry answer can never claim an update is due.
+ */
+export function compareVersions(left, right) {
+    const a = parseVersion(left);
+    const b = parseVersion(right);
+    if (!a || !b)
+        return 0;
+    const length = Math.max(a.core.length, b.core.length);
+    for (let i = 0; i < length; i++) {
+        const difference = (a.core[i] ?? 0) - (b.core[i] ?? 0);
+        if (difference !== 0)
+            return difference > 0 ? 1 : -1;
+    }
+    // Numeric identifiers compare numerically and rank below alphanumeric ones.
+    const compareIdentifiers = (one, other) => {
+        const numeric = /^\d+$/.test(one);
+        const otherNumeric = /^\d+$/.test(other);
+        if (numeric && otherNumeric)
+            return Math.sign(Number(one) - Number(other));
+        if (numeric !== otherNumeric)
+            return numeric ? -1 : 1;
+        return one < other ? -1 : one > other ? 1 : 0;
+    };
+    if (!a.prerelease && !b.prerelease)
+        return 0;
+    if (!a.prerelease)
+        return 1;
+    if (!b.prerelease)
+        return -1;
+    for (let i = 0; i < Math.max(a.prerelease.length, b.prerelease.length); i++) {
+        const one = a.prerelease[i];
+        const other = b.prerelease[i];
+        if (one === undefined)
+            return -1;
+        if (other === undefined)
+            return 1;
+        const difference = compareIdentifiers(one, other);
+        if (difference !== 0)
+            return difference;
+    }
+    return 0;
+}
+/** Whether `candidate` is a strictly newer release than `current`. */
+export function isNewerVersion(candidate, current) {
+    return compareVersions(candidate, current) > 0;
+}

package/dist/web/clientState.js

@@ -0,0 +1,82 @@
+/**
+ * State the browser console keeps about itself.
+ *
+ * The sidebar's blue dot asks for attention once: it marks a conversation that
+ * finished after the reader last opened it. Remembering that answer is neither a
+ * conversation setting (config.json is read by the terminal UI on every tool
+ * call) nor part of a transcript, so the console owns a file of its own:
+ *
+ *   ~/.neutrino/web.json
+ *   { "seen": { "standard": ["id:2025-01-02T03-04-05-678Z", "live:L3"], "pro": [] } }
+ *
+ * Both workspaces keep their own record, because each has its own sidebar. The
+ * file is a convenience: a missing, unreadable or hand-mangled one costs a dot,
+ * never a request.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { NEUTRINO_DIR, ensureDirs } from "../config.js";
+export const WEB_STATE_FILE = path.join(NEUTRINO_DIR, "web.json");
+/**
+ * Identities are `id:<session id>` for a conversation with history and
+ * `live:<key>` for one that has nothing saved yet (see `sessionIdentity` in
+ * web/app.js). Anything else is refused, so a crafted request body cannot grow
+ * the file without bound.
+ */
+const IDENTITY_RE = /^(?:id|live):[A-Za-z0-9._-]{1,200}$/;
+/** How many finished conversations one workspace remembers, newest last. */
+export const SEEN_LIMIT = 300;
+/** Whether a value from a request is an identity this file can hold. */
+export function isSeenIdentity(value) {
+    return typeof value === "string" && IDENTITY_RE.test(value);
+}
+/** The whole file, never throwing: an unreadable record simply holds nothing. */
+function readState() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(WEB_STATE_FILE, "utf-8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** The `seen` map of the file, or an empty one when it is missing or malformed. */
+function seenState(state) {
+    const seen = state.seen;
+    return seen && typeof seen === "object" && !Array.isArray(seen)
+        ? seen
+        : {};
+}
+/** Identities of one workspace, oldest first, with unusable entries dropped. */
+function workspaceSeen(state, mode) {
+    const list = seenState(state)[mode];
+    if (!Array.isArray(list))
+        return [];
+    return list.filter(isSeenIdentity).slice(-SEEN_LIMIT);
+}
+/** The conversations this workspace has already shown the reader, oldest first. */
+export function loadSeen(mode = "standard") {
+    return workspaceSeen(readState(), mode);
+}
+/**
+ * Record (`seen: true`) or forget (`seen: false`) the given conversations and
+ * write the file back. Returns the workspace's new record.
+ *
+ * Identities that are not valid are ignored rather than rejected: the route
+ * already validated them, so this is only a guard on what reaches the disk.
+ */
+export function updateSeen(mode, identities, seen) {
+    const wanted = new Set(identities.filter(isSeenIdentity));
+    if (wanted.size === 0)
+        return loadSeen(mode);
+    const state = readState();
+    // A recorded conversation moves to the end, so trimming keeps the newest.
+    const kept = workspaceSeen(state, mode).filter((identity) => !wanted.has(identity));
+    // Trim after the merge: recording a new conversation can push the oldest out.
+    const next = (seen ? [...kept, ...wanted] : kept).slice(-SEEN_LIMIT);
+    ensureDirs();
+    fs.writeFileSync(WEB_STATE_FILE, JSON.stringify({ ...state, seen: { ...seenState(state), [mode]: next } }, null, 2), "utf-8");
+    return next;
+}

package/dist/web/hub.js

@@ -58,6 +58,10 @@ class LiveHub {
         const entry = this.entries.get(key);
         return Boolean(entry) && (!mode || entry.mode === mode);
     }
+    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 = [];