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

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

@@ -1,150 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { errMsg, log } from './log.js';
-import {
-  apiFailure,
-  apiSession,
-  bodyField,
-  cors,
-  readJsonBody,
-  sendJson,
-  type ApiSession,
-} from './api-http.js';
-import { parseId } from '../db/ids.js';
-import type { AgentConnectors } from '../db/agent-connectors.js';
-
-const PREFIX = '/api/agents';
-
-export interface AgentConnectorApiDeps {
-  agentConnectors: (email: string, agentId: string) => Promise<AgentConnectors>;
-  addConnector: (
-    email: string,
-    agentId: string,
-    connectorId: string,
-  ) => Promise<AgentConnectors>;
-  removeConnector: (
-    email: string,
-    agentId: string,
-    connectorId: string,
-  ) => Promise<AgentConnectors>;
-  mintCode: (
-    email: string,
-    agentId: string,
-  ) => Promise<{ code: string; expiresAt: number; agent: string }>;
-}
-
-type Routable =
-  | { kind: 'connectors'; id: string }
-  | { kind: 'connector'; id: string; connectorId: string }
-  | { kind: 'code'; id: string };
-
-type Target = Routable | { kind: 'unknown' } | null;
-
-const ALLOWED: Record<Routable['kind'], string[]> = {
-  connectors: ['GET', 'POST'],
-  connector: ['DELETE'],
-  code: ['POST'],
-};
-
-function connectorTarget(id: string, rest: string[]): Target {
-  if (rest.length === 1) return { kind: 'connectors', id };
-  if (rest.length > 2) return { kind: 'unknown' };
-  const connectorId = parseId(rest[1] ?? '');
-  return connectorId === null
-    ? { kind: 'unknown' }
-    : { kind: 'connector', id, connectorId };
-}
-
-export function target(path: string): Target {
-  if (!path.startsWith(`${PREFIX}/`)) return null;
-  const segments = path.slice(PREFIX.length + 1).split('/').filter(Boolean);
-  const id = parseId(segments[0] ?? '');
-  const head = segments[1];
-  if (id === null || head === undefined) return null;
-  if (head === 'connectors') return connectorTarget(id, segments.slice(1));
-  if (head === 'code' && segments.length === 2) return { kind: 'code', id };
-  return null;
-}
-
-async function handleConnectors(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AgentConnectorApiDeps,
-  session: ApiSession,
-  id: string,
-): Promise<void> {
-  if (req.method === 'GET') {
-    sendJson(req, res, 200, await deps.agentConnectors(session.email, id));
-    return;
-  }
-  const connectorId = bodyField(await readJsonBody(req), 'connectorId');
-  if (typeof connectorId !== 'string' || parseId(connectorId) === null) {
-    sendJson(req, res, 400, { error: 'connectorId is required' });
-    return;
-  }
-  sendJson(req, res, 200, await deps.addConnector(session.email, id, connectorId));
-}
-
-async function handleCode(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AgentConnectorApiDeps,
-  session: ApiSession,
-  id: string,
-): Promise<void> {
-  const minted = await deps.mintCode(session.email, id);
-  log.info({ agent: id, email: session.email }, 'agent-api: minted pairing code');
-  sendJson(req, res, 201, minted);
-}
-
-async function route(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AgentConnectorApiDeps,
-  session: ApiSession,
-  tgt: Routable,
-): Promise<void> {
-  try {
-    if (tgt.kind === 'connectors') await handleConnectors(req, res, deps, session, tgt.id);
-    else if (tgt.kind === 'code') await handleCode(req, res, deps, session, tgt.id);
-    else
-      sendJson(
-        req,
-        res,
-        200,
-        await deps.removeConnector(session.email, tgt.id, tgt.connectorId),
-      );
-  } catch (err) {
-    apiFailure(req, res, err, 'agent-api');
-  }
-}
-
-export function handleAgentConnectorRequest(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AgentConnectorApiDeps,
-): boolean {
-  const tgt = target((req.url ?? '').split('?')[0] ?? '');
-  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 connector' });
-    return true;
-  }
-  if (!ALLOWED[tgt.kind].includes(req.method ?? '')) {
-    sendJson(req, res, 405, { error: 'method not allowed' });
-    return true;
-  }
-  const session = apiSession(req);
-  if (!session) {
-    sendJson(req, res, 401, { error: 'unauthorized' });
-    return true;
-  }
-  route(req, res, deps, session, tgt).catch((err: unknown) => {
-    log.warn({ err: errMsg(err) }, 'agent-api: unhandled error');
-    if (!res.headersSent) sendJson(req, res, 500, { error: 'agent api failed' });
-  });
-  return true;
-}

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

