@stage-labs/metro 0.1.0-beta.2 → 0.1.0-beta.21

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

@@ -0,0 +1,240 @@
+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

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

package/runtime/node_modules/@metro-labs/mcp/src/stations/account-store.ts

@@ -0,0 +1,80 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { errMsg } from '../daemon/log.js';
+import { chmodIfExists } from '../daemon/secure-fs.js';
+
+export type Die = (msg: string) => never;
+
+export interface MakeLoaderOpts<T> {
+  prefix: string;
+  file: string;
+  allowlistEnv: string[];
+  validate: (raw: T[], die: Die) => void;
+}
+
+export interface Loader<T> {
+  die: Die;
+  loadAccounts: () => T[];
+}
+
+export function makeAccountStore<T extends { id: string }>(
+  opts: MakeLoaderOpts<T>,
+): Loader<T> {
+  const die: Die = (msg) => {
+    process.stderr.write(`${opts.prefix}: ${msg}\n`);
+    process.exit(2);
+  };
+
+  let allowlistRaw: string | undefined;
+  for (const k of opts.allowlistEnv) {
+    allowlistRaw ??= process.env[k];
+  }
+  const allowlist = new Set(
+    (allowlistRaw ?? '')
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean),
+  );
+
+  function loadAccounts(): T[] {
+    if (!existsSync(opts.file))
+      return die(
+        `no accounts file ${opts.file} — the daemon writes it from the database at boot; set DATABASE_URL and populate the accounts table`,
+      );
+    chmodIfExists(opts.file);
+    let raw: T[];
+    try {
+      raw = JSON.parse(readFileSync(opts.file, 'utf8')) as T[];
+    } catch (e) {
+      return die(`bad ${opts.file}: ${errMsg(e)}`);
+    }
+    if (!Array.isArray(raw) || raw.length === 0)
+      die(`${opts.file} must be a non-empty array`);
+    opts.validate(raw, die);
+    const selected = allowlist.size
+      ? raw.filter((a) => allowlist.has(a.id))
+      : raw;
+    if (selected.length === 0) {
+      die(
+        `no accounts match ${opts.allowlistEnv[0]} (${[...allowlist].join(', ')})`,
+      );
+    }
+    return selected;
+  }
+
+  return { die, loadAccounts };
+}
+
+export function resolveAccountId(
+  accounts: Map<string, unknown>,
+  args: { account?: string; line?: string },
+  parseAccountId: (line: string) => string | undefined,
+): string {
+  let id = args.account;
+  id ??= args.line ? parseAccountId(args.line) : undefined;
+  id ??= (accounts.size === 1 ? [...accounts.keys()][0] : 'default') ?? 'default';
+  if (!accounts.has(id))
+    throw new Error(
+      `unknown account '${id}' (have: ${[...accounts.keys()].join(', ')})`,
+    );
+  return id;
+}

package/runtime/node_modules/@metro-labs/mcp/src/stations/attach-inline.ts

