@gmickel/gno 2.9.2 → 2.10.0

package/src/cli/runtime-health.ts

@@ -0,0 +1,328 @@
+/**
+ * Which Bun the GNO processes on this machine run on (fn-213).
+ *
+ * Two read-only checks for `gno doctor` and `gno status`:
+ * - client registrations whose interpreter or entrypoint is missing, below
+ *   the supported Bun, or a different Bun than the one running the check;
+ * - running residents (`serve`, `daemon`) on a Bun below the floor or older
+ *   than the one running the check, including residents started by another
+ *   GNO version, whose runtime is read from their `/api/status`.
+ *
+ * Nothing here starts a registered command or signals a process; an
+ * interpreter is only asked for `--version`, under a short timeout.
+ *
+ * @module src/cli/runtime-health
+ */
+
+// node:fs realpathSync: synchronous link resolution; Bun has no realpath API.
+import { realpathSync } from "node:fs";
+// node:path basename: no Bun path utilities.
+import { basename } from "node:path";
+
+import type { McpScope, McpTarget } from "./commands/mcp/paths";
+
+import { BUN_FLOOR, bunMeetsFloor } from "../app/bun-runtime";
+import { VERSION } from "../app/constants";
+import { getServersKey } from "./commands/mcp/config";
+import { resolveMcpConfigLocation } from "./commands/mcp/config-discovery";
+import {
+  getJsoncServerEntry,
+  getTomlServerEntry,
+  getYamlServerEntry,
+} from "./commands/mcp/config-editors";
+import { getTargetDisplayName, resolveAllMcpPaths } from "./commands/mcp/paths";
+import { readExistingRegistration } from "./commands/mcp/repair-entry";
+import {
+  type DetachKind,
+  isProcessAlive,
+  readPidFile,
+  resolveProcessPaths,
+} from "./detach";
+
+export type RuntimeIssueSeverity = "error" | "warn" | "info";
+
+export interface RuntimeIssue {
+  kind: "registration" | "resident";
+  severity: RuntimeIssueSeverity;
+  /** What it is about: a client registration or a resident process. */
+  subject: string;
+  message: string;
+  /** Command or steps that repair it. */
+  repair: string;
+}
+
+/** How long an interpreter may take to answer `--version`. */
+const VERSION_PROBE_TIMEOUT_MS = 2000;
+/** How long a resident may take to answer `/api/status`. */
+const RESIDENT_PROBE_TIMEOUT_MS = 2000;
+const SEMVER = /^\d+\.\d+\.\d+(?:[-+][\w.-]+)?$/;
+/** A Bun version in a version manager's install path. */
+const VERSION_IN_PATH =
+  /[\\/](?:installs|tools|Cellar)[\\/]bun[\\/](\d+\.\d+\.\d+[^\\/]*)[\\/]/;
+
+const realpathOrNull = (path: string): string | null => {
+  try {
+    return realpathSync(path);
+  } catch {
+    return null;
+  }
+};
+
+/** The Bun version of an interpreter: from its install path, else `--version`. */
+async function interpreterVersion(path: string): Promise<string | null> {
+  const resolved = realpathOrNull(path) ?? path;
+  const fromPath = VERSION_IN_PATH.exec(resolved)?.[1];
+  if (fromPath) {
+    return fromPath;
+  }
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const probe = Bun.spawn([path, "--version"], {
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    // Bound the read, not only the process: a child of the probe can hold
+    // stdout open after the probe itself is killed.
+    const timedOut = new Promise<null>((resolve) => {
+      timer = setTimeout(() => resolve(null), VERSION_PROBE_TIMEOUT_MS);
+    });
+    const output = await Promise.race([
+      new Response(probe.stdout).text(),
+      timedOut,
+    ]);
+    if (output === null) {
+      probe.kill(9);
+      return null;
+    }
+    const version = output.trim();
+    return SEMVER.test(version) ? version : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+const isGnoExecutable = (command: string): boolean =>
+  ["gno", "gno.exe", "gno.cmd"].includes(basename(command).toLowerCase());
+
+async function readRegistrationEntry(
+  configPath: string,
+  format: string
+): Promise<unknown> {
+  const file = Bun.file(configPath);
+  if (!(await file.exists())) {
+    return undefined;
+  }
+  const content = await file.text();
+  if (!content.trim()) {
+    return undefined;
+  }
+  const parsed =
+    format === "codex_toml"
+      ? getTomlServerEntry(content, configPath)
+      : format === "yaml_standard"
+        ? getYamlServerEntry(
+            content,
+            configPath,
+            getServersKey("yaml_standard")
+          )
+        : getJsoncServerEntry(
+            content,
+            configPath,
+            getServersKey(format as Parameters<typeof getServersKey>[0])
+          );
+  return parsed.exists ? parsed.entry : undefined;
+}
+
+const repairCommand = (target: McpTarget, scope: McpScope): string =>
+  `gno mcp install --target ${target} --scope ${scope} --force`;
+
+/**
+ * Registrations whose launch is broken or on another Bun. Unreadable or
+ * malformed configs are left to `gno mcp status`.
+ */
+export async function checkRegistrationRuntimes(
+  overrides: { cwd?: string; homeDir?: string } = {}
+): Promise<RuntimeIssue[]> {
+  const issues: RuntimeIssue[] = [];
+  const runningBun = realpathOrNull(process.execPath);
+  const versions = new Map<string, Promise<string | null>>();
+  for (const { target, scope, paths } of resolveAllMcpPaths(
+    "all",
+    "all",
+    overrides
+  )) {
+    let entry: unknown;
+    let configPath = paths.configPath;
+    try {
+      configPath = await resolveMcpConfigLocation(paths);
+      entry = await readRegistrationEntry(configPath, paths.configFormat);
+    } catch {
+      continue;
+    }
+    const registration =
+      entry === undefined
+        ? null
+        : readExistingRegistration(entry, paths.configFormat);
+    if (
+      !registration ||
+      registration.extra.enabled === false ||
+      registration.extra.disabled === true
+    ) {
+      continue;
+    }
+    const { command, args } = registration;
+    const viaBun = args[0] === "run" && args.length >= 2;
+    if (!viaBun && !isGnoExecutable(command)) {
+      continue;
+    }
+    const subject = `${getTargetDisplayName(target)} (${scope}) ${configPath}`;
+    const repair = repairCommand(target, scope);
+    const launchFiles = viaBun ? [command, args[1] ?? ""] : [command];
+    const missing = launchFiles.filter((path) => !realpathOrNull(path));
+    if (missing.length > 0) {
+      issues.push({
+        kind: "registration",
+        severity: "error",
+        subject,
+        message: `launches ${missing.join(" and ")}, which no longer exists`,
+        repair,
+      });
+      continue;
+    }
+    if (!viaBun) {
+      // The gno launcher finds Bun on PATH when it starts.
+      continue;
+    }
+    const resolved = realpathOrNull(command) ?? command;
+    if (!versions.has(resolved)) {
+      versions.set(resolved, interpreterVersion(command));
+    }
+    const version = await versions.get(resolved);
+    if (version && !bunMeetsFloor(version)) {
+      issues.push({
+        kind: "registration",
+        severity: "error",
+        subject,
+        message: `runs Bun ${version} (${command}), older than the supported minimum ${BUN_FLOOR}`,
+        repair,
+      });
+    } else if (resolved !== runningBun) {
+      issues.push({
+        kind: "registration",
+        severity: "info",
+        subject,
+        message: `runs ${version ? `Bun ${version}` : "a Bun of unknown version"} (${command}), not this Bun ${Bun.version}`,
+        repair,
+      });
+    }
+  }
+  return issues;
+}
+
+/** The Bun a resident reports through `/api/status`, if it is GNO. */
+async function residentBunVersion(port: number): Promise<string | null> {
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}/api/status`, {
+      signal: AbortSignal.timeout(RESIDENT_PROBE_TIMEOUT_MS),
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const body = (await response.json()) as {
+      indexName?: unknown;
+      bootstrap?: { runtime?: { kind?: unknown; currentVersion?: unknown } };
+    };
+    const runtime = body?.bootstrap?.runtime;
+    // Only a GNO status payload counts; anything else on the port is ignored.
+    if (
+      typeof body?.indexName !== "string" ||
+      runtime?.kind !== "bun" ||
+      typeof runtime.currentVersion !== "string" ||
+      !SEMVER.test(runtime.currentVersion)
+    ) {
+      return null;
+    }
+    return runtime.currentVersion;
+  } catch {
+    return null;
+  }
+}
+
+function restartSteps(
+  kind: DetachKind,
+  pid: number,
+  sameVersion: boolean
+): string {
+  if (sameVersion) {
+    return `restart it: gno ${kind} --stop, then start it again (for example gno ${kind} --detach)`;
+  }
+  const stop =
+    process.platform === "win32" ? `taskkill /PID ${pid}` : `kill ${pid}`;
+  return `it was started by another GNO version, so gno ${kind} --stop leaves it alone; stop it with ${stop}, then start it again (for example gno ${kind} --detach)`;
+}
+
+/**
+ * Running residents on an unsupported or older Bun. A resident started by
+ * another GNO version is read through its HTTP status; it is never signalled.
+ */
+export async function checkResidentRuntimes(): Promise<RuntimeIssue[]> {
+  const issues: RuntimeIssue[] = [];
+  for (const kind of ["serve", "daemon"] as const) {
+    const { pidFile } = resolveProcessPaths(kind);
+    let payload: Awaited<ReturnType<typeof readPidFile>>;
+    try {
+      payload = await readPidFile(pidFile);
+    } catch {
+      continue;
+    }
+    if (!payload || payload.cmd !== kind || !isProcessAlive(payload.pid)) {
+      continue;
+    }
+    const sameVersion = payload.version === VERSION;
+    let version = payload.bun_version ?? null;
+    if (!version && typeof payload.port === "number") {
+      version = await residentBunVersion(payload.port);
+    }
+    const subject = `gno ${kind} (pid ${payload.pid}, GNO ${payload.version})`;
+    const repair = restartSteps(kind, payload.pid, sameVersion);
+    if (!version) {
+      if (!sameVersion) {
+        issues.push({
+          kind: "resident",
+          severity: "info",
+          subject,
+          message:
+            "is running from another GNO version; its Bun version is unknown",
+          repair,
+        });
+      }
+      continue;
+    }
+    if (!bunMeetsFloor(version)) {
+      issues.push({
+        kind: "resident",
+        severity: "error",
+        subject,
+        message: `runs Bun ${version}, older than the supported minimum ${BUN_FLOOR}`,
+        repair,
+      });
+    } else if (Bun.semver.order(version, Bun.version) < 0) {
+      issues.push({
+        kind: "resident",
+        severity: "warn",
+        subject,
+        message: `runs Bun ${version}, older than this Bun ${Bun.version}`,
+        repair,
+      });
+    }
+  }
+  return issues;
+}
+
+/** One line per issue for terminal output. */
+export function formatRuntimeIssue(issue: RuntimeIssue): string {
+  return `${issue.subject}: ${issue.message}. Repair: ${issue.repair}`;
+}

package/src/core/network-boundary-inventory.ts

@@ -61,6 +61,22 @@ export const NETWORK_BOUNDARY_INVENTORY = [
     action: null,
     enforcement: "no_collection_data",
   },
+  {
+    id: "registration-bun-version-probe",
+    key: "src/cli/runtime-health.ts::child_process#1",
+    path: "src/cli/runtime-health.ts",
+    primitive: "child_process",
+    action: null,
+    enforcement: "no_collection_data",
+  },
+  {
+    id: "resident-bun-version-probe",
+    key: "src/cli/runtime-health.ts::fetch#1",
+    path: "src/cli/runtime-health.ts",
+    primitive: "fetch",
+    action: null,
+    enforcement: "no_collection_data",
+  },
   {
     id: "terminal-pager",
     key: "src/cli/pager.ts::child_process#1",

package/src/ingestion/file-processor.ts

@@ -19,6 +19,14 @@
  * If no backend can start, the file fails closed with
  * ISOLATION_UNAVAILABLE; it is never prepared unbounded.
  *
+ * A message that cannot be deserialized on the way to or from the processor
+ * (fn-213) fails the file with PROCESSOR_MESSAGE_FAILED and replaces the
+ * processor, and one stderr line names the direction, backend, file and
+ * step. Bun 1.4.0 and later report it as a `messageerror` event on the
+ * receiving side of a worker; over the child's IPC channel Bun closes the
+ * channel on both ends instead, so the child backend cannot tell which
+ * direction failed.
+ *
  * One processor is reused across files (starting one costs about a third of
  * a second of module loading). It is replaced after an overrun, after a
  * file that leaves memory above half the budget, and after a short idle
@@ -78,8 +86,26 @@ export interface ReadyMessage {
   type: "ready";
 }
 
+/** Posted by the worker when a job it was sent could not be deserialized. */
+export interface UndeliverableJobMessage {
+  type: "undeliverable-job";
+}
+
+/** Which message could not be delivered; the child backend cannot tell. */
+export type DeliveryDirection = "job" | "result" | "unknown";
+
+/** Why a processor stopped working. */
+interface ProcessorFailure {
+  reason: string;
+  /** Set when a message could not be delivered. */
+  delivery?: DeliveryDirection;
+}
+
 export type FileProcessorBackendKind = "worker" | "child";
 
+/** Error code of a file whose message to or from the processor was lost. */
+export const PROCESSOR_MESSAGE_FAILED = "PROCESSOR_MESSAGE_FAILED";
+
 /** Error codes of a file stopped at its budget. */
 export const BUDGET_ERROR_CODES: ReadonlySet<string> = new Set([
   "TIMEOUT",
@@ -149,7 +175,7 @@ interface Processor {
   /** Settles once the processor has loaded and can take a file. */
   readonly ready: Promise<void>;
   /** Settles, with a reason, if the processor dies or errors. */
-  readonly failed: Promise<string>;
+  readonly failed: Promise<ProcessorFailure>;
   /** Send one file; its messages go to `onMessage`. */
   run(
     request: PrepareFileRequest,
@@ -164,6 +190,8 @@ interface Processor {
   /** Child process id (child backend), for shutdown and tests. */
   readonly pid: number | null;
   stop(): void;
+  /** Tests only: raise the event Bun raises for an undeliverable message. */
+  simulateUndeliverable?(direction: "job" | "result"): void;
 }
 
 const phaseName = (index: number): string => PREPARE_PHASES[index] ?? "startup";
@@ -176,25 +204,38 @@ function startWorker(): Processor {
   const phaseSlot = new Int32Array(new SharedArrayBuffer(4));
   let onMessage: ((message: FileWorkerMessage) => void) | null = null;
   let markReady: () => void = () => undefined;
-  let markFailed: (reason: string) => void = () => undefined;
+  let markFailed: (failure: ProcessorFailure) => void = () => undefined;
   let dead = false;
   const ready = new Promise<void>((resolve) => {
     markReady = resolve;
   });
-  const failed = new Promise<string>((resolve) => {
-    markFailed = (reason) => {
+  const failed = new Promise<ProcessorFailure>((resolve) => {
+    markFailed = (failure) => {
       dead = true;
-      resolve(reason);
+      resolve(failure);
     };
   });
   worker.onmessage = (
-    event: MessageEvent<FileWorkerMessage | ReadyMessage>
+    event: MessageEvent<
+      FileWorkerMessage | ReadyMessage | UndeliverableJobMessage
+    >
   ) => {
     if (event.data.type === "ready") markReady();
-    else onMessage?.(event.data);
+    else if (event.data.type === "undeliverable-job") {
+      markFailed({
+        reason: "the file worker could not deserialize its job",
+        delivery: "job",
+      });
+    } else onMessage?.(event.data);
+  };
+  worker.onmessageerror = () => {
+    markFailed({
+      reason: "a message from the file worker could not be deserialized",
+      delivery: "result",
+    });
   };
   worker.onerror = (event: ErrorEvent) => {
-    markFailed(event.message || "file worker failed");
+    markFailed({ reason: event.message || "file worker failed" });
   };
   return {
     kind: "worker",
@@ -212,7 +253,12 @@ function startWorker(): Processor {
     pid: null,
     stop() {
       worker.terminate();
-      markFailed("file processor was stopped");
+      markFailed({ reason: "file processor was stopped" });
+    },
+    simulateUndeliverable(direction) {
+      if (direction === "result") {
+        worker.dispatchEvent(new MessageEvent("messageerror"));
+      } else worker.postMessage({ simulateUndeliverable: true });
     },
   };
 }
@@ -267,12 +313,21 @@ function startChild(): Processor {
   child.unref();
   liveChildren.add(child);
   ensureShutdownHooks();
-  const failed = child.exited.then((code) => {
+  const failed = child.exited.then((code): ProcessorFailure => {
     exited = true;
     liveChildren.delete(child);
-    return stopping
-      ? "file processor was stopped"
-      : `file processor child exited (${code})`;
+    if (stopping) return { reason: "file processor was stopped" };
+    // Bun closes the channel on both ends when either side receives a
+    // message it cannot deserialize. The child exits cleanly only once its
+    // channel is gone (file-child.ts), and a crash never exits cleanly; the
+    // exit can be reported before Bun's own disconnect callback.
+    if (code === 0) {
+      return {
+        reason: "the IPC channel to the file processor child closed",
+        delivery: "unknown",
+      };
+    }
+    return { reason: `file processor child exited (${code})` };
   });
   return {
     kind: "child",
@@ -367,6 +422,19 @@ export function activeFileProcessorPid(): number | null {
   return processor?.pid ?? null;
 }
 
+/**
+ * Tests only: make the running worker processor raise the event Bun raises
+ * when a message cannot be deserialized (a real payload cannot be made to
+ * fail from JavaScript). False when no worker processor is running.
+ */
+export function simulateUndeliverableMessage(
+  direction: "job" | "result"
+): boolean {
+  if (!processor?.simulateUndeliverable) return false;
+  processor.simulateUndeliverable(direction);
+  return true;
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Processor lifecycle
 // ─────────────────────────────────────────────────────────────────────────────
@@ -429,11 +497,30 @@ const awaitReady = (active: Processor): Promise<string | null> => {
   });
   return Promise.race([
     active.ready.then(() => null),
-    active.failed,
+    active.failed.then((failure) => failure.reason),
     timedOut,
   ]).finally(() => clearTimeout(timer));
 };
 
+/** Failure of a file whose message to or from the processor was lost. */
+function undeliverableFailure(
+  request: PrepareFileRequest,
+  kind: FileProcessorBackendKind,
+  phase: string,
+  failure: ProcessorFailure
+): PrepareFailure {
+  const direction = failure.delivery ?? "unknown";
+  const file = `${request.input.collection}/${request.input.relativePath}`;
+  console.error(
+    `gno: file processor message lost (direction ${direction}, backend ${kind}) for ${file} during ${phase}: ${failure.reason}; the processor was replaced`
+  );
+  return {
+    code: PROCESSOR_MESSAGE_FAILED,
+    message: `The file processor could not deliver a message during ${phase} (${failure.reason}); the processor was replaced`,
+    details: { direction, backend: kind, phase },
+  };
+}
+
 const runOne = async (
   request: PrepareFileRequest,
   budget: FileBudgetLimits,
@@ -511,9 +598,23 @@ const runOne = async (
     const sampler = setInterval(() => {
       void checkMemory();
     }, MEMORY_SAMPLE_INTERVAL_MS);
-    void active.failed.then((reason) =>
-      finish({ ok: false, error: { code: "INTERNAL", message: reason } }, false)
-    );
+    void active.failed.then((failure) => {
+      if (settled) return;
+      finish(
+        {
+          ok: false,
+          error: failure.delivery
+            ? undeliverableFailure(
+                request,
+                active.kind,
+                active.phase(),
+                failure
+              )
+            : { code: "INTERNAL", message: failure.reason },
+        },
+        false
+      );
+    });
     // A process already over the budget does not start another file.
     const rss = process.memoryUsage.rss();
     if (rss > budget.maxMemoryBytes) {

package/src/ingestion/prepare-worker.ts

@@ -8,6 +8,7 @@ import type {
   FileWorkerMessage,
   FileWorkerRequest,
   ReadyMessage,
+  UndeliverableJobMessage,
 } from "./file-processor";
 
 import { defaultChunker } from "./chunker";
@@ -16,14 +17,31 @@ import { PREPARE_PHASES, prepareFile } from "./prepare-file";
 
 declare const self: Worker;
 
-const post = (message: FileWorkerMessage | ReadyMessage): void => {
+const post = (
+  message: FileWorkerMessage | ReadyMessage | UndeliverableJobMessage
+): void => {
   self.postMessage(message);
 };
 
-self.onmessage = async (event: MessageEvent<FileWorkerRequest>) => {
+// A job that cannot be deserialized never reaches onmessage (Bun 1.4.0+
+// raises messageerror instead); tell the parent so the file fails at once.
+// A listener, not `onmessageerror`: Bun's worker scope never calls that
+// property.
+self.addEventListener("messageerror", () => {
+  post({ type: "undeliverable-job" });
+});
+
+self.onmessage = async (
+  event: MessageEvent<FileWorkerRequest | { simulateUndeliverable: true }>
+) => {
   // Only the parent that created this worker may drive it; a Bun Worker sees
   // its parent's messages with an empty origin.
   if (event.origin !== "") return;
+  if ("simulateUndeliverable" in event.data) {
+    // Tests only (simulateUndeliverableMessage): raise the real event.
+    self.dispatchEvent(new MessageEvent("messageerror"));
+    return;
+  }
   const { request, phaseSlot } = event.data;
   const outcome = await prepareFile(request, {
     convert: convertForPreparation,

package/src/serve/public/components/BootstrapStatus.tsx

@@ -65,8 +65,8 @@ export function BootstrapStatus({
 
   return (
     <section className="space-y-4">
-      <div className="flex items-start justify-between gap-4">
-        <div>
+      <div className="flex flex-col gap-4 sm:flex-row sm:items-start sm:justify-between">
+        <div className="min-w-0">
           <div className="mb-2 flex items-center gap-2">
             <PackageIcon className="size-4 text-primary" />
             <h2 className="font-semibold text-2xl">Bootstrap & Storage</h2>
@@ -77,7 +77,7 @@ export function BootstrapStatus({
           </p>
         </div>
         {missingModels > 0 && !bootstrap.models.downloading && (
-          <Button onClick={onDownloadModels} size="sm">
+          <Button className="self-start" onClick={onDownloadModels} size="sm">
             <DownloadIcon className="mr-2 size-4" />
             Download missing models
           </Button>