@serfab/cadre-host 1.13.0 → 1.15.0

package/src/server/routes/nat.ts

@@ -1,63 +1,75 @@
-/**
- * NAT/DDNS HTTP routes — thin adapters around `NatHandlers`
- * (`createNatHandlers(service)`). Side-effects (settings change, reachability
- * re-test, DDNS reconfiguration) emit a `connectivity-changed` bus event.
- *
- * Mount path: `/nat/*` — matches the existing CLI (cadre-host nat ...).
- */
-
-import type { FastifyInstance } from 'fastify';
-
-import type { NatHandlers, NatSettingsFile, NatStatusSnapshot } from '../../nat/types.js';
-import type { EventBus } from '../events/bus.js';
-
-export interface NatRoutesOptions {
-  handlers: NatHandlers;
-  events: EventBus;
-}
-
-export function registerNatRoutes(app: FastifyInstance, opts: NatRoutesOptions): void {
-  const { handlers, events } = opts;
-
-  app.get('/nat/status', async () => handlers.getStatus());
-
-  app.post('/nat/test', async () => {
-    const snap = await handlers.testReachability();
-    publishConnectivity(events, snap);
-    return snap;
-  });
-
-  app.get('/nat/providers', async () => handlers.listDdnsProviders());
-
-  app.put('/nat/ddns', async (request) => {
-    const body = (request.body ?? {}) as {
-      providerId?: string;
-      hostname?: string;
-      config?: Record<string, string>;
-      externallyManaged?: boolean;
-    };
-    const snap = await handlers.putDdns({
-      providerId: body.providerId ?? '',
-      hostname: body.hostname ?? '',
-      config: body.config ?? {},
-      externallyManaged: body.externallyManaged ?? false,
-    });
-    publishConnectivity(events, snap);
-    return snap;
-  });
-
-  app.put('/nat/settings', async (request) => {
-    const body = (request.body ?? {}) as Partial<Omit<NatSettingsFile, 'version'>>;
-    const snap = await handlers.putSettings(body);
-    publishConnectivity(events, snap);
-    return snap;
-  });
-}
-
-export function publishConnectivity(events: EventBus, snap: NatStatusSnapshot): void {
-  events.publish({
-    type: 'connectivity-changed',
-    portMode: snap.portMode,
-    directReachability: snap.directReachability,
-  });
-}
+/**
+ * NAT/DDNS HTTP routes — thin adapters around `NatHandlers`
+ * (`createNatHandlers(service)`). Side-effects (settings change, reachability
+ * re-test, DDNS reconfiguration, a manual forward) emit a `connectivity-changed`
+ * bus event. The service's own change listener covers the changes that happen
+ * on their own (a mapping completing after a spawn, an IP change) — see
+ * `server/index.ts`.
+ *
+ * Mount path: `/nat/*` — matches the existing CLI (cadre-host nat ...).
+ */
+
+import type { FastifyInstance } from 'fastify';
+
+import type { ManualForwardPatch, NatHandlers, NatSettingsFile, NatStatusSnapshot } from '../../nat/types.js';
+import type { EventBus } from '../events/bus.js';
+
+export interface NatRoutesOptions {
+  handlers: NatHandlers;
+  events: EventBus;
+}
+
+export function registerNatRoutes(app: FastifyInstance, opts: NatRoutesOptions): void {
+  const { handlers, events } = opts;
+
+  app.get('/nat/status', async () => handlers.getStatus());
+
+  app.post('/nat/test', async () => {
+    const snap = await handlers.testReachability();
+    publishConnectivity(events, snap);
+    return snap;
+  });
+
+  app.get('/nat/providers', async () => handlers.listDdnsProviders());
+
+  app.put('/nat/ddns', async (request) => {
+    const body = (request.body ?? {}) as {
+      providerId?: string;
+      hostname?: string;
+      config?: Record<string, string>;
+      externallyManaged?: boolean;
+    };
+    const snap = await handlers.putDdns({
+      providerId: body.providerId ?? '',
+      hostname: body.hostname ?? '',
+      config: body.config ?? {},
+      externallyManaged: body.externallyManaged ?? false,
+    });
+    publishConnectivity(events, snap);
+    return snap;
+  });
+
+  app.put('/nat/settings', async (request) => {
+    const body = (request.body ?? {}) as Partial<Omit<NatSettingsFile, 'version' | 'forwards'>>;
+    const snap = await handlers.putSettings(body);
+    publishConnectivity(events, snap);
+    return snap;
+  });
+
+  // The ports the user forwarded on their router for one node. `null` clears a
+  // port; both cleared removes the entry. Unknown node → 404 unknown_node; a
+  // body that is not an object, or a port outside 1–65535 → 400 invalid_config
+  // (all from the service, which reads only `tcp` and `ws`).
+  app.put<{ Params: { nodeId: string } }>('/nat/nodes/:nodeId/forward', async (request) => {
+    const snap = await handlers.putForward(request.params.nodeId, (request.body ?? {}) as ManualForwardPatch);
+    publishConnectivity(events, snap);
+    return snap;
+  });
+}
+
+export function publishConnectivity(events: EventBus, snap: NatStatusSnapshot): void {
+  events.publish({
+    type: 'connectivity-changed',
+    directReachability: snap.directReachability,
+  });
+}

