@stage-labs/metro 0.1.0-beta.7 → 0.1.0-beta.70

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

@@ -0,0 +1,82 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { log } from './log.js';
+import { isRecord } from './is-record.js';
+import type { StationName } from '../db/stations.js';
+import { knownAccounts } from '../db/agent-map.js';
+
+const INSTALL_TIMEOUT_MS = 15 * 60_000;
+
+export interface RuntimeManifest {
+  core: Record<string, string>;
+  stations: Record<string, Record<string, string>>;
+}
+
+export interface RuntimeStore {
+  dir: string;
+  manifest: RuntimeManifest;
+}
+
+const ranges = (raw: unknown): Record<string, string> =>
+  isRecord(raw)
+    ? Object.fromEntries(Object.entries(raw).filter((e): e is [string, string] => typeof e[1] === 'string'))
+    : {};
+
+export function readManifest(path: string): RuntimeManifest {
+  const raw: unknown = JSON.parse(readFileSync(path, 'utf8'));
+  if (!isRecord(raw)) throw new Error(`${path} is not a runtime manifest`);
+  const stations = isRecord(raw.stations) ? raw.stations : {};
+  return {
+    core: ranges(raw.core),
+    stations: Object.fromEntries(Object.entries(stations).map(([name, deps]) => [name, ranges(deps)])),
+  };
+}
+
+export function runtimeStore(): RuntimeStore | null {
+  const dir = process.env.METRO_RUNTIME_STORE?.trim() ?? '';
+  const manifest = process.env.METRO_RUNTIME_MANIFEST?.trim() ?? '';
+  if (dir === '' || manifest === '') return null;
+  return { dir, manifest: readManifest(manifest) };
+}
+
+export function dependenciesFor(manifest: RuntimeManifest, stations: Iterable<string>): Record<string, string> {
+  const out: Record<string, string> = { ...manifest.core };
+  for (const station of new Set(stations)) Object.assign(out, manifest.stations[station] ?? {});
+  return Object.fromEntries(Object.entries(out).sort(([a], [b]) => a.localeCompare(b)));
+}
+
+const packageText = (deps: Record<string, string>): string =>
+  `${JSON.stringify({ name: 'metro-runtime', private: true, dependencies: deps }, null, 2)}\n`;
+
+function current(dir: string): string | null {
+  try {
+    return readFileSync(join(dir, 'package.json'), 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+export function installRuntime(store: RuntimeStore, stations: Iterable<string>): boolean {
+  const wanted = packageText(dependenciesFor(store.manifest, stations));
+  const installed = existsSync(join(store.dir, 'node_modules', '.metro-installed'));
+  if (installed && current(store.dir) === wanted) return false;
+  mkdirSync(store.dir, { recursive: true });
+  writeFileSync(join(store.dir, 'package.json'), wanted);
+  log.info({ dir: store.dir }, 'runtime: installing the channel SDKs this machine needs');
+  const run = spawnSync('bun', ['install', '--no-summary', '--no-progress'], {
+    cwd: store.dir,
+    stdio: ['ignore', 'inherit', 'inherit'],
+    timeout: INSTALL_TIMEOUT_MS,
+  });
+  if (run.error !== undefined || run.status !== 0)
+    throw new Error(`bun install failed in ${store.dir}: ${run.error?.message ?? `exit ${String(run.status)}`}`);
+  writeFileSync(join(store.dir, 'node_modules', '.metro-installed'), `${new Date().toISOString()}\n`);
+  return true;
+}
+
+export function ensureStationDeps(station: StationName): void {
+  const store = runtimeStore();
+  if (store === null) return;
+  installRuntime(store, [...knownAccounts().map((a) => a.station), station]);
+}

package/runtime/node_modules/@metro-labs/mcp/src/daemon/secure-fs.ts

@@ -0,0 +1,57 @@
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { dirname } from 'node:path';
+import { errMsg, log } from './log.js';
+
+export function ensureSecureDir(dir: string): void {
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  try {
+    chmodSync(dir, 0o700);
+  } catch {
+  }
+}
+
+export function chmodIfExists(path: string, mode = 0o600): void {
+  if (!existsSync(path)) return;
+  try {
+    if ((statSync(path).mode & 0o777) !== mode) chmodSync(path, mode);
+  } catch {
+  }
+}
+
+export function writeSecure(path: string, data: string): void {
+  ensureSecureDir(dirname(path));
+  const tmp = `${path}.tmp-${process.pid}`;
+  writeFileSync(tmp, data, { mode: 0o600 });
+  try {
+    chmodSync(tmp, 0o600);
+  } catch {
+  }
+  renameSync(tmp, path);
+  chmodIfExists(path, 0o600);
+}
+
+export function readJson<T>(
+  path: string,
+  fallback: T,
+  opts?: { warn?: string },
+): T {
+  if (!existsSync(path)) return fallback;
+  try {
+    return JSON.parse(readFileSync(path, 'utf8')) as T;
+  } catch (err) {
+    if (opts?.warn) log.warn({ err: errMsg(err), path }, opts.warn);
+    return fallback;
+  }
+}
+
+export function writeJson(path: string, value: unknown): void {
+  writeFileSync(path, JSON.stringify(value, null, 2));
+}

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

@@ -0,0 +1,21 @@
+export interface ServerEntry {
+  id: string;
+  host: string;
+  name: string | null;
+  addedAt: string;
+}
+
+const HOST_RE = /^[a-z0-9][a-z0-9.-]*(?::\d{1,5})?$/;
+const HOST_MAX = 253;
+const NAME_MAX = 40;
+
+export function parseServerHost(raw: string): string | null {
+  const host = raw.trim().toLowerCase();
+  return host.length <= HOST_MAX && HOST_RE.test(host) ? host : null;
+}
+
+export function parseServerName(raw: unknown): string | null {
+  if (typeof raw !== 'string') return null;
+  const name = raw.replace(/[\p{Cc}]/gu, '').trim().slice(0, NAME_MAX);
+  return name === '' ? null : name;
+}

package/runtime/node_modules/@metro-labs/mcp/src/daemon/servers-api.ts

@@ -0,0 +1,80 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { log } from './log.js';
+import { apiFailure, cors, readJsonBody, sendJson } from './api-http.js';
+import { signedIdentity } from './signed-identity.js';
+import type { ServerEntry } from './server-types.js';
+import { parseId } from '../db/ids.js';
+
+const PREFIX = '/api/servers';
+
+export interface ServersApiDeps {
+  list: (subject: string) => Promise<ServerEntry[]>;
+  add: (subject: string, body: unknown) => Promise<ServerEntry>;
+  rename: (subject: string, id: string, body: unknown) => Promise<ServerEntry>;
+  remove: (subject: string, id: string) => Promise<{ id: string; host: string }>;
+}
+
+type Target = { kind: 'index' } | { kind: 'server'; id: string } | { kind: 'unknown' } | null;
+
+function target(path: string): Target {
+  if (path === PREFIX || path === `${PREFIX}/`) return { kind: 'index' };
+  if (!path.startsWith(`${PREFIX}/`)) return null;
+  const segments = path.slice(PREFIX.length + 1).split('/').filter(Boolean);
+  const id = parseId(segments[0] ?? '');
+  return id === null || segments.length !== 1 ? { kind: 'unknown' } : { kind: 'server', id };
+}
+
+const ALLOWED: Record<'index' | 'server', string[]> = { index: ['GET', 'POST'], server: ['PUT', 'DELETE'] };
+
+async function answer(
+  req: IncomingMessage,
+  deps: ServersApiDeps,
+  owner: string,
+  tgt: { kind: 'index' } | { kind: 'server'; id: string },
+): Promise<unknown> {
+  if (tgt.kind === 'index')
+    return req.method === 'GET' ? { servers: await deps.list(owner) } : deps.add(owner, await readJsonBody(req));
+  return req.method === 'DELETE' ? deps.remove(owner, tgt.id) : deps.rename(owner, tgt.id, await readJsonBody(req));
+}
+
+async function route(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ServersApiDeps,
+  tgt: { kind: 'index' } | { kind: 'server'; id: string },
+): Promise<void> {
+  try {
+    const owner = await signedIdentity(req);
+    if (owner === null) {
+      sendJson(req, res, 401, { error: 'unauthorized' });
+      return;
+    }
+    const body = await answer(req, deps, owner, tgt);
+    if (req.method !== 'GET') log.info({ method: req.method, target: tgt }, 'servers-api: list changed');
+    sendJson(req, res, 200, body);
+  } catch (err) {
+    apiFailure(req, res, err, 'servers-api');
+  }
+}
+
+export function handleServersApiRequest(req: IncomingMessage, res: ServerResponse, deps: ServersApiDeps): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  const tgt = target(path);
+  if (tgt === null) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (tgt.kind === 'unknown') {
+    sendJson(req, res, 404, { error: 'no such server' });
+    return true;
+  }
+  if (!ALLOWED[tgt.kind].includes(req.method ?? '')) {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  route(req, res, deps, tgt).catch((err: unknown) => {
+    apiFailure(req, res, err, 'servers-api');
+  });
+  return true;
+}

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

@@ -0,0 +1,29 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { apiFailure, apiSession, cors, sendJson } from './api-http.js';
+
+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 });
+    })
+    .catch((err: unknown) => {
+      apiFailure(req, res, err, 'session');
+    });
+  return true;
+}

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

