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

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

@@ -0,0 +1,118 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { errMsg, log } from './log.js';
+import { configDir } from './paths.js';
+import { metroBaseUrl } from './agent-import.js';
+
+const FETCH_TIMEOUT_MS = 15_000;
+const CACHE_MS = 60_000;
+
+export interface HostedConnector {
+  id: string;
+  name: string;
+  url: string;
+  transport: string;
+  signIn: 'connected' | 'disconnected' | null;
+}
+
+export interface HostedCredential {
+  token: string;
+  url: string;
+}
+
+function readJsonFile(path: string): Record<string, unknown> | null {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'));
+    return typeof parsed === 'object' && parsed !== null ? (parsed as Record<string, unknown>) : null;
+  } catch {
+    return null;
+  }
+}
+
+function agentOfToken(token: string): string | null {
+  const body = token.split('.')[1];
+  if (body === undefined) return null;
+  try {
+    const claims = JSON.parse(Buffer.from(body, 'base64url').toString('utf8')) as { agent?: unknown };
+    return typeof claims.agent === 'string' ? claims.agent : null;
+  } catch {
+    return null;
+  }
+}
+
+function credential(file: Record<string, unknown> | null): HostedCredential | null {
+  if (file === null || typeof file.token !== 'string' || file.token === '') return null;
+  return { token: file.token, url: typeof file.url === 'string' && file.url !== '' ? file.url : metroBaseUrl() };
+}
+
+export function hostedCredentialsFor(agentId: string, dir = configDir()): HostedCredential[] {
+  const out: HostedCredential[] = [];
+  const login = credential(readJsonFile(join(dir, 'credentials.json')));
+  if (login !== null && agentOfToken(login.token) === agentId) out.push(login);
+  const runtime = join(dir, `runtime-${agentId}.json`);
+  if (existsSync(runtime)) {
+    const cred = credential(readJsonFile(runtime));
+    if (cred !== null) out.push(cred);
+  }
+  return out;
+}
+
+const isConnector = (v: unknown): v is HostedConnector =>
+  typeof v === 'object' &&
+  v !== null &&
+  typeof (v as { id?: unknown }).id === 'string' &&
+  typeof (v as { name?: unknown }).name === 'string';
+
+class Refused extends Error {}
+
+async function fetchHosted(cred: HostedCredential): Promise<HostedConnector[]> {
+  const res = await fetch(`${cred.url}/api/cli/connectors`, {
+    headers: { authorization: `Bearer ${cred.token}` },
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+    redirect: 'manual',
+  });
+  if (res.status === 401 || res.status === 403 || res.status === 409) {
+    await res.arrayBuffer().catch(() => undefined);
+    throw new Refused(`metro no longer accepts this credential (${String(res.status)})`);
+  }
+  if (!res.ok) throw new Error(`metro answered ${String(res.status)} for the connectors`);
+  const body = (await res.json()) as { connectors?: unknown };
+  return Array.isArray(body.connectors) ? body.connectors.filter(isConnector) : [];
+}
+
+async function firstAccepted(agentId: string, creds: HostedCredential[]): Promise<HostedConnector[] | null> {
+  for (const cred of creds) {
+    try {
+      return await fetchHosted(cred);
+    } catch (err) {
+      if (!(err instanceof Refused)) throw err;
+      log.warn({ agent: agentId, reason: errMsg(err) }, 'hosted connectors: credential refused, trying the next');
+    }
+  }
+  return null;
+}
+
+const cache = new Map<string, { at: number; list: HostedConnector[] }>();
+
+export async function hostedConnectorsFor(agentId: string, dir = configDir()): Promise<HostedConnector[]> {
+  const hit = cache.get(agentId);
+  if (hit !== undefined && Date.now() - hit.at < CACHE_MS) return hit.list;
+  const creds = hostedCredentialsFor(agentId, dir);
+  if (creds.length === 0) return [];
+  try {
+    const list = await firstAccepted(agentId, creds);
+    if (list === null) {
+      log.warn({ agent: agentId }, 'hosted connectors: every stored credential is stale; metro login again');
+      return [];
+    }
+    cache.set(agentId, { at: Date.now(), list });
+    return list;
+  } catch (err) {
+    log.warn({ agent: agentId, err: errMsg(err) }, 'hosted connectors: unavailable, listing none');
+    return [];
+  }
+}
+
+export function forgetHostedConnectors(): void {
+  cache.clear();
+}

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