package/src/server/routes/nodes.ts

@@ -1,188 +1,96 @@
-/**
- * /api/nodes — list managed cadre nodes, look up details, and control
- * lifecycle.
- *
- * Bus events for lifecycle transitions are emitted by the orchestrator's
- * `onStateChange` (forwarded by `createLocalUiServer.start`) — the route
- * handlers don't re-publish.
- *
- * start/stop/restart are real for the admin's owner node only (start/restart
- * re-spawn it from the persisted `OwnerSpawnConfig`). Every other node this
- * route can see is a donated node, whose lifecycle belongs to the donation
- * surface — this route no longer spawns generic nodes, and a stop here would
- * be undone at once by the donation supervisor's respawn. So all three verbs
- * answer a known non-owner node with 501, pointing at the donation teardown.
- *
- * Owner start/restart are founder-only: a donor-only host that once ran as a
- * founder still holds the owner handle and saved config (so re-enabling
- * `ownCadre` can resume it), but spawning it here would bring the owner node
- * back without its trust circle, NAT or strand services — so those answer 409.
- */
-
-import { existsSync, openSync, readSync, closeSync, statSync } from 'node:fs';
-
-import type { FastifyInstance, FastifyReply } from 'fastify';
-
-import type { HostProcessOrchestrator } from '../../orchestrator/index.js';
-import { defaultLogPath } from '../../orchestrator/log-rotator.js';
-
-import type { HostRole } from './status.js';
-
-const DEFAULT_LOG_LINES = 200;
-const MAX_LOG_LINES = 2000;
-
-export interface NodesRoutesOptions {
-  orchestrator: HostProcessOrchestrator;
-  role: HostRole;
-}
-
-export function registerNodesRoutes(app: FastifyInstance, opts: NodesRoutesOptions): void {
-  const { orchestrator, role } = opts;
-
-  app.get('/api/nodes', async () => {
-    return { ok: true, data: { nodes: orchestrator.listNodes() } };
-  });
-
-  app.get<{ Params: { id: string } }>('/api/nodes/:id', async (request, reply) => {
-    const node = orchestrator.getNode(request.params.id);
-    if (!node) return notFound(reply, request.params.id);
-    let stats = null;
-    try {
-      stats = await orchestrator.getStats(node.dockerId);
-    } catch {
-      // Stats unavailable (dead process etc.) — surface null.
-    }
-    return { ok: true, data: { node, stats } };
-  });
-
-  app.get<{ Params: { id: string }; Querystring: { lines?: string } }>(
-    '/api/nodes/:id/logs',
-    async (request, reply) => {
-      const node = orchestrator.getNode(request.params.id);
-      if (!node) return notFound(reply, request.params.id);
-      const requested = Number(request.query.lines ?? DEFAULT_LOG_LINES);
-      const tail = Number.isFinite(requested)
-        ? Math.max(1, Math.min(MAX_LOG_LINES, Math.floor(requested)))
-        : DEFAULT_LOG_LINES;
-      const lines = tailLogFile(defaultLogPath(node.workdir), tail);
-      return { ok: true, data: { lines } };
-    },
-  );
-
-  // start / stop / restart: real for the admin's owner node (started from the
-  // persisted OwnerSpawnConfig). Donated-node lifecycle belongs to the donation
-  // surface — those ids return a clear not_implemented that points there;
-  // unknown ids 404.
-  app.post<{ Params: { id: string } }>('/api/nodes/:id/stop', async (request, reply) => {
-    const { id } = request.params;
-    if (!orchestrator.isOwnerNode(id)) {
-      return ownerOnlyFallback(reply, orchestrator, id, 'stop');
-    }
-    const dockerId = orchestrator.resolveDockerId(id);
-    if (!dockerId) return notFound(reply, id);
-    await orchestrator.stopContainer(dockerId);
-    // The orchestrator emits its own onStateChange — createLocalUiServer
-    // forwards that to the bus. Don't double-publish here.
-    return { ok: true };
-  });
-
-  app.post<{ Params: { id: string } }>('/api/nodes/:id/start', async (request, reply) => {
-    const { id } = request.params;
-    if (orchestrator.isOwnerNode(id)) {
-      if (role === 'donor') return ownCadreDisabled(reply, 'start');
-      if (!orchestrator.hasOwnerConfig()) {
-        return notImplemented(reply, `start ${id}: owner node has no saved spawn config.`);
-      }
-      const node = await orchestrator.ensureOwnerNode();
-      return { ok: true, data: { node } };
-    }
-    return ownerOnlyFallback(reply, orchestrator, id, 'start');
-  });
-
-  app.post<{ Params: { id: string } }>('/api/nodes/:id/restart', async (request, reply) => {
-    const { id } = request.params;
-    if (orchestrator.isOwnerNode(id)) {
-      if (role === 'donor') return ownCadreDisabled(reply, 'restart');
-      if (!orchestrator.hasOwnerConfig()) {
-        return notImplemented(reply, `restart ${id}: owner node has no saved spawn config.`);
-      }
-      const node = await orchestrator.restartOwnerNode();
-      return { ok: true, data: { node } };
-    }
-    return ownerOnlyFallback(reply, orchestrator, id, 'restart');
-  });
-}
-
-/**
- * 404 for unknown ids; 501 not_implemented for known non-owner nodes — all of
- * them donated. A donated node's containerId is its donation id, so the
- * message names `node.id` rather than the route param, which may be the
- * opaque dockerId — only the donation id is what the terminate command takes.
- */
-function ownerOnlyFallback(
-  reply: FastifyReply,
-  orchestrator: HostProcessOrchestrator,
-  id: string,
-  verb: 'start' | 'stop' | 'restart',
-) {
-  const node = orchestrator.getNode(id);
-  if (!node) return notFound(reply, id);
-  return notImplemented(
-    reply,
-    `${verb} ${id}: only the owner node can be started, stopped or restarted here; a donated node's lifecycle is owned by the donation surface — end it with 'cadre-host grant terminate ${node.id}' (DELETE /grants-admin/donations/${node.id}).`,
-  );
-}
-
-function notFound(reply: FastifyReply, id: string) {
-  return reply.code(404).send({
-    ok: false,
-    error: { code: 'not_found', message: `Unknown node: ${id}` },
-  });
-}
-
-function notImplemented(reply: FastifyReply, message: string) {
-  return reply.code(501).send({ ok: false, error: { code: 'not_implemented', message } });
-}
-
-function ownCadreDisabled(reply: FastifyReply, verb: 'start' | 'restart') {
-  return reply.code(409).send({
-    ok: false,
-    error: {
-      code: 'own_cadre_disabled',
-      message: `${verb} owner: this host's own cadre is turned off (donor-only mode). Set ownCadre.enabled in host.config.json and restart cadre-host to run it again.`,
-    },
-  });
-}
-
-/**
- * Read the last `n` lines from a log file by walking the tail in chunks.
- * Returns [] for a missing file.
- */
-export function tailLogFile(path: string, n: number): string[] {
-  if (!existsSync(path)) return [];
-  const fd = openSync(path, 'r');
-  try {
-    const size = statSync(path).size;
-    const chunkSize = 8192;
-    let pos = size;
-    const buffers: Buffer[] = [];
-    let newlineCount = 0;
-    while (pos > 0 && newlineCount <= n) {
-      const readLen = Math.min(chunkSize, pos);
-      pos -= readLen;
-      const buf = Buffer.alloc(readLen);
-      readSync(fd, buf, 0, readLen, pos);
-      buffers.unshift(buf);
-      for (let i = 0; i < buf.length; i++) {
-        if (buf[i] === 0x0a) newlineCount++;
-      }
-    }
-    const joined = Buffer.concat(buffers).toString('utf8');
-    const lines = joined.split('\n');
-    const trimmed = lines[lines.length - 1] === '' ? lines.slice(0, -1) : lines;
-    return trimmed.slice(-n);
-  } finally {
-    closeSync(fd);
-  }
-}
-
+/**
+ * /api/nodes — list managed cadre nodes (orchestrator handles), look up one
+ * node's details, and tail its log. Read-only: every node's lifecycle belongs to
+ * `/api/hosted-nodes`, whose supervisor would undo at once a stop issued
+ * anywhere else. A handle's `partyId` is the placeholder an unclaimed node was
+ * started with until its first respawn after the claim; the hosted-node record
+ * carries the real party.
+ */
+
+import { existsSync, openSync, readSync, closeSync, statSync } from 'node:fs';
+
+import type { FastifyInstance, FastifyReply } from 'fastify';
+
+import type { HostProcessOrchestrator } from '../../orchestrator/index.js';
+import { defaultLogPath } from '../../orchestrator/log-rotator.js';
+
+const DEFAULT_LOG_LINES = 200;
+const MAX_LOG_LINES = 2000;
+
+export interface NodesRoutesOptions {
+  orchestrator: HostProcessOrchestrator;
+}
+
+export function registerNodesRoutes(app: FastifyInstance, opts: NodesRoutesOptions): void {
+  const { orchestrator } = opts;
+
+  app.get('/api/nodes', async () => {
+    return { ok: true, data: { nodes: orchestrator.listNodes() } };
+  });
+
+  app.get<{ Params: { id: string } }>('/api/nodes/:id', async (request, reply) => {
+    const node = orchestrator.getNode(request.params.id);
+    if (!node) return notFound(reply, request.params.id);
+    let stats = null;
+    try {
+      stats = await orchestrator.getStats(node.dockerId);
+    } catch {
+      // Stats unavailable (dead process etc.) — surface null.
+    }
+    return { ok: true, data: { node, stats } };
+  });
+
+  app.get<{ Params: { id: string }; Querystring: { lines?: string } }>(
+    '/api/nodes/:id/logs',
+    async (request, reply) => {
+      const node = orchestrator.getNode(request.params.id);
+      if (!node) return notFound(reply, request.params.id);
+      const requested = Number(request.query.lines ?? DEFAULT_LOG_LINES);
+      const tail = Number.isFinite(requested)
+        ? Math.max(1, Math.min(MAX_LOG_LINES, Math.floor(requested)))
+        : DEFAULT_LOG_LINES;
+      const lines = tailLogFile(defaultLogPath(node.workdir), tail);
+      return { ok: true, data: { lines } };
+    },
+  );
+}
+
+function notFound(reply: FastifyReply, id: string) {
+  return reply.code(404).send({
+    ok: false,
+    error: { code: 'not_found', message: `Unknown node: ${id}` },
+  });
+}
+
+/**
+ * Read the last `n` lines from a log file by walking the tail in chunks.
+ * Returns [] for a missing file.
+ */
+export function tailLogFile(path: string, n: number): string[] {
+  if (!existsSync(path)) return [];
+  const fd = openSync(path, 'r');
+  try {
+    const size = statSync(path).size;
+    const chunkSize = 8192;
+    let pos = size;
+    const buffers: Buffer[] = [];
+    let newlineCount = 0;
+    while (pos > 0 && newlineCount <= n) {
+      const readLen = Math.min(chunkSize, pos);
+      pos -= readLen;
+      const buf = Buffer.alloc(readLen);
+      readSync(fd, buf, 0, readLen, pos);
+      buffers.unshift(buf);
+      for (let i = 0; i < buf.length; i++) {
+        if (buf[i] === 0x0a) newlineCount++;
+      }
+    }
+    const joined = Buffer.concat(buffers).toString('utf8');
+    const lines = joined.split('\n');
+    const trimmed = lines[lines.length - 1] === '' ? lines.slice(0, -1) : lines;
+    return trimmed.slice(-n);
+  } finally {
+    closeSync(fd);
+  }
+}
+