@@ -0,0 +1,100 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+export const MAX_INLINE_BYTES = 8 * 1024 * 1024;
+
+const INLINE_TEMP_PREFIX = 'metro-inline-';
+
+const BASE64_RE = /^[A-Za-z0-9+/_-]*={0,2}$/;
+
+const mib = (n: number): string => `${(n / (1024 * 1024)).toFixed(2)} MiB`;
+
+const LIMIT_HINT =
+  `inline \`data\` is capped at ${mib(MAX_INLINE_BYTES)} (${MAX_INLINE_BYTES} bytes) of decoded ` +
+  'bytes per attachment and per send, because the base64 travels inside the MCP request body. ' +
+  'Pass `url`, or a `path` already on the daemon host, for anything larger.';
+
+function assertInlineSize(bytes: number, label: string): void {
+  if (bytes > MAX_INLINE_BYTES)
+    throw new Error(`inline attachment ${label} is ${mib(bytes)}; ${LIMIT_HINT}`);
+}
+
+export function assertInlineTotal(bytes: number): void {
+  if (bytes > MAX_INLINE_BYTES)
+    throw new Error(
+      `inline attachments total ${mib(bytes)} in one send; ${LIMIT_HINT}`,
+    );
+}
+
+const padOf = (b64: string): number =>
+  b64.endsWith('==') ? 2 : b64.endsWith('=') ? 1 : 0;
+
+export const decodedLengthOf = (b64: string): number =>
+  Math.max(0, Math.floor((b64.length * 3) / 4) - padOf(b64));
+
+const malformed = (why: string): Error =>
+  new Error(
+    `inline \`data\` ${why}; pass the file's bytes base64-encoded ` +
+      '(standard or url-safe alphabet, optionally behind a `data:<mime>;base64,` prefix)',
+  );
+
+const DATA_URL_RE = /^data:([^,]*),/i;
+
+export interface InlineSource {
+  data: string;
+  mime?: string;
+}
+
+export function splitInlineData(raw: string): InlineSource {
+  const compact = raw.replace(/\s+/g, '');
+  const match = DATA_URL_RE.exec(compact);
+  if (!match) return { data: raw };
+  const params = (match[1] ?? '').split(';');
+  if (!params.slice(1).some((p) => p.toLowerCase() === 'base64'))
+    throw malformed('is a `data:` url whose payload is not base64');
+  const mime = params[0]?.toLowerCase();
+  const data = compact.slice(match[0].length);
+  return mime === undefined || mime === '' ? { data } : { data, mime };
+}
+
+export function decodeInline(raw: string, label: string): Uint8Array {
+  const b64 = raw.replace(/\s+/g, '');
+  if (!b64) throw malformed('is empty');
+  const expected = decodedLengthOf(b64);
+  assertInlineSize(expected, label);
+  if (!BASE64_RE.test(b64)) throw malformed('is not base64');
+  if (b64.length % 4 === 1 || (padOf(b64) > 0 && b64.length % 4 !== 0))
+    throw malformed('is not a whole number of base64 quanta');
+  const buf = Buffer.from(b64, 'base64');
+  if (buf.length !== expected)
+    throw malformed(`decoded to ${buf.length} bytes instead of ${expected}`);
+  return new Uint8Array(buf);
+}
+
+export const safeFileName = (name: string | undefined): string => {
+  const base = (name ?? '').split(/[\\/]/).pop() ?? '';
+  const clean = base
+    .replace(/[^A-Za-z0-9._-]/g, '_')
+    .replace(/^\.+/, '')
+    .slice(0, 64);
+  return clean || 'attachment';
+};
+
+export interface InlineTemp {
+  dir: string;
+  path: string;
+}
+
+export async function writeInlineTemp(
+  data: Uint8Array,
+  name: string | undefined,
+): Promise<InlineTemp> {
+  const dir = await mkdtemp(join(tmpdir(), INLINE_TEMP_PREFIX));
+  const path = join(dir, safeFileName(name));
+  await writeFile(path, data, { mode: 0o600 });
+  return { dir, path };
+}
+
+export const removeInlineTemp = (dir: string): Promise<void> =>
+  rm(dir, { recursive: true, force: true });

package/runtime/node_modules/@metro-labs/mcp/src/stations/attach-interactive.ts

