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

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

@@ -0,0 +1,383 @@
+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,
+  isLocalMode,
+  loadMetroEnv,
+  STATE_DIR,
+  trainsDir,
+} from './paths.js';
+import { installCrashGuard, markDaemonReady } from './crash-guard.js';
+import {
+  loadTunnelConfig,
+  Tunnel,
+  tunnelConfigFromEnv,
+  warnOnLegacyWebhooks,
+  webhookPort,
+} from './tunnel.js';
+import {
+  localConnectHint,
+  publicConnectHint,
+  tunnelPendingHint,
+} from './connect-hint.js';
+import { TrainSupervisor } 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,
+  mintAgentCodeForUser,
+  releaseRuntimeForUser,
+} from '../db/runtime-admin.js';
+import { loadAgentForRuntime, localAgentKey } from '../db/materialize.js';
+import { fileSource } from '../db/file-source.js';
+import { ensureLocalSessionSecret } from './local-secret.js';
+import { localSessionApis } from './local-mode.js';
+import type { ModeInfo } from './mode-api.js';
+import type { SessionApis } from './session-apis.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,
+  type ReloadedStations,
+} from '../db/materialize.js';
+import {
+  httpSource,
+  runtimeConfigFromEnv,
+  startRuntimePoller,
+} from './runtime-source.js';
+import {  createAgentForUser,  deleteAgentForUser,  listAgentsForUser,  ownedAgentOrThrow,  resetAgentKeyForUser,    type ResetAgentKey,} from '../db/agent-admin.js';
+import {
+  attachAccountToAgent,
+  detachAccountFromAgent,
+} from '../db/account-attach.js';
+import {
+  createConnectorForUser,
+  createPendingConnectorForUser,
+  deleteConnectorForUser,
+  disconnectConnectorForUser,
+  connectorNamesByIds,
+  connectorSummariesByIds,
+  getConnectorForUser,
+  listConnectorsForUser,
+  renameConnectorForUser,
+  reconnectConnectorForUser,
+  verifyConnectorForUser,
+} from '../db/connectors.js';
+import { relayTarget } from '../db/connector-relay.js';
+import {
+  addMemberForUser,
+  createProjectForUser,
+  deleteProjectForUser,
+  listMembersForUser,
+  listProjectsForUser,
+  removeMemberForUser,
+  renameProjectForUser,
+  setMemberRoleForUser,
+} from '../db/projects.js';
+import {
+  addConnectorToAgentForUser,
+  agentConnectorsForUser,
+  connectorIdsByAgent,
+  removeConnectorFromAgentForUser,
+} 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() ?? tunnelConfigFromEnv();
+const tunnel = tunnelCfg ? new Tunnel(tunnelCfg, webhookPort(), announcePublic) : null;
+
+function announcePublic(url: string): void {
+  process.stderr.write(`\n${publicConnectHint(url)}`);
+}
+
+setTrainCallBackend((train, action, args) =>
+  supervisor.call(train, action, args),
+);
+
+const runtime = runtimeConfigFromEnv();
+const linkedSource = runtime === null ? null : httpSource(runtime);
+const localSource = linkedSource ?? (isLocalMode() ? fileSource : null);
+
+function announceLocalEndpoint(): void {
+  if (isLocalMode())
+    process.stderr.write(
+      `\n${tunnel === null ? localConnectHint(webhookPort()) : tunnelPendingHint()}`,
+    );
+  const key = localAgentKey();
+  if (key === null) {
+    if (isLocalMode()) log.info('no agent on this machine yet');
+    else 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);
+}
+
+const reloadStations = (): Promise<ReloadedStations> =>
+  localSource === null ? reloadAccountsFromDb() : reloadFrom(localSource);
+
+async function syncStations(station: StationName): Promise<void> {
+  const { removed } = await reloadStations();
+  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.subject, owner.agentId);
+  },
+  complete: async (owner, station, config) => {
+    const ref = await attachAccountToAgent(
+      owner.subject,
+      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(
+  subject: string,
+  id: string,
+): Promise<ResetAgentKey> {
+  const reset = await resetAgentKeyForUser(subject, 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: listAgentsForUser,
+  createAgent: createAgentForUser,
+  deleteAgent: deleteAgentForUser,
+  resetKey: resetAgentKey,
+  gatherAccounts: gatherAccountsForAgents,
+  capabilities: accountStationCapabilities,
+  liveness: agentLiveness,
+  releaseRuntime: releaseRuntimeForUser,
+  connectorIds: connectorIdsByAgent,
+  runtimes: runtimeLabels,
+  prepareAccount,
+  attachAccount: attachAccountToAgent,
+  detachAccount: detachAccountFromAgent,
+  syncStations,
+};
+
+const runApi: RunApiDeps = {
+  claimRuntime,
+  fenceRuntime,
+  touchRuntime,
+  loadAgent: loadAgentForRuntime,
+  blockedStations: blockedStationsFor,
+};
+
+const agentConnectorApi: AgentConnectorApiDeps = {
+  agentConnectors: agentConnectorsForUser,
+  addConnector: addConnectorToAgentForUser,
+  removeConnector: removeConnectorFromAgentForUser,
+  mintCode: mintAgentCodeForUser,
+};
+
+const projectApi: ProjectApiDeps = {
+  listProjects: listProjectsForUser,
+  createProject: createProjectForUser,
+  renameProject: renameProjectForUser,
+  deleteProject: deleteProjectForUser,
+  listMembers: listMembersForUser,
+  addMember: addMemberForUser,
+  setMemberRole: setMemberRoleForUser,
+  removeMember: removeMemberForUser,
+};
+
+const connectorApi: ConnectorApiDeps = {
+  listConnectors: listConnectorsForUser,
+  connectorNamesByIds,
+  connectorSummariesByIds,
+  agentConnectors: agentConnectorsForUser,
+  fenceRuntime,
+  renameConnector: renameConnectorForUser,
+  createConnector: createConnectorForUser,
+  createPendingConnector: createPendingConnectorForUser,
+  reconnectConnector: reconnectConnectorForUser,
+  getConnector: getConnectorForUser,
+  verifyConnector: verifyConnectorForUser,
+  disconnectConnector: disconnectConnectorForUser,
+  deleteConnector: deleteConnectorForUser,
+};
+
+const hostedMode = (): ModeInfo => ({
+  mode: linkedSource === null ? 'hosted' : 'linked',
+  owner: null,
+  project: null,
+});
+
+function sessionApis(): SessionApis {
+  if (isLocalMode())
+    return localSessionApis({
+      syncStations,
+      closeAgentSession,
+      gatherAccounts: gatherAccountsForAgents,
+      capabilities: accountStationCapabilities,
+      liveness: agentLiveness,
+      prepareAccount,
+    });
+  return {
+    agentApi,
+    agentConnectorApi,
+    connectorApi,
+    projectApi,
+    runApi,
+    relayApi: { target: relayTarget, fence: fenceRuntime },
+    mode: hostedMode,
+  };
+}
+
+async function main(): Promise<void> {
+  if (isLocalMode()) ensureLocalSessionSecret();
+  if (localSource === null) await materializeFromDb();
+  else await materializeFrom(localSource, { allowEmpty: linkedSource === null });
+  warnOnLegacyWebhooks();
+  supervisor.start();
+  const metroMcp = await createMetroMcp();
+  webhookServer = await startWebhookServer(
+    emit,
+    sessionApis(),
+    metroMcp.httpHandler,
+    metroCall,
+  );
+  metroMcp.startInbound();
+  startUploadReaper();
+  if (linkedSource !== null)
+    startRuntimePoller({ sync: syncLocal, stopAll: stopLocalStations });
+  if (localSource !== null) announceLocalEndpoint();
+  tunnel?.start();
+  log.info(
+    { tunnel: !!tunnel, trainsDir: trainsDir(), 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);
+});

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

@@ -0,0 +1,143 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { log } from './log.js';
+import {
+  agentIdentity,
+  apiFailure,
+  assertLease,
+  bodyField,
+  cors,
+  readJsonBody,
+  sendJson,
+} from './api-http.js';
+import { extractToken } from '../mcp/request-identity.js';
+import { publicBaseOrDefault } from './attach-serve.js';
+import { AGENT_CODE_RE, takeAgentCode } from './agent-pair.js';
+import { relayServersJson } from './connector-json.js';
+import { sessionTtlFromEnv } from './session-config.js';
+import { signAgentToken } from './session.js';
+import type { ConnectorApiDeps } from './connector-api.js';
+
+const CLAIM_PATH = '/api/cli/claim';
+const MCP_PATH = '/api/cli/mcp';
+const SESSION_PATH = '/api/cli/session';
+const CONNECTORS_PATH = '/api/cli/connectors';
+
+const ALLOWED: Record<string, string> = {
+  [CLAIM_PATH]: 'POST',
+  [MCP_PATH]: 'GET',
+  [SESSION_PATH]: 'GET',
+  [CONNECTORS_PATH]: 'GET',
+};
+
+function secretOrNull(): string | null {
+  const secret = process.env.METRO_SESSION_SECRET?.trim() ?? '';
+  return secret === '' ? null : secret;
+}
+
+async function handleClaim(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ConnectorApiDeps,
+): Promise<void> {
+  const secret = secretOrNull();
+  if (secret === null) {
+    sendJson(req, res, 503, { error: 'sign-in is not configured' });
+    return;
+  }
+  const raw = bodyField(await readJsonBody(req), 'code');
+  const code = typeof raw === 'string' ? raw.trim() : '';
+  if (!AGENT_CODE_RE.test(code)) {
+    sendJson(req, res, 400, {
+      error:
+        'that does not look like an agent code — metro login wants the ma_… code from the agent page',
+    });
+    return;
+  }
+  const taken = takeAgentCode(code);
+  if (taken === undefined) {
+    sendJson(req, res, 400, {
+      error: 'that code has expired or was already used',
+    });
+    return;
+  }
+  const agent = await deps.agentConnectors(taken.subject, taken.agentId);
+  const token = signAgentToken(
+    { subject: taken.subject, agentId: agent.id },
+    secret,
+    { ttlSec: sessionTtlFromEnv() },
+  );
+  log.info({ subject: taken.subject, agent: agent.id }, 'cli: code claimed');
+  sendJson(req, res, 200, {
+    token,
+    email: taken.subject,
+    subject: taken.subject,
+    agent: agent.name,
+  });
+}
+
+async function handleRead(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ConnectorApiDeps,
+  path: string,
+): Promise<void> {
+  const who = agentIdentity(req);
+  if (who === null) {
+    sendJson(req, res, 401, { error: 'unauthorized' });
+    return;
+  }
+  await assertLease(who, deps.fenceRuntime);
+  const agent = await deps.agentConnectors(who.subject, who.agentId);
+  if (path === SESSION_PATH) {
+    sendJson(req, res, 200, {
+      email: who.subject,
+      subject: who.subject,
+      agent: agent.name,
+    });
+    return;
+  }
+  if (path === CONNECTORS_PATH) {
+    sendJson(req, res, 200, {
+      agent: agent.name,
+      connectors: await deps.connectorSummariesByIds(agent.connectorIds),
+    });
+    return;
+  }
+  const entries = await deps.connectorNamesByIds(agent.connectorIds);
+  const json = relayServersJson(
+    entries,
+    publicBaseOrDefault(),
+    extractToken(req) ?? '',
+  );
+  sendJson(req, res, 200, { json, agent: agent.name });
+}
+
+export function handleCliPairRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ConnectorApiDeps,
+): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  const method = ALLOWED[path];
+  if (method === undefined) {
+    if (!path.startsWith('/api/cli/') && path !== '/api/cli') return false;
+    sendJson(req, res, 404, { error: 'no such route' });
+    return true;
+  }
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== method) {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  const work =
+    path === CLAIM_PATH
+      ? handleClaim(req, res, deps)
+      : handleRead(req, res, deps, path);
+  work.catch((err: unknown) => {
+    apiFailure(req, res, err, 'cli');
+  });
+  return true;
+}

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

@@ -0,0 +1,33 @@
+import { hostname } from 'node:os';
+
+const uiBase = (): string => process.env.METRO_UI_URL ?? 'https://metro.box';
+
+export const connectLink = (base: string): string =>
+  `${uiBase()}/#/connect/${encodeURIComponent(base)}`;
+
+export function localConnectHint(port: number): string {
+  const here = `http://127.0.0.1:${String(port)}`;
+  const forward = `ssh -L ${String(port)}:127.0.0.1:${String(port)} ${hostname()}`;
+  return [
+    'Manage this machine from the web UI:',
+    '',
+    `  ${connectLink(here)}`,
+    '',
+    `From another computer, forward the port first:  ${forward}`,
+    '',
+  ].join('\n');
+}
+
+export function publicConnectHint(url: string): string {
+  return [
+    'Manage this machine from the web UI, from anywhere:',
+    '',
+    `  ${connectLink(url)}`,
+    '',
+    'Sign in right away: the first wallet to sign in owns this machine.',
+    '',
+  ].join('\n');
+}
+
+export const tunnelPendingHint = (): string =>
+  'Bringing up a public address through a Cloudflare quick tunnel…\n';