@stage-labs/metro 0.1.0-beta.15 → 0.1.0-beta.151

package/dist/cli/util.js

@@ -1,72 +0,0 @@
-/** Shared CLI primitives consumed by index.ts + config.ts. */
-export const exitErr = (msg, code) => Object.assign(new Error(msg), { code });
-export const isJson = (f) => f.json === true;
-export const writeJson = (obj) => void process.stdout.write(JSON.stringify(obj) + '\n');
-export const emit = (f, human, structured) => isJson(f) ? writeJson(structured) : void process.stdout.write(human + '\n');
-export const need = (positional, min, usage) => {
-    if (positional.length < min)
-        throw exitErr(`usage: ${usage}`, 1);
-};
-/** Return the last string value for `key` (or undefined). */
-export function flagOne(f, key) {
-    const v = f[key];
-    if (typeof v === 'string')
-        return v;
-    if (Array.isArray(v) && v.length)
-        return v[v.length - 1];
-    return undefined;
-}
-/** Return all string values for `key`, also splitting comma-separated entries. */
-export function flagList(f, key) {
-    const v = f[key];
-    const raw = typeof v === 'string' ? [v] : Array.isArray(v) ? v : [];
-    return raw.flatMap(s => s.split(',').map(p => p.trim()).filter(Boolean));
-}
-export function parseArgs(argv) {
-    const positional = [], flags = {};
-    const add = (k, val) => {
-        const cur = flags[k];
-        if (cur === undefined) {
-            flags[k] = val;
-            return;
-        }
-        if (typeof val === 'boolean') {
-            flags[k] = val;
-            return;
-        }
-        flags[k] = Array.isArray(cur) ? [...cur, val] : [cur, val];
-    };
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i];
-        if (!a.startsWith('--')) {
-            positional.push(a);
-            continue;
-        }
-        const eq = a.indexOf('=');
-        if (eq !== -1) {
-            add(a.slice(2, eq), a.slice(eq + 1));
-            continue;
-        }
-        const next = argv[i + 1];
-        if (next !== undefined && !next.startsWith('--')) {
-            add(a.slice(2), next);
-            i++;
-        }
-        else
-            add(a.slice(2), true);
-    }
-    return { positional, flags };
-}
-export async function resolveText(positional, from) {
-    if (positional.length > from)
-        return positional.slice(from).join(' ');
-    if (process.stdin.isTTY)
-        throw exitErr('text is required (or pipe text on stdin)', 1);
-    const chunks = [];
-    for await (const c of process.stdin)
-        chunks.push(c);
-    const stdin = Buffer.concat(chunks).toString('utf8').replace(/\n$/, '');
-    if (!stdin)
-        throw exitErr('text is required (or pipe text on stdin)', 1);
-    return stdin;
-}

package/dist/cli/webhook.js