package/src/server/routes/settings.ts

@@ -5,10 +5,10 @@
  * This route is a thin passthrough plus a write-whitelist:
  *
  *   - uiPort        rejected (restart required; only edit at install time)
- *   - libp2pPort    rejected (restart required)
  *   - upnpEnabled   accepted → also propagated to NatService.putSettings
  *   - updates.autoApply  accepted → propagated to UpdateService.putSettings
  *   - updates.manifestUrl accepted → propagated to UpdateService.putSettings
+ *   - claimAddresses accepted (replaced whole) → read by the next claim code
  *   - anything else 400 invalid_setting
  *
  * GET returns the full `HostConfigFile` (the SPA wants the full shape so it
@@ -20,20 +20,17 @@ import type { FastifyInstance } from 'fastify';
 import type { NatService } from '../../nat/index.js';
 import type { UpdateService } from '../../update/index.js';
 import type { HostSettingsStore } from '../settings-store.js';
+import { claimAddressSettingsProblem, type ClaimAddressSettings } from '../../installer/config.js';
 
-const FORBIDDEN_KEYS = new Set<string>(['uiPort', 'libp2pPort', 'dataDir', 'identityPath', 'installId', 'installedAt', 'installerVersion', 'version', 'ownCadre']);
+const FORBIDDEN_KEYS = new Set<string>(['uiPort', 'dataDir', 'installId', 'installedAt', 'installerVersion', 'version']);
 
-const WRITABLE_TOP_KEYS = new Set<string>(['upnpEnabled', 'updates']);
+const WRITABLE_TOP_KEYS = new Set<string>(['upnpEnabled', 'updates', 'claimAddresses']);
 const WRITABLE_UPDATES_KEYS = new Set<string>(['autoApply', 'manifestUrl']);
 
 export interface SettingsRoutesOptions {
   settingsStore: HostSettingsStore;
-  /**
-   * Present only when the host runs its own personal cadre. In donor-only mode
-   * an `upnpEnabled` write still persists to host.config.json but has no running
-   * NatService to propagate into.
-   */
-  nat?: NatService;
+  /** An `upnpEnabled` write takes effect on it at once. */
+  nat: NatService;
   update?: UpdateService;
 }
 
@@ -55,18 +52,15 @@ export function registerSettingsRoutes(app: FastifyInstance, opts: SettingsRoute
     }
 
     const current = settingsStore.read();
-    const patch: { upnpEnabled?: boolean; updates?: typeof current.updates } = {};
+    const patch: { upnpEnabled?: boolean; updates?: typeof current.updates; claimAddresses?: ClaimAddressSettings } = {};
 
     if ('upnpEnabled' in body) {
       patch.upnpEnabled = body.upnpEnabled as boolean;
-      // Propagate UPnP toggle into the running NatService so the change
+      // Propagate the UPnP toggle into the running NatService so the change
       // takes effect immediately. NatService persists into nat.json — that's
       // independent of host.config.json's `upnpEnabled` (which the installer
       // uses on first run to seed nat.json). Update both for consistency.
-      // In donor-only mode there is no NatService — the write still persists.
-      if (nat) {
-        await nat.putSettings({ upnpEnabled: body.upnpEnabled as boolean });
-      }
+      await nat.putSettings({ upnpEnabled: body.upnpEnabled as boolean });
     }
     if ('updates' in body) {
       const updates = body.updates as { autoApply?: boolean; manifestUrl?: string };
@@ -82,6 +76,13 @@ export function registerSettingsRoutes(app: FastifyInstance, opts: SettingsRoute
       }
     }
 
+    if ('claimAddresses' in body) {
+      const { lan, addrs } = body.claimAddresses as ClaimAddressSettings;
+      patch.claimAddresses = {
+        ...(lan !== undefined ? { lan } : {}),
+        ...(addrs !== undefined ? { addrs: addrs.map((a) => a.trim()).filter((a) => a.length > 0) } : {}),
+      };
+    }
     const next = settingsStore.update(patch);
     return { ok: true, data: next };
   });
