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

package/runtime/node_modules/@metro-labs/mcp/src/mcp/frame-scope.ts

@@ -1,21 +0,0 @@
-import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
-import { eventInScope } from '../db/agent-scope.js';
-import { str } from './str.js';
-
-export interface FrameOrigin {
-  line: string | undefined;
-  owner: Set<string>;
-}
-
-export function frameLine(message: JSONRPCMessage): string | undefined {
-  const params: unknown = (message as { params?: unknown }).params;
-  if (typeof params !== 'object' || params === null) return undefined;
-  const meta: unknown = (params as { meta?: unknown }).meta;
-  if (typeof meta !== 'object' || meta === null) return undefined;
-  return str((meta as { line?: unknown }).line) || undefined;
-}
-
-export function frameInScope(scope: Set<string>, origin: FrameOrigin): boolean {
-  if (origin.line !== undefined) return eventInScope(scope, origin.line);
-  return origin.owner.size > 0 && [...origin.owner].every((id) => scope.has(id));
-}

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

@@ -1,192 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import {
-  BodyTooLargeError,
-  readBody as readBodyBuffer,
-} from '../daemon/http.js';
-import {
-  allowedAgents,
-  authConfigFromEnv,
-  authenticate,
-  runWithIdentity,
-  type RequestIdentity,
-} from './request-identity.js';
-import {
-  headerValue,
-  isStandaloneGet,
-  serveChannelGet,
-} from './raw-get-stream.js';
-import { channelLog, type McpSession } from './session.js';
-import {
-  SessionCapacityError,
-  SessionRegistry,
-  type AgentLiveness,
-} from './session-registry.js';
-import { routeSession, sessionScopeKey } from './session-route.js';
-
-const isInitialize = (b: unknown): boolean =>
-  !!b &&
-  typeof b === 'object' &&
-  (b as { method?: string }).method === 'initialize';
-
-const MCP_BODY_MAX = 32 * 1024 * 1024;
-
-async function readBody(req: IncomingMessage): Promise<unknown> {
-  const raw = (await readBodyBuffer(req, MCP_BODY_MAX)).toString('utf8');
-  try {
-    return raw ? JSON.parse(raw) : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-type ParsedBody = { ok: true; body: unknown } | { ok: false };
-
-async function readOrReject(
-  req: IncomingMessage,
-  res: ServerResponse,
-): Promise<ParsedBody> {
-  try {
-    const body = req.method === 'POST' ? await readBody(req) : undefined;
-    return { ok: true, body };
-  } catch (err) {
-    if (!(err instanceof BodyTooLargeError)) throw err;
-    res.writeHead(413).end('payload too large');
-    return { ok: false };
-  }
-}
-
-async function resolveSession(
-  registry: SessionRegistry,
-  req: IncomingMessage,
-  body: unknown,
-  identity: RequestIdentity,
-  res: ServerResponse,
-): Promise<McpSession | undefined> {
-  const presented = headerValue(req, 'mcp-session-id');
-  const scopeKey = sessionScopeKey(identity);
-  const route = routeSession({
-    isInitialize: isInitialize(body),
-    presented,
-    ownership: registry.ownership(presented, scopeKey),
-    hasOwnSession: registry.forScope(scopeKey) !== undefined,
-  });
-  if (route.kind === 'reject') {
-    channelLog(
-      'session: refused',
-      'status',
-      route.status,
-      'presented',
-      presented ?? '(none)',
-      'scope',
-      scopeKey,
-    );
-    res.writeHead(route.status).end(route.message);
-    return undefined;
-  }
-  if (route.kind === 'use') {
-    const found =
-      presented === undefined
-        ? registry.forScope(scopeKey)
-        : registry.get(presented);
-    if (found) return found;
-    res.writeHead(404).end('Session not found');
-    return undefined;
-  }
-  try {
-    return await registry.create(identity, route.adoptId);
-  } catch (err) {
-    if (!(err instanceof SessionCapacityError)) throw err;
-    res.writeHead(503).end(err.message);
-    return undefined;
-  }
-}
-
-async function serveGet(
-  session: McpSession,
-  req: IncomingMessage,
-  res: ServerResponse,
-  identity: RequestIdentity,
-): Promise<void> {
-  if (session.currentSink && !session.owner.streamBelongsTo(identity)) {
-    channelLog(
-      'session: refused stream takeover',
-      'session',
-      session.id,
-      'scope',
-      session.scopeKey,
-    );
-    res.writeHead(409).end('Conflict: stream held by another identity');
-    return;
-  }
-  const served = await serveChannelGet({
-    transport: session.transport,
-    eventStore: session.eventStore,
-    scope: allowedAgents(identity),
-    req,
-    res,
-    previous: session.currentSink,
-    log: channelLog,
-    registerSink: (sink) => {
-      session.bindSink(sink, identity);
-    },
-  });
-  if (served) session.channel.replayMissed();
-}
-
-let activeRegistry: SessionRegistry | undefined;
-
-export function agentLiveness(): Map<string, AgentLiveness> {
-  return activeRegistry?.liveness() ?? new Map<string, AgentLiveness>();
-}
-
-export async function closeAgentSession(agentId: string): Promise<boolean> {
-  const scopeKey = sessionScopeKey({ kind: 'agent', agentId });
-  return (await activeRegistry?.closeScope(scopeKey)) ?? false;
-}
-
-export async function createMetroMcp(): Promise<{
-  httpHandler: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-  startInbound: () => void;
-}> {
-  await activeRegistry?.closeAll();
-  const registry = new SessionRegistry(channelLog);
-  activeRegistry = registry;
-
-  const httpHandler = async (
-    req: IncomingMessage,
-    res: ServerResponse,
-  ): Promise<void> => {
-    const identity = authenticate(req, authConfigFromEnv());
-    if (!identity) {
-      res.writeHead(401).end('unauthorized');
-      return;
-    }
-    const parsed = await readOrReject(req, res);
-    if (!parsed.ok) return;
-    await runWithIdentity(identity, async () => {
-      const session = await resolveSession(
-        registry,
-        req,
-        parsed.body,
-        identity,
-        res,
-      );
-      if (!session) return;
-      session.touch();
-      if (isStandaloneGet(req)) {
-        await serveGet(session, req, res, identity);
-        return;
-      }
-      await session.transport.handleRequest(req, res, parsed.body);
-    });
-  };
-
-  const startInbound = (): void => {
-    registry.startInbound();
-    channelLog(
-      'inbound: per-session bus subscriptions (bounded replay on reconnect)',
-    );
-  };
-
-  return { httpHandler, startInbound };
-}

package/runtime/node_modules/@metro-labs/mcp/src/mcp/permission-relay.ts

@@ -1,66 +0,0 @@
-import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { z } from 'zod';
-import type { InboundRelay } from '../channels/inbound.js';
-import type { ChannelOwner } from './channel-owner.js';
-import { metroCall } from './ctx.js';
-
-const PermissionRequestSchema = z.object({
-  method: z.literal('notifications/claude/channel/permission_request'),
-  params: z.object({
-    request_id: z.string(),
-    tool_name: z.string(),
-    description: z.string(),
-    input_preview: z.string(),
-  }),
-});
-
-type PermissionRequest = z.infer<typeof PermissionRequestSchema>;
-
-const trainOf = (line: string): string => line.split('/')[2] ?? '';
-
-async function metroSend(line: string, text: string): Promise<void> {
-  await metroCall(trainOf(line), 'send', { line, text });
-}
-
-function promptBody(params: PermissionRequest['params']): string {
-  return (
-    `Claude wants to run ${params.tool_name}: ${params.description}\n` +
-    (params.input_preview ? `\n${params.input_preview}\n` : '') +
-    `\nReply "yes ${params.request_id}" or "no ${params.request_id}"`
-  );
-}
-
-export interface PermissionRelayDeps {
-  mcp: Server;
-  relay: InboundRelay;
-  owner: ChannelOwner;
-  log: (...a: unknown[]) => void;
-}
-
-export function registerPermissionRelay(deps: PermissionRelayDeps): void {
-  const { mcp, relay, owner, log } = deps;
-  mcp.setNotificationHandler(
-    PermissionRequestSchema as never,
-    async (n: PermissionRequest) => {
-      const { params } = n;
-      const line = relay.knownLine;
-      if (!line) {
-        log('permission_request but no known line to relay to', params.request_id);
-        return;
-      }
-      if (!owner.inScope(line)) {
-        log(
-          'permission_request: known line is outside the channel session scope',
-          params.request_id,
-        );
-        return;
-      }
-      relay.registerPermission(params.request_id);
-      try {
-        await metroSend(line, promptBody(params));
-      } catch (e) {
-        log('relay send failed', e);
-      }
-    },
-  );
-}

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

@@ -1,73 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import type { IncomingMessage } from 'node:http';
-import { verifySession } from '../daemon/session.js';
-import { agentIdForKey } from '../db/key-map.js';
-
-export type RequestIdentity =
-  | { kind: 'agent'; agentId: string }
-  | { kind: 'google'; email: string; agentIds: string[] };
-
-const storage = new AsyncLocalStorage<RequestIdentity>();
-
-export function runWithIdentity<T>(
-  identity: RequestIdentity,
-  fn: () => Promise<T>,
-): Promise<T> {
-  return storage.run(identity, fn);
-}
-
-export function currentIdentity(): RequestIdentity | undefined {
-  return storage.getStore();
-}
-
-export interface AuthConfig {
-  sessionSecret: string;
-}
-
-export function authConfigFromEnv(): AuthConfig {
-  return { sessionSecret: process.env.METRO_SESSION_SECRET?.trim() ?? '' };
-}
-
-export function extractToken(req: IncomingMessage): string | undefined {
-  const header = req.headers.authorization;
-  if (header?.startsWith('Bearer ')) {
-    const t = header.slice(7).trim();
-    if (t) return t;
-  }
-  const qt = new URL(req.url ?? '/', 'http://localhost').searchParams.get(
-    'token',
-  );
-  return qt ?? undefined;
-}
-
-const looksLikeJwt = (token: string): boolean =>
-  /^[\w-]+\.[\w-]+\.[\w-]+$/.test(token);
-
-export function authenticate(
-  req: IncomingMessage,
-  cfg: AuthConfig,
-): RequestIdentity | null {
-  const token = extractToken(req);
-  if (!token) return null;
-
-  const agentId = agentIdForKey(token);
-  if (agentId !== undefined) return { kind: 'agent', agentId };
-
-  if (cfg.sessionSecret !== '' && looksLikeJwt(token)) {
-    try {
-      const { email, agentIds } = verifySession(token, cfg.sessionSecret);
-      return { kind: 'google', email, agentIds };
-    } catch {
-      return null;
-    }
-  }
-  return null;
-}
-
-export function allowedAgents(
-  identity: RequestIdentity | undefined,
-): Set<string> {
-  if (identity?.kind === 'google') return new Set(identity.agentIds);
-  if (identity?.kind === 'agent') return new Set([identity.agentId]);
-  return new Set();
-}

package/runtime/node_modules/@metro-labs/mcp/src/mcp/session-registry.ts

@@ -1,172 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { currentBusSeq } from '../daemon/events.js';
-import { errMsg } from '../daemon/log.js';
-import { newReplayLedger, type ReplayLedger } from '../channels/relay.js';
-import { McpSession, channelLog } from './session.js';
-import { agentsInScopeKey } from './session-route.js';
-import { sessionScopeKey, type SessionOwnership } from './session-route.js';
-import type { RequestIdentity } from './request-identity.js';
-
-export const MAX_SESSIONS = 64;
-export const SESSION_IDLE_MS = 10 * 60_000;
-export const LEDGER_MAX = 256;
-const SWEEP_MS = 60_000;
-
-export interface AgentLiveness {
-  connected: boolean;
-  lastSeenAt: number;
-}
-
-export class SessionCapacityError extends Error {
-  constructor() {
-    super('too many live MCP sessions');
-  }
-}
-
-export class SessionRegistry {
-  private readonly byId = new Map<string, McpSession>();
-  private readonly byScope = new Map<string, McpSession>();
-  private readonly ledgers = new Map<string, ReplayLedger>();
-  private readonly sweeper: ReturnType<typeof setInterval>;
-  private readonly log: (...a: unknown[]) => void;
-  private started = false;
-  private floor = 0;
-
-  constructor(log: (...a: unknown[]) => void = channelLog) {
-    this.log = log;
-    this.sweeper = setInterval(() => {
-      this.sweep(Date.now());
-    }, SWEEP_MS);
-    this.sweeper.unref?.();
-  }
-
-  get size(): number {
-    return this.byId.size;
-  }
-
-  get(sessionId: string): McpSession | undefined {
-    return this.byId.get(sessionId);
-  }
-
-  liveness(): Map<string, AgentLiveness> {
-    const out = new Map<string, AgentLiveness>();
-    for (const session of this.byId.values())
-      for (const id of agentsInScopeKey(session.scopeKey)) {
-        const prev = out.get(id);
-        out.set(id, {
-          connected: (prev?.connected ?? false) || session.streamAttached,
-          lastSeenAt: Math.max(prev?.lastSeenAt ?? 0, session.lastSeenAt),
-        });
-      }
-    return out;
-  }
-
-  forScope(scopeKey: string): McpSession | undefined {
-    return this.byScope.get(scopeKey);
-  }
-
-  ownership(
-    presented: string | undefined,
-    scopeKey: string,
-  ): SessionOwnership {
-    if (presented === undefined) return 'none';
-    const found = this.byId.get(presented);
-    if (!found) return 'none';
-    return found.scopeKey === scopeKey ? 'mine' : 'theirs';
-  }
-
-  startInbound(): void {
-    if (this.started) return;
-    this.started = true;
-    this.floor = currentBusSeq();
-    for (const session of this.byId.values()) session.startChannel();
-  }
-
-  async create(
-    identity: RequestIdentity,
-    adoptId?: string,
-  ): Promise<McpSession> {
-    const scopeKey = sessionScopeKey(identity);
-    const id = adoptId ?? randomUUID();
-    await this.byScope.get(scopeKey)?.close();
-    await this.byId.get(id)?.close();
-    await this.makeRoom();
-    const session = await McpSession.open({
-      id,
-      scopeKey,
-      adopted: adoptId !== undefined,
-      ledger: this.ledgerFor(scopeKey),
-      onClosed: (s) => {
-        this.forget(s);
-      },
-    });
-    this.byId.set(id, session);
-    this.byScope.set(scopeKey, session);
-    if (this.started) session.startChannel();
-    this.log('session: opened', 'id', id, 'scope', scopeKey, 'live', this.byId.size);
-    return session;
-  }
-
-  async closeScope(scopeKey: string): Promise<boolean> {
-    const session = this.byScope.get(scopeKey);
-    if (!session) return false;
-    this.log('session: closed, credential rotated', 'id', session.id, 'scope', scopeKey);
-    await session.close();
-    return true;
-  }
-
-  async closeAll(): Promise<void> {
-    clearInterval(this.sweeper);
-    for (const session of [...this.byId.values()]) await session.close();
-    this.ledgers.clear();
-  }
-
-  sweep(now: number): number {
-    let reaped = 0;
-    for (const session of [...this.byId.values()]) {
-      if (session.streamAttached) continue;
-      if (now - session.lastSeenAt <= SESSION_IDLE_MS) continue;
-      this.log('session: reaped idle', 'id', session.id, 'scope', session.scopeKey);
-      session.close().catch((err: unknown) => {
-        this.log('session: reap close failed', 'id', session.id, errMsg(err));
-      });
-      reaped += 1;
-    }
-    return reaped;
-  }
-
-  private forget(session: McpSession): void {
-    if (this.byId.get(session.id) === session) this.byId.delete(session.id);
-    if (this.byScope.get(session.scopeKey) === session)
-      this.byScope.delete(session.scopeKey);
-  }
-
-  private async makeRoom(): Promise<void> {
-    if (this.byId.size < MAX_SESSIONS) return;
-    this.sweep(Date.now());
-    if (this.byId.size < MAX_SESSIONS) return;
-    const idle = [...this.byId.values()]
-      .filter((s) => !s.streamAttached)
-      .sort((a, b) => a.lastSeenAt - b.lastSeenAt)
-      .at(0);
-    if (!idle) throw new SessionCapacityError();
-    await idle.close();
-  }
-
-  private ledgerFor(scopeKey: string): ReplayLedger {
-    const found = this.ledgers.get(scopeKey);
-    if (found) {
-      this.ledgers.delete(scopeKey);
-      this.ledgers.set(scopeKey, found);
-      return found;
-    }
-    const fresh = newReplayLedger(this.started ? this.floor : currentBusSeq());
-    this.ledgers.set(scopeKey, fresh);
-    while (this.ledgers.size > LEDGER_MAX) {
-      const oldest = this.ledgers.keys().next();
-      if (oldest.done) break;
-      this.ledgers.delete(oldest.value);
-    }
-    return fresh;
-  }
-}

package/runtime/node_modules/@metro-labs/mcp/src/mcp/session-route.ts

@@ -1,43 +0,0 @@
-import { allowedAgents, type RequestIdentity } from './request-identity.js';
-
-export function sessionScopeKey(identity: RequestIdentity): string {
-  const ids = [...allowedAgents(identity)].sort();
-  if (ids.length > 0) return `${AGENTS_PREFIX}${ids.join(',')}`;
-  return `email:${identity.kind === 'google' ? identity.email : identity.agentId}`;
-}
-
-const AGENTS_PREFIX = 'agents:';
-
-export function agentsInScopeKey(scopeKey: string): string[] {
-  if (!scopeKey.startsWith(AGENTS_PREFIX)) return [];
-  return scopeKey.slice(AGENTS_PREFIX.length).split(',').filter(Boolean);
-}
-
-export type SessionOwnership = 'none' | 'mine' | 'theirs';
-
-export type SessionRoute =
-  | { kind: 'create'; adoptId?: string }
-  | { kind: 'use' }
-  | { kind: 'reject'; status: number; message: string };
-
-export interface SessionRouteInput {
-  isInitialize: boolean;
-  presented: string | undefined;
-  ownership: SessionOwnership;
-  hasOwnSession: boolean;
-}
-
-const NO_SESSION_HEADER = 'Bad Request: Mcp-Session-Id header is required';
-const NOT_FOUND = 'Session not found';
-
-export function routeSession(input: SessionRouteInput): SessionRoute {
-  if (input.isInitialize) return { kind: 'create' };
-  if (input.presented === undefined)
-    return input.hasOwnSession
-      ? { kind: 'use' }
-      : { kind: 'reject', status: 400, message: NO_SESSION_HEADER };
-  if (input.ownership === 'mine') return { kind: 'use' };
-  if (input.ownership === 'theirs')
-    return { kind: 'reject', status: 404, message: NOT_FOUND };
-  return { kind: 'create', adoptId: input.presented };
-}