@gmickel/gno 2.9.2 → 2.10.1

package/src/cli/commands/mcp/status.ts

@@ -101,6 +101,54 @@ interface StatusResult {
 // Config Reading
 // ─────────────────────────────────────────────────────────────────────────────
 
+const isStringArray = (value: unknown): boolean =>
+  Array.isArray(value) && value.every((item) => typeof item === "string");
+
+/**
+ * Client settings that never change how the command runs: timeouts, labels
+ * and approval prompts. Anything else (cwd, url, headers, another transport,
+ * unknown keys) keeps an entry fail-closed, because the connector verifier
+ * starts the registered command.
+ */
+const INERT_ENTRY_KEYS: Record<string, (value: unknown) => boolean> = {
+  type: (value) => value === "stdio",
+  timeout: (value) => typeof value === "number",
+  startup_timeout_sec: (value) => typeof value === "number",
+  tool_timeout_sec: (value) => typeof value === "number",
+  description: (value) => typeof value === "string",
+  autoApprove: isStringArray,
+  alwaysAllow: isStringArray,
+  enabled: (value) => typeof value === "boolean",
+  disabled: (value) => typeof value === "boolean",
+};
+
+/** Keys other than the launch keys are all known and inert. */
+function hasOnlyInertExtras(
+  record: Record<string, unknown>,
+  launchKeys: readonly string[],
+  allowed: Record<string, (value: unknown) => boolean>
+): boolean {
+  return Object.entries(record).every(
+    ([key, value]) =>
+      launchKeys.includes(key) || (allowed[key]?.(value) ?? false)
+  );
+}
+
+/** OpenCode writes `type: "local"` and `enabled` itself. */
+const OPENCODE_INERT_KEYS: Record<string, (value: unknown) => boolean> = {
+  timeout: (value) => typeof value === "number",
+  enabled: (value) => typeof value === "boolean",
+};
+
+/** A registration the client has switched off. */
+function isDisabledEntry(entry: unknown): boolean {
+  if (!entry || typeof entry !== "object") {
+    return false;
+  }
+  const record = entry as Record<string, unknown>;
+  return record.enabled === false || record.disabled === true;
+}
+
 /**
  * Normalize entry to standard format for display.
  */
@@ -120,12 +168,10 @@ function normalizeEntry(
       !Array.isArray(record.command) ||
       record.command.length === 0 ||
       !record.command.every((part) => typeof part === "string") ||
-      Object.keys(record).some(
-        (key) =>
-          key !== "type" &&
-          key !== "command" &&
-          key !== "enabled" &&
-          key !== "environment"
+      !hasOnlyInertExtras(
+        record,
+        ["type", "command", "environment"],
+        OPENCODE_INERT_KEYS
       )
     ) {
       return null;
@@ -149,9 +195,7 @@ function normalizeEntry(
     record.command.length === 0 ||
     !Array.isArray(record.args) ||
     !record.args.every((argument) => typeof argument === "string") ||
-    Object.keys(record).some(
-      (key) => key !== "command" && key !== "args" && key !== "env"
-    )
+    !hasOnlyInertExtras(record, ["command", "args", "env"], INERT_ENTRY_KEYS)
   ) {
     return null;
   }
@@ -211,12 +255,8 @@ export async function checkMcpTargetStatus(
       return { target, scope, configPath, configured: false };
     }
     const entry = parsed.entry;
-    if (
-      configFormat === "mcp" &&
-      entry &&
-      typeof entry === "object" &&
-      (entry as { enabled?: unknown }).enabled === false
-    ) {
+    // A registration the client has switched off is not configured.
+    if (isDisabledEntry(entry)) {
       return { target, scope, configPath, configured: false };
     }
     const configIdentity = entryIdentity(entry);

package/src/cli/commands/mcp.ts

@@ -7,6 +7,8 @@
 import type { McpToolProfile } from "../../mcp/tool-profile";
 import type { GlobalOptions } from "../context";
 
+import { warnIfBunBelowFloor } from "../../app/bun-runtime";
+
 /**
  * Start the MCP server.
  * Reads global options for --index and --config flags.
@@ -15,6 +17,8 @@ export async function mcpCommand(
   options: GlobalOptions,
   commandOptions: { enableWrite?: boolean; toolProfile?: McpToolProfile } = {}
 ): Promise<void> {
+  // stderr only: stdout carries the MCP protocol.
+  warnIfBunBelowFloor("mcp");
   const { startMcpServer } = await import("../../mcp/server.js");
   await startMcpServer({
     indexName: options.index,

package/src/cli/commands/serve.ts

@@ -5,6 +5,8 @@
  * @module src/cli/commands/serve
  */
 
+import { warnIfBunBelowFloor } from "../../app/bun-runtime";
+
 export type { ServeOptions, ServeResult } from "../../serve";
 
 /**
@@ -14,6 +16,7 @@ export type { ServeOptions, ServeResult } from "../../serve";
 export async function serve(
   options: import("../../serve").ServeOptions = {}
 ): Promise<import("../../serve").ServeResult> {
+  warnIfBunBelowFloor("serve");
   const { startServer } = await import("../../serve");
   return startServer(options);
 }

package/src/cli/commands/status.ts

@@ -44,6 +44,12 @@ import {
   resolveProcessPaths,
   statusProcess,
 } from "../detach";
+import {
+  checkRegistrationRuntimes,
+  checkResidentRuntimes,
+  formatRuntimeIssue,
+  type RuntimeIssue,
+} from "../runtime-health";
 
 /**
  * Options for status command.
@@ -70,6 +76,8 @@ export type StatusResult =
       contentTypeBoost: ContentTypeBoostStatus;
       memory: MemoryStatus;
       backgroundIssues: ResidentBackgroundIssue[];
+      /** Registrations and residents on a missing, old or other Bun (fn-213). */
+      runtimeIssues?: RuntimeIssue[];
       /** Files whose latest conversion stopped at the per-file budget. */
       budgetStops: BudgetStop[];
     }
@@ -433,6 +441,10 @@ export async function status(
       contentTypeBoost: buildContentTypeBoostStatus(config.contentTypes ?? []),
       memory: await buildMemoryStatus(store, config.collections),
       backgroundIssues: await collectResidentIssues(),
+      runtimeIssues: [
+        ...(await checkRegistrationRuntimes()),
+        ...(await checkResidentRuntimes()),
+      ],
       budgetStops: await collectBudgetStops(store),
     };
   } finally {
@@ -486,6 +498,9 @@ export function formatStatus(
         ...(result.backgroundIssues.length
           ? { backgroundIssues: result.backgroundIssues }
           : {}),
+        ...(result.runtimeIssues?.length
+          ? { runtimeIssues: result.runtimeIssues }
+          : {}),
       },
       null,
       2
@@ -524,5 +539,14 @@ export function formatStatus(
         ]
       : []),
     ...(issueLines.length ? ["", "Background issues:", ...issueLines] : []),
+    ...(result.runtimeIssues?.length
+      ? [
+          "",
+          "Bun runtime:",
+          ...result.runtimeIssues.map(
+            (issue) => `  [${issue.severity}] ${formatRuntimeIssue(issue)}`
+          ),
+        ]
+      : []),
   ].join("\n");
 }

