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

package/runtime/node_modules/@metro-labs/daemon/src/net/tunnel.ts

@@ -0,0 +1,316 @@
+import { execFile, spawn, type ChildProcess } from 'node:child_process';
+import { Resolver } from 'node:dns/promises';
+import { request as httpsRequest } from 'node:https';
+import { errMsg, log } from '@metro-labs/core/log';
+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;
+  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;
+const PUBLIC_RESOLVERS = ['1.1.1.1', '8.8.8.8'];
+
+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,
+  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 RESOLVE_EVERY_MS = 3_000;
+const RESOLVE_GIVE_UP_MS = 180_000;
+
+export async function resolvesPublicly(host: string): Promise<boolean> {
+  return (await publicAddresses(host)).length > 0;
+}
+
+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;
+}
+
+
+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;
+    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/policy/policy.ts

@@ -0,0 +1,118 @@
+import { ApiError } from '@metro-labs/http/api-error';
+import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
+import type { ToolGroup } from '@metro-labs/core/stations/types';
+
+export type Access = 'allow' | 'ask' | 'deny';
+
+export const ACCESS: readonly Access[] = ['allow', 'ask', 'deny'];
+
+export interface ToolPolicy {
+  read?: Access;
+  write?: Access;
+  tools?: Record<string, Access>;
+}
+
+export type PolicyTarget =
+  | { kind: 'channel'; station: string; account: string }
+  | { kind: 'connector'; id: string };
+
+export interface PolicyTool {
+  name: string;
+  group: ToolGroup;
+}
+
+const TOOL_NAME_RE = /^[A-Za-z0-9_.-]{1,128}$/;
+const MAX_TOOLS = 500;
+const RANK: Record<Access, number> = { allow: 0, ask: 1, deny: 2 };
+
+const isAccess = (value: unknown): value is Access => typeof value === 'string' && (ACCESS as readonly string[]).includes(value);
+
+export const targetKey = (target: PolicyTarget): string =>
+  target.kind === 'channel' ? `channel:${target.station}/${target.account}` : `connector:${target.id}`;
+
+export function decide(policy: ToolPolicy | undefined, tool: PolicyTool): Access {
+  return policy?.tools?.[tool.name] ?? policy?.[tool.group] ?? 'allow';
+}
+
+export function strictest(list: readonly Access[]): Access {
+  return list.reduce<Access>((worst, a) => (RANK[a] > RANK[worst] ? a : worst), 'allow');
+}
+
+function tolerantTools(raw: unknown, where: string): Record<string, Access> | undefined {
+  const kept: Record<string, Access> = {};
+  for (const [name, value] of Object.entries(isRecord(raw) ? raw : {})) {
+    if (TOOL_NAME_RE.test(name) && isAccess(value)) kept[name] = value;
+    else log.warn({ where, tool: name }, 'policy: a tool entry is not valid, ignored');
+  }
+  return Object.keys(kept).length > 0 ? kept : undefined;
+}
+
+export function parsePolicy(raw: unknown, where: string): ToolPolicy | undefined {
+  if (raw === undefined || raw === null) return undefined;
+  if (!isRecord(raw)) {
+    log.warn({ where }, 'policy: not an object, ignored');
+    return undefined;
+  }
+  const out: ToolPolicy = {};
+  for (const group of ['read', 'write'] as const) {
+    const value = raw[group];
+    if (isAccess(value)) out[group] = value;
+    else if (value !== undefined) log.warn({ where, group, value }, 'policy: a group value is not allow, ask or deny, ignored');
+  }
+  const tools = tolerantTools(raw.tools, where);
+  if (tools !== undefined) out.tools = tools;
+  return out;
+}
+
+function strictAccess(value: unknown, what: string): Access | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (!isAccess(value)) throw new ApiError(`${what} must be allow, ask or deny`, 400);
+  return value;
+}
+
+function strictTools(raw: unknown): Record<string, Access> | undefined {
+  if (raw === undefined || raw === null) return undefined;
+  if (!isRecord(raw)) throw new ApiError('policy.tools must be an object', 400);
+  const entries = Object.entries(raw);
+  if (entries.length > MAX_TOOLS) throw new ApiError(`policy.tools holds at most ${String(MAX_TOOLS)} tools`, 400);
+  const tools: Record<string, Access> = {};
+  for (const [name, value] of entries) {
+    if (!TOOL_NAME_RE.test(name)) throw new ApiError(`'${name}' is not a tool name`, 400);
+    const access = strictAccess(value, name);
+    if (access !== undefined) tools[name] = access;
+  }
+  return Object.keys(tools).length > 0 ? tools : undefined;
+}
+
+export function normalizePolicy(raw: unknown): ToolPolicy {
+  if (!isRecord(raw)) throw new ApiError('policy must be an object', 400);
+  const read = strictAccess(raw.read, 'read');
+  const write = strictAccess(raw.write, 'write');
+  const tools = strictTools(raw.tools);
+  return {
+    ...(read === undefined ? {} : { read }),
+    ...(write === undefined ? {} : { write }),
+    ...(tools === undefined ? {} : { tools }),
+  };
+}
+
+const stored = new Map<string, { target: PolicyTarget; policy: ToolPolicy }>();
+const listeners = new Set<() => void>();
+
+export function onPoliciesChanged(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+export function setPolicies(kind: PolicyTarget['kind'], entries: readonly (readonly [PolicyTarget, ToolPolicy])[]): void {
+  for (const key of [...stored.keys()]) if (key.startsWith(`${kind}:`)) stored.delete(key);
+  for (const [target, policy] of entries) if (target.kind === kind) stored.set(targetKey(target), { target, policy });
+  for (const listener of listeners) listener();
+}
+
+export const storedPolicies = (): { target: PolicyTarget; policy: ToolPolicy }[] => [...stored.values()];
+
+export const storedPolicy = (target: PolicyTarget): ToolPolicy | undefined => stored.get(targetKey(target))?.policy;
+
+export const policyFor = (target: PolicyTarget, tool: PolicyTool): Access => decide(storedPolicy(target), tool);

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

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ApiError } from '@metro-labs/http/api-error';
+import { setBearerSessions, type ApiSession } from '@metro-labs/http/api-http';
+import { bearerSession, clientId, jwksUrl, SigningKeys, workosBase, type KeyStore } from '@metro-labs/http/workos-token';
+import { ensureSecureDir, writeSecure } from '@metro-labs/core/secure-fs';
+
+const KEYS_FILE = '.jwks';
+
+export function jwksStore(dir: string): KeyStore {
+  const path = join(dir, KEYS_FILE);
+  return {
+    read: () => (existsSync(path) ? readFileSync(path, 'utf8') : null),
+    write: (text) => {
+      ensureSecureDir(dir);
+      writeSecure(path, text);
+    },
+  };
+}
+
+export function bearerSessionsFor(owner: () => string | null, keys: SigningKeys): (req: Parameters<typeof bearerSession>[0]) => Promise<ApiSession | null> {
+  return async (req) => {
+    const session = await bearerSession(req, keys);
+    if (session === null) return null;
+    const held = owner();
+    if (held === null || session.organization === null || session.organization !== held)
+      throw new ApiError('this machine belongs to another organization', 403);
+    return { subject: held, role: session.role === 'admin' ? 'admin' : 'member' };
+  };
+}
+
+export function installBearerSessions(dir: string, owner: () => string | null, env: NodeJS.ProcessEnv = process.env): void {
+  const keys = new SigningKeys(jwksUrl(clientId(env), workosBase(env)), jwksStore(dir));
+  setBearerSessions(bearerSessionsFor(owner, keys));
+}

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