@@ -99,6 +100,10 @@ function validatePatch(body: Record<string, unknown>): { error?: string } {
   if ('upnpEnabled' in body && typeof body.upnpEnabled !== 'boolean') {
     return { error: '"upnpEnabled" must be a boolean' };
   }
+  if ('claimAddresses' in body) {
+    const problem = claimAddressSettingsProblem(body.claimAddresses);
+    if (problem) return { error: problem };
+  }
   if ('updates' in body) {
     if (!body.updates || typeof body.updates !== 'object') {
       return { error: '"updates" must be an object' };

package/src/server/routes/status.ts

@@ -5,91 +5,54 @@
  * The response budget is < 5 ms; favour `getStatus()` over `testReachability()`.
  */
 
-import { readFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
 import type { FastifyInstance } from 'fastify';
 
 import type { HostProcessOrchestrator } from '../../orchestrator/index.js';
 import type { ManagedNodeInfo } from '../../orchestrator/types.js';
-import type { TrustCircleService } from '../../auth/index.js';
 import type { NatService } from '../../nat/index.js';
 import type { NatStatusSnapshot } from '../../nat/types.js';
 import type { UpdateService } from '../../update/index.js';
+import { packageVersion } from '../../package-version.js';
 
 const PROCESS_STARTED_AT = process.hrtime.bigint();
 
-/**
- * Which role the running process is in: `'founder'` also runs the host's own
- * cadre (`ownCadre.enabled` at start), `'donor'` only donates nodes.
- */
-export type HostRole = 'founder' | 'donor';
-
 export interface StatusRouteOptions {
   orchestrator: HostProcessOrchestrator;
-  role: HostRole;
-  /** Present only when the host runs its own personal cadre (`ownCadre.enabled`). */
-  trustCircle?: TrustCircleService;
-  /** Present only when the host runs its own personal cadre (`ownCadre.enabled`). */
-  nat?: NatService;
+  nat: NatService;
   update?: UpdateService;
 }
 
 export interface StatusResponse {
   service: { name: 'cadre-host'; version: string; uptimeSeconds: number };
-  /**
-   * Decided at start from `ownCadre.enabled` — the running process, not the file
-   * on disk, which may have been edited since without a restart.
-   */
-  role: HostRole;
   nodes: Array<{
     id: string;
     partyId: string;
     status: ManagedNodeInfo['status'];
     profile: ManagedNodeInfo['profile'];
-    /** Present (true) only on the host's own owner node; every other node is donated. */
-    owner?: true;
   }>;
-  /** Omitted in donor-only mode (no host-own trust circle). */
-  trustCircle?: { members: number; pending: number };
-  /** Omitted in donor-only mode (no NAT service). */
-  connectivity?: NatStatusSnapshot;
+  connectivity: NatStatusSnapshot;
   update?: { available?: string; lastChecked?: string };
 }
 
 export function registerStatusRoute(app: FastifyInstance, opts: StatusRouteOptions): void {
-  const version = readPackageVersion();
-
   app.get('/api/status', async (): Promise<StatusResponse> => {
     const nodes = opts.orchestrator.listNodes().map((n) => ({
       id: n.id,
       partyId: n.partyId,
       status: n.status,
       profile: n.profile,
-      ...(n.owner ? { owner: true as const } : {}),
     }));
 
     const response: StatusResponse = {
       service: {
         name: 'cadre-host',
-        version,
+        version: packageVersion,
         uptimeSeconds: secondsSince(PROCESS_STARTED_AT),
       },
-      role: opts.role,
       nodes,
+      connectivity: opts.nat.getStatus(),
     };
 
-    // Trust-circle + connectivity exist only when the host runs its own
-    // personal cadre; donor-only mode omits both.
-    if (opts.trustCircle) {
-      const tc = await opts.trustCircle.list();
-      response.trustCircle = { members: tc.members.length, pending: tc.pending.length };
-    }
-    if (opts.nat) {
-      response.connectivity = opts.nat.getStatus();
-    }
-
     if (opts.update) {
       const state = await opts.update.getState();
       const update: { available?: string; lastChecked?: string } = {};
@@ -107,28 +70,3 @@ function secondsSince(start: bigint): number {
   const elapsedNs = now - start;
   return Number(elapsedNs / 1_000_000_000n);
 }
-
-let cachedVersion: string | null = null;
-function readPackageVersion(): string {
-  if (cachedVersion) return cachedVersion;
-  try {
-    // dist/server/routes/status.js -> ../../../package.json
-    // src/server/routes/status.ts  -> ../../../package.json (vitest)
-    const here = dirname(fileURLToPath(import.meta.url));
-    const candidates = [
-      resolve(here, '..', '..', '..', 'package.json'),
-      resolve(here, '..', '..', 'package.json'),
-    ];
-    for (const p of candidates) {
-      try {
-        const parsed = JSON.parse(readFileSync(p, 'utf8')) as { version?: string };
-        if (parsed.version) {
-          cachedVersion = parsed.version;
-          return cachedVersion;
-        }
-      } catch { /* try next */ }
-    }
-  } catch { /* ignore */ }
-  cachedVersion = '0.0.0-unknown';
-  return cachedVersion;
-}