@stage-labs/metro 0.1.0-beta.7 → 0.1.0-beta.70

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

@@ -0,0 +1,204 @@
+import { join } from 'node:path';
+import { type Server } from 'node:http';
+import { userSelf } from './events.js';
+import { setTrainCallBackend } from './train-call.js';
+import { errMsg, log, logFatalSync } from './log.js';
+import { acquireLock, isLocalMode, STATE_DIR, trainsDir } from './paths.js';
+import { installCrashGuard, markDaemonReady } from './crash-guard.js';
+import { METRO_VERSION } from './version.js';
+import { funnelDriver, Tunnel, tunnelWanted, 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 { localAgentKey } from '../db/materialize.js';
+import { fileSource } from '../db/file-source.js';
+import { applyLocalOwner } from './local-owner.js';
+import { localOwner } from '../db/file-admin.js';
+import { ensureStationDeps } from './runtime-deps.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, reloadFrom } from '../db/materialize.js';
+import type { StationName } from '../db/stations.js';
+import { startUploadReaper } from './upload-store.js';
+
+installCrashGuard();
+acquireLock(join(STATE_DIR, '.tail-lock'));
+
+log.info({ self: userSelf() }, '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 tunnel = tunnelWanted() ? new Tunnel(funnelDriver(webhookPort()), announcePublic) : null;
+
+function announcePublic(url: string): void {
+  process.stderr.write(`\n${publicConnectHint(url, localOwner())}`);
+}
+
+setTrainCallBackend((train, action, args) =>
+  supervisor.call(train, action, args),
+);
+
+function announceLocalEndpoint(): void {
+  process.stderr.write(
+    `\n${tunnel === null ? localConnectHint(webhookPort(), localOwner()) : tunnelPendingHint()}`,
+  );
+  const key = localAgentKey();
+  if (key === null) {
+    log.info('no agent on this machine yet');
+    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 syncStations(station: StationName): Promise<void> {
+  const { removed } = await reloadFrom(fileSource);
+  if (stationByName(station)?.hasTrain === false) return;
+  if (removed.includes(station)) await supervisor.stopTrain(station);
+  else {
+    ensureStationDeps(station);
+    supervisor.requestReload(station);
+  }
+}
+
+const hostedMode = (): ModeInfo => ({
+  mode: 'hosted',
+  owner: null,
+  project: null,
+  version: METRO_VERSION,
+});
+
+async function sessionApis(): Promise<SessionApis> {
+  if (isLocalMode())
+    return localSessionApis({
+      syncStations,
+      restart: () => {
+        exitCode = RESTART_EXIT;
+        onShutdown();
+      },
+      stop: () => {
+        exitCode = HOLD_EXIT;
+        onShutdown();
+      },
+      closeAgentSession,
+      gatherAccounts: gatherAccountsForAgents,
+      capabilities: accountStationCapabilities,
+      liveness: agentLiveness,
+      prepareAccount,
+    });
+  const vault = await import('../db/vault.js');
+  const servers = await import('../db/servers.js');
+  return {
+    vaultApi: {
+      list: vault.listVaultForOwner,
+      put: vault.putVaultForOwner,
+      get: vault.getVaultForOwner,
+      remove: vault.deleteVaultForOwner,
+    },
+    serversApi: {
+      list: servers.listServersForOwner,
+      add: servers.addServerForOwner,
+      rename: servers.renameServerForOwner,
+      remove: servers.deleteServerForOwner,
+    },
+    mode: hostedMode,
+  };
+}
+
+async function main(): Promise<void> {
+  if (isLocalMode()) {
+    applyLocalOwner();
+    await materializeFrom(fileSource, { allowEmpty: true });
+  }
+  supervisor.start();
+  const metroMcp = await createMetroMcp();
+  webhookServer = await startWebhookServer(
+    emit,
+    await sessionApis(),
+    metroMcp.httpHandler,
+    metroCall,
+  );
+  metroMcp.startInbound();
+  startUploadReaper();
+  if (isLocalMode()) announceLocalEndpoint();
+  tunnel?.start();
+  log.info(
+    { tunnel: !!tunnel, trainsDir: trainsDir(), mcp: '/', version: METRO_VERSION },
+    'dispatcher ready',
+  );
+  markDaemonReady();
+}
+
+const SHUTDOWN_TIMEOUT_MS = 3_000;
+const RESTART_EXIT = 75;
+const HOLD_EXIT = 76;
+let exitCode = 0;
+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 supervisor.stop();
+  process.exit(exitCode);
+}
+const onShutdown = (): void => {
+  shutdown().catch((err: unknown) => {
+    log.error({ err: errMsg(err) }, 'dispatcher: shutdown failed');
+    process.exit(1);
+  });
+};
+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/bundle-api.ts

@@ -0,0 +1,111 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from './log.js';
+import { apiFailure, apiSession, cors, readJsonBody, sendJson } from './api-http.js';
+import { ApiError } from './api-error.js';
+import { isRecord } from './is-record.js';
+import { parseId } from '../db/ids.js';
+import type { LoadedAccount, LoadedAgent, LoadedConnector } from '../db/materialize.js';
+import { STATIONS } from '../db/stations.js';
+
+const AGENTS = '/api/agents';
+const RESTORE_PATH = `${AGENTS}/restore`;
+const BUNDLE_MAX = 2 * 1024 * 1024;
+const STATION_NAMES = new Set<string>(STATIONS);
+
+export interface AgentBundle {
+  version: 1;
+  agent: { id: string; name: string; key: string; stations: LoadedAccount[] };
+  connectors: LoadedConnector[];
+}
+
+export const loadedAgentOf = (bundle: AgentBundle): LoadedAgent => ({
+  id: bundle.agent.id,
+  name: bundle.agent.name,
+  key: bundle.agent.key,
+  accounts: bundle.agent.stations,
+  connectors: [],
+});
+
+export interface RestoredAgent {
+  id: string;
+  name: string;
+  stations: number;
+  connectors: number;
+}
+
+export interface BundleApiDeps {
+  bundle: (subject: string, agentId: string) => Promise<AgentBundle>;
+  restore: (subject: string, bundle: AgentBundle) => Promise<RestoredAgent>;
+}
+
+const bad = (what: string): ApiError => new ApiError(`bundle: ${what}`, 400);
+
+function stationOf(raw: unknown): LoadedAccount {
+  if (!isRecord(raw) || typeof raw.station !== 'string' || !STATION_NAMES.has(raw.station))
+    throw bad('a station is not a known station');
+  if (typeof raw.id !== 'string' || !isRecord(raw.config)) throw bad('a station has no id or config');
+  const allowlist = Array.isArray(raw.allowlist)
+    ? raw.allowlist.filter((s): s is string => typeof s === 'string')
+    : null;
+  return { station: raw.station as LoadedAccount['station'], id: raw.id, allowlist, config: raw.config };
+}
+
+function connectorOf(raw: unknown): LoadedConnector {
+  if (!isRecord(raw) || typeof raw.id !== 'string' || typeof raw.name !== 'string' || typeof raw.url !== 'string')
+    throw bad('a connector is missing its id, name or url');
+  if (!isRecord(raw.config)) throw bad('a connector has no config');
+  return { id: raw.id, name: raw.name, url: raw.url, transport: 'http', config: raw.config };
+}
+
+function agentOf(raw: unknown): AgentBundle['agent'] {
+  if (!isRecord(raw)) throw bad('not a v1 agent bundle');
+  const { id, name, key, stations } = raw;
+  if (typeof id !== 'string' || parseId(id) === null) throw bad('agent id is not an id');
+  if (typeof name !== 'string' || typeof key !== 'string' || key === '') throw bad('agent has no name or key');
+  if (!Array.isArray(stations)) throw bad('agent has no station list');
+  return { id, name, key, stations: stations.map(stationOf) };
+}
+
+export function parseBundle(raw: unknown): AgentBundle {
+  if (!isRecord(raw) || raw.version !== 1) throw bad('not a v1 agent bundle');
+  const connectors = Array.isArray(raw.connectors) ? raw.connectors : [];
+  return { version: 1, agent: agentOf(raw.agent), connectors: connectors.map(connectorOf) };
+}
+
+async function answer(req: IncomingMessage, deps: BundleApiDeps, subject: string, path: string): Promise<unknown> {
+  if (path === RESTORE_PATH) return deps.restore(subject, parseBundle(await readJsonBody(req, BUNDLE_MAX)));
+  const id = parseId(path.slice(AGENTS.length + 1).split('/')[0] ?? '');
+  if (id === null) throw new ApiError('no such agent', 404);
+  return deps.bundle(subject, id);
+}
+
+export function handleBundleRequest(req: IncomingMessage, res: ServerResponse, deps: BundleApiDeps): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  const isRestore = path === RESTORE_PATH;
+  const isBundle = /^\/api\/agents\/[^/]+\/bundle$/.test(path);
+  if (!isRestore && !isBundle) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== (isRestore ? 'POST' : 'GET')) {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  apiSession(req)
+    .then((session) => {
+      if (!session) throw new ApiError('unauthorized', 401);
+      return answer(req, deps, session.subject, path);
+    })
+    .then((body) => {
+      sendJson(req, res, isRestore ? 201 : 200, body);
+    })
+    .catch((err: unknown) => {
+      if (err instanceof ApiError) apiFailure(req, res, err, 'bundle-api');
+      else {
+        log.warn({ err: errMsg(err) }, 'bundle-api: request failed');
+        if (!res.headersSent) sendJson(req, res, 500, { error: 'bundle api failed' });
+      }
+    });
+  return true;
+}

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

@@ -0,0 +1,97 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from './log.js';
+import { apiFailure, apiSession, cors, sendJson } from './api-http.js';
+import { ApiError } from './api-error.js';
+import {
+  claudeDir,
+  deleteClaudeSession,
+  listClaudeProjects,
+  listClaudeSessions,
+  listMemory,
+  readMemoryFile,
+  readTranscript,
+} from './claude-files.js';
+
+const PREFIX = '/api/claude';
+const PAGE = 100;
+const PAGE_MAX = 500;
+
+export interface ClaudeApiDeps {
+  authorize: (subject: string) => void;
+  dir?: () => string;
+}
+
+function projectOf(query: URLSearchParams): string {
+  const project = query.get('project');
+  if (project === null || project === '') throw new ApiError('project is required', 400);
+  return project;
+}
+
+function pageOf(query: URLSearchParams): { offset: number; limit: number } {
+  const offset = Math.max(0, Math.floor(Number(query.get('offset') ?? '0')) || 0);
+  const limit = Math.min(PAGE_MAX, Math.max(1, Math.floor(Number(query.get('limit') ?? String(PAGE))) || PAGE));
+  return { offset, limit };
+}
+
+type Handler = (query: URLSearchParams, dir: string, item: string) => unknown;
+
+const COLLECTIONS: Record<string, Handler> = {
+  projects: (_query, dir) => ({ projects: listClaudeProjects(dir) }),
+  sessions: (query, dir) => ({ sessions: listClaudeSessions(projectOf(query), dir) }),
+  memory: (query, dir) => listMemory(projectOf(query), dir),
+};
+
+const ITEMS: Record<string, Handler> = {
+  sessions: (query, dir, id) => {
+    const { offset, limit } = pageOf(query);
+    return readTranscript(projectOf(query), id, offset, limit, dir);
+  },
+  memory: (query, dir, name) => ({ name, content: readMemoryFile(projectOf(query), name, dir) }),
+};
+
+function answer(method: string, path: string, query: URLSearchParams, dir: string): unknown {
+  const rest = path.slice(PREFIX.length + 1).split('/').filter(Boolean);
+  const [head = '', item] = rest;
+  if (method === 'DELETE') {
+    if (rest.length !== 2 || head !== 'sessions') throw new ApiError('method not allowed', 405);
+    deleteClaudeSession(projectOf(query), item ?? '', dir);
+    return { deleted: item };
+  }
+  const handler = rest.length === 1 ? COLLECTIONS[head] : rest.length === 2 ? ITEMS[head] : undefined;
+  if (handler === undefined) throw new ApiError('no such route', 404);
+  return handler(query, dir, item ?? '');
+}
+
+export function handleClaudeRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: ClaudeApiDeps,
+): boolean {
+  const [path = '', search = ''] = (req.url ?? '').split('?');
+  if (path !== PREFIX && !path.startsWith(`${PREFIX}/`)) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== 'GET' && req.method !== 'DELETE') {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  apiSession(req)
+    .then((session) => {
+      if (!session) throw new ApiError('unauthorized', 401);
+      deps.authorize(session.subject);
+      return answer(req.method ?? 'GET', path, new URLSearchParams(search), (deps.dir ?? claudeDir)());
+    })
+    .then((body) => {
+      sendJson(req, res, 200, body);
+    })
+    .catch((err: unknown) => {
+      if (err instanceof ApiError) apiFailure(req, res, err, 'claude-api');
+      else {
+        log.warn({ err: errMsg(err) }, 'claude-api: request failed');
+        if (!res.headersSent) sendJson(req, res, 500, { error: 'claude-api failed' });
+      }
+    });
+  return true;
+}