package/runtime/node_modules/@metro-labs/{mcp/src/daemon → daemon/src/routes}/http.ts

@@ -1,12 +1,18 @@
 import { handleSessionApis, type SessionApis } from './session-apis.js';
+import { handleGatewayRequest } from '../gateway/gateway.js';
+import { handleRelayRequest } from '../connectors/relay.js';
+import { handleThreemaCallback } from './threema-callback.js';
+import { BodyTooLargeError, readBody, WEBHOOK_BODY_MAX } from './body.js';
+
+export { BodyTooLargeError, readBody } from './body.js';
 import {
   createServer,
   type IncomingMessage,
   type Server,
   type ServerResponse,
 } from 'node:http';
-import { Line } from '../stations/lines.js';
-import { errMsg, log } from './log.js';
+import { Line } from '@metro-labs/core/lines';
+import { errMsg, log } from '@metro-labs/core/log';
 import {
   classifyEvent,
   formatDisplay,
@@ -14,30 +20,25 @@ import {
   publishEvent,
   userSelf,
   type MetroEvent,
-} from './events.js';
-import type { TrainEvent } from './protocol.js';
-import { agentForLine, agentIdForLine } from '../db/agent-map.js';
-import {
-  findEndpointByWebhookId,
-  listEndpoints,
-  tokenMatches,
-  webhookPort,
-  type Endpoint,
-} from './tunnel.js';
-import { attachmentEventUrl, handleAttachRequest } from './attach-serve.js';
+} from '@metro-labs/core/events';
+import type { TrainEvent } from '@metro-labs/core/trains/protocol';
+import { agentForLine, agentIdForLine } from '../agents/map.js';
+import type { Endpoint } from '@metro-labs/core/endpoints';
+import { findEndpointByWebhookId, listEndpoints, tokenMatches } from '../stations/webhook-endpoints.js';
+import { attachmentEventUrl, handleAttachRequest, webhookPort } from '../files/attach-serve.js';
 import { webhookEntry } from '@metro-labs/webhook';
-import { handleGoogleAuthRequest } from './google-oauth.js';
-import { handleUploadRequest } from './upload-api.js';
+import { attachTerminalSockets } from '../terminal/socket.js';
+import { tmuxCommand } from '../terminal/api.js';
+import { handleModeRequest } from '@metro-labs/http/mode-api';
+import { handleUploadRequest } from '../files/upload-api.js';
 import {
   handleMonitorRequest,
-  type MonitorCall,
 } from '../monitor/api.js';