@@ -1,20 +0,0 @@
-import { makeCodeStore } from './pair-codes.js';
-
-export interface AgentCode {
-  email: string;
-  agentId: string;
-}
-
-const store = makeCodeStore<AgentCode>('ma');
-
-export const AGENT_CODE_RE = store.pattern;
-
-export const mintAgentCode = (
-  entry: AgentCode,
-  now?: number,
-): { code: string; expiresAt: number } => store.mint(entry, now);
-
-export const takeAgentCode = (code: string, now?: number): AgentCode | undefined =>
-  store.take(code, now);
-
-export const agentCodeCount = (): number => store.count();

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

@@ -1,152 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { ApiError } from './api-error.js';
-import { errMsg, log } from './log.js';
-import {
-  verifyAgentToken,
-  verifyRunToken,
-  verifySession,
-  type AgentClaims,
-  type RunClaims,
-} from './session.js';
-import { extractToken } from '../mcp/request-identity.js';
-
-const BODY_MAX = 4 * 1024;
-const DRAIN_MAX = 2 * BODY_MAX;
-
-export interface ApiSession {
-  email: string;
-}
-
-export function cors(req: IncomingMessage): Record<string, string> {
-  return {
-    'access-control-allow-origin': req.headers.origin ?? '*',
-    'access-control-allow-methods': 'GET, POST, PUT, DELETE, OPTIONS',
-    'access-control-allow-headers': 'Authorization, Content-Type',
-    'access-control-max-age': '86400',
-    vary: 'Origin',
-  };
-}
-
-export function sendJson(
-  req: IncomingMessage,
-  res: ServerResponse,
-  status: number,
-  body: unknown,
-): void {
-  res.writeHead(status, {
-    'content-type': 'application/json',
-    'cache-control': 'no-store',
-    ...cors(req),
-  });
-  res.end(JSON.stringify(body));
-}
-
-export function apiSession(req: IncomingMessage): ApiSession | null {
-  const secret = process.env.METRO_SESSION_SECRET?.trim() ?? '';
-  if (secret === '') return null;
-  const token = extractToken(req) ?? '';
-  if (token === '') return null;
-  try {
-    const { email } = verifySession(token, secret);
-    return { email: email.toLowerCase() };
-  } catch {
-    return null;
-  }
-}
-
-export function runIdentity(req: IncomingMessage): RunClaims | null {
-  const secret = process.env.METRO_SESSION_SECRET?.trim() ?? '';
-  if (secret === '') return null;
-  const token = extractToken(req) ?? '';
-  if (token === '') return null;
-  try {
-    const claims = verifyRunToken(token, secret);
-    return { ...claims, email: claims.email.toLowerCase() };
-  } catch {
-    return null;
-  }
-}
-
-export interface AgentIdentity extends AgentClaims {
-  runtimeId?: string;
-}
-
-export function agentIdentity(req: IncomingMessage): AgentIdentity | null {
-  const secret = process.env.METRO_SESSION_SECRET?.trim() ?? '';
-  if (secret === '') return null;
-  const token = extractToken(req) ?? '';
-  if (token === '') return null;
-  try {
-    const { email, agentId } = verifyAgentToken(token, secret);
-    return { email: email.toLowerCase(), agentId };
-  } catch {
-    const run = runIdentity(req);
-    if (run === null) return null;
-    return { email: run.email, agentId: run.agentId, runtimeId: run.runtimeId };
-  }
-}
-
-export type Fence = (runtimeId: string, agentId: string) => Promise<void>;
-
-const RELEASED = 'this machine no longer holds the agent';
-
-export async function assertLease(
-  who: AgentIdentity,
-  fence: Fence,
-): Promise<void> {
-  if (who.runtimeId === undefined) return;
-  try {
-    await fence(who.runtimeId, who.agentId);
-  } catch (err) {
-    if (err instanceof ApiError) throw new ApiError(RELEASED, 401);
-    throw err;
-  }
-}
-
-export function projectParam(req: IncomingMessage): string | null {
-  const raw = new URL(req.url ?? '/', 'http://localhost').searchParams.get(
-    'project',
-  );
-  return raw === null || raw === '' ? null : raw;
-}
-
-export async function readJsonBody(req: IncomingMessage): Promise<unknown> {
-  const chunks: Buffer[] = [];
-  let total = 0;
-  let over = false;
-  for await (const c of req) {
-    const buf = c as Buffer;
-    total += buf.length;
-    if (total > BODY_MAX) over = true;
-    if (!over) chunks.push(buf);
-    else if (total > DRAIN_MAX) break;
-  }
-  if (over) throw new ApiError('request body too large', 413);
-  const raw = Buffer.concat(chunks).toString('utf8').trim();
-  if (raw === '') return {};
-  try {
-    return JSON.parse(raw);
-  } catch {
-    throw new ApiError('body must be JSON', 400);
-  }
-}
-
-export function apiFailure(
-  req: IncomingMessage,
-  res: ServerResponse,
-  err: unknown,
-  label = 'agent-api',
-): void {
-  if (err instanceof ApiError) {
-    sendJson(req, res, err.status, { error: err.message });
-    return;
-  }
-  log.warn({ err: errMsg(err) }, `${label}: request failed`);
-  if (!res.headersSent) sendJson(req, res, 500, { error: `${label} failed` });
-}
-
-export function bodyField(body: unknown, key: string): unknown {
-  return typeof body === 'object' && body !== null && !Array.isArray(body)
-    ? (body as Record<string, unknown>)[key]
-    : undefined;
-}

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