@@ -0,0 +1,161 @@
+import { StationAttachError } from './attach.js';
+
+export const INTERACTIVE_STATIONS = ['telegram-user', 'whatsapp'] as const;
+
+export type InteractiveStation = (typeof INTERACTIVE_STATIONS)[number];
+
+export type AttachStep = 'code' | 'password' | 'scan' | 'pair';
+
+export interface AttachPrompt {
+  step: AttachStep;
+  prompt: string;
+  qr?: string;
+  pairingCode?: string;
+}
+
+export interface AttachOutcome {
+  config: Record<string, unknown>;
+  identity: Record<string, string>;
+}
+
+export interface DriverHooks {
+  prompt: (p: AttachPrompt) => void;
+  done: (o: AttachOutcome) => void;
+  fail: (message: string) => void;
+}
+
+export interface AttachDriver {
+  submit: (input: { code?: unknown; password?: unknown }) => Promise<void>;
+  cancel: () => Promise<void>;
+}
+
+export interface StartedAttach {
+  driver: AttachDriver;
+  prompt: AttachPrompt;
+}
+
+const CODE_PROMPT =
+  'Telegram sent a login code to that number. Enter it here.';
+const PASSWORD_PROMPT =
+  'This account has two-step verification. Enter its password.';
+const SCAN_PROMPT =
+  'Open WhatsApp on your phone, go to Settings, Linked Devices, Link a Device, and scan this code.';
+const PAIR_PROMPT =
+  'Open WhatsApp on your phone, go to Settings, Linked Devices, Link a Device, Link with phone number, and type this code.';
+
+export function isInteractiveStation(raw: unknown): raw is InteractiveStation {
+  return (
+    typeof raw === 'string' &&
+    (INTERACTIVE_STATIONS as readonly string[]).includes(raw)
+  );
+}
+
+function refuse(err: unknown, fallback: string): never {
+  throw new StationAttachError(
+    err instanceof Error && err.message !== '' ? err.message : fallback,
+    400,
+  );
+}
+
+async function startTelegramUser(
+  input: Record<string, unknown>,
+  hooks: DriverHooks,
+): Promise<StartedAttach> {
+  const { TelegramUserLogin, TelegramUserLoginError, validateCredentials } =
+    await import('@metro-labs/telegram-user/login');
+  const isOwn = (e: unknown): boolean => e instanceof TelegramUserLoginError;
+  let login;
+  try {
+    login = new TelegramUserLogin(
+      validateCredentials({
+        apiId: input.apiId,
+        apiHash: input.apiHash,
+        phone: input.phone,
+      }),
+    );
+    await login.requestCode();
+  } catch (err) {
+    await login?.close();
+    refuse(isOwn(err) ? err : null, 'Telegram refused to start the sign-in');
+  }
+  const settled = login;
+  return {
+    prompt: { step: 'code', prompt: CODE_PROMPT },
+    driver: {
+      cancel: () => settled.close(),
+      submit: async (values) => {
+        try {
+          if (typeof values.password === 'string') {
+            hooks.done(await settled.submitPassword(values.password));
+            return;
+          }
+          if (typeof values.code !== 'string')
+            throw new StationAttachError('enter the login code', 400);
+          const result = await settled.submitCode(values.code);
+          if (result === 'password') {
+            hooks.prompt({ step: 'password', prompt: PASSWORD_PROMPT });
+            return;
+          }
+          hooks.done(result);
+        } catch (err) {
+          if (err instanceof StationAttachError) throw err;
+          refuse(isOwn(err) ? err : null, 'Telegram refused the sign-in');
+        }
+      },
+    },
+  };
+}
+
+async function startWhatsapp(
+  input: Record<string, unknown>,
+  hooks: DriverHooks,
+): Promise<StartedAttach> {
+  const { WhatsappLogin, WhatsappLoginError, normalizePhone } = await import(
+    '@metro-labs/whatsapp/login'
+  );
+  const isOwn = (e: unknown): boolean => e instanceof WhatsappLoginError;
+  let login;
+  try {
+    login = new WhatsappLogin(normalizePhone(input.phone), {
+      onQr: (qr) => {
+        hooks.prompt({ step: 'scan', prompt: SCAN_PROMPT, qr });
+      },
+      onPairingCode: (pairingCode) => {
+        hooks.prompt({ step: 'pair', prompt: PAIR_PROMPT, pairingCode });
+      },
+      onPaired: hooks.done,
+      onFailed: hooks.fail,
+    });
+    await login.start();
+  } catch (err) {
+    await login?.cancel();
+    refuse(isOwn(err) ? err : null, 'WhatsApp refused to start the pairing');
+  }
+  const settled = login;
+  const qrMode = settled.mode === 'qr';
+  return {
+    prompt: qrMode
+      ? { step: 'scan', prompt: SCAN_PROMPT }
+      : { step: 'pair', prompt: PAIR_PROMPT },
+    driver: {
+      cancel: () => settled.cancel(),
+      submit: () =>
+        Promise.reject(
+          new StationAttachError(
+            'this pairing finishes on your phone, there is nothing to submit here',
+            409,
+          ),
+        ),
+    },
+  };
+}
+
+export async function startInteractiveAttach(
+  station: InteractiveStation,
+  input: Record<string, unknown>,
+  hooks: DriverHooks,
+): Promise<StartedAttach> {
+  return station === 'telegram-user'
+    ? startTelegramUser(input, hooks)
+    : startWhatsapp(input, hooks);
+}