@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

package/runtime/node_modules/@metro-labs/daemon/src/routes/session-apis.ts

@@ -0,0 +1,65 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { handleSessionApiRequest } from './session.js';
+import { handleApprovalsRequest } from '../approvals/api.js';
+import { handleAgentApiRequest, type AgentApiDeps } from '../agents/api.js';
+import { handleEnrollRequest, type EnrollApiDeps } from '../connectors/enroll-api.js';
+import { handleClaudeRequest, type ClaudeApiDeps } from '../claude/api.js';
+import type { ModeInfo } from '@metro-labs/http/mode-api';
+import { handleBundleRequest, type BundleApiDeps } from '../agents/bundle.js';
+import { handleUpdateRequest, type UpdateApiDeps } from '../server/update.js';
+import { handleControlRequest, type ControlApiDeps } from '../server/control.js';
+import { handleOwnerRequest, type OwnerApiDeps } from '../server/owner.js';
+import { handleMachineRequest, type MachineApiDeps } from '../server/machine.js';
+import { handleModelRequest, type ModelApiDeps } from '../gateway/model-api.js';
+import type { GatewayDeps } from '../gateway/gateway.js';
+import { handleTerminalRequest, type TerminalApiDeps } from '../terminal/api.js';
+import { handleSchedulesRequest } from '../agent-user/schedules-api.js';
+import { handleFilesRequest } from '../agent-user/files-api.js';
+import { handleVaultRequest } from '../vault/api.js';
+import { handleVoiceRequest } from '../voice/api.js';
+import { handleRunEventsRequest } from '../monitor/run-events.js';
+
+export interface SessionApis {
+  agentApi?: AgentApiDeps;
+  bundleApi?: BundleApiDeps;
+  updateApi?: UpdateApiDeps;
+  controlApi?: ControlApiDeps;
+  ownerApi?: OwnerApiDeps;
+  machineApi?: MachineApiDeps;
+  modelApi?: ModelApiDeps;
+  gateway?: GatewayDeps;
+  terminalApi?: TerminalApiDeps;
+  claudeApi?: ClaudeApiDeps;
+  enrollApi?: EnrollApiDeps;
+  mode?: () => ModeInfo;
+}
+
+const when = <T>(dep: T | undefined, run: (dep: T) => boolean): (() => boolean)[] =>
+  dep === undefined ? [] : [() => run(dep)];
+
+export function handleSessionApis(
+  req: IncomingMessage,
+  res: ServerResponse,
+  apis: SessionApis,
+): boolean {
+  const routes: (() => boolean)[] = [
+    () => handleSessionApiRequest(req, res),
+    () => handleRunEventsRequest(req, res),
+    () => handleApprovalsRequest(req, res),
+    ...when(apis.enrollApi, (d) => handleEnrollRequest(req, res, d)),
+    ...when(apis.bundleApi, (d) => handleBundleRequest(req, res, d)),
+    ...when(apis.updateApi, (d) => handleUpdateRequest(req, res, d)),
+    ...when(apis.controlApi, (d) => handleControlRequest(req, res, d)),
+    () => handleSchedulesRequest(req, res),
+    () => handleFilesRequest(req, res),
+    () => handleVaultRequest(req, res),
+    () => handleVoiceRequest(req, res),
+    ...when(apis.ownerApi, (d) => handleOwnerRequest(req, res, d)),
+    ...when(apis.machineApi, (d) => handleMachineRequest(req, res, d)),
+    ...when(apis.modelApi, (d) => handleModelRequest(req, res, d)),
+    ...when(apis.terminalApi, (d) => handleTerminalRequest(req, res, d)),
+    ...when(apis.claudeApi, (d) => handleClaudeRequest(req, res, d)),
+    ...when(apis.agentApi, (d) => handleAgentApiRequest(req, res, d)),
+  ];
+  return routes.some((run) => run());
+}

package/runtime/node_modules/@metro-labs/daemon/src/routes/session.ts

@@ -0,0 +1,29 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { apiFailure, apiSession, cors, sendJson } from '@metro-labs/http/api-http';
+
+const PATH = '/api/session';
+
+export function handleSessionApiRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (path !== PATH) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== 'GET') {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  apiSession(req)
+    .then((session) => {
+      if (!session) sendJson(req, res, 401, { error: 'unauthorized' });
+      else sendJson(req, res, 200, { subject: session.subject, role: session.role });
+    })
+    .catch((err: unknown) => {
+      apiFailure(req, res, err, 'session');
+    });
+  return true;
+}