@@ -0,0 +1,61 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { handleSessionApiRequest } from './session-api.js';
+import { handleAgentApiRequest, type AgentApiDeps } from './agent-api.js';
+import {
+  handleConnectorApiRequest,
+  type ConnectorApiDeps,
+} from './connector-api.js';
+import type { RelayApiDeps } from './relay.js';
+import type { IdentityRouteDeps } from './identity-routes.js';
+import { handleLocalCliRequest, type LocalCliDeps } from './local-cli-api.js';
+import { handleClaudeRequest, type ClaudeApiDeps } from './claude-api.js';
+import type { ModeInfo } from './mode-api.js';
+import { handleVaultApiRequest, type VaultApiDeps } from './vault-api.js';
+import { handleServersApiRequest, type ServersApiDeps } from './servers-api.js';
+import { handleBundleRequest, type BundleApiDeps } from './bundle-api.js';
+import { handleUpdateRequest, type UpdateApiDeps } from './update-api.js';
+import { handleControlRequest, type ControlApiDeps } from './control-api.js';
+import { handleMachineRequest, type MachineApiDeps } from './machine-api.js';
+import { handleTerminalRequest, type TerminalApiDeps } from './terminal-api.js';
+
+export interface SessionApis {
+  agentApi?: AgentApiDeps;
+  bundleApi?: BundleApiDeps;
+  vaultApi?: VaultApiDeps;
+  serversApi?: ServersApiDeps;
+  updateApi?: UpdateApiDeps;
+  controlApi?: ControlApiDeps;
+  machineApi?: MachineApiDeps;
+  terminalApi?: TerminalApiDeps;
+  localCli?: LocalCliDeps;
+  claudeApi?: ClaudeApiDeps;
+  connectorApi?: ConnectorApiDeps;
+  relayApi?: RelayApiDeps;
+  identity?: IdentityRouteDeps;
+  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),
+    ...when(apis.localCli, (d) => handleLocalCliRequest(req, res, d)),
+    ...when(apis.connectorApi, (d) => handleConnectorApiRequest(req, res, d)),
+    ...when(apis.bundleApi, (d) => handleBundleRequest(req, res, d)),
+    ...when(apis.vaultApi, (d) => handleVaultApiRequest(req, res, d)),
+    ...when(apis.serversApi, (d) => handleServersApiRequest(req, res, d)),
+    ...when(apis.updateApi, (d) => handleUpdateRequest(req, res, d)),
+    ...when(apis.controlApi, (d) => handleControlRequest(req, res, d)),
+    ...when(apis.machineApi, (d) => handleMachineRequest(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/mcp/src/daemon/signed-identity.ts

@@ -0,0 +1,36 @@
+import type { IncomingMessage } from 'node:http';
+import { verifyMessage } from 'viem';
+import { normalizeAddress } from '../db/address.js';
+
+export const AUTH_SCHEME = 'Metro';
+const SKEW_MS = 5 * 60_000;
+const SIGNATURE_RE = /^0x[0-9a-fA-F]{130}$/;
+
+export const identityChallenge = (method: string, path: string, at: number): string =>
+  `metro-auth\n${method} ${path}\n${String(at)}`;
+
+export interface SignedHeader {
+  address: string;
+  at: number;
+  signature: `0x${string}`;
+}
+
+export function parseIdentityHeader(header: string): SignedHeader | null {
+  const [scheme, rawAddress, rawAt, signature] = header.trim().split(/\s+/);
+  if (scheme !== AUTH_SCHEME || rawAddress === undefined || rawAt === undefined || signature === undefined) return null;
+  const address = normalizeAddress(rawAddress);
+  const at = Number(rawAt);
+  if (address === null || !Number.isFinite(at) || !SIGNATURE_RE.test(signature)) return null;
+  return { address, at, signature: signature as `0x${string}` };
+}
+
+export async function signedIdentity(req: IncomingMessage, now = Date.now()): Promise<string | null> {
+  const proof = parseIdentityHeader(req.headers.authorization ?? '');
+  if (proof === null || Math.abs(now - proof.at) > SKEW_MS) return null;
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  const message = identityChallenge(req.method ?? '', path, proof.at);
+  const ok = await verifyMessage({ address: proof.address as `0x${string}`, message, signature: proof.signature }).catch(
+    () => false,
+  );
+  return ok ? proof.address : null;
+}

package/runtime/node_modules/@metro-labs/mcp/src/daemon/supervisor-io.ts

@@ -0,0 +1,97 @@
+import { watch, type FSWatcher } from 'node:fs';
+import { join, parse as parsePath } from 'node:path';
+import { errMsg, log } from './log.js';
+import type { Pending } from './protocol.js';
+
+export const RESTART_BACKOFFS_MS = [1_000, 5_000, 30_000] as const;
+export const MAX_CONSECUTIVE_FAILS = 5;
+export const HOT_RELOAD_DEBOUNCE_MS = 300;
+export const TRAIN_EXT = /\.(ts|js|mjs)$/;
+
+export interface TrainState {
+  name: string;
+  path: string;
+  proc: ReturnType<typeof Bun.spawn> | null;
+  pending: Map<string, Pending>;
+  buf: string;
+  errBuf: string;
+  failCount: number;
+  restartTimer: ReturnType<typeof setTimeout> | null;
+  startedAt: string | null;
+  stopped: boolean;
+}
+
+export function startWatcher(
+  dir: string,
+  timers: Map<string, ReturnType<typeof setTimeout>>,
+  onChange: (name: string, path: string) => void,
+): FSWatcher | null {
+  try {
+    const w = watch(dir, (_event, filename) => {
+      if (!filename) return;
+      const base = filename;
+      if (!TRAIN_EXT.test(base) || base.startsWith('_') || base.startsWith('.'))
+        return;
+      const name = parsePath(base).name;
+      const existing = timers.get(name);
+      if (existing) clearTimeout(existing);
+      timers.set(
+        name,
+        setTimeout(() => {
+          timers.delete(name);
+          onChange(name, join(dir, base));
+        }, HOT_RELOAD_DEBOUNCE_MS),
+      );
+    });
+    w.on('error', (err) => {
+      log.warn({ err: errMsg(err) }, 'train hot-reload: watcher error');
+    });
+    log.info({ dir }, 'train hot-reload: watching');
+    return w;
+  } catch (err) {
+    log.warn(
+      { err: errMsg(err) },
+      'train hot-reload: watch unavailable (on-demand restart only)',
+    );
+    return null;
+  }
+}
+
+export function killGracefully(
+  proc: ReturnType<typeof Bun.spawn> | null,
+): Promise<unknown> | null {
+  if (proc?.exitCode !== null) return null;
+  try {
+    proc.kill('SIGTERM');
+  } catch {
+  }
+  const grace = setTimeout(() => {
+    try {
+      proc.kill('SIGKILL');
+    } catch {
+    }
+  }, 2_000);
+  return proc.exited.finally(() => {
+    clearTimeout(grace);
+  });
+}
+
+export async function pumpStream(
+  stream: unknown,
+  name: string,
+  kind: 'stdout' | 'stderr',
+  onChunk: (s: string) => void,
+): Promise<void> {
+  if (!stream || typeof stream === 'number') return;
+  const reader = (stream as ReadableStream<Uint8Array>).getReader();
+  const dec = new TextDecoder();
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      onChunk(dec.decode(value, { stream: true }));
+    }
+  } catch (err) {
+    log.debug({ name, err: errMsg(err) }, `train: ${kind} pump ended`);
+  }
+}