@@ -1,181 +0,0 @@
-/** CLI subcommands: `metro call`, `metro trains list`, `metro webhook ...`, `metro tunnel ...`. */
-import { copyFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { spawnSync } from 'node:child_process';
-import { ipcCall } from '../ipc.js';
-import { loadMetroEnv } from '../paths.js';
-import { TRAINS_DIR } from '../trains/supervisor.js';
-import { addEndpoint, listEndpoints, loadTunnelConfig, removeEndpoint, saveTunnelConfig, webhookPort, } from '../tunnel.js';
-import { emit, exitErr, flagOne, isJson, need, writeJson } from './util.js';
-function urlFor(endpointId) {
-    const t = loadTunnelConfig();
-    return t ? `https://${t.hostname}/wh/${endpointId}` : `http://127.0.0.1:${webhookPort()}/wh/${endpointId}`;
-}
-export async function cmdWebhook(p, f) {
-    const sub = p[0];
-    if (sub === 'add')
-        return cmdWebhookAdd(p.slice(1), f);
-    if (sub === 'list' || sub === undefined)
-        return cmdWebhookList(f);
-    if (sub === 'remove' || sub === 'rm')
-        return cmdWebhookRemove(p.slice(1), f);
-    throw exitErr('usage: metro webhook [add <label> [--secret=…] | list | remove <id>]', 1);
-}
-async function cmdWebhookAdd(p, f) {
-    need(p, 1, 'metro webhook add <label> [--secret=<shared-secret>]');
-    const ep = addEndpoint(p[0], flagOne(f, 'secret'));
-    const url = urlFor(ep.id);
-    emit(f, `webhook ${ep.id} (${ep.label}) → ${url}${ep.secret ? `\nshared secret: ${ep.secret}` : ''}`, { ok: true, endpoint: ep, url });
-}
-async function cmdWebhookList(f) {
-    const eps = listEndpoints().map(ep => ({ ...ep, url: urlFor(ep.id) }));
-    if (isJson(f))
-        return writeJson({ endpoints: eps });
-    if (!eps.length)
-        return void process.stdout.write('metro webhooks\n\n  (none — run `metro webhook add <label>`)\n\n');
-    process.stdout.write('metro webhooks\n\n');
-    for (const ep of eps) {
-        process.stdout.write(`  ${ep.id}  ${ep.label}${ep.secret ? '  (signed)' : ''}\n        ${ep.url}\n`);
-    }
-    process.stdout.write('\n');
-}
-async function cmdWebhookRemove(p, f) {
-    need(p, 1, 'metro webhook remove <id>');
-    const ok = removeEndpoint(p[0]);
-    if (!ok)
-        throw exitErr(`no webhook with id "${p[0]}"`, 1);
-    emit(f, `removed webhook ${p[0]}`, { ok: true, id: p[0] });
-}
-export async function cmdTunnel(p, f) {
-    const sub = p[0];
-    if (sub === 'setup')
-        return cmdTunnelSetup(p.slice(1), f);
-    if (sub === 'status' || sub === undefined)
-        return cmdTunnelStatus(f);
-    throw exitErr('usage: metro tunnel [setup <name> <hostname> | status]', 1);
-}
-async function cmdTunnelSetup(p, f) {
-    need(p, 2, 'metro tunnel setup <tunnel-name> <hostname>     (e.g. `metro tunnel setup metro webhook.example.com`)');
-    const [name, hostname] = p;
-    if (!hasCloudflared()) {
-        throw exitErr('cloudflared not on PATH — install with `brew install cloudflared` (or see https://developers.cloudflare.com/cloudflared/)', 2);
-    }
-    /** Idempotent: if tunnel exists, `tunnel create` errors with "already exists" — that's fine, continue. */
-    run('cloudflared', ['tunnel', 'create', name], { allowFail: true });
-    /** DNS route is also idempotent in newer cloudflared; older versions error if the CNAME exists. Same handling. */
-    run('cloudflared', ['tunnel', 'route', 'dns', name, hostname], { allowFail: true });
-    saveTunnelConfig({ name, hostname });
-    emit(f, `tunnel saved: ${name} → ${hostname}\n` +
-        'first run: `cloudflared tunnel login` if you haven\'t (browser OAuth).\n' +
-        'then start metro — the daemon will spawn `cloudflared tunnel run` for you.', { ok: true, name, hostname });
-}
-async function cmdTunnelStatus(f) {
-    const cfg = loadTunnelConfig();
-    if (isJson(f))
-        return writeJson({ configured: !!cfg, tunnel: cfg });
-    if (!cfg)
-        return void process.stdout.write('metro tunnel\n\n  (not configured — run `metro tunnel setup <name> <hostname>`)\n\n');
-    process.stdout.write(`metro tunnel\n\n  name:     ${cfg.name}\n  hostname: ${cfg.hostname}\n\n`);
-}
-const hasCloudflared = () => spawnSync('cloudflared', ['--version'], { stdio: 'ignore' }).status === 0;
-function run(cmd, args, opts = {}) {
-    const r = spawnSync(cmd, args, { stdio: 'inherit' });
-    if (r.status !== 0 && !opts.allowFail)
-        throw exitErr(`${cmd} ${args.join(' ')} exited ${r.status}`, 2);
-}
-/* ──────────── metro call <train> <action> [args]  +  metro trains list ──────────── */
-async function readArgs(raw) {
-    if (raw === undefined)
-        return {};
-    if (raw === '-') {
-        const chunks = [];
-        for await (const c of process.stdin)
-            chunks.push(c);
-        const s = Buffer.concat(chunks).toString('utf8').trim();
-        return s ? JSON.parse(s) : {};
-    }
-    if (raw.startsWith('@'))
-        return JSON.parse(readFileSync(raw.slice(1), 'utf8'));
-    /** Bare string allowed (handed to the train as-is). */
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return raw;
-    }
-}
-export async function cmdCall(p, f) {
-    need(p, 2, 'metro call <train> <action> [args-json | @file | -]');
-    loadMetroEnv();
-    const [train, action, rawArgs] = p;
-    const resp = await ipcCall({ op: 'forward-call', train, action, args: await readArgs(rawArgs) });
-    if (!resp.ok)
-        throw new Error(resp.error);
-    if (!('response' in resp))
-        throw new Error('daemon returned malformed forward-call response');
-    if (resp.response.error)
-        throw new Error(`train '${train}': ${resp.response.error}`);
-    if (isJson(f))
-        writeJson(resp.response.result ?? null);
-    else
-        process.stdout.write(JSON.stringify(resp.response.result ?? null) + '\n');
-}
-export async function cmdTrains(p, f) {
-    const sub = p[0] ?? 'list';
-    if (sub === 'restart')
-        return cmdTrainsRestart(p.slice(1), f);
-    if (sub === 'new')
-        return cmdTrainsNew(p.slice(1), f);
-    if (sub !== 'list')
-        throw new Error(`metro trains <list|restart|new>   (got '${sub}')`);
-    loadMetroEnv();
-    const resp = await ipcCall({ op: 'trains-list' });
-    if (!resp.ok)
-        throw new Error(resp.error);
-    if (!('trains' in resp))
-        throw new Error('daemon returned malformed trains-list response');
-    if (isJson(f))
-        return writeJson({ trains: resp.trains });
-    if (!resp.trains.length) {
-        process.stdout.write('metro trains\n\n  (no trains in ~/.metro/trains/)\n');
-        return;
-    }
-    process.stdout.write('metro trains\n\n');
-    for (const t of resp.trains) {
-        const mark = t.running ? '●' : '○';
-        const pid = t.pid ? ` pid ${t.pid}` : '';
-        const started = t.startedAt ? ` since ${t.startedAt.slice(11, 19)}` : '';
-        const fails = t.failCount ? ` · ${t.failCount} fail${t.failCount === 1 ? '' : 's'}` : '';
-        process.stdout.write(`  ${mark} ${t.name.padEnd(16)}${pid}${started}${fails}\n        ${t.path}\n`);
-    }
-    process.stdout.write('\n');
-}
-async function cmdTrainsRestart(p, f) {
-    need(p, 1, 'metro trains restart <name>');
-    loadMetroEnv();
-    const resp = await ipcCall({ op: 'train-restart', name: p[0] });
-    if (!resp.ok)
-        throw new Error(resp.error);
-    emit(f, `restarted train '${p[0]}'`, { ok: true, name: p[0] });
-}
-/** dist/cli/webhook.js → <package-root>/examples/telegram.ts */
-const bundledExample = () => join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'examples', 'telegram.ts');
-async function cmdTrainsNew(p, f) {
-    need(p, 1, 'metro trains new <name>');
-    const name = p[0];
-    if (!/^[A-Za-z0-9_-]+$/.test(name))
-        throw exitErr(`bad train name '${name}' (use [A-Za-z0-9_-])`, 1);
-    const src = bundledExample();
-    if (!existsSync(src))
-        throw exitErr(`bundled example missing at ${src} (broken install?)`, 2);
-    mkdirSync(TRAINS_DIR, { recursive: true });
-    const dest = join(TRAINS_DIR, `${name}.ts`);
-    if (existsSync(dest))
-        throw exitErr(`train already exists: ${dest}`, 1);
-    copyFileSync(src, dest);
-    const metroPkg = join(homedir(), '.metro', 'package.json');
-    const pkgHint = existsSync(metroPkg) ? '' : '\n  (run `cd ~/.metro && bun init` first if your train needs deps)';
-    emit(f, `created ${dest}${pkgHint}\n  next: edit the file, then \`metro trains restart ${name}\``, { ok: true, path: dest, pkgInitialized: existsSync(metroPkg) });
-}