package/src/cli/detach.ts

@@ -56,6 +56,8 @@ export interface PidFilePayload {
   version: string;
   started_at: string;
   port?: number | null;
+  /** Bun the resident runs on (fn-213); absent in older pid-files. */
+  bun_version?: string;
 }
 
 /** Result of a `--status` call (matches process-status@1.0). */
@@ -246,6 +248,9 @@ export async function readPidFile(
     version: record.version,
     started_at: record.started_at,
     port,
+    ...(typeof record.bun_version === "string" && record.bun_version
+      ? { bun_version: record.bun_version }
+      : {}),
   };
 }
 
@@ -610,6 +615,11 @@ export async function spawnDetached(
       version: VERSION,
       started_at: new Date().toISOString(),
       port: options.port ?? null,
+      // The child runs on this process's Bun unless a caller replaced the
+      // command.
+      ...(options.cmdPrefix || options.execPath
+        ? {}
+        : { bun_version: Bun.version }),
     };
 
     // If the pid-file write fails (disk full, permission race, bad path on

package/src/cli/program.ts

@@ -2644,7 +2644,7 @@ function wireMcpCommand(program: Command): void {
       "advertised tool set the registration starts with: core (7 read tools + capture/remember with --enable-write) or full (default)"
     )
     .option("--json", "JSON output")
