@stage-labs/metro 0.1.0-beta.13 → 0.1.0-beta.130

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

@@ -0,0 +1,237 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { stationByName } from '../stations/registry.js';
+import { errMsg, log } from '@metro-labs/core/log';
+import { subscribeEvents, type MetroEvent } from '@metro-labs/core/events';
+import { callTargetDenied, eventInScope } from '../agents/scope.js';
+import { hasAnyKey } from '../agents/keys.js';
+import {
+  allowedAgents,
+  authenticate,
+} from '../mcp/request-identity.js';
+import { METRO_VERSION } from '@metro-labs/core/version';
+
+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 monitorEnabled = (): boolean => hasAnyKey();
+
+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);
+  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/daemon/src/net/tunnel.ts

@@ -0,0 +1,389 @@
+import type { Endpoint } from '@metro-labs/core/endpoints';
+import { execFile, spawn, type ChildProcess } from 'node:child_process';
+import { timingSafeEqual } from 'node:crypto';
+import { Resolver } from 'node:dns/promises';
+import { request as httpsRequest } from 'node:https';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { errMsg, log } from '@metro-labs/core/log';
+import { readJson } from '@metro-labs/core/secure-fs';
+import { localOwner } from '../agents/file-admin.js';
+
+const RESTART_DELAY_MS = 2_000;
+const RESTART_DELAY_MAX_MS = 30_000;
+const TAKEN_RE = /listener already exists/i;
+const ADOPTED_MISSES = 2;
+const adoptedCheckMs = (): number => Number(process.env.METRO_TUNNEL_WATCH_MS) || 30_000;
+const FUNNEL_ON_RE = /\(Funnel on\)/i;
+
+export const tunnelWanted = (): boolean => process.env.METRO_TUNNEL?.trim() === 'tailscale';
+
+const FUNNEL_URL_RE = /https:\/\/[a-z0-9-]+(?:\.[a-z0-9-]+)+\.ts\.net(?::\d{2,5})?(?=[\s/]|$)/i;
+const SILENT_MS = 20_000;
+
+export const funnelUrlIn = (text: string): string | null =>
+  FUNNEL_URL_RE.exec(text)?.[0]?.toLowerCase() ?? null;
+
+export interface Adopted {
+  url: string | null;
+  hint: string;
+  alive?: () => Promise<boolean>;
+}
+
+export interface TunnelDriver {
+  name: string;
+  command: string;
+  args: string[];
+  urlIn: (text: string) => string | null;
+  waitsForDns: boolean;
+  adopt?: () => Promise<Adopted>;
+}
+
+const runText = (command: string, args: string[]): Promise<string> =>
+  new Promise((resolve) => {
+    execFile(command, args, { encoding: 'utf8', timeout: 10_000 }, (_err, stdout, stderr) => {
+      resolve(`${stdout}\n${stderr}`);
+    });
+  });
+
+export type Probe = (url: string, owner: string | null) => Promise<boolean>;
+
+const PROBE_MS = 5_000;
+
+async function publicAddresses(host: string): Promise<string[]> {
+  const found = await Promise.all(
+    PUBLIC_RESOLVERS.map(async (server) => {
+      const resolver = new Resolver();
+      resolver.setServers([server]);
+      const [v4, v6] = await Promise.all([resolver.resolve4(host).catch(() => []), resolver.resolve6(host).catch(() => [])]);
+      return [...v4, ...v6];
+    }),
+  );
+  return [...new Set(found.flat())];
+}
+
+function modeThrough(ip: string, host: string): Promise<{ mode?: unknown; owner?: unknown } | null> {
+  return new Promise((resolve) => {
+    const req = httpsRequest(
+      { host: ip, servername: host, port: 443, path: '/api/mode', method: 'GET', headers: { host }, timeout: PROBE_MS },
+      (res) => {
+        const chunks: Buffer[] = [];
+        res.on('data', (c: Buffer) => chunks.push(c));
+        res.on('end', () => {
+          try {
+            resolve(res.statusCode === 200 ? (JSON.parse(Buffer.concat(chunks).toString('utf8')) as { mode?: unknown }) : null);
+          } catch {
+            resolve(null);
+          }
+        });
+      },
+    );
+    req.on('timeout', () => {
+      req.destroy();
+    });
+    req.on('error', () => {
+      resolve(null);
+    });
+    req.end();
+  });
+}
+
+export async function daemonAnswersAt(url: string, owner: string | null): Promise<boolean> {
+  const host = new URL(url).host;
+  const addresses = await publicAddresses(host);
+  if (addresses.length === 0) return false;
+  const body = await modeThrough(addresses[0] ?? '', host);
+  return body !== null && body.mode === 'local' && (owner === null || body.owner === owner);
+}
+
+export function nodeNameIn(statusJson: string): string | null {
+  try {
+    const parsed: unknown = JSON.parse(statusJson);
+    const self = typeof parsed === 'object' && parsed !== null ? (parsed as { Self?: { DNSName?: unknown } }).Self : undefined;
+    const name = typeof self?.DNSName === 'string' ? self.DNSName.replace(/\.$/, '').toLowerCase() : '';
+    return name === '' ? null : name;
+  } catch {
+    return null;
+  }
+}
+
+async function adoptFunnel(bin: string, port: number, probe: Probe, owner: () => string | null): Promise<Adopted> {
+  const name = nodeNameIn(await runText(bin, ['status', '--json']));
+  const watched = (url: string): Adopted => ({
+    url,
+    hint: `a Funnel already publishes this daemon at ${url}; using it`,
+    alive: () => probe(url, owner()),
+  });
+  if (name !== null) {
+    const url = `https://${name}`;
+    if (await probe(url, owner())) return watched(url);
+  }
+  const found = funnelAlreadyServing(await runText(bin, ['funnel', 'status']), port);
+  return found.url === null ? found : watched(found.url);
+}
+
+export function funnelAlreadyServing(status: string, port: number): Adopted {
+  const lines = status.split('\n');
+  const target = `http://127.0.0.1:${String(port)}`;
+  for (const [i, line] of lines.entries()) {
+    if (line.trimStart().startsWith('#')) continue;
+    const url = funnelUrlIn(line);
+    if (url === null) continue;
+    const body = lines.slice(i + 1, i + 6).join('\n');
+    if (!body.includes(target)) continue;
+    if (FUNNEL_ON_RE.test(line)) return { url, hint: `a Funnel already publishes this daemon at ${url}; using it` };
+    return {
+      url: null,
+      hint: `${url} is a tailnet-only serve config on this node, not a Funnel; run: tailscale serve reset`,
+    };
+  }
+  return { url: null, hint: 'port 443 is held by another serve config on this node; run: tailscale serve reset' };
+}
+
+function tailscaleBin(): string {
+  const configured = process.env.METRO_TAILSCALE_BIN?.trim() ?? '';
+  return configured === '' ? 'tailscale' : configured;
+}
+
+export const funnelDriver = (
+  port: number,
+  bin = tailscaleBin(),
+  probe: Probe = daemonAnswersAt,
+  owner: () => string | null = localOwner,
+): TunnelDriver => ({
+  name: 'tailscale funnel',
+  command: bin,
+  args: ['funnel', String(port)],
+  urlIn: funnelUrlIn,
+  waitsForDns: true,
+  adopt: () => adoptFunnel(bin, port, probe, owner),
+});
+
+let liveUrl: string | null = null;
+
+export const currentTunnelUrl = (): string | null => liveUrl;
+
+export type Resolves = (host: string) => Promise<boolean>;
+
+const PUBLIC_RESOLVERS = ['1.1.1.1', '8.8.8.8'];
+const RESOLVE_EVERY_MS = 3_000;
+const RESOLVE_GIVE_UP_MS = 180_000;
+
+async function resolvesAt(server: string, host: string): Promise<boolean> {
+  const resolver = new Resolver();
+  resolver.setServers([server]);
+  const answers = await Promise.all([
+    resolver.resolve4(host).catch(() => []),
+    resolver.resolve6(host).catch(() => []),
+  ]);
+  return answers.some((a) => a.length > 0);
+}
+
+export async function resolvesPublicly(host: string): Promise<boolean> {
+  const found = await Promise.all(PUBLIC_RESOLVERS.map((server) => resolvesAt(server, host)));
+  return found.some(Boolean);
+}
+
+async function untilResolvable(host: string, resolves: Resolves): Promise<boolean> {
+  const deadline = Date.now() + RESOLVE_GIVE_UP_MS;
+  while (Date.now() < deadline) {
+    if (await resolves(host)) return true;
+    await new Promise((r) => setTimeout(r, RESOLVE_EVERY_MS));
+  }
+  return false;
+}
+
+interface AccountRecord {
+  id?: unknown;
+  webhookId?: unknown;
+  label?: unknown;
+  secret?: unknown;
+  createdAt?: unknown;
+}
+
+export const webhookPort = (): number =>
+  Number(process.env.METRO_WEBHOOK_PORT) || 8420;
+
+export type { Endpoint };
+
+const accountsFile = (): string =>
+  process.env.WEBHOOK_ACCOUNTS_FILE ??
+  join(homedir(), '.metro', 'webhook-accounts.json');
+
+const str = (v: unknown): string | undefined =>
+  typeof v === 'string' && v !== '' ? v : undefined;
+
+function toEndpoint(raw: AccountRecord): Endpoint | null {
+  const id = str(raw.id);
+  if (id === undefined) return null;
+  return {
+    id,
+    webhookId: str(raw.webhookId),
+    label: str(raw.label) ?? id,
+    secret: str(raw.secret),
+    createdAt: str(raw.createdAt) ?? '',
+  };
+}
+
+export function listEndpoints(): Endpoint[] {
+  const raw = readJson<AccountRecord[]>(accountsFile(), [], {
+    warn: 'webhook-accounts.json: malformed, ignoring',
+  });
+  if (!Array.isArray(raw)) return [];
+  return raw.map(toEndpoint).filter((e): e is Endpoint => e !== null);
+}
+
+export const findEndpointByWebhookId = (
+  webhookId: string,
+): Endpoint | undefined =>
+  listEndpoints().find((e) => e.webhookId === webhookId);
+
+export function tokenMatches(secret: string, given: string): boolean {
+  const want = Buffer.from(secret);
+  const got = Buffer.from(given);
+  return want.length === got.length && timingSafeEqual(want, got);
+}
+
+export class Tunnel {
+  private child: ChildProcess | null = null;
+  private closed = false;
+  private output: string[] = [];
+  private restartDelay = RESTART_DELAY_MS;
+  private watch: ReturnType<typeof setInterval> | null = null;
+
+  constructor(
+    private driver: TunnelDriver,
+    private onUrl: (url: string) => void = () => undefined,
+    private resolves: Resolves = resolvesPublicly,
+  ) {}
+
+  private noticeUrl(text: string): void {
+    const url = this.driver.urlIn(text);
+    if (url === null || url === liveUrl) return;
+    liveUrl = url;
+    this.restartDelay = RESTART_DELAY_MS;
+    if (!this.driver.waitsForDns) {
+      log.info({ url }, `${this.driver.name} up`);
+      this.onUrl(url);
+      return;
+    }
+    log.info({ url }, `${this.driver.name} up; waiting for its name to resolve`);
+    this.announceWhenResolvable(url).catch((err: unknown) => {
+      log.warn({ err: errMsg(err) }, `${this.driver.name}: announce failed`);
+    });
+  }
+
+  private async announceWhenResolvable(url: string): Promise<void> {
+    const resolved = await untilResolvable(new URL(url).host, this.resolves);
+    if (liveUrl !== url) return;
+    if (!resolved) log.warn({ url }, `${this.driver.name} name still not resolving; announcing anyway`);
+    this.onUrl(url);
+  }
+
+  private read(d: Buffer | string): void {
+    const text = (typeof d === 'string' ? d : d.toString('utf8')).trim();
+    if (text === '') return;
+    this.output.push(text);
+    log.debug({ output: text }, this.driver.name);
+    this.noticeUrl(text);
+  }
+
+  private silentCheck(): void {
+    if (this.closed || liveUrl !== null || this.child === null) return;
+    log.warn(
+      { output: this.output.join('\n') },
+      `${this.driver.name}: no public address after ${String(SILENT_MS / 1000)}s; its own output follows`,
+    );
+  }
+
+  start(): void {
+    if (this.closed) return;
+    log.info({ command: this.driver.command, args: this.driver.args }, `${this.driver.name} starting`);
+    this.output = [];
+    const child = spawn(this.driver.command, this.driver.args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    this.child = child;
+    child.stdout?.on('data', (d: Buffer | string) => {
+      this.read(d);
+    });
+    child.stderr?.on('data', (d: Buffer | string) => {
+      this.read(d);
+    });
+    setTimeout(() => {
+      this.silentCheck();
+    }, SILENT_MS).unref();
+    child.on('exit', (code) => {
+      this.child = null;
+      liveUrl = null;
+      if (this.closed) return;
+      this.afterExit(code).catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, `${this.driver.name}: exit handling failed`);
+      });
+    });
+    child.on('error', (err) => {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        this.closed = true;
+        log.error(
+          { command: this.driver.command },
+          `${this.driver.name}: the binary is not installed, so there is no public address; install it and restart`,
+        );
+        return;
+      }
+      log.warn({ err: errMsg(err) }, `${this.driver.name} spawn error`);
+    });
+  }
+
+  private async afterExit(code: number | null): Promise<void> {
+    const output = this.output.join('\n');
+    if (this.driver.adopt !== undefined && TAKEN_RE.test(output)) {
+      const found = await this.driver.adopt();
+      if (this.closed) return;
+      if (found.url !== null) {
+        log.info({ url: found.url }, `${this.driver.name}: ${found.hint}`);
+        this.noticeUrl(found.url);
+        if (found.alive !== undefined) this.watchAdopted(found.url, found.alive);
+        return;
+      }
+      log.error({ output }, `${this.driver.name}: ${found.hint}`);
+    } else log.warn({ code, output: this.output.slice(-5).join('\n') }, `${this.driver.name} exited; restarting`);
+    setTimeout(() => {
+      this.start();
+    }, this.restartDelay);
+    this.restartDelay = Math.min(this.restartDelay * 2, RESTART_DELAY_MAX_MS);
+  }
+
+  private watchAdopted(url: string, alive: () => Promise<boolean>): void {
+    let misses = 0;
+    const tick = async (): Promise<void> => {
+      if (this.closed || liveUrl !== url) {
+        this.unwatch();
+        return;
+      }
+      misses = (await alive()) ? 0 : misses + 1;
+      if (misses < ADOPTED_MISSES) return;
+      this.unwatch();
+      log.warn({ url }, `${this.driver.name}: the Funnel this daemon adopted no longer answers; publishing our own`);
+      liveUrl = null;
+      this.restartDelay = RESTART_DELAY_MS;
+      this.start();
+    };
+    this.unwatch();
+    this.watch = setInterval(() => {
+      tick().catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, `${this.driver.name}: adopted-funnel check failed`);
+      });
+    }, adoptedCheckMs());
+    this.watch.unref();
+  }
+
+  private unwatch(): void {
+    if (this.watch !== null) clearInterval(this.watch);
+    this.watch = null;
+  }
+
+  stop(): void {
+    this.closed = true;
+    this.unwatch();
+    this.child?.kill('SIGINT');
+    this.child = null;
+  }
+}

package/runtime/node_modules/@metro-labs/daemon/src/routes/body.ts

@@ -0,0 +1,24 @@
+import type { IncomingMessage } from 'node:http';
+
+export const WEBHOOK_BODY_MAX = 25 * 1024 * 1024;
+
+export class BodyTooLargeError extends Error {
+  constructor(readonly limit: number) {
+    super(`request body exceeds ${limit} bytes`);
+  }
+}
+
+export async function readBody(
+  req: IncomingMessage,
+  maxBytes: number,
+): Promise<Buffer> {
+  const chunks: Buffer[] = [];
+  let total = 0;
+  for await (const c of req) {
+    const buf = c as Buffer;
+    total += buf.length;
+    if (total > maxBytes) throw new BodyTooLargeError(maxBytes);
+    chunks.push(buf);
+  }
+  return Buffer.concat(chunks);
+}