@gmickel/gno 2.9.1 → 2.10.0

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 }
+      : {}),
   };
 }
 
@@ -510,6 +515,17 @@ function acquireStartLock(pidFile: string, kind: DetachKind): string {
   );
 }
 
+/** Take the start lock if it is free right now; null when someone holds it. */
+function tryAcquireStartLock(pidFile: string): string | null {
+  const lockPath = startLockPath(pidFile);
+  try {
+    closeSync(openSync(lockPath, "wx", 0o600));
+    return lockPath;
+  } catch {
+    return null;
+  }
+}
+
 function releaseStartLock(lockPath: string): void {
   try {
     unlinkSync(lockPath);
@@ -599,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
@@ -943,12 +964,35 @@ async function waitForExit(
 /**
  * Stop a detached process: SIGTERM → poll → SIGKILL → poll → error.
  *
- * The pid-file is **not** unlinked on success by this helper — we let the
- * target's own signal handler clean it up (see `createSignalPromise` in
- * `src/cli/commands/daemon.ts`). Callers may unlink the file as a fallback
- * when liveness is `false` after the kill sequence; `stopProcess` itself only
- * unlinks stale pid-files it discovers on entry.
+ * The target's own signal handler normally removes the pid-file. A target
+ * killed before that handler existed (SIGTERM during early startup, or the
+ * SIGKILL escalation) cannot, so once the exit is confirmed this helper
+ * removes the pid-file if it still names the pid it stopped.
+ */
+/**
+ * Remove the pid-file only if it still names `pid` (never a newer instance's).
+ * The check and the unlink run under the start lock, so a concurrent
+ * `--detach` cannot write its pid-file in between. If a start holds the lock,
+ * the file is left alone: `guardDoubleStart` already treats a dead pid as
+ * stale.
  */
+async function removePidFileIfOwnedBy(
+  pidFile: string,
+  pid: number
+): Promise<void> {
+  const lockPath = tryAcquireStartLock(pidFile);
+  if (!lockPath) return;
+  try {
+    const current = await readPidFile(pidFile).catch(() => null);
+    if (current?.pid !== pid) return;
+    await unlink(pidFile).catch(() => {
+      /* already gone */
+    });
+  } finally {
+    releaseStartLock(lockPath);
+  }
+}
+
 export async function stopProcess(options: StopOptions): Promise<StopOutcome> {
   const timeoutMs = options.timeoutMs ?? RESIDENT_STOP_GRACE_MS;
   const pollIntervalMs = options.pollIntervalMs ?? 100;
@@ -1004,6 +1048,7 @@ export async function stopProcess(options: StopOptions): Promise<StopOutcome> {
     sleep
   );
   if (exitedOnSigterm) {
+    await removePidFileIfOwnedBy(options.pidFile, payload.pid);
     return { kind: "stopped", pid: payload.pid, signal: "SIGTERM" };
   }
 
@@ -1011,6 +1056,7 @@ export async function stopProcess(options: StopOptions): Promise<StopOutcome> {
     kill(payload.pid, "SIGKILL");
   } catch (error) {
     if (isErrnoException(error) && error.code === "ESRCH") {
+      await removePidFileIfOwnedBy(options.pidFile, payload.pid);
       return { kind: "stopped", pid: payload.pid, signal: "SIGTERM" };
     }
     throw error;
@@ -1025,6 +1071,7 @@ export async function stopProcess(options: StopOptions): Promise<StopOutcome> {
     sleep
   );
   if (exitedOnSigkill) {
+    await removePidFileIfOwnedBy(options.pidFile, payload.pid);
     return { kind: "stopped", pid: payload.pid, signal: "SIGKILL" };
   }
 

package/src/cli/program.ts

@@ -25,6 +25,7 @@ import {
   formatFindingsRunStatusLine,
   readFindingsRunStatus,
 } from "../core/findings-run-state";
+import { residentShutdownHandlerInstalled } from "../core/resident-shutdown-handler";
 import { parseAndValidateTagFilter } from "../core/tags";
 import {
   formatWriteLeaseBusyJson,
@@ -2643,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;
@@ -2686,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,
@@ -5564,8 +5570,16 @@ function installPidFileCleanup(pidFile: string): void {
       // Already gone or permission-denied — nothing actionable here.
     }
   };
-  process.once("SIGINT", cleanup);
-  process.once("SIGTERM", cleanup);
+  // Registering a listener disables the default terminate action. A signal
+  // that arrives before the daemon/server installs its own shutdown handler
+  // (still starting up) would otherwise be swallowed, and `--stop` would wait
+  // out its grace period and SIGKILL. Until that handler exists, exit now.
+  const onSignal = (exitCode: number) => () => {
+    cleanup();
+    if (!residentShutdownHandlerInstalled()) process.exit(exitCode);
+  };
+  process.once("SIGINT", onSignal(130));
+  process.once("SIGTERM", onSignal(143));
   // Also run on a clean (`exit(0)`) path so crashes leave a stale pid-file
   // that `--status` can detect via liveness check, but orderly shutdown
   // (e.g. startServer returned) still cleans up.

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/config/types.ts

@@ -138,6 +138,9 @@ export const CollectionSchema = z.object({
   /** Optional shell command to run before indexing */
   updateCmd: z.string().optional(),
 
+  /** Kill `updateCmd` (and anything it started) after this long; default 10 min */
+  updateCmdTimeoutMs: z.number().int().positive().optional(),
+
   /** Optional BCP-47 language hint */
   languageHint: z
     .string()

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/core/project-profile-apply-state.ts

@@ -78,6 +78,9 @@ export function applyProjectProfileDesiredState(
     include: [],
     exclude: desired.collection.exclude,
     ...(existing?.updateCmd ? { updateCmd: existing.updateCmd } : {}),
+    ...(existing?.updateCmdTimeoutMs
+      ? { updateCmdTimeoutMs: existing.updateCmdTimeoutMs }
+      : {}),
     ...(desired.collection.languageHint
       ? { languageHint: desired.collection.languageHint }
       : existing?.languageHint

package/src/core/resident-shutdown-handler.ts

@@ -0,0 +1,23 @@
+/**
+ * Whether this process's resident (serve or daemon) has installed its own
+ * SIGINT/SIGTERM shutdown handler.
+ *
+ * A detached resident registers a pid-file cleanup listener before startup,
+ * and registering any listener disables the default terminate action. Until
+ * the resident's handler exists, that cleanup listener must exit the process
+ * itself, or a stop sent during startup is swallowed. Counting listeners
+ * cannot tell: the CLI bootstrap and the file processor add their own.
+ *
+ * @module src/core/resident-shutdown-handler
+ */
+
+let installed = false;
+
+/** Called by serve and the daemon right after registering their handlers. */
+export function markResidentShutdownHandlerInstalled(): void {
+  installed = true;
+}
+
+export function residentShutdownHandlerInstalled(): boolean {
+  return installed;
+}