-    .action(async (cmdOpts: Record<string, unknown>) => {
+    .action(async (cmdOpts: Record<string, unknown>, command: Command) => {
       const target = cmdOpts.target as string;
       const toolProfile = parseToolProfileOption(cmdOpts.toolProfile);
       const requestedScope = cmdOpts.scope;
@@ -2687,9 +2687,14 @@ function wireMcpCommand(program: Command): void {
         scope: scope as "user" | "project",
         force: Boolean(cmdOpts.force),
         dryRun: Boolean(cmdOpts.dryRun),
-        enableWrite: Boolean(cmdOpts.enableWrite),
+        // Only options the user passed: --force keeps the rest of an
+        // existing registration (--index has a default, so check its source).
+        enableWrite: cmdOpts.enableWrite === true ? true : undefined,
         toolProfile,
-        indexName: globals.index,
+        indexName:
+          command.getOptionValueSourceWithGlobals("index") === "cli"
+            ? globals.index
+            : undefined,
         configPath: globals.config,
         // Pass undefined if not set, so global --json can take effect
         json: cmdOpts.json === true ? true : undefined,
@@ -2865,23 +2870,59 @@ function wireManagementCommands(program: Command): void {
       });
     });
 
-  collectionCmd
-    .command("remove <name>")
-    .description("Remove a collection")
-    .action(async (name: string) => {
-      const { collectionRemove } = await import("./commands/collection");
-      await collectionRemove(name, { configPath: getGlobals().config });
-    });
+  addWriteLeaseFlags(
+    collectionCmd
+      .command("remove <name>")
+      .description("Remove a collection and its indexed documents")
+  ).action(async (name: string, cmdOpts: Record<string, unknown>) => {
+    const { collectionRemove } = await import("./commands/collection");
+    const lease = parseWriteLeaseFlags(cmdOpts);
+    const result = await withCliWriteLease(
+      {
+        indexName: getGlobals().index,
+        lockWaitMs: lease.lockWaitMs,
+        noWait: lease.noWait,
+      },
+      async () => {
+        await collectionRemove(name, {
+          configPath: getGlobals().config,
+          indexName: getGlobals().index,
+        });
+        return { success: true as const };
+      }
+    );
+    throwIfWriteLeaseBusy(result, false);
+  });
 
-  collectionCmd
-    .command("rename <old> <new>")
-    .description("Rename a collection")
-    .action(async (oldName: string, newName: string) => {
+  addWriteLeaseFlags(
+    collectionCmd
+      .command("rename <old> <new>")
+      .description("Rename a collection (run gno update afterwards)")
+  ).action(
+    async (
+      oldName: string,
+      newName: string,
+      cmdOpts: Record<string, unknown>
+    ) => {
       const { collectionRename } = await import("./commands/collection");
-      await collectionRename(oldName, newName, {
-        configPath: getGlobals().config,
-      });
-    });
+      const lease = parseWriteLeaseFlags(cmdOpts);
+      const result = await withCliWriteLease(
+        {
+          indexName: getGlobals().index,
+          lockWaitMs: lease.lockWaitMs,
+          noWait: lease.noWait,
+        },
+        async () => {
+          await collectionRename(oldName, newName, {
+            configPath: getGlobals().config,
+            indexName: getGlobals().index,
+          });
+          return { success: true as const };
+        }
+      );
+      throwIfWriteLeaseBusy(result, false);
+    }
+  );
 
   addWriteLeaseFlags(
     collectionCmd
@@ -3615,7 +3656,11 @@ function wireManagementCommands(program: Command): void {
         lockWaitMs: lease.lockWaitMs,
         noWait: lease.noWait,
       },
-      () => cleanup({ indexName: getGlobals().index })
+      () =>
+        cleanup({
+          configPath: getGlobals().config,
+          indexName: getGlobals().index,
+        })
     );
     throwIfWriteLeaseBusy(result, false);
 

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",