@@ -1,330 +0,0 @@
-import type { ProjectApiDeps } from './project-api.js';
-import { join } from 'node:path';
-import { type Server } from 'node:http';
-import { selfLine, userSelf } from './events.js';
-import { setTrainCallBackend } from './train-call.js';
-import { errMsg, log, logFatalSync } from './log.js';
-import { acquireLock, loadMetroEnv, STATE_DIR } from './paths.js';
-import { installCrashGuard, markDaemonReady } from './crash-guard.js';
-import {
-  loadTunnelConfig,
-  Tunnel,
-  warnOnLegacyWebhooks,
-  webhookPort,
-} from './tunnel.js';
-import { TrainSupervisor, TRAINS_DIR } from './supervisor.js';
-import {
-  makeEmit,
-  startWebhookServer,
-  trainEventToMetroEvent,
-} from './http.js';
-import { type RunApiDeps } from './run-api.js';
-import {
-  claimRuntime,
-  fenceRuntime,
-  runtimeLabels,
-  touchRuntime,
-} from '../db/runtimes.js';
-import {
-  blockedStationsFor,
-  mintAgentCodeForEmail,
-  releaseRuntimeForEmail,
-} from '../db/runtime-admin.js';
-import { loadAgentForRuntime, localAgentKey } from '../db/materialize.js';
-import {
-  agentLiveness,
-  closeAgentSession,
-  createMetroMcp,
-} from '../mcp/index.js';
-import { metroCall } from '../mcp/ctx.js';
-import { gatherAccountsForAgents } from '../mcp/accounts.js';
-import {
-  accountStationCapabilities,
-  stationByName,
-} from '../stations/registry.js';
-import { prepareAccount } from '../stations/attach.js';
-import {
-  materializeFrom,
-  materializeFromDb,
-  reloadAccountsFromDb,
-  reloadFrom,
-} from '../db/materialize.js';
-import {
-  httpSource,
-  runtimeConfigFromEnv,
-  startRuntimePoller,
-} from './runtime-source.js';
-import {  createAgentForEmail,  deleteAgentForEmail,  listAgentsForEmail,  ownedAgentOrThrow,  resetAgentKeyForEmail,    type ResetAgentKey,} from '../db/agent-admin.js';
-import {
-  attachAccountToAgent,
-  detachAccountFromAgent,
-} from '../db/account-attach.js';
-import {
-  createConnectorForEmail,
-  createPendingConnectorForEmail,
-  deleteConnectorForEmail,
-  disconnectConnectorForEmail,
-  connectorNamesByIds,
-  getConnectorForEmail,
-  listConnectorsForEmail,
-  renameConnectorForEmail,
-  reconnectConnectorForEmail,
-  verifyConnectorForEmail,
-} from '../db/connectors.js';
-import { relayTarget } from '../db/connector-relay.js';
-import {
-  addMemberForEmail,
-  createProjectForEmail,
-  deleteProjectForEmail,
-  listMembersForEmail,
-  listProjectsForEmail,
-  removeMemberForEmail,
-  renameProjectForEmail,
-  setMemberRoleForEmail,
-} from '../db/projects.js';
-import {
-  addConnectorToAgentForEmail,
-  agentConnectorsForEmail,
-  connectorIdsByAgent,
-  removeConnectorFromAgentForEmail,
-} from '../db/agent-connectors.js';
-import type { AgentConnectorApiDeps } from './agent-connector-api.js';
-import type { StationName } from '../db/schema.js';
-import { AttachSessions } from './attach-session.js';
-import { startUploadReaper } from './upload-store.js';
-import type { AgentApiDeps } from './agent-api.js';
-import type { ConnectorApiDeps } from './connector-api.js';
-
-installCrashGuard();
-loadMetroEnv();
-acquireLock(join(STATE_DIR, '.tail-lock'));
-
-const self = userSelf();
-log.info({ self, line: selfLine() }, 'user identity');
-
-process.stdout.on('error', (err) => {
-  if ((err as NodeJS.ErrnoException).code !== 'EPIPE')
-    log.warn({ err: errMsg(err) }, 'stdout error');
-});
-
-const supervisor = new TrainSupervisor();
-const emit = makeEmit();
-
-supervisor.onTrainEvent((env, train) => {
-  const entry = trainEventToMetroEvent(env, train);
-  if (entry) emit(entry);
-});
-
-let webhookServer: Server | null = null;
-const tunnelCfg = loadTunnelConfig();
-const tunnel = tunnelCfg ? new Tunnel(tunnelCfg, webhookPort()) : null;
-
-setTrainCallBackend((train, action, args) =>
-  supervisor.call(train, action, args),
-);
-
-const runtime = runtimeConfigFromEnv();
-const localSource = runtime === null ? null : httpSource(runtime);
-
-function announceLocalEndpoint(): void {
-  const key = localAgentKey();
-  if (key === null) {
-    log.warn('this agent has no key — reset it in the web UI to connect an agent');
-    return;
-  }
-  const url = `http://127.0.0.1:${String(webhookPort())}/mcp?token=${key}`;
-  process.stderr.write(
-    `\nConnect an agent on this machine:\n\n  claude mcp add --transport http metro "${url}"\n\n`,
-  );
-}
-
-async function applyStations(removed: StationName[]): Promise<void> {
-  for (const station of removed) await supervisor.stopTrain(station);
-}
-
-async function syncLocal(): Promise<void> {
-  if (localSource === null) return;
-  const { removed, changed } = await reloadFrom(localSource);
-  await applyStations(removed);
-  for (const station of changed) supervisor.requestReload(station);
-}
-
-async function stopLocalStations(): Promise<void> {
-  for (const station of supervisor.running()) await supervisor.stopTrain(station);
-}
-
-async function syncStations(station: StationName): Promise<void> {
-  const { removed } = await reloadAccountsFromDb();
-  if (stationByName(station)?.hasTrain === false) return;
-  if (removed.includes(station)) await supervisor.stopTrain(station);
-  else supervisor.requestReload(station);
-}
-
-const attachSessions = new AttachSessions({
-  authorize: async (owner) => {
-    await ownedAgentOrThrow(owner.email, owner.agentId);
-  },
-  complete: async (owner, station, config) => {
-    const ref = await attachAccountToAgent(
-      owner.email,
-      owner.agentId,
-      station,
-      config,
-    );
-    const activated = await syncStations(station).then(
-      () => true,
-      (err: unknown) => {
-        log.warn(
-          { station, err: errMsg(err) },
-          'attach-session: station reload failed, the change lands at the next boot',
-        );
-        return false;
-      },
-    );
-    return { accountId: ref.accountId, activated };
-  },
-});
-
-async function resetAgentKey(
-  email: string,
-  id: string,
-): Promise<ResetAgentKey> {
-  const reset = await resetAgentKeyForEmail(email, id);
-  const closed = await closeAgentSession(id);
-  log.info(
-    { agent: reset.name, id: reset.id, sessionClosed: closed },
-    'agent-api: key rotated, live session dropped',
-  );
-  return reset;
-}
-
-const agentApi: AgentApiDeps = {
-  attachSessions,
-  listAgents: listAgentsForEmail,
-  createAgent: createAgentForEmail,
-  deleteAgent: deleteAgentForEmail,
-  resetKey: resetAgentKey,
-  gatherAccounts: gatherAccountsForAgents,
-  capabilities: accountStationCapabilities,
-  liveness: agentLiveness,
-  releaseRuntime: releaseRuntimeForEmail,
-  connectorIds: connectorIdsByAgent,
-  runtimes: runtimeLabels,
-  prepareAccount,
-  attachAccount: attachAccountToAgent,
-  detachAccount: detachAccountFromAgent,
-  syncStations,
-};
-
-const runApi: RunApiDeps = {
-  claimRuntime,
-  fenceRuntime,
-  touchRuntime,
-  loadAgent: loadAgentForRuntime,
-  blockedStations: blockedStationsFor,
-};
-
-const agentConnectorApi: AgentConnectorApiDeps = {
-  agentConnectors: agentConnectorsForEmail,
-  addConnector: addConnectorToAgentForEmail,
-  removeConnector: removeConnectorFromAgentForEmail,
-  mintCode: mintAgentCodeForEmail,
-};
-
-const projectApi: ProjectApiDeps = {
-  listProjects: listProjectsForEmail,
-  createProject: createProjectForEmail,
-  renameProject: renameProjectForEmail,
-  deleteProject: deleteProjectForEmail,
-  listMembers: listMembersForEmail,
-  addMember: addMemberForEmail,
-  setMemberRole: setMemberRoleForEmail,
-  removeMember: removeMemberForEmail,
-};
-
-const connectorApi: ConnectorApiDeps = {
-  listConnectors: listConnectorsForEmail,
-  connectorNamesByIds,
-  agentConnectors: agentConnectorsForEmail,
-  fenceRuntime,
-  renameConnector: renameConnectorForEmail,
-  createConnector: createConnectorForEmail,
-  createPendingConnector: createPendingConnectorForEmail,
-  reconnectConnector: reconnectConnectorForEmail,
-  getConnector: getConnectorForEmail,
-  verifyConnector: verifyConnectorForEmail,
-  disconnectConnector: disconnectConnectorForEmail,
-  deleteConnector: deleteConnectorForEmail,
-};
-
-async function main(): Promise<void> {
-  if (localSource === null) await materializeFromDb();
-  else await materializeFrom(localSource);
-  warnOnLegacyWebhooks();
-  supervisor.start();
-  const metroMcp = await createMetroMcp();
-  webhookServer = await startWebhookServer(
-    emit,
-    {
-      agentApi,
-      agentConnectorApi,
-      connectorApi,
-      projectApi,
-      runApi,
-      relayApi: { target: relayTarget, fence: fenceRuntime },
-    },
-    metroMcp.httpHandler,
-    metroCall,
-  );
-  metroMcp.startInbound();
-  startUploadReaper();
-  if (localSource !== null) {
-    startRuntimePoller({ sync: syncLocal, stopAll: stopLocalStations });
-    announceLocalEndpoint();
-  }
-  tunnel?.start();
-  log.info(
-    { tunnel: !!tunnel, trainsDir: TRAINS_DIR, mcp: '/' },
-    'dispatcher ready',
-  );
-  markDaemonReady();
-}
-
-const SHUTDOWN_TIMEOUT_MS = 3_000;
-let shuttingDown = false;
-async function shutdown(): Promise<void> {
-  if (shuttingDown) return;
-  shuttingDown = true;
-  log.info('dispatcher shutting down');
-  tunnel?.stop();
-  if (webhookServer) {
-    const server = webhookServer;
-    await Promise.race([
-      new Promise<void>((r) => {
-        server.close(() => {
-          r();
-        });
-      }),
-      new Promise<void>((r) => {
-        setTimeout(r, SHUTDOWN_TIMEOUT_MS).unref();
-      }),
-    ]);
-  }
-  await attachSessions.stop();
-  await supervisor.stop();
-  process.exit(0);
-}
-const onShutdown = (): void => {
-  shutdown().catch((err: unknown) => {
-    log.error({ err: errMsg(err) }, 'dispatcher: shutdown failed');
-    process.exit(1);
-  });
-};
-if (process.env.METRO_STDIN_SHUTDOWN === '1')
-  process.stdin.on('end', onShutdown).on('close', onShutdown);
-for (const sig of ['SIGINT', 'SIGTERM'] as const) process.on(sig, onShutdown);
-
-await main().catch((err: unknown) => {
-  logFatalSync({ err: errMsg(err) }, 'dispatcher failed to start');
-  process.exit(1);
-});