package/dist/codex-rc/client.js

@@ -1,225 +0,0 @@
-/** JSON-RPC/WS client for codex app-server: each event → `turn/start`. */
-import { errMsg, log } from '../log.js';
-import { buildTurnInput, encodeRpc, extractThreadStartedId, isStatusActive, openSocket, parseUrl, } from './protocol.js';
-const RECONNECT_DELAY_MS = 2_000;
-const MAX_QUEUE = 100;
-/** Backstop in case `turn/completed` never arrives — unstick the single-flight gate. */
-const TURN_TIMEOUT_MS = 120_000;
-export class CodexRC {
-    url;
-    clientVersion;
-    ws = null;
-    nextId = 1;
-    pending = new Map();
-    threadId = null;
-    threadListener = null;
-    queue = [];
-    connected = false;
-    connecting = false;
-    turnInFlight = false;
-    turnTimeout = null;
-    closed = false;
-    endpoint;
-    constructor(url, clientVersion) {
-        this.url = url;
-        this.clientVersion = clientVersion;
-        this.endpoint = parseUrl(url);
-    }
-    start() { void this.connect(); }
-    getThreadId() { return this.threadId; }
-    onThread(listener) { this.threadListener = listener; }
-    setThreadId(id) {
-        if (this.threadId === id)
-            return;
-        this.threadId = id;
-        this.threadListener?.(id);
-    }
-    stop() {
-        this.closed = true;
-        this.clearTurnTimeout();
-        this.ws?.close();
-        this.ws = null;
-    }
-    push(line) {
-        if (this.queue.length >= MAX_QUEUE) {
-            log.warn({ url: this.url }, 'codex-rc queue full, dropping oldest');
-            this.queue.shift();
-        }
-        this.queue.push(line);
-        void this.drainQueue();
-    }
-    async connect() {
-        if (this.closed || this.connected || this.connecting)
-            return;
-        this.connecting = true;
-        try {
-            const ws = openSocket(this.endpoint);
-            this.ws = ws;
-            ws.on('error', err => log.warn({ err: errMsg(err) }, 'codex-rc websocket error'));
-            await new Promise((resolve, reject) => {
-                ws.once('open', () => resolve());
-                ws.once('error', err => reject(err));
-            });
-            ws.on('message', data => this.onMessage(data));
-            ws.on('close', () => this.onClose());
-            const clientInfo = { name: 'metro', version: this.clientVersion, title: null };
-            await this.call('initialize', { clientInfo });
-            this.setThreadId(await this.pickOrCreateThread());
-            this.connected = true;
-            log.info({ url: this.url, thread: this.threadId ?? '(none yet)' }, 'codex-rc connected');
-            void this.drainQueue();
-        }
-        catch (err) {
-            log.warn({ err: errMsg(err), url: this.url }, 'codex-rc connect failed; retrying');
-            this.scheduleReconnect();
-        }
-        finally {
-            this.connecting = false;
-        }
-    }
-    onMessage(raw) {
-        let msg;
-        try {
-            msg = JSON.parse(raw.toString());
-        }
-        catch (err) {
-            log.warn({ err: errMsg(err) }, 'codex-rc malformed message');
-            return;
-        }
-        if (msg.id !== undefined && this.pending.has(msg.id)) {
-            const p = this.pending.get(msg.id);
-            this.pending.delete(msg.id);
-            if (msg.error)
-                p.reject(new Error(msg.error.message ?? 'rpc error'));
-            else
-                p.resolve(msg.result);
-            return;
-        }
-        this.handleNotification(msg);
-    }
-    handleNotification(msg) {
-        switch (msg.method) {
-            case 'thread/started': {
-                const id = extractThreadStartedId(msg.params);
-                if (id) {
-                    this.setThreadId(id);
-                    log.info({ thread: id }, 'codex-rc thread started');
-                    void this.drainQueue();
-                }
-                break;
-            }
-            case 'thread/status/changed': {
-                const s = isStatusActive(msg.params, this.threadId);
-                if (!s.match)
-                    break;
-                if (s.active)
-                    this.turnInFlight = true;
-                else {
-                    this.clearTurnTimeout();
-                    this.turnInFlight = false;
-                    void this.drainQueue();
-                }
-                break;
-            }
-            case 'turn/completed':
-                this.clearTurnTimeout();
-                this.turnInFlight = false;
-                void this.drainQueue();
-                break;
-            case 'turn/started':
-                this.turnInFlight = true;
-                break;
-            case 'thread/closed':
-            case 'thread/archived':
-                log.warn({ method: msg.method }, 'codex-rc thread closed/archived');
-                this.setThreadId(null);
-                break;
-        }
-    }
-    onClose() {
-        if (this.closed)
-            return;
-        this.connected = false;
-        this.ws = null;
-        for (const p of this.pending.values())
-            p.reject(new Error('websocket closed'));
-        this.pending.clear();
-        this.scheduleReconnect();
-    }
-    scheduleReconnect() {
-        if (this.closed)
-            return;
-        this.connected = false;
-        setTimeout(() => void this.connect(), RECONNECT_DELAY_MS);
-    }
-    /** Prefer the most-recently-loaded thread (the TUI's if attached); else create our own. */
-    async pickOrCreateThread() {
-        try {
-            const loaded = await this.call('thread/loaded/list', {});
-            const existing = loaded.data?.[loaded.data.length - 1];
-            if (existing)
-                return existing;
-        }
-        catch (err) {
-            log.warn({ err: errMsg(err) }, 'codex-rc thread/loaded/list failed');
-        }
-        try {
-            const created = await this.call('thread/start', {});
-            return created.thread?.id ?? null;
-        }
-        catch (err) {
-            log.warn({ err: errMsg(err) }, 'codex-rc thread/start failed');
-            return null;
-        }
-    }
-    async drainQueue() {
-        if (!this.connected || this.turnInFlight || !this.queue.length)
-            return;
-        if (!this.threadId) {
-            this.setThreadId(await this.pickOrCreateThread());
-            if (!this.threadId)
-                return;
-        }
-        const line = this.queue[0];
-        this.turnInFlight = true;
-        this.armTurnTimeout();
-        try {
-            await this.call('turn/start', { threadId: this.threadId, input: buildTurnInput(line) });
-            this.queue.shift();
-        }
-        catch (err) {
-            const dead = errMsg(err).includes('thread not found');
-            log.warn({ err: errMsg(err) }, dead ? 'codex-rc thread gone; will create a new one' : 'codex-rc turn/start failed; will retry');
-            this.clearTurnTimeout();
-            this.turnInFlight = false;
-            if (dead)
-                this.setThreadId(null);
-            setTimeout(() => void this.drainQueue(), 1_000);
-        }
-    }
-    armTurnTimeout() {
-        this.clearTurnTimeout();
-        this.turnTimeout = setTimeout(() => {
-            log.warn({ thread: this.threadId, queue: this.queue.length }, `codex-rc turn/completed not received within ${TURN_TIMEOUT_MS}ms; force-clearing gate`);
-            this.turnInFlight = false;
-            this.turnTimeout = null;
-            void this.drainQueue();
-        }, TURN_TIMEOUT_MS);
-    }
-    clearTurnTimeout() {
-        if (this.turnTimeout) {
-            clearTimeout(this.turnTimeout);
-            this.turnTimeout = null;
-        }
-    }
-    call(method, params) {
-        if (!this.ws)
-            return Promise.reject(new Error('not connected'));
-        const id = this.nextId++;
-        const ws = this.ws;
-        return new Promise((resolve, reject) => {
-            this.pending.set(id, { resolve: resolve, reject });
-            ws.send(encodeRpc(id, method, params));
-        });
-    }
-}

