@stage-labs/metro 0.1.0-beta.32 → 0.1.0-beta.321

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

@@ -1,368 +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,
-  isLocalMode,
-  loadMetroEnv,
-  STATE_DIR,
-  trainsDir,
-} from './paths.js';
-import { installCrashGuard, markDaemonReady } from './crash-guard.js';
-import {
-  loadTunnelConfig,
-  Tunnel,
-  warnOnLegacyWebhooks,
-  webhookPort,
-} from './tunnel.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 { localConnectHint, 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,
-  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();
-const tunnel = tunnelCfg ? new Tunnel(tunnelCfg, webhookPort()) : null;
-
-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${localConnectHint(webhookPort())}`);
-  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,
-  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

@@ -1,134 +0,0 @@
-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 ALLOWED: Record<string, string> = {
-  [CLAIM_PATH]: 'POST',
-  [MCP_PATH]: 'GET',
-  [SESSION_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;
-  }
-  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;
-}