package/runtime/node_modules/@metro-labs/daemon/src/routes/threema-callback.ts

@@ -0,0 +1,103 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from '@metro-labs/core/log';
+import { tokenMatches } from '../stations/webhook-endpoints.js';
+import {
+  findThreemaCallback,
+  type ThreemaCallback,
+} from '../stations/threema-callbacks.js';
+import { forwardTrainCall, type TrainCallBackend } from '../stations/train-call.js';
+import { BodyTooLargeError, readBody } from './body.js';
+
+const PREFIX = '/api/threema/';
+const CALLBACK_PATH = /^\/api\/threema\/([0-9]{17,20})\/([A-Za-z0-9_-]{32,128})$/;
+const BODY_MAX = 64 * 1024;
+const REQUIRED = ['from', 'to', 'messageId', 'date', 'nonce', 'box', 'mac'] as const;
+
+function callbackTarget(path: string): ThreemaCallback | null {
+  const m = CALLBACK_PATH.exec(path);
+  const callbackId = m?.[1];
+  const token = m?.[2];
+  if (callbackId === undefined || token === undefined) return null;
+  const row = findThreemaCallback(callbackId);
+  return row !== undefined && tokenMatches(row.callbackToken, token) ? row : null;
+}
+
+function parseFields(raw: Buffer): Record<string, string> | null {
+  const params = new URLSearchParams(raw.toString('utf8'));
+  const out: Record<string, string> = {};
+  for (const key of REQUIRED) {
+    const value = params.get(key)?.trim() ?? '';
+    if (value === '') return null;
+    out[key] = value;
+  }
+  const nickname = params.get('nickname')?.trim() ?? '';
+  if (nickname !== '') out.nickname = nickname;
+  return out;
+}
+
+async function deliver(
+  res: ServerResponse,
+  target: ThreemaCallback,
+  fields: Record<string, string>,
+  forward: TrainCallBackend,
+): Promise<void> {
+  let response;
+  try {
+    response = await forward('threema', 'callback', { account: target.id, ...fields });
+  } catch (err) {
+    log.warn(
+      { account: target.id, err: errMsg(err) },
+      'threema: the callback could not reach the train, so Threema is asked to retry',
+    );
+    res.writeHead(503).end('threema train unavailable');
+    return;
+  }
+  if (response.error !== undefined) {
+    log.warn({ account: target.id, err: response.error }, 'threema: callback refused');
+    res.writeHead(400).end('refused');
+    return;
+  }
+  res.writeHead(200).end('ok');
+}
+
+async function readFields(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<Record<string, string> | null> {
+  let raw: Buffer;
+  try {
+    raw = await readBody(req, BODY_MAX);
+  } catch (err) {
+    if (!(err instanceof BodyTooLargeError)) throw err;
+    res.writeHead(413).end('payload too large');
+    return null;
+  }
+  const fields = parseFields(raw);
+  if (fields === null) res.writeHead(400).end('missing callback fields');
+  return fields;
+}
+
+export async function handleThreemaCallback(
+  req: IncomingMessage,
+  res: ServerResponse,
+  forward: TrainCallBackend = forwardTrainCall,
+): Promise<boolean> {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (!path.startsWith(PREFIX)) return false;
+  const target = callbackTarget(path);
+  if (target === null) {
+    res.writeHead(404).end();
+    return true;
+  }
+  if (req.method === 'GET') {
+    res.writeHead(200).end(`metro threema callback ${target.callbackId} ready\n`);
+    return true;
+  }
+  if (req.method !== 'POST') {
+    res.writeHead(405).end();
+    return true;
+  }
+  const fields = await readFields(req, res);
+  if (fields !== null) await deliver(res, target, fields, forward);
+  return true;
+}

package/runtime/node_modules/@metro-labs/daemon/src/server/cloudwatch.ts

@@ -0,0 +1,178 @@
+import { readFile, statfs } from 'node:fs/promises';
+import { uptime } from 'node:os';
+import { errMsg, log } from '@metro-labs/core/log';
+import { isRecord } from '@metro-labs/core/is-record';
+import { signV4 } from '@metro-labs/http/sigv4';
+
+const IMDS = 'http://169.254.169.254/latest';
+const EVERY_MS = 60_000;
+const FIRST_MS = 15_000;
+const IMDS_TIMEOUT_MS = 2_000;
+const SEND_TIMEOUT_MS = 15_000;
+const NAMESPACE = 'CWAgent';
+const CONTENT_TYPE = 'application/x-www-form-urlencoded; charset=utf-8';
+const BOOT_WINDOW_S = 300;
+const SENT = 'sending memory and disk to CloudWatch every minute';
+
+export interface Readings {
+  memory: number;
+  disk: number;
+}
+
+export interface Started {
+  name: 'server_booted' | 'metro_started';
+  at: number;
+}
+
+interface RoleKeys {
+  accessKeyId: string;
+  secretAccessKey: string;
+  sessionToken: string;
+}
+
+interface Instance {
+  instanceId: string;
+  region: string;
+  keys: RoleKeys | null;
+}
+
+export interface PublisherDeps {
+  fetch: (url: string, init: RequestInit) => Promise<Response>;
+  readings: () => Promise<Readings | null>;
+}
+
+export function memoryPercent(meminfo: string): number | null {
+  const kb = (name: string): number | null => {
+    const match = new RegExp(`^${name}:\\s+(\\d+) kB`, 'm').exec(meminfo);
+    return match === null ? null : Number(match[1]);
+  };
+  const total = kb('MemTotal');
+  const available = kb('MemAvailable');
+  if (total === null || available === null || total <= 0) return null;
+  return ((total - available) / total) * 100;
+}
+
+export function diskPercent(fs: { blocks: number; bfree: number; bavail: number }): number | null {
+  const used = fs.blocks - fs.bfree;
+  const room = used + fs.bavail;
+  return room > 0 ? (used / room) * 100 : null;
+}
+
+async function liveReadings(): Promise<Readings | null> {
+  const memory = memoryPercent(await readFile('/proc/meminfo', 'utf8'));
+  const disk = diskPercent(await statfs('/'));
+  return memory === null || disk === null ? null : { memory, disk };
+}
+
+const LIVE: PublisherDeps = { fetch: (url, init) => fetch(url, init), readings: liveReadings };
+
+async function imdsGet(deps: PublisherDeps, token: string, path: string): Promise<string> {
+  const res = await deps.fetch(`${IMDS}/${path}`, { headers: { 'x-aws-ec2-metadata-token': token }, signal: AbortSignal.timeout(IMDS_TIMEOUT_MS) });
+  return res.ok ? (await res.text()).trim() : '';
+}
+
+async function imdsToken(deps: PublisherDeps): Promise<string> {
+  try {
+    const res = await deps.fetch(`${IMDS}/api/token`, {
+      method: 'PUT',
+      headers: { 'x-aws-ec2-metadata-token-ttl-seconds': '300' },
+      signal: AbortSignal.timeout(IMDS_TIMEOUT_MS),
+    });
+    return res.ok ? (await res.text()).trim() : '';
+  } catch {
+    return '';
+  }
+}
+
+function keysOf(raw: string): RoleKeys | null {
+  const parsed: unknown = JSON.parse(raw);
+  if (!isRecord(parsed)) return null;
+  const { AccessKeyId: accessKeyId, SecretAccessKey: secretAccessKey, Token: sessionToken } = parsed;
+  if (typeof accessKeyId !== 'string' || typeof secretAccessKey !== 'string' || typeof sessionToken !== 'string') return null;
+  return { accessKeyId, secretAccessKey, sessionToken };
+}
+
+export async function thisInstance(deps: PublisherDeps): Promise<Instance | null> {
+  const token = await imdsToken(deps);
+  if (token === '') return null;
+  const instanceId = await imdsGet(deps, token, 'meta-data/instance-id');
+  const region = await imdsGet(deps, token, 'meta-data/placement/region');
+  if (instanceId === '' || region === '') return null;
+  const role = (await imdsGet(deps, token, 'meta-data/iam/security-credentials/')).split('\n')[0] ?? '';
+  if (role === '') return { instanceId, region, keys: null };
+  return { instanceId, region, keys: keysOf(await imdsGet(deps, token, `meta-data/iam/security-credentials/${role}`)) };
+}
+
+export function startedOf(nowMs: number, processSeconds: number, bootSeconds: number): Started {
+  const at = (secondsAgo: number): number => Math.round(nowMs / 1000 - secondsAgo);
+  return bootSeconds < BOOT_WINDOW_S ? { name: 'server_booted', at: at(bootSeconds) } : { name: 'metro_started', at: at(processSeconds) };
+}
+
+export function readingParams(instanceId: string, readings: Readings, started: Started | null = null): Record<string, string> {
+  const datum = (at: number, name: string, value: number, dims: [string, string][], unit = 'Percent'): [string, string][] => [
+    [`MetricData.member.${String(at)}.MetricName`, name],
+    [`MetricData.member.${String(at)}.Unit`, unit],
+    [`MetricData.member.${String(at)}.Value`, value.toFixed(2)],
+    ...dims.flatMap(([key, v], i): [string, string][] => [
+      [`MetricData.member.${String(at)}.Dimensions.member.${String(i + 1)}.Name`, key],
+      [`MetricData.member.${String(at)}.Dimensions.member.${String(i + 1)}.Value`, v],
+    ]),
+  ];
+  return Object.fromEntries([
+    ['Action', 'PutMetricData'],
+    ['Version', '2010-08-01'],
+    ['Namespace', NAMESPACE],
+    ...datum(1, 'mem_used_percent', readings.memory, [['InstanceId', instanceId]]),
+    ...datum(2, 'disk_used_percent', readings.disk, [
+      ['InstanceId', instanceId],
+      ['path', '/'],
+    ]),
+    ...(started === null ? [] : datum(3, started.name, started.at, [['InstanceId', instanceId]], 'Seconds')),
+  ]);
+}
+
+async function send(deps: PublisherDeps, instance: Instance, keys: RoleKeys, readings: Readings, started: Started | null): Promise<void> {
+  const url = `https://monitoring.${instance.region}.amazonaws.com/`;
+  const body = new URLSearchParams(readingParams(instance.instanceId, readings, started)).toString();
+  const signed = await signV4({ method: 'POST', url, headers: { 'content-type': CONTENT_TYPE }, body, region: instance.region, service: 'monitoring', ...keys });
+  const res = await deps.fetch(url, { method: 'POST', headers: signed.headers, body, signal: AbortSignal.timeout(SEND_TIMEOUT_MS) });
+  if (res.ok) return;
+  const text = await res.text();
+  const code = /<Code>([^<]+)<\/Code>/.exec(text)?.[1] ?? `HTTP ${String(res.status)}`;
+  const message = /<Message>([^<]+)<\/Message>/.exec(text)?.[1];
+  throw new Error(`CloudWatch refused the readings: ${code}${message === undefined ? '' : ` (${message})`}`);
+}
+
+export async function publishOnce(deps: PublisherDeps = LIVE, started: Started | null = null): Promise<string> {
+  const instance = await thisInstance(deps);
+  if (instance === null) return 'off: this server is not an EC2 instance';
+  if (instance.keys === null) return `waiting: instance ${instance.instanceId} has no IAM role, so memory and disk are not sent`;
+  const readings = await deps.readings();
+  if (readings === null) return 'skipped: could not read memory or disk';
+  await send(deps, instance, instance.keys, readings, started);
+  return SENT;
+}
+
+export function startCloudWatchPublisher(): void {
+  if (process.platform !== 'linux') return;
+  let started: Started | null = startedOf(Date.now(), process.uptime(), uptime());
+  let last = '';
+  const note = (status: string, warn: boolean): void => {
+    if (status === last) return;
+    last = status;
+    if (warn) log.warn({ status }, 'cloudwatch: could not send memory and disk');
+    else log.info({ status }, 'cloudwatch');
+  };
+  const run = (): void => {
+    publishOnce(LIVE, started)
+      .then((status) => {
+        if (status === SENT) started = null;
+        note(status, false);
+      })
+      .catch((err: unknown) => {
+        note(errMsg(err), true);
+      });
+  };
+  setTimeout(run, FIRST_MS).unref?.();
+  setInterval(run, EVERY_MS).unref?.();
+}

package/runtime/node_modules/@metro-labs/daemon/src/server/control.ts

@@ -0,0 +1,39 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { ApiError } from '@metro-labs/http/api-error';
+import { sessionRoute } from '@metro-labs/http/api-http';
+import { log } from '@metro-labs/core/log';
+
+const STOP = '/api/stop';
+const RESTART = '/api/restart';
+const EXIT_DELAY_MS = 500;
+
+export interface ControlApiDeps {
+  restart: () => void;
+  stop: () => void;
+  served?: () => boolean;
+}
+
+interface Action {
+  run: () => void;
+  body: Record<string, boolean>;
+}
+
+const servedByCli = (): boolean => (process.env.METRO_CLI_BIN?.trim() ?? '') !== '';
+
+function actionFor(path: string, deps: ControlApiDeps): Action {
+  return path === STOP ? { run: deps.stop, body: { stopping: true } } : { run: deps.restart, body: { restarting: true } };
+}
+
+export function handleControlRequest(req: IncomingMessage, res: ServerResponse, deps: ControlApiDeps): boolean {
+  return sessionRoute(req, res, { methods: { [STOP]: ['POST'], [RESTART]: ['POST'] }, admin: true, label: 'control-api' }, async (session, path) => {
+    const action = actionFor(path, deps);
+    if (!(deps.served ?? servedByCli)())
+      throw new ApiError(
+        'this daemon was not started by metro serve, so nothing on the machine would bring it back: use the shell instead',
+        400,
+      );
+    log.info({ path, subject: session.subject }, 'control-api: requested from the page');
+    setTimeout(action.run, EXIT_DELAY_MS).unref();
+    return Promise.resolve(action.body);
+  });
+}

package/runtime/node_modules/@metro-labs/daemon/src/server/machine.ts

@@ -0,0 +1,58 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { hostname, homedir } from 'node:os';
+import { statfs } from 'node:fs/promises';
+import { errMsg, log } from '@metro-labs/core/log';
+import { sessionRoute } from '@metro-labs/http/api-http';
+import { publicBaseUrl, webhookPort } from '../files/attach-serve.js';
+import { claudeDir } from '../claude/files.js';
+import { METRO_VERSION } from '@metro-labs/core/version';
+import { agentsDir } from '../agents/files.js';
+import { localOwner } from '../agents/file-admin.js';
+
+const PATH = '/api/server';
+
+export interface MachineApiDeps {
+  startedAt?: string;
+}
+
+const bootedAt = new Date(Date.now() - process.uptime() * 1000).toISOString();
+
+interface Disk {
+  path: string;
+  totalBytes: number;
+  freeBytes: number;
+}
+
+async function diskInfo(path = homedir()): Promise<Disk | null> {
+  try {
+    const s = await statfs(path);
+    return { path, totalBytes: s.bsize * s.blocks, freeBytes: s.bsize * s.bavail };
+  } catch (err) {
+    log.warn({ err: errMsg(err), path }, 'machine: could not read the disk');
+    return null;
+  }
+}
+
+export async function machineInfo(startedAt = bootedAt): Promise<Record<string, unknown>> {
+  const store = process.env.METRO_RUNTIME_STORE?.trim() ?? '';
+  return {
+    disk: await diskInfo(),
+    version: METRO_VERSION,
+    owner: localOwner(),
+    hostname: hostname(),
+    platform: process.platform,
+    arch: process.arch,
+    port: webhookPort(),
+    publicUrl: publicBaseUrl(),
+    uptimeSeconds: Math.round(process.uptime()),
+    startedAt,
+    bun: process.versions.bun ?? null,
+    agentsDir: agentsDir(),
+    claudeDir: claudeDir(),
+    runtimeStore: store === '' ? null : store,
+  };
+}
+
+export function handleMachineRequest(req: IncomingMessage, res: ServerResponse, deps: MachineApiDeps): boolean {
+  return sessionRoute(req, res, { methods: { [PATH]: ['GET'] }, admin: false, label: 'machine-api' }, () => machineInfo(deps.startedAt));
+}

package/runtime/node_modules/@metro-labs/daemon/src/server/owner.ts

@@ -0,0 +1,26 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { ApiError } from '@metro-labs/http/api-error';
+import { readJsonBody, sessionRoute, type ApiSession } from '@metro-labs/http/api-http';
+import { isOrganizationId } from '@metro-labs/http/workos-token';
+import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
+
+const PATH = '/api/owner';
+
+export interface OwnerApiDeps {
+  setOwner: (owner: string) => string;
+}
+
+async function move(req: IncomingMessage, session: ApiSession, deps: OwnerApiDeps): Promise<{ owner: string }> {
+  const body = await readJsonBody(req);
+  const owner = isRecord(body) && typeof body.owner === 'string' ? body.owner.trim() : '';
+  if (!isOrganizationId(owner)) throw new ApiError('owner must be an organization id', 400);
+  if (owner === session.subject) throw new ApiError('this machine already belongs to that organization', 409);
+  const saved = deps.setOwner(owner);
+  log.info({ from: session.subject, to: saved }, 'owner: this machine moved to another organization');
+  return { owner: saved };
+}
+
+export function handleOwnerRequest(req: IncomingMessage, res: ServerResponse, deps: OwnerApiDeps): boolean {
+  return sessionRoute(req, res, { methods: { [PATH]: ['POST'] }, admin: true, label: 'owner-api' }, (session) => move(req, session, deps));
+}

package/runtime/node_modules/@metro-labs/daemon/src/server/update.ts

@@ -0,0 +1,90 @@
+import { execFile } from 'node:child_process';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { log } from '@metro-labs/core/log';
+import { ApiError } from '@metro-labs/http/api-error';
+import { sessionRoute } from '@metro-labs/http/api-http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { METRO_VERSION } from '@metro-labs/core/version';
+
+const PATH = '/api/update';
+const CHECK_TTL_MS = 10 * 60_000;
+const CHECK_TIMEOUT_MS = 30_000;
+const UPDATE_TIMEOUT_MS = 5 * 60_000;
+const RESTART_DELAY_MS = 500;
+const OUTPUT_TAIL = 800;
+
+interface UpdateCheck {
+  current: string;
+  latest: string;
+  newer: boolean;
+}
+
+interface UpdateResult {
+  updated: boolean;
+  version: string;
+  restarting: boolean;
+}
+
+export interface UpdateApiDeps {
+  restart: () => void;
+  cliBin?: () => string;
+}
+
+const cliBinFromEnv = (): string => process.env.METRO_CLI_BIN?.trim() ?? '';
+
+function runCli(bin: string, args: string[], timeout: number): Promise<{ stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    execFile(process.execPath, [bin, ...args], { timeout, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
+      if (err === null) resolve({ stdout, stderr });
+      else reject(new ApiError(`metro update failed: ${(stderr || err.message).trim().slice(-OUTPUT_TAIL)}`, 502));
+    });
+  });
+}
+
+let cached: { at: number; check: UpdateCheck } | null = null;
+
+function parseCheck(raw: string): UpdateCheck {
+  let body: unknown;
+  try {
+    body = JSON.parse(raw.trim().split('\n').at(-1) ?? '');
+  } catch {
+    throw new ApiError('metro update --check returned no report', 502);
+  }
+  if (!isRecord(body) || typeof body.current !== 'string' || typeof body.latest !== 'string')
+    throw new ApiError('metro update --check returned an unexpected report', 502);
+  return { current: body.current, latest: body.latest, newer: body.newer === true };
+}
+
+async function check(bin: string, fresh = false, now = Date.now()): Promise<UpdateCheck> {
+  if (!fresh && cached !== null && now - cached.at < CHECK_TTL_MS) return cached.check;
+  const out = await runCli(bin, ['update', '--check'], CHECK_TIMEOUT_MS);
+  cached = { at: now, check: parseCheck(out.stdout) };
+  return cached.check;
+}
+
+async function apply(bin: string, deps: UpdateApiDeps): Promise<UpdateResult> {
+  const before = await check(bin, true);
+  if (!before.newer) return { updated: false, version: before.current, restarting: false };
+  const out = await runCli(bin, ['update'], UPDATE_TIMEOUT_MS);
+  cached = null;
+  log.info({ from: before.current, to: before.latest, output: out.stderr.trim().slice(-OUTPUT_TAIL) }, 'update-api: metro updated, restarting');
+  setTimeout(() => {
+    deps.restart();
+  }, RESTART_DELAY_MS).unref();
+  return { updated: true, version: before.latest, restarting: true };
+}
+
+function binOrThrow(deps: UpdateApiDeps): string {
+  const bin = (deps.cliBin ?? cliBinFromEnv)();
+  if (bin === '')
+    throw new ApiError('this daemon was not started by metro serve, so it cannot update itself: run metro update on the machine', 400);
+  return bin;
+}
+
+export function handleUpdateRequest(req: IncomingMessage, res: ServerResponse, deps: UpdateApiDeps): boolean {
+  return sessionRoute(req, res, { methods: { [PATH]: ['GET', 'POST'] }, admin: ['POST'], label: 'update-api' }, async () => {
+    const bin = binOrThrow(deps);
+    if (req.method === 'GET') return { ...(await check(bin)), running: METRO_VERSION };
+    return apply(bin, deps);
+  });
+}

package/runtime/node_modules/@metro-labs/daemon/src/server.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import './boot/boot.js';