package/dist/codex-rc/protocol.js

@@ -1,38 +0,0 @@
-/** Codex JSON-RPC over WS: endpoint parsing, socket open, message encode/decode. */
-import { createConnection } from 'node:net';
-import { WebSocket } from 'ws';
-/** Accept ws://, wss://, unix:///abs/path, or /abs/path (shorthand for unix). */
-export function parseUrl(input) {
-    if (input.startsWith('ws://') || input.startsWith('wss://'))
-        return { kind: 'tcp', url: input };
-    if (input.startsWith('unix://'))
-        return { kind: 'unix', path: input.replace(/^unix:\/+/, '/') };
-    if (input.startsWith('/'))
-        return { kind: 'unix', path: input };
-    throw new Error(`unsupported METRO_CODEX_RC: ${input} (expected ws://, wss://, unix://, or abs path)`);
-}
-export function openSocket(endpoint) {
-    if (endpoint.kind === 'tcp')
-        return new WebSocket(endpoint.url);
-    return new WebSocket('ws://localhost/', {
-        createConnection: () => createConnection({ path: endpoint.path }),
-    });
-}
-export function encodeRpc(id, method, params) {
-    return JSON.stringify({ jsonrpc: '2.0', id, method, params });
-}
-/** Extract the active-thread state from a `thread/status/changed` params payload. */
-/** Codex 0.130+: `status: {active}` ⇒ in-flight; any other shape ⇒ idle. */
-export function isStatusActive(params, expectedThreadId) {
-    const p = params;
-    if (p?.threadId !== expectedThreadId)
-        return { match: false, active: false };
-    const active = typeof p.status === 'object' && p.status !== null && 'active' in p.status;
-    return { match: true, active };
-}
-export function extractThreadStartedId(params) {
-    return params?.thread?.id;
-}
-export function buildTurnInput(line) {
-    return [{ type: 'text', text: line, textElements: [] }];
-}