-import { applyMcpCors, handleMcpPreflight } from './cors.js';
+import { applyMcpCors, handleMcpPreflight } from '@metro-labs/http/cors';
+import { METRO_VERSION } from '@metro-labs/core/version';
 
 const LRU_CAP = 2_000;
 
-const METRO_VERSION = process.env.npm_package_version ?? '0.1.0-beta.15';
-
 function dedupKey(
   e: Pick<MetroEvent, 'station' | 'line' | 'messageId'>,
 ): string | null {
@@ -125,6 +126,18 @@ function eventText(env: TrainEvent): string | undefined {
   return env.emoji ? `[react ${env.emoji}]` : undefined;
 }
 
+function addressingFacts(
+  env: TrainEvent,
+  isPrivate: boolean,
+): Pick<MetroEvent, 'isPrivate' | 'mentionsSelf' | 'replyToSelf' | 'senderVerified'> {
+  return {
+    ...(isPrivate ? { isPrivate: true } : {}),
+    ...(env.mentions_self === true ? { mentionsSelf: true } : {}),
+    ...(env.reply_to_self === true ? { replyToSelf: true } : {}),
+    ...(typeof env.sender_verified === 'boolean' ? { senderVerified: env.sender_verified } : {}),
+  };
+}
+
 export function trainEventToMetroEvent(
   env: TrainEvent,
   trainName: string,
@@ -152,6 +165,7 @@ export function trainEventToMetroEvent(
     text,
     messageId: env.message_id,
     replyTo: env.reply_to,
+    ...addressingFacts(env, isPrivate),
     payload: env.payload,
   };
 }
@@ -162,16 +176,18 @@ export async function startWebhookServer(
   emit: Emit,
   apis: SessionApis = {},
   mcp?: McpHandler,
-  monitorCall?: MonitorCall,
+  monitor = false,
 ): Promise<Server> {
   const port = webhookPort();
   const server = createServer((req, res) => {
-    handleRequest(req, res, emit, apis, mcp, monitorCall).catch(
+    handleRequest(req, res, emit, apis, mcp, monitor).catch(
       (err: unknown) => {
       log.warn({ err: errMsg(err) }, 'webhook handler error');
       if (!res.headersSent) res.writeHead(500).end();
     });
   });
+  if (apis.terminalApi !== undefined)
+    attachTerminalSockets(server, { command: apis.terminalApi.command ?? tmuxCommand });
   await new Promise<void>((resolve, reject) => {
     server.once('error', reject);
     const host = process.env.METRO_HTTP_HOST ?? '127.0.0.1';
@@ -196,29 +212,6 @@ function isMcpPath(req: IncomingMessage): boolean {
   return path === '/' || path === '/mcp';
 }
 
-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);
-}
-
 function flatHeaders(req: IncomingMessage): Record<string, string> {
   return Object.fromEntries(
     Object.entries(req.headers).map(([k, v]) => [
@@ -322,20 +315,35 @@ async function handleWebhookRoute(
   return true;
 }
 
+function handleSignInRoutes(
+  req: IncomingMessage,
+  res: ServerResponse,
+  apis: SessionApis,
+): boolean {
+  return apis.mode !== undefined && handleModeRequest(req, res, apis.mode);
+}
+
+function handleEarlyRoutes(req: IncomingMessage, res: ServerResponse, apis: SessionApis): boolean {
+  if (handleHealth(req, res)) return true;
+  if (apis.gateway !== undefined && handleGatewayRequest(req, res, apis.gateway)) return true;
+  if (handleSignInRoutes(req, res, apis)) return true;
+  return handleSessionApis(req, res, apis);
+}
+
 async function handlePreMcpRoutes(
   req: IncomingMessage,
   res: ServerResponse,
   emit: Emit,
   apis: SessionApis,
-  monitorCall?: MonitorCall,
+  monitor = false,
 ): Promise<boolean> {
-  if (handleHealth(req, res)) return true;
-  if (await handleGoogleAuthRequest(req, res)) return true;
-  if (handleSessionApis(req, res, apis)) return true;
+  if (handleEarlyRoutes(req, res, apis)) return true;
   if (handleUploadRequest(req, res)) return true;
   if (handleAttachRequest(req, res)) return true;
+  if (apis.relayApi && handleRelayRequest(req, res, apis.relayApi)) return true;
   if (await handleWebhookRoute(req, res, emit)) return true;
-  return Boolean(monitorCall && handleMonitorRequest(req, res, monitorCall));
+  if (await handleThreemaCallback(req, res)) return true;
+  return monitor && handleMonitorRequest(req, res);
 }
 
 async function handleRequest(
@@ -344,9 +352,9 @@ async function handleRequest(
   emit: Emit,
   apis: SessionApis = {},
   mcp?: McpHandler,
-  monitorCall?: MonitorCall,
+  monitor = false,
 ): Promise<void> {
-  if (await handlePreMcpRoutes(req, res, emit, apis, monitorCall)) return;
+  if (await handlePreMcpRoutes(req, res, emit, apis, monitor)) return;
   if (mcp && isMcpPath(req)) {
     applyMcpCors(req, res);
     if (handleMcpPreflight(req, res)) return;