@@ -0,0 +1,369 @@
+import { handleSessionApis, type SessionApis } from './session-apis.js';
+import { handleRelayRequest } from './relay.js';
+import {
+  createServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from 'node:http';
+import { Line } from '../stations/lines.js';
+import { errMsg, log } from './log.js';
+import {
+  classifyEvent,
+  formatDisplay,
+  mintId,
+  publishEvent,
+  userSelf,
+  type MetroEvent,
+} from './events.js';
+import type { TrainEvent } from './protocol.js';
+import { agentForLine, agentIdForLine } from '../db/agent-map.js';
+import {
+  findEndpointByWebhookId,
+  listEndpoints,
+  tokenMatches,
+  webhookPort,
+  type Endpoint,
+} from './tunnel.js';
+import { attachmentEventUrl, handleAttachRequest } from './attach-serve.js';
+import { webhookEntry } from '@metro-labs/webhook';
+import { handleSiweAuthRequest } from './siwe-routes.js';
+import { handleModeRequest } from './mode-api.js';
+import { handleUploadRequest } from './upload-api.js';
+import {
+  handleMonitorRequest,
+  type MonitorCall,
+} from '../monitor/api.js';
+import { applyMcpCors, handleMcpPreflight } from './cors.js';
+
+const LRU_CAP = 2_000;
+
+const METRO_VERSION = process.env.npm_package_version ?? '0.1.0-beta.15';
+
+function dedupKey(
+  e: Pick<MetroEvent, 'station' | 'line' | 'messageId'>,
+): string | null {
+  if (!e.messageId) return null;
+  return `${e.station} ${e.line} ${e.messageId}`;
+}
+
+export interface DedupSeq {
+  admit(entry: MetroEvent): number | null;
+}
+
+export function makeDedupSeq(): DedupSeq {
+  const seen = new Map<string, true>();
+  const seqByLine = new Map<string, number>();
+
+  log.info('dedup+seq: live-from-boot (no persisted seed)');
+
+  const isInbound = (e: MetroEvent): boolean => !Line.isLocal(e.from);
+
+  return {
+    admit(entry: MetroEvent): number | null {
+      const key = dedupKey(entry);
+      if (key && isInbound(entry)) {
+        if (seen.has(key)) {
+          log.debug(
+            {
+              station: entry.station,
+              line: entry.line,
+              messageId: entry.messageId,
+            },
+            'dedup: dropped duplicate inbound message',
+          );
+          return null;
+        }
+        seen.set(key, true);
+        while (seen.size > LRU_CAP) {
+          const oldest = seen.keys().next();
+          if (oldest.done) break;
+          seen.delete(oldest.value);
+        }
+      }
+      const next = (seqByLine.get(entry.line) ?? 0) + 1;
+      seqByLine.set(entry.line, next);
+      while (seqByLine.size > LRU_CAP) {
+        const oldest = seqByLine.keys().next();
+        if (oldest.done) break;
+        seqByLine.delete(oldest.value);
+      }
+      return next;
+    },
+  };
+}
+
+function withAttachmentUrl(entry: MetroEvent): MetroEvent {
+  const payload = entry.payload;
+  if (!payload || typeof payload !== 'object') return entry;
+  const agentId = agentIdForLine(entry.line);
+  if (agentId === undefined) return entry;
+  const url = attachmentEventUrl(payload as Record<string, unknown>, agentId);
+  if (!url) return entry;
+  return { ...entry, payload: { ...payload, url } };
+}
+
+type Emit = (entry: MetroEvent) => void;
+
+export function makeEmit(dedupSeq?: DedupSeq): Emit {
+  const tracker = dedupSeq ?? makeDedupSeq();
+  return function emit(entry: MetroEvent): void {
+    const seq = tracker.admit(entry);
+    if (seq === null) return;
+    const enriched: MetroEvent = withAttachmentUrl({
+      ...entry,
+      seq,
+      agent: entry.agent ?? agentForLine(entry.line),
+      display: entry.display ?? formatDisplay(entry),
+      event: entry.event ?? classifyEvent(entry),
+    });
+    process.stdout.write(JSON.stringify(enriched) + '\n');
+    publishEvent(enriched);
+  };
+}
+
+function eventText(env: TrainEvent): string | undefined {
+  if (env.text !== undefined) return env.text;
+  return env.emoji ? `[react ${env.emoji}]` : undefined;
+}
+
+export function trainEventToMetroEvent(
+  env: TrainEvent,
+  trainName: string,
+): MetroEvent | null {
+  const line = env.line;
+  if (typeof line !== 'string') {
+    log.warn({ train: trainName }, 'train: dropped event without `line`');
+    return null;
+  }
+  const station = env.station ?? Line.station(line) ?? trainName;
+  const isPrivate = env.is_private === true;
+  const text = eventText(env);
+  return {
+    event: env.event,
+    agent: agentForLine(line),
+    id: env.id ?? mintId(),
+    ts: env.ts ?? new Date().toISOString(),
+    station,
+    line: line as MetroEvent['line'],
+    lineName: env.line_name,
+    from: (env.from ?? `metro://${station}`) as MetroEvent['from'],
+    fromName: env.from_name,
+    fromDisplayName: env.from_display_name,
+    to: (env.to ?? (isPrivate ? userSelf() : line)) as MetroEvent['to'],
+    text,
+    messageId: env.message_id,
+    replyTo: env.reply_to,
+    payload: env.payload,
+  };
+}
+
+type McpHandler = (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+
+export async function startWebhookServer(
+  emit: Emit,
+  apis: SessionApis = {},
+  mcp?: McpHandler,
+  monitorCall?: MonitorCall,
+): Promise<Server> {
+  const port = webhookPort();
+  const server = createServer((req, res) => {
+    handleRequest(req, res, emit, apis, mcp, monitorCall).catch(
+      (err: unknown) => {
+      log.warn({ err: errMsg(err) }, 'webhook handler error');
+      if (!res.headersSent) res.writeHead(500).end();
+    });
+  });
+  await new Promise<void>((resolve, reject) => {
+    server.once('error', reject);
+    const host = process.env.METRO_HTTP_HOST ?? '127.0.0.1';
+    server.listen(port, host, () => {
+      log.info(
+        {
+          host,
+          port,
+          endpoints: listEndpoints().length,
+          mcp: mcp ? '/' : 'off',
+        },
+        'webhook + mcp ready',
+      );
+      resolve();
+    });
+  });
+  return server;
+}
+
+function isMcpPath(req: IncomingMessage): boolean {
+  const path = (req.url ?? '').split('?')[0];
+  return path === '/' || path === '/mcp';
+}
+
+export const WEBHOOK_BODY_MAX = 25 * 1024 * 1024;
+
+export class BodyTooLargeError extends Error {
+  constructor(readonly limit: number) {
+    super(`request body exceeds ${limit} bytes`);
+  }
+}
+
+export async function readBody(
+  req: IncomingMessage,
+  maxBytes: number,
+): Promise<Buffer> {
+  const chunks: Buffer[] = [];
+  let total = 0;
+  for await (const c of req) {
+    const buf = c as Buffer;
+    total += buf.length;
+    if (total > maxBytes) throw new BodyTooLargeError(maxBytes);
+    chunks.push(buf);
+  }
+  return Buffer.concat(chunks);
+}
+
+function flatHeaders(req: IncomingMessage): Record<string, string> {
+  return Object.fromEntries(
+    Object.entries(req.headers).map(([k, v]) => [
+      k,
+      Array.isArray(v) ? v.join(',') : (v ?? ''),
+    ]),
+  );
+}
+
+function parseBody(raw: Buffer): unknown {
+  const text = raw.toString('utf8');
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+async function handleWebhookPost(
+  req: IncomingMessage,
+  res: ServerResponse,
+  emit: Emit,
+  endpointId: string,
+  endpoint: Endpoint,
+): Promise<void> {
+  let raw: Buffer;
+  try {
+    raw = await readBody(req, WEBHOOK_BODY_MAX);
+  } catch (err) {
+    if (!(err instanceof BodyTooLargeError)) throw err;
+    log.warn({ endpoint: endpointId, limit: err.limit }, 'webhook body too large — rejecting');
+    res.writeHead(413).end('payload too large');
+    return;
+  }
+  const body = parseBody(raw);
+  emit(
+    webhookEntry(
+      endpoint,
+      flatHeaders(req),
+      body,
+      req.method ?? 'POST',
+      hookPath(endpointId),
+    ),
+  );
+  res.writeHead(200).end('ok');
+}
+
+function handleHealth(req: IncomingMessage, res: ServerResponse): boolean {
+  const reqPath = (req.url ?? '').split('?')[0];
+  if (reqPath !== '/health' && reqPath !== '/healthz') return false;
+  res.writeHead(200, { 'content-type': 'application/json' }).end(
+    JSON.stringify({
+      status: 'ok',
+      version: METRO_VERSION,
+      uptime: Math.round(process.uptime()),
+    }),
+  );
+  return true;
+}
+
+const HOOK_PATH =
+  /^\/api\/webhooks\/([0-9]{17,20})\/([A-Za-z0-9_-]{32,128})$/;
+
+const HOOK_PREFIX = '/api/webhooks/';
+
+const hookPath = (webhookId: string): string => `${HOOK_PREFIX}${webhookId}`;
+
+function hookTarget(
+  path: string,
+): { id: string; endpoint: Endpoint } | null {
+  const m = HOOK_PATH.exec(path);
+  const webhookId = m?.[1];
+  const token = m?.[2];
+  if (webhookId === undefined || token === undefined) return null;
+  const endpoint = findEndpointByWebhookId(webhookId);
+  if (!endpoint?.secret || !tokenMatches(endpoint.secret, token)) return null;
+  return { id: webhookId, endpoint };
+}
+
+async function handleWebhookRoute(
+  req: IncomingMessage,
+  res: ServerResponse,
+  emit: Emit,
+): Promise<boolean> {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (!path.startsWith(HOOK_PREFIX)) return false;
+  const target = hookTarget(path);
+  if (target === null) {
+    res.writeHead(404).end();
+    return true;
+  }
+  if (req.method === 'GET') {
+    res.writeHead(200).end(`metro webhook ${target.id} ready\n`);
+    return true;
+  }
+  if (req.method !== 'POST') {
+    res.writeHead(405).end();
+    return true;
+  }
+  await handleWebhookPost(req, res, emit, target.id, target.endpoint);
+  return true;
+}
+
+function handleSignInRoutes(
+  req: IncomingMessage,
+  res: ServerResponse,
+  apis: SessionApis,
+): boolean {
+  if (handleSiweAuthRequest(req, res, apis.siwe)) return true;
+  return apis.mode !== undefined && handleModeRequest(req, res, apis.mode);
+}
+
+async function handlePreMcpRoutes(
+  req: IncomingMessage,
+  res: ServerResponse,
+  emit: Emit,
+  apis: SessionApis,
+  monitorCall?: MonitorCall,
+): Promise<boolean> {
+  if (handleHealth(req, res)) return true;
+  if (handleSignInRoutes(req, res, apis)) return true;
+  if (handleSessionApis(req, res, apis)) return true;
+  if (handleUploadRequest(req, res)) return true;
+  if (handleAttachRequest(req, res)) return true;
+  if (apis.relayApi && handleRelayRequest(req, res, apis.relayApi)) return true;
+  if (await handleWebhookRoute(req, res, emit)) return true;
+  return Boolean(monitorCall && handleMonitorRequest(req, res, monitorCall));
+}
+
+async function handleRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  emit: Emit,
+  apis: SessionApis = {},
+  mcp?: McpHandler,
+  monitorCall?: MonitorCall,
+): Promise<void> {
+  if (await handlePreMcpRoutes(req, res, emit, apis, monitorCall)) return;
+  if (mcp && isMcpPath(req)) {
+    applyMcpCors(req, res);
+    if (handleMcpPreflight(req, res)) return;
+    await mcp(req, res);
+    return;
+  }
+  res.writeHead(404).end();
+}

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

@@ -0,0 +1,86 @@
+import { execFileSync } from 'node:child_process';
+import { errMsg, log } from './log.js';
+import { Line } from '../stations/lines.js';
+
+const TTL_MS = 5_000;
+type Cache = { id: string; at: number } | null;
+
+function memo(loader: () => string): () => string {
+  let cache: Cache = null;
+  return () => {
+    if (cache && Date.now() - cache.at < TTL_MS) return cache.id;
+    const id = loader();
+    cache = { id, at: Date.now() };
+    return id;
+  };
+}
+
+const claudeAccountId = memo(() => {
+  let raw: string;
+  try {
+    raw = execFileSync('claude', ['auth', 'status', '--json'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+  } catch (e) {
+    throw new Error(
+      `metro: failed to run 'claude auth status --json' — is Claude Code installed? (${errMsg(e)})`,
+    );
+  }
+  let p: { loggedIn?: boolean; orgId?: string };
+  try {
+    p = JSON.parse(raw) as { loggedIn?: boolean; orgId?: string };
+  } catch {
+    throw new Error(
+      `metro: 'claude auth status --json' returned non-JSON: ${raw.slice(0, 200)}`,
+    );
+  }
+  if (!p.loggedIn || !p.orgId)
+    throw new Error(
+      "metro: Claude Code is not logged in — run 'claude auth login'",
+    );
+  return p.orgId;
+});
+
+export const claudeUserId = (): string =>
+  process.env.METRO_USER_ID ?? claudeAccountId();
+
+export const claudeSessionId = (): string | null =>
+  process.env.METRO_USER_SESSION_ID ??
+  process.env.CLAUDE_CODE_SESSION_ID ??
+  null;
+
+export function userSelf(): Line {
+  const explicit = process.env.METRO_FROM;
+  if (explicit) return explicit as Line;
+  if (!process.env.CLAUDECODE) return 'metro://user' as Line;
+  try {
+    return Line.user('claude', claudeUserId());
+  } catch (e) {
+    log.warn(
+      { reason: errMsg(e) },
+      'could not resolve a Claude account id; relaying as metro://user',
+    );
+    return 'metro://user' as Line;
+  }
+}
+
+export function daemonSelf(): Line {
+  const explicit = process.env.METRO_FROM ?? process.env.METRO_SELF_URI;
+  return (explicit ?? 'metro://user') as Line;
+}
+
+export function selfLine(): Line | null {
+  if (!process.env.CLAUDECODE) return null;
+  const s = claudeSessionId();
+  if (!s) return null;
+  try {
+    return Line.claude(claudeUserId(), s);
+  } catch (e) {
+    log.warn(
+      { reason: errMsg(e) },
+      'could not resolve a Claude account id; relaying with no self line',
+    );
+    return null;
+  }
+}

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

@@ -0,0 +1,67 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from './log.js';
+import {
+  apiFailure,
+  apiSession,
+  bodyField,
+  cors,
+  readJsonBody,
+  sendJson,
+} from './api-http.js';
+import { parsePairingCode } from './agent-import.js';
+import type { CreatedAgent } from '../db/agent-admin.js';
+
+const PATH = '/api/agents/import';
+
+export interface ImportedAgent extends CreatedAgent {
+  stations: number;
+}
+
+export interface ImportApiDeps {
+  importAgent: (subject: string, code: string) => Promise<ImportedAgent>;
+}
+
+async function handle(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ImportApiDeps,
+  subject: string,
+): Promise<void> {
+  try {
+    const code = parsePairingCode(bodyField(await readJsonBody(req), 'code'));
+    const made = await deps.importAgent(subject, code);
+    log.info(
+      { agent: made.name, id: made.id, stations: made.stations },
+      'import-api: agent imported from metro',
+    );
+    sendJson(req, res, 201, made);
+  } catch (err) {
+    apiFailure(req, res, err, 'import-api');
+  }
+}
+
+export function handleImportRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ImportApiDeps,
+): boolean {
+  if ((req.url ?? '').split('?')[0] !== PATH) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== 'POST') {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  const session = apiSession(req);
+  if (!session) {
+    sendJson(req, res, 401, { error: 'unauthorized' });
+    return true;
+  }
+  handle(req, res, deps, session.subject).catch((err: unknown) => {
+    log.warn({ err: errMsg(err) }, 'import-api: unhandled error');
+    if (!res.headersSent) sendJson(req, res, 500, { error: 'import failed' });
+  });
+  return true;
+}

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

@@ -0,0 +1,56 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from './log.js';
+import { apiSession, cors, sendJson } from './api-http.js';
+import type { HostedConnector } from './hosted-connectors.js';
+
+const PATH = '/api/connectors';
+
+export interface LocalConnectorsDeps {
+  listConnectors: (subject: string) => Promise<HostedConnector[]>;
+}
+
+const payload = (c: HostedConnector): Record<string, unknown> => ({
+  id: c.id,
+  name: c.name,
+  url: c.url,
+  transport: c.transport,
+  auth: c.signIn === null ? 'none' : 'oauth',
+  header: null,
+  signIn: c.signIn,
+  verified: null,
+  managed: 'metro.box',
+});
+
+export function handleLocalConnectorsRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: LocalConnectorsDeps,
+): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (path !== PATH && !path.startsWith(`${PATH}/`)) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (path !== PATH || req.method !== 'GET') {
+    sendJson(req, res, path === PATH ? 405 : 404, {
+      error: 'connectors are managed on metro.box, not on a local daemon',
+    });
+    return true;
+  }
+  const session = apiSession(req);
+  if (!session) {
+    sendJson(req, res, 401, { error: 'unauthorized' });
+    return true;
+  }
+  deps
+    .listConnectors(session.subject)
+    .then((list) => {
+      sendJson(req, res, 200, { connectors: list.map(payload) });
+    })
+    .catch((err: unknown) => {
+      log.warn({ err: errMsg(err) }, 'local connectors: request failed');
+      if (!res.headersSent) sendJson(req, res, 500, { error: 'connectors failed' });
+    });
+  return true;
+}