package/dist/dispatcher/server.js

@@ -1,122 +0,0 @@
-/** Dispatcher's plumbing: outbound event emission + train-envelope translation + HTTP receiver. */
-import { createHmac, randomUUID, timingSafeEqual } from 'node:crypto';
-import { createServer, } from 'node:http';
-import { Line } from '../lines.js';
-import { errMsg, log } from '../log.js';
-import { noteSeen } from '../paths.js';
-import { appendHistory, formatDisplay, mintId, noteUserFromLine, userSelf, } from '../history.js';
-import { handleMonitorRequest } from '../cli/tail.js';
-import { findEndpoint, listEndpoints, webhookPort } from '../tunnel.js';
-export function makeEmit(codexRc) {
-    return function emit(entry) {
-        /** `display` first so it survives Monitor's body truncation — the user must see it to echo it. */
-        const enriched = { display: formatDisplay(entry), ...entry };
-        const json = JSON.stringify(enriched);
-        process.stdout.write(json + '\n');
-        codexRc?.push(json);
-        noteSeen(entry.line, entry.lineName);
-        for (const l of [entry.line, entry.from, entry.to])
-            if (l)
-                noteUserFromLine(l);
-        appendHistory(enriched);
-    };
-}
-/** Translate the snake_case train wire envelope to a camelCase `HistoryEntry`. */
-/** Trains can omit `id`/`station`/`to`; metro fills sensible defaults. */
-export function trainEventToHistoryEntry(env, trainName) {
-    const line = env.line;
-    if (typeof line !== 'string') {
-        log.warn({ train: trainName }, 'train: dropped event without `line`');
-        return null;
-    }
-    const station = env.station ?? Line.station(line) ?? trainName;
-    const isPrivate = env.is_private === true;
-    /** Trains may still emit `emoji` for reactions — fold it into text so the new envelope stays minimal. */
-    const text = env.text ?? (env.emoji ? `[react ${env.emoji}]` : undefined);
-    return {
-        id: env.id ?? mintId(),
-        ts: env.ts ?? new Date().toISOString(),
-        station,
-        line: line,
-        lineName: env.line_name,
-        from: (env.from ?? `metro://${station}`),
-        fromName: env.from_name,
-        to: (env.to ?? (isPrivate ? userSelf() : line)),
-        text,
-        messageId: env.message_id,
-        replyTo: env.reply_to,
-        payload: env.payload,
-    };
-}
-export async function startWebhookServer(emit) {
-    const port = webhookPort();
-    const server = createServer((req, res) => {
-        handleRequest(req, res, emit).catch(err => {
-            log.warn({ err: errMsg(err) }, 'webhook handler error');
-            if (!res.headersSent)
-                res.writeHead(500).end();
-        });
-    });
-    await new Promise((resolve, reject) => {
-        server.once('error', reject);
-        server.listen(port, '127.0.0.1', () => {
-            log.info({ port, endpoints: listEndpoints().length }, 'webhook + monitor ready');
-            resolve();
-        });
-    });
-    return server;
-}
-async function handleRequest(req, res, emit) {
-    if (handleMonitorRequest(req, res, emit))
-        return;
-    const m = req.url?.match(/^\/wh\/([A-Za-z0-9_-]+)/);
-    if (!m) {
-        res.writeHead(404).end();
-        return;
-    }
-    const endpointId = m[1];
-    const endpoint = findEndpoint(endpointId);
-    if (!endpoint) {
-        res.writeHead(404).end();
-        return;
-    }
-    if (req.method === 'GET') {
-        res.writeHead(200).end(`metro webhook ${endpointId} ready\n`);
-        return;
-    }
-    if (req.method !== 'POST') {
-        res.writeHead(405).end();
-        return;
-    }
-    const chunks = [];
-    for await (const c of req)
-        chunks.push(c);
-    const raw = Buffer.concat(chunks);
-    const headers = Object.fromEntries(Object.entries(req.headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(',') : v ?? '']));
-    if (endpoint.secret && !verifySig(endpoint.secret, raw, headers['x-hub-signature-256'])) {
-        log.warn({ endpoint: endpointId }, 'webhook signature mismatch — rejecting');
-        res.writeHead(401).end('signature mismatch');
-        return;
-    }
-    let body = raw.toString('utf8');
-    try {
-        body = JSON.parse(body);
-    }
-    catch { /* keep as string */ }
-    const line = Line.webhook(endpointId);
-    emit({
-        id: mintId(), ts: new Date().toISOString(), station: 'webhook',
-        line, lineName: endpoint.label, from: line, to: line,
-        messageId: headers['x-github-delivery'] || headers['x-request-id'] || randomUUID(),
-        text: `${headers['x-github-event'] ?? headers['x-intercom-topic'] ?? 'event'} ${req.method} ${req.url}`,
-        payload: { headers, body },
-    });
-    res.writeHead(200).end('ok');
-}
-function verifySig(secret, raw, header) {
-    if (!header?.startsWith('sha256='))
-        return false;
-    const given = Buffer.from(header.slice(7), 'hex');
-    const want = createHmac('sha256', secret).update(raw).digest();
-    return given.length === want.length && timingSafeEqual(given, want);
-}