@stage-labs/metro 0.1.0-beta.20 → 0.1.0-beta.201

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 };
-}

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

@@ -1,240 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { stationByName } from '../stations/registry.js';
-import { errMsg, log } from '../daemon/log.js';
-import { subscribeEvents, type MetroEvent } from '../daemon/events.js';
-import { callTargetDenied, eventInScope } from '../db/agent-scope.js';
-import { hasAnyKey } from '../db/key-map.js';
-import {
-  allowedAgents,
-  authConfigFromEnv,
-  authenticate,
-} from '../mcp/request-identity.js';
-
-export type MonitorCall = (
-  train: string,
-  action: string,
-  args: Record<string, unknown>,
-) => Promise<{ result: unknown }>;
-
-const KEEPALIVE_MS = 25_000;
-const CALL_BODY_MAX = 256 * 1024;
-const METRO_VERSION = process.env.npm_package_version ?? '0.1.0-beta.15';
-
-function monitorEnabled(): boolean {
-  return hasAnyKey() || authConfigFromEnv().sessionSecret !== '';
-}
-
-function cors(req: IncomingMessage): Record<string, string> {
-  return {
-    'access-control-allow-origin': req.headers.origin ?? '*',
-    'access-control-allow-methods': 'GET, POST, OPTIONS',
-    'access-control-allow-headers': 'Authorization, Content-Type',
-    'access-control-max-age': '86400',
-    vary: 'Origin',
-  };
-}
-
-function sendJson(
-  res: ServerResponse,
-  req: IncomingMessage,
-  status: number,
-  body: unknown,
-): void {
-  res.writeHead(status, { 'content-type': 'application/json', ...cors(req) });
-  res.end(JSON.stringify(body));
-}
-
-function parseCallArgs(raw: string): Record<string, unknown> {
-  if (!raw) return {};
-  const parsed = JSON.parse(raw) as { args?: unknown };
-  const value =
-    parsed && typeof parsed === 'object' && 'args' in parsed
-      ? parsed.args
-      : parsed;
-  if (!value || typeof value !== 'object' || Array.isArray(value))
-    throw new Error('call body must be a JSON object');
-  return value as Record<string, unknown>;
-}
-
-async function readCallArgs(
-  req: IncomingMessage,
-): Promise<Record<string, unknown>> {
-  const chunks: Buffer[] = [];
-  let total = 0;
-  for await (const chunk of req) {
-    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk as string);
-    total += buf.length;
-    if (total > CALL_BODY_MAX)
-      throw new Error(`request body exceeds ${CALL_BODY_MAX} bytes`);
-    chunks.push(buf);
-  }
-  return parseCallArgs(Buffer.concat(chunks).toString('utf8').trim());
-}
-
-function startTailStream(
-  req: IncomingMessage,
-  res: ServerResponse,
-  allowed: Set<string>,
-): void {
-  res.writeHead(200, {
-    'content-type': 'text/event-stream',
-    'cache-control': 'no-cache, no-transform',
-    connection: 'keep-alive',
-    'x-accel-buffering': 'no',
-    ...cors(req),
-  });
-  const timers: { keepalive?: ReturnType<typeof setInterval> } = {};
-  const subs: { stop?: () => void } = {};
-  let done = false;
-  const cleanup = (): void => {
-    if (done) return;
-    done = true;
-    subs.stop?.();
-    if (timers.keepalive) clearInterval(timers.keepalive);
-    try {
-      res.end();
-    } catch {
-      log.debug('monitor: tail cleanup end failed');
-    }
-  };
-  const write = (chunk: string): void => {
-    if (done) return;
-    if (res.destroyed || res.writableEnded) {
-      cleanup();
-      return;
-    }
-    try {
-      res.write(chunk);
-    } catch (err) {
-      log.debug({ err: errMsg(err) }, 'monitor: tail write failed');
-      cleanup();
-    }
-  };
-  write(': metro monitor tail (live)\n\n');
-  let id = 0;
-  subs.stop = subscribeEvents((e: MetroEvent): void => {
-    if (!eventInScope(allowed, e.line)) return;
-    id += 1;
-    write(`id: ${id}\nevent: live\ndata: ${JSON.stringify(e)}\n\n`);
-  });
-  timers.keepalive = setInterval(() => {
-    write(': keepalive\n\n');
-  }, KEEPALIVE_MS);
-  timers.keepalive.unref?.();
-  req.on('close', cleanup);
-  req.on('error', cleanup);
-}
-
-async function handleCall(
-  req: IncomingMessage,
-  res: ServerResponse,
-  train: string,
-  action: string,
-  call: MonitorCall,
-  allowed: Set<string>,
-): Promise<void> {
-  let args: Record<string, unknown>;
-  try {
-    args = await readCallArgs(req);
-  } catch (err) {
-    sendJson(res, req, 400, { error: `bad JSON body: ${errMsg(err)}` });
-    return;
-  }
-  if (callTargetDenied(allowed, train, args)) {
-    sendJson(res, req, 403, {
-      error: 'metro: this account is outside your authorized scope',
-    });
-    return;
-  }
-  if (stationByName(train)?.hasTrain === false) {
-    sendJson(res, req, 400, {
-      error: `metro: station '${train}' runs in-core and takes no calls`,
-    });
-    return;
-  }
-  try {
-    const { result } = await call(train, action, args);
-    sendJson(res, req, 200, { result });
-  } catch (err) {
-    sendJson(res, req, 502, { error: errMsg(err) });
-  }
-}
-
-function routeApi(
-  req: IncomingMessage,
-  res: ServerResponse,
-  path: string,
-  call: MonitorCall,
-  allowed: Set<string>,
-): void {
-  const callMatch = /^\/api\/call\/([^/]+)\/([^/]+)$/.exec(path);
-  if (callMatch) {
-    if (req.method !== 'POST') {
-      sendJson(res, req, 405, { error: 'method not allowed' });
-      return;
-    }
-    handleCall(
-      req,
-      res,
-      callMatch[1] ?? '',
-      callMatch[2] ?? '',
-      call,
-      allowed,
-    ).catch((err: unknown) => {
-      log.warn({ err: errMsg(err) }, 'monitor: call handler error');
-      if (!res.headersSent) sendJson(res, req, 500, { error: errMsg(err) });
-    });
-    return;
-  }
-  if (path === '/api/tail') {
-    if (req.method !== 'GET') {
-      sendJson(res, req, 405, { error: 'method not allowed' });
-      return;
-    }
-    startTailStream(req, res, allowed);
-    return;
-  }
-  sendJson(res, req, 404, { error: 'not found' });
-}
-
-function preflight(
-  req: IncomingMessage,
-  res: ServerResponse,
-  path: string,
-): boolean {
-  if (!monitorEnabled()) {
-    sendJson(res, req, 404, { error: 'not found' });
-    return true;
-  }
-  if (req.method === 'OPTIONS') {
-    res.writeHead(204, cors(req)).end();
-    return true;
-  }
-  if (req.method === 'GET' && path === '/api/health') {
-    sendJson(res, req, 200, {
-      ok: true,
-      service: 'metro',
-      version: METRO_VERSION,
-      uptime_s: Math.round(process.uptime()),
-    });
-    return true;
-  }
-  return false;
-}
-
-export function handleMonitorRequest(
-  req: IncomingMessage,
-  res: ServerResponse,
-  call: MonitorCall,
-): boolean {
-  const path = (req.url ?? '').split('?', 2)[0] ?? '';
-  if (!path.startsWith('/api/')) return false;
-  if (preflight(req, res, path)) return true;
-  const identity = authenticate(req, authConfigFromEnv());
-  if (!identity) {
-    sendJson(res, req, 401, { error: 'unauthorized' });
-    return true;
-  }
-  routeApi(req, res, path, call, allowedAgents(identity));
-  return true;
-}

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

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-import './daemon/boot.js';

package/runtime/node_modules/@metro-labs/telegram-user/src/accounts.ts

@@ -1,81 +0,0 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import {
-  makeAccountStore,
-  resolveAccountId,
-  type Die,
-} from '@metro-labs/mcp/stations/account-store';
-import type { UserAccount } from './types.js';
-
-const ACCOUNTS_FILE =
-  process.env.TELEGRAM_USER_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'telegram-user-accounts.json');
-
-const isSignedInt = (s: string): boolean => /^-?\d+$/.test(s);
-const isTopic = (s: string): boolean => /^\d+$/.test(s);
-
-function validateAccount(a: UserAccount, seen: Set<string>, die: Die): void {
-  if (!a.id) die('account missing id');
-  if (!a.session || typeof a.session !== 'string')
-    die(`account '${a.id}' missing session`);
-  if (!Number.isInteger(a.apiId) || (a.apiId ?? 0) <= 0)
-    die(`account '${a.id}' missing apiId`);
-  if (!a.apiHash || typeof a.apiHash !== 'string')
-    die(`account '${a.id}' missing apiHash`);
-  if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
-  seen.add(a.id);
-}
-
-export const { loadAccounts } = makeAccountStore<UserAccount>({
-  prefix: 'telegram-user',
-  file: ACCOUNTS_FILE,
-  allowlistEnv: ['TELEGRAM_USER_ONLY_ACCOUNTS', 'TELEGRAM_USER_ACCOUNTS'],
-  validate(raw, die) {
-    const seen = new Set<string>();
-    for (const a of raw) validateAccount(a, seen, die);
-  },
-});
-
-export const accounts = new Map<string, UserAccount>();
-
-export function accountFor(args: { account?: string; line?: string }): string {
-  return resolveAccountId(accounts, args, (line) => targetOf(line)?.accountId);
-}
-
-export function lineOf(
-  accountId: string,
-  chatId: number | string,
-  topicId?: number,
-): string {
-  const tail = topicId !== undefined ? `${chatId}/${topicId}` : `${chatId}`;
-  return `metro://telegram-user/${accountId}/${tail}`;
-}
-
-interface Target {
-  accountId: string;
-  chatId: number;
-  topicId?: number;
-}
-
-function splitScoped(path: string[]): { accountId: string; rest: string[] } {
-  const first = path[0];
-  if (path.length >= 2 && first !== undefined && !isSignedInt(first))
-    return { accountId: first, rest: path.slice(1) };
-  return { accountId: 'default', rest: path };
-}
-
-export function targetOf(line: string): Target | undefined {
-  const prefix = 'metro://telegram-user/';
-  if (!line.startsWith(prefix)) return undefined;
-  const path = line.slice(prefix.length).split('/').filter(Boolean);
-  const { accountId, rest } = splitScoped(path);
-  const [chatId, topicId] = rest;
-  if (rest.length < 1 || rest.length > 2 || chatId === undefined) return undefined;
-  if (!isSignedInt(chatId)) return undefined;
-  if (topicId !== undefined && !isTopic(topicId)) return undefined;
-  return {
-    accountId,
-    chatId: Number(chatId),
-    ...(topicId !== undefined ? { topicId: Number(topicId) } : {}),
-  };
-}