@stage-labs/metro 0.1.0-beta.4 → 0.1.0-beta.41

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

@@ -0,0 +1,27 @@
+const DEFAULT_SESSION_TTL_SEC = 30 * 24 * 3600;
+const PREVIEW = /^([a-z0-9-]+--)?metro-ui\.netlify\.app$/;
+
+export function sessionTtlFromEnv(): number {
+  const ttl = Number(process.env.METRO_SESSION_TTL_SEC);
+  return Number.isFinite(ttl) && ttl > 0 ? ttl : DEFAULT_SESSION_TTL_SEC;
+}
+
+export function allowedWebHost(host: string): boolean {
+  if (host === 'metro.box' || host === 'localhost' || host === '127.0.0.1')
+    return true;
+  return PREVIEW.test(host);
+}
+
+export function validateReturnTo(returnTo: string): boolean {
+  let url: URL;
+  try {
+    url = new URL(returnTo);
+  } catch {
+    return false;
+  }
+  const host = url.hostname;
+  if (url.protocol === 'http:' && (host === 'localhost' || host === '127.0.0.1'))
+    return true;
+  if (url.protocol !== 'https:') return false;
+  return allowedWebHost(host);
+}

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

@@ -0,0 +1,218 @@
+import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+import { ID_RE } from '../db/ids.js';
+
+export class SessionError extends Error {}
+
+const b64url = (buf: Buffer): string =>
+  buf
+    .toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/, '');
+
+const b64urlJson = (v: unknown): string =>
+  b64url(Buffer.from(JSON.stringify(v)));
+
+const decodeJson = (seg: string): unknown =>
+  JSON.parse(
+    Buffer.from(seg.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString(
+      'utf8',
+    ),
+  );
+
+const HEADER = b64urlJson({ alg: 'HS256', typ: 'JWT' });
+
+function sign(payload: Record<string, unknown>, secret: string): string {
+  if (secret === '') throw new SessionError('missing signing secret');
+  const body = b64urlJson(payload);
+  const data = `${HEADER}.${body}`;
+  const sig = b64url(createHmac('sha256', secret).update(data).digest());
+  return `${data}.${sig}`;
+}
+
+function verify(token: string, secret: string): Record<string, unknown> {
+  if (secret === '') throw new SessionError('missing signing secret');
+  const parts = token.split('.');
+  if (parts.length !== 3) throw new SessionError('malformed token');
+  const data = `${parts[0]}.${parts[1]}`;
+  const expected = b64url(createHmac('sha256', secret).update(data).digest());
+  const a = Buffer.from(parts[2] ?? '');
+  const b = Buffer.from(expected);
+  if (a.length !== b.length || !timingSafeEqual(a, b))
+    throw new SessionError('bad signature');
+  let payload: unknown;
+  try {
+    payload = decodeJson(parts[1] ?? '');
+  } catch {
+    throw new SessionError('malformed payload');
+  }
+  if (typeof payload !== 'object' || payload === null)
+    throw new SessionError('malformed payload');
+  return payload as Record<string, unknown>;
+}
+
+const nowSec = (now?: number): number => Math.floor((now ?? Date.now()) / 1000);
+
+export function newNonce(): string {
+  return b64url(randomBytes(16));
+}
+
+interface StateClaims {
+  return_to: string;
+  nonce: string;
+}
+
+export function signState(
+  claims: StateClaims,
+  secret: string,
+  opts: { ttlSec?: number; now?: number } = {},
+): string {
+  const iat = nowSec(opts.now);
+  return sign(
+    {
+      typ: 'state',
+      return_to: claims.return_to,
+      nonce: claims.nonce,
+      iat,
+      exp: iat + (opts.ttlSec ?? 600),
+    },
+    secret,
+  );
+}
+
+export function verifyState(
+  token: string,
+  secret: string,
+  now?: number,
+): StateClaims {
+  const p = verify(token, secret);
+  if (p.typ !== 'state') throw new SessionError('wrong token type');
+  if (typeof p.exp !== 'number' || p.exp < nowSec(now))
+    throw new SessionError('state expired');
+  if (typeof p.return_to !== 'string' || typeof p.nonce !== 'string')
+    throw new SessionError('malformed state');
+  return { return_to: p.return_to, nonce: p.nonce };
+}
+
+interface SessionClaims {
+  subject: string;
+  agentIds: string[];
+}
+
+export interface AgentClaims {
+  subject: string;
+  agentId: string;
+}
+
+export interface RunClaims {
+  subject: string;
+  agentId: string;
+  runtimeId: string;
+}
+
+export function signSession(
+  claims: SessionClaims,
+  secret: string,
+  opts: { ttlSec?: number; now?: number } = {},
+): string {
+  const iat = nowSec(opts.now);
+  return sign(
+    {
+      typ: 'session',
+      sub: claims.subject,
+      agent_ids: claims.agentIds,
+      iat,
+      exp: iat + (opts.ttlSec ?? 30 * 24 * 3600),
+    },
+    secret,
+  );
+}
+
+export function verifySession(
+  token: string,
+  secret: string,
+  now?: number,
+): SessionClaims {
+  const p = verify(token, secret);
+  if (p.typ !== 'session') throw new SessionError('wrong token type');
+  if (typeof p.exp !== 'number' || p.exp < nowSec(now))
+    throw new SessionError('session expired');
+  const ids = p.agent_ids;
+  if (
+    typeof p.sub !== 'string' ||
+    !Array.isArray(ids) ||
+    ids.some((a) => typeof a !== 'string' || !ID_RE.test(a))
+  )
+    throw new SessionError('malformed session');
+  return { subject: p.sub, agentIds: ids as string[] };
+}
+
+export function signAgentToken(
+  claims: AgentClaims,
+  secret: string,
+  opts: { ttlSec?: number; now?: number } = {},
+): string {
+  const iat = nowSec(opts.now);
+  return sign(
+    {
+      typ: 'agent',
+      sub: claims.subject,
+      agent: claims.agentId,
+      iat,
+      exp: iat + (opts.ttlSec ?? 30 * 24 * 3600),
+    },
+    secret,
+  );
+}
+
+export function verifyAgentToken(
+  token: string,
+  secret: string,
+  now?: number,
+): AgentClaims {
+  const p = verify(token, secret);
+  if (p.typ !== 'agent') throw new SessionError('wrong token type');
+  if (typeof p.exp !== 'number' || p.exp < nowSec(now))
+    throw new SessionError('agent token expired');
+  if (typeof p.sub !== 'string' || typeof p.agent !== 'string')
+    throw new SessionError('malformed agent token');
+  return { subject: p.sub, agentId: p.agent };
+}
+
+export function signRunToken(
+  claims: RunClaims,
+  secret: string,
+  opts: { ttlSec?: number; now?: number } = {},
+): string {
+  const iat = nowSec(opts.now);
+  return sign(
+    {
+      typ: 'run',
+      sub: claims.subject,
+      agent: claims.agentId,
+      rt: claims.runtimeId,
+      iat,
+      exp: iat + (opts.ttlSec ?? 365 * 24 * 3600),
+    },
+    secret,
+  );
+}
+
+export function verifyRunToken(
+  token: string,
+  secret: string,
+  now?: number,
+): RunClaims {
+  const p = verify(token, secret);
+  if (p.typ !== 'run') throw new SessionError('wrong token type');
+  if (typeof p.exp !== 'number' || p.exp < nowSec(now))
+    throw new SessionError('run token expired');
+  if (
+    typeof p.sub !== 'string' ||
+    typeof p.agent !== 'string' ||
+    typeof p.rt !== 'string' ||
+    !ID_RE.test(p.agent)
+  )
+    throw new SessionError('malformed run token');
+  return { subject: p.sub, agentId: p.agent, runtimeId: p.rt };
+}

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

@@ -0,0 +1,82 @@
+import { verifyMessage, type Hex } from 'viem';
+import { parseSiweMessage, validateSiweMessage } from 'viem/siwe';
+import { ApiError } from './api-error.js';
+import { allowedWebHost } from './session-config.js';
+
+export class SiweError extends ApiError {}
+
+export interface SiweLogin {
+  message: string;
+  signature: string;
+}
+
+export interface SiweVerifyArgs {
+  address: `0x${string}`;
+  message: string;
+  signature: Hex;
+}
+
+export interface SiweDeps {
+  takeNonce: (nonce: string) => boolean;
+  now?: number;
+  verify?: (args: SiweVerifyArgs) => Promise<boolean>;
+}
+
+const HEX_SIGNATURE = /^0x[0-9a-fA-F]{130}$/;
+
+export function allowedSiweDomain(domain: string): boolean {
+  return allowedWebHost(domain.replace(/:\d+$/, ''));
+}
+
+function hostOf(uri: string): string | null {
+  try {
+    return new URL(uri).host;
+  } catch {
+    return null;
+  }
+}
+
+function fieldsOrThrow(message: string): {
+  address: `0x${string}`;
+  domain: string;
+  nonce: string;
+  parsed: ReturnType<typeof parseSiweMessage>;
+} {
+  const parsed = parseSiweMessage(message);
+  const { address, domain, nonce, uri, version } = parsed;
+  if (
+    address === undefined ||
+    domain === undefined ||
+    nonce === undefined ||
+    uri === undefined ||
+    version !== '1'
+  )
+    throw new SiweError('that is not a sign-in message', 400);
+  if (!allowedSiweDomain(domain))
+    throw new SiweError(`sign-in messages for ${domain} are not accepted here`, 400);
+  if (hostOf(uri) !== domain)
+    throw new SiweError('the sign-in message names a different site', 400);
+  return { address, domain, nonce, parsed };
+}
+
+export async function verifySiweLogin(
+  input: SiweLogin,
+  deps: SiweDeps,
+): Promise<string> {
+  if (!HEX_SIGNATURE.test(input.signature))
+    throw new SiweError('that is not an Ethereum signature', 400);
+  const { address, domain, nonce, parsed } = fieldsOrThrow(input.message);
+  const time = new Date(deps.now ?? Date.now());
+  if (!validateSiweMessage({ message: parsed, domain, nonce, time }))
+    throw new SiweError('this sign-in message is expired or does not match', 400);
+  if (!deps.takeNonce(nonce))
+    throw new SiweError('that sign-in has expired or was already used', 400);
+  const verify = deps.verify ?? verifyMessage;
+  const signature = input.signature as Hex;
+  if (!(await verify({ address, message: input.message, signature })))
+    throw new SiweError(
+      'the signature does not match the address; smart-contract wallets are not supported yet',
+      401,
+    );
+  return address.toLowerCase();
+}

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

@@ -0,0 +1,43 @@
+import { generateSiweNonce } from 'viem/siwe';
+
+const TTL_MS = 10 * 60_000;
+const SWEEP_MS = 60_000;
+const MAX_LIVE = 500;
+
+const live = new Map<string, number>();
+let sweeper: ReturnType<typeof setInterval> | null = null;
+
+function sweep(now = Date.now()): void {
+  for (const [nonce, expiresAt] of live) if (expiresAt <= now) live.delete(nonce);
+}
+
+function ensureSweeper(): void {
+  if (sweeper !== null) return;
+  sweeper = setInterval(sweep, SWEEP_MS);
+  sweeper.unref?.();
+}
+
+export function mintNonce(now = Date.now()): string {
+  sweep(now);
+  while (live.size >= MAX_LIVE) {
+    const oldest = live.keys().next();
+    if (oldest.done) break;
+    live.delete(oldest.value);
+  }
+  const nonce = generateSiweNonce();
+  live.set(nonce, now + TTL_MS);
+  ensureSweeper();
+  return nonce;
+}
+
+export function takeNonce(nonce: string, now = Date.now()): boolean {
+  const expiresAt = live.get(nonce);
+  if (expiresAt === undefined) return false;
+  live.delete(nonce);
+  return expiresAt > now;
+}
+
+export function nonceCount(): number {
+  sweep();
+  return live.size;
+}

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

@@ -0,0 +1,89 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { log } from './log.js';
+import {
+  apiFailure,
+  bodyField,
+  cors,
+  readJsonBody,
+  sendJson,
+} from './api-http.js';
+import { mintNonce, takeNonce } from './siwe-nonces.js';
+import { verifySiweLogin } from './siwe-auth.js';
+import { signSession } from './session.js';
+import { sessionTtlFromEnv } from './session-config.js';
+import { ensureUserWithProject } from '../db/projects.js';
+
+const NONCE_PATH = '/auth/siwe/nonce';
+const VERIFY_PATH = '/auth/siwe/verify';
+
+export interface SiweRouteDeps {
+  ensureUser: (address: string) => Promise<string>;
+}
+
+const defaultDeps: SiweRouteDeps = { ensureUser: ensureUserWithProject };
+
+async function handleVerify(
+  req: IncomingMessage,
+  res: ServerResponse,
+  secret: string,
+  deps: SiweRouteDeps,
+): Promise<void> {
+  const body = await readJsonBody(req);
+  const message = bodyField(body, 'message');
+  const signature = bodyField(body, 'signature');
+  if (typeof message !== 'string' || typeof signature !== 'string') {
+    sendJson(req, res, 400, { error: 'message and signature are required' });
+    return;
+  }
+  const address = await verifySiweLogin({ message, signature }, { takeNonce });
+  const userId = await deps.ensureUser(address);
+  log.info({ userId, address }, 'siwe: session issued');
+  const session = signSession({ subject: address, agentIds: [] }, secret, {
+    ttlSec: sessionTtlFromEnv(),
+  });
+  sendJson(req, res, 200, { session, address });
+}
+
+const ROUTES: Record<string, string> = {
+  [NONCE_PATH]: 'GET',
+  [VERIFY_PATH]: 'POST',
+};
+
+function refused(
+  req: IncomingMessage,
+  res: ServerResponse,
+  path: string,
+): boolean {
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== ROUTES[path]) {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  return false;
+}
+
+export function handleSiweAuthRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: SiweRouteDeps = defaultDeps,
+): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (ROUTES[path] === undefined) return false;
+  if (refused(req, res, path)) return true;
+  const secret = process.env.METRO_SESSION_SECRET?.trim() ?? '';
+  if (secret === '') {
+    sendJson(req, res, 503, { error: 'sign-in is not configured' });
+    return true;
+  }
+  if (path === NONCE_PATH) {
+    sendJson(req, res, 200, { nonce: mintNonce() });
+    return true;
+  }
+  handleVerify(req, res, secret, deps).catch((err: unknown) => {
+    apiFailure(req, res, err, 'siwe');
+  });
+  return true;
+}

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`);
+  }
+}