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

package/dist/stations/index.js

@@ -1,129 +0,0 @@
-/** Line URI scheme + ChatStation interface + station listing. The whole station surface. */
-import { tryClaudeAccountId } from './claude.js';
-import { tryCodexAccountId } from './codex.js';
-import { listUsers } from '../registry.js';
-import { listEndpoints, webhookPort } from '../webhooks.js';
-import { loadTunnelConfig } from '../tunnel.js';
-export const asLine = (s) => s;
-const PREFIX = 'metro://';
-const build = (station, ...seg) => asLine(`${PREFIX}${station}/${seg.map(String).join('/')}`);
-/** Shared parser for `metro://{claude,codex}/<userId>/<sessionId>`. Skips the `/user/…` participant URI. */
-function parseLocalSession(line, station) {
-    const p = Line.parse(line);
-    if (p?.station !== station || p.path[0] === 'user' || p.path.length < 2)
-        return null;
-    return { userId: p.path[0], sessionId: p.path[1] };
-}
-/** URI helpers. Lives on a const that doubles as the `Line` type's value-side namespace. */
-export const Line = {
-    discord: (channelId) => build('discord', channelId),
-    telegram: (chatId, topicId) => topicId !== undefined ? build('telegram', chatId, topicId) : build('telegram', chatId),
-    /** `metro://claude/<orgId>/<sessionId>` — orgId from `claude auth status`, session from `CLAUDE_CODE_SESSION_ID`. */
-    claude: (orgId, sessionId) => build('claude', orgId, sessionId),
-    /** `metro://codex/<accountId>/<threadId>` — accountId from auth.json, thread from codex-rc handshake. */
-    codex: (accountId, threadId) => build('codex', accountId, threadId),
-    /** `metro://webhook/<endpoint-id>` — one HTTP receive endpoint, registered via `metro webhook add`. */
-    webhook: (endpointId) => build('webhook', endpointId),
-    /** Participant URI — `metro://<station>/user/<id>`. */
-    user: (station, id) => build(station, 'user', id),
-    parse(line) {
-        if (!line.startsWith(PREFIX))
-            return null;
-        const rest = line.slice(PREFIX.length);
-        const slash = rest.indexOf('/');
-        if (slash <= 0)
-            return null;
-        const path = rest.slice(slash + 1).split('/').filter(Boolean);
-        return path.length ? { station: rest.slice(0, slash), path } : null;
-    },
-    station: (line) => Line.parse(line)?.station ?? null,
-    parseDiscord(line) {
-        const p = Line.parse(line);
-        return p?.station === 'discord' && p.path.length === 1 ? p.path[0] : null;
-    },
-    parseTelegram(line) {
-        const p = Line.parse(line);
-        if (p?.station !== 'telegram')
-            return null;
-        const chatId = Number(p.path[0]);
-        if (!Number.isFinite(chatId))
-            return null;
-        if (p.path.length === 1)
-            return { chatId };
-        const topicId = Number(p.path[1]);
-        return Number.isFinite(topicId) ? { chatId, topicId } : null;
-    },
-    parseClaude: (line) => parseLocalSession(line, 'claude'),
-    parseCodex: (line) => parseLocalSession(line, 'codex'),
-    parseWebhook(line) {
-        const p = Line.parse(line);
-        return p?.station === 'webhook' && p.path.length === 1 ? p.path[0] : null;
-    },
-    isLocal: (line) => {
-        const s = Line.station(line);
-        return s === 'claude' || s === 'codex';
-    },
-};
-function seenSummary(station) {
-    const users = listUsers(station);
-    if (!users.length)
-        return '';
-    const sessions = users.reduce((n, u) => n + u.sessions.length, 0);
-    return ` · seen ${users.length} user${users.length === 1 ? '' : 's'}, ${sessions} session${sessions === 1 ? '' : 's'}`;
-}
-function claudeStationDetail() {
-    const seen = seenSummary('claude');
-    if (!process.env.CLAUDECODE)
-        return `launch metro from inside a Claude Code session${seen}`;
-    const orgId = tryClaudeAccountId();
-    return `${orgId ? `account: ${orgId}` : 'logged out — run `claude auth login`'}${seen}`;
-}
-function codexStationDetail() {
-    const rc = process.env.METRO_CODEX_RC;
-    const accountId = tryCodexAccountId();
-    const seen = seenSummary('codex');
-    const parts = [
-        accountId ? `account: ${accountId}` : (rc ? '(no Codex account — run `codex login`)' : null),
-        rc ? `push → ${rc}` : (!accountId ? 'set METRO_CODEX_RC=ws://… to push' : null),
-    ].filter(Boolean);
-    return `${parts.join(' · ')}${seen}`;
-}
-export const listStations = () => [
-    {
-        name: 'discord',
-        capabilities: { in: ['text', 'image'], out: ['text'], features: ['reply', 'send', 'edit', 'react', 'download', 'fetch'] },
-        configured: !!process.env.DISCORD_BOT_TOKEN, detail: 'DISCORD_BOT_TOKEN',
-    },
-    {
-        name: 'telegram',
-        capabilities: { in: ['text', 'image'], out: ['text'], features: ['reply', 'send', 'edit', 'react', 'download', 'fetch'] },
-        configured: !!process.env.TELEGRAM_BOT_TOKEN, detail: 'TELEGRAM_BOT_TOKEN',
-    },
-    {
-        name: 'claude',
-        capabilities: { in: ['text'], out: ['text'], features: ['send'] },
-        configured: !!process.env.CLAUDECODE,
-        detail: claudeStationDetail(),
-    },
-    {
-        name: 'codex',
-        capabilities: { in: ['text'], out: ['text'], features: ['send'] },
-        configured: !!(process.env.METRO_CODEX_RC || process.env.CODEX_HOME),
-        detail: codexStationDetail(),
-    },
-    {
-        name: 'webhook',
-        capabilities: { in: ['text'], out: [], features: [] },
-        configured: listEndpoints().length > 0,
-        detail: webhookStationDetail(),
-    },
-];
-function webhookStationDetail() {
-    const eps = listEndpoints();
-    const t = loadTunnelConfig();
-    const base = t ? `https://${t.hostname}` : `http://127.0.0.1:${webhookPort()}`;
-    if (!eps.length)
-        return `no endpoints (run \`metro webhook add <label>\`)${t ? ` · tunnel → ${t.hostname}` : ''}`;
-    return `${eps.length} endpoint${eps.length === 1 ? '' : 's'} · base ${base}${t ? '' : ' (no tunnel — run `metro tunnel setup`)'}`;
-}
-export const fmtCapabilities = (c) => `in: ${c.in.join('+') || '–'} · out: ${c.out.join('+') || '–'} · features: ${c.features.join(', ') || '–'}`;

package/dist/stations/telegram-md.js

@@ -1,34 +0,0 @@
-/** Convert markdown → Telegram HTML. Stream-safe: unmatched markers fall through as literal text. */
-const ENTITY_MAP = { '&': '&amp;', '<': '&lt;', '>': '&gt;' };
-const esc = (s) => s.replace(/[&<>]/g, c => ENTITY_MAP[c]);
-/** SOH — invalid in Telegram text + never in user output, so collisions are impossible. */
-const SENT = '\x01';
-export function mdToTelegramHtml(md) {
-    const slots = [];
-    const stash = (html) => { slots.push(html); return `${SENT}${slots.length - 1}${SENT}`; };
-    /* Fenced code first so its contents aren't touched by other rules. */
-    let work = md.replace(/```([A-Za-z0-9_+\-.]*)\n?([\s\S]*?)```/g, (_m, lang, code) => {
-        return stash(lang
-            ? `<pre><code class="language-${esc(lang)}">${esc(code)}</code></pre>`
-            : `<pre>${esc(code)}</pre>`);
-    });
-    /* Inline code (single-line only — multi-line spans look like unclosed mid-stream fences). */
-    work = work.replace(/`([^`\n]+)`/g, (_m, code) => stash(`<code>${esc(code)}</code>`));
-    work = esc(work);
-    work = work.replace(/\[([^\]\n]+)\]\(([^)\s]+)\)/g, (_m, text, url) => stash(`<a href="${url.replace(/"/g, '%22')}">${text}</a>`));
-    /* Bold before italic so `*`-rule doesn't eat half of `**bold**`. */
-    work = work.replace(/\*\*([^*\n]+?)\*\*/g, '<b>$1</b>').replace(/__([^_\n]+?)__/g, '<b>$1</b>');
-    /* \S guards keep `2 * 3` arithmetic and `foo_bar` identifiers intact. */
-    work = work
-        .replace(/(^|[^*\w])\*(\S[^*\n]*?\S|\S)\*(?!\w)/g, '$1<i>$2</i>')
-        .replace(/(^|[^_\w])_(\S[^_\n]*?\S|\S)_(?!\w)/g, '$1<i>$2</i>');
-    work = work.replace(/~~([^~\n]+?)~~/g, '<s>$1</s>');
-    /* Headings → bold (Telegram has no heading element). */
-    work = work.replace(/^#{1,6}\s+(.+?)\s*$/gm, '<b>$1</b>');
-    /* Collapse consecutive `> ` lines into one <blockquote>. */
-    work = work.replace(/(^|\n)((?:&gt;\s?[^\n]*\n?)+)/g, (_m, lead, block) => {
-        const inner = block.replace(/^&gt;\s?/gm, '').replace(/\n+$/, '');
-        return `${lead}<blockquote>${inner}</blockquote>${block.endsWith('\n') ? '\n' : ''}`;
-    });
-    return work.replace(new RegExp(`${SENT}(\\d+)${SENT}`, 'g'), (_m, idx) => slots[Number(idx)]);
-}

package/dist/stations/telegram-upload.js

@@ -1,113 +0,0 @@
-/** Telegram outgoing sends — single multipart, media groups, and the rich-content dispatch. */
-import { readFile } from 'node:fs/promises';
-import { basename } from 'node:path';
-import { log } from '../log.js';
-import { mdToTelegramHtml } from './telegram-md.js';
-const API_BASE = 'https://api.telegram.org';
-const NO_PREVIEW = { link_preview_options: { is_disabled: true } };
-export const inlineKeyboard = (rows) => ({ inline_keyboard: rows });
-async function post(token, method, form) {
-    const res = await fetch(`${API_BASE}/bot${token}/${method}`, {
-        method: 'POST', body: form, signal: AbortSignal.timeout(60_000),
-    });
-    const json = (await res.json());
-    if (!json.ok)
-        throw new Error(`telegram ${method}: ${json.description ?? 'unknown error'}`);
-    return json.result;
-}
-function appendFields(form, fields) {
-    for (const [k, v] of Object.entries(fields)) {
-        if (v === undefined || v === null)
-            continue;
-        form.append(k, typeof v === 'string' ? v : JSON.stringify(v));
-    }
-}
-async function appendFile(form, field, filePath) {
-    form.append(field, new Blob([new Uint8Array(await readFile(filePath))]), basename(filePath));
-}
-const isParseError = (err) => err instanceof Error && err.message.includes("can't parse entities");
-/** sendPhoto / sendDocument / sendVoice with HTML-caption + plain fallback. */
-async function sendOne(token, base, method, fileField, filePath, caption) {
-    const attempt = async (html) => {
-        const form = new FormData();
-        appendFields(form, {
-            ...base,
-            caption: html ? mdToTelegramHtml(caption) : caption,
-            ...(html ? { parse_mode: 'HTML' } : {}),
-        });
-        await appendFile(form, fileField, filePath);
-        return post(token, method, form);
-    };
-    try {
-        return String((await attempt(true)).message_id);
-    }
-    catch (err) {
-        if (!isParseError(err))
-            throw err;
-        log.warn('telegram: HTML rejected, retrying plain');
-        return String((await attempt(false)).message_id);
-    }
-}
-/** sendMediaGroup — 2-10 same-kind files. Caption goes on the first item only. */
-async function sendGroup(token, base, kind, paths, caption) {
-    const form = new FormData();
-    appendFields(form, base);
-    const media = await Promise.all(paths.map(async (p, i) => {
-        const field = `m${i}`;
-        await appendFile(form, field, p);
-        return {
-            type: kind, media: `attach://${field}`,
-            ...(i === 0 && caption ? { caption: mdToTelegramHtml(caption), parse_mode: 'HTML' } : {}),
-        };
-    }));
-    form.append('media', JSON.stringify(media));
-    const sent = await post(token, 'sendMediaGroup', form);
-    return String(sent[0].message_id);
-}
-/** Plain text via sendMessage with HTML + plain fallback. */
-async function sendText(send, base, text) {
-    const attempt = (html) => send('sendMessage', html ? { ...base, ...NO_PREVIEW, text: mdToTelegramHtml(text), parse_mode: 'HTML' }
-        : { ...base, ...NO_PREVIEW, text });
-    try {
-        return String((await attempt(true)).message_id);
-    }
-    catch (err) {
-        if (!isParseError(err))
-            throw err;
-        log.warn('telegram: HTML rejected, sending plain');
-        return String((await attempt(false)).message_id);
-    }
-}
-/** Dispatch for text + images + documents + voice + buttons. Returns the first message id. */
-export async function tgSendRich(token, send, base, text, opts) {
-    const images = opts?.images ?? [], docs = opts?.documents ?? [], voice = opts?.voice;
-    const total = images.length + docs.length + (voice ? 1 : 0);
-    const baseWithButtons = opts?.buttons?.length
-        ? { ...base, reply_markup: inlineKeyboard(opts.buttons) } : base;
-    if (total === 0)
-        return sendText(send, baseWithButtons, text);
-    if (total === 1) {
-        if (voice)
-            return sendOne(token, baseWithButtons, 'sendVoice', 'voice', voice, text);
-        if (images.length)
-            return sendOne(token, baseWithButtons, 'sendPhoto', 'photo', images[0], text);
-        return sendOne(token, baseWithButtons, 'sendDocument', 'document', docs[0], text);
-    }
-    /* Multi-attachment: media groups don't support reply_markup — buttons are dropped. */
-    if (opts?.buttons?.length)
-        log.warn('telegram: buttons dropped on multi-attachment send');
-    let first;
-    let caption = text;
-    const claim = async (id) => { first ??= id; caption = ''; };
-    if (voice)
-        await claim(await sendOne(token, base, 'sendVoice', 'voice', voice, caption));
-    if (images.length === 1)
-        await claim(await sendOne(token, base, 'sendPhoto', 'photo', images[0], caption));
-    else if (images.length)
-        await claim(await sendGroup(token, base, 'photo', images, caption));
-    if (docs.length === 1)
-        await claim(await sendOne(token, base, 'sendDocument', 'document', docs[0], caption));
-    else if (docs.length)
-        await claim(await sendGroup(token, base, 'document', docs, caption));
-    return first;
-}

package/dist/stations/telegram.js

@@ -1,234 +0,0 @@
-/** Telegram station: long-poll Bot API; sends markdown as HTML with plain-text fallback. */
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { errMsg, log } from '../log.js';
-import { mintId } from '../history.js';
-import { mdToTelegramHtml } from './telegram-md.js';
-import { inlineKeyboard, tgSendRich } from './telegram-upload.js';
-import { Line, } from './index.js';
-import { STATE_DIR } from '../paths.js';
-const API_BASE = 'https://api.telegram.org';
-const NO_PREVIEW = { link_preview_options: { is_disabled: true } };
-const MAX_BYTES = 20 * 1024 * 1024;
-const token = () => {
-    const t = process.env.TELEGRAM_BOT_TOKEN;
-    if (!t)
-        throw new Error('TELEGRAM_BOT_TOKEN is not set');
-    return t;
-};
-async function tg(method, body, opts = {}) {
-    const signals = [AbortSignal.timeout(opts.timeoutMs ?? 30_000)];
-    if (opts.signal)
-        signals.push(opts.signal);
-    const res = await fetch(`${API_BASE}/bot${token()}/${method}`, {
-        method: 'POST', headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body), signal: AbortSignal.any(signals),
-    });
-    const json = (await res.json());
-    if (!json.ok)
-        throw new Error(`telegram ${method}: ${json.description ?? 'unknown error'}`);
-    return json.result;
-}
-const isParseError = (err) => errMsg(err).includes("can't parse entities");
-const isNoopEdit = (err) => errMsg(err).includes('message is not modified');
-const targetOf = (line) => {
-    const t = Line.parseTelegram(line);
-    if (!t)
-        throw new Error(`not a telegram line: ${line}`);
-    return t;
-};
-function attachmentTags(m) {
-    const out = [];
-    if (m.photo?.length)
-        out.push('[image]');
-    if (m.document?.mime_type?.startsWith('image/'))
-        out.push('[image]');
-    else if (m.document)
-        out.push(`[file: ${m.document.file_name ?? m.document.file_id}]`);
-    if (m.voice)
-        out.push('[voice]');
-    if (m.audio)
-        out.push('[audio]');
-    return out;
-}
-export class TelegramStation {
-    name = 'telegram';
-    pollOffset = 0;
-    pollAbort = null;
-    messageHandler = () => { };
-    reactionHandler = () => { };
-    offsetFile = join(STATE_DIR, 'telegram-offset.json');
-    /** Snapshot recent inbounds in memory so `metro download <line> <id>` can resolve them. */
-    recent = new Map();
-    onMessage(handler) { this.messageHandler = handler; }
-    onReaction(handler) { this.reactionHandler = handler; }
-    async start() {
-        await tg('deleteWebhook', { drop_pending_updates: false }).catch(() => { });
-        const persisted = Number(existsSync(this.offsetFile) ? readFileSync(this.offsetFile, 'utf8').trim() : 0) || 0;
-        if (persisted > 0)
-            this.pollOffset = persisted;
-        else {
-            /* First run: anchor on latest update id (-1 returns most recent without consuming). */
-            const initial = await tg('getUpdates', { offset: -1, timeout: 0 });
-            this.pollOffset = initial.length ? initial[0].update_id + 1 : 0;
-            this.saveOffset();
-        }
-        log.info({ offset: this.pollOffset }, 'telegram station: polling started');
-        this.pollAbort = new AbortController();
-        void this.pollLoop();
-    }
-    async stop() { this.pollAbort?.abort(); this.pollAbort = null; }
-    async getMe() {
-        return tg('getMe', {});
-    }
-    async send(line, text, opts) {
-        const { chatId, topicId } = targetOf(line);
-        const base = { chat_id: chatId };
-        if (topicId !== undefined)
-            base.message_thread_id = topicId;
-        if (opts?.replyTo)
-            base.reply_parameters = { message_id: Number(opts.replyTo) };
-        return tgSendRich(token(), tg, base, text, opts);
-    }
-    async edit(line, messageId, text, opts) {
-        const { chatId } = targetOf(line);
-        const base = { chat_id: chatId, message_id: Number(messageId), ...NO_PREVIEW };
-        if (opts?.buttons)
-            base.reply_markup = opts.buttons.length ? inlineKeyboard(opts.buttons) : { inline_keyboard: [] };
-        try {
-            await tg('editMessageText', { ...base, text: mdToTelegramHtml(text), parse_mode: 'HTML' });
-        }
-        catch (err) {
-            if (isNoopEdit(err))
-                return;
-            if (!isParseError(err))
-                throw err;
-            log.warn({ err: errMsg(err) }, 'telegram: HTML edit rejected, retrying plain');
-            try {
-                await tg('editMessageText', { ...base, text });
-            }
-            catch (e) {
-                if (!isNoopEdit(e))
-                    throw e;
-            }
-        }
-    }
-    async react(line, messageId, emoji) {
-        await tg('setMessageReaction', {
-            chat_id: targetOf(line).chatId, message_id: Number(messageId),
-            reaction: emoji ? [{ type: 'emoji', emoji }] : [],
-        });
-    }
-    async download(line, messageId, outDir) {
-        /* Telegram has no "get message by id" — resolve from the in-memory snapshot. */
-        const { chatId } = targetOf(line);
-        const m = this.recent.get(`${chatId}:${messageId}`);
-        if (!m)
-            return [];
-        const refs = [];
-        if (m.photo?.length)
-            refs.push({ id: m.photo[m.photo.length - 1].file_id, mime: 'image/jpeg' });
-        if (m.document?.mime_type?.startsWith('image/'))
-            refs.push({ id: m.document.file_id, mime: m.document.mime_type });
-        const out = [];
-        for (const [i, { id, mime }] of refs.entries()) {
-            try {
-                const file = await tg('getFile', { file_id: id });
-                const res = await fetch(`${API_BASE}/file/bot${token()}/${file.file_path}`, { signal: AbortSignal.timeout(30_000) });
-                if (!res.ok)
-                    throw new Error(`status ${res.status}`);
-                const buf = Buffer.from(await res.arrayBuffer());
-                if (buf.byteLength > MAX_BYTES) {
-                    log.warn({ id, size: buf.byteLength }, 'telegram: attachment too large');
-                    continue;
-                }
-                const path = join(outDir, `${chatId}-${messageId}-${i}.${mime.split('/')[1] ?? 'bin'}`);
-                await writeFile(path, buf);
-                out.push({ path, mediaType: mime });
-            }
-            catch (err) {
-                log.warn({ err: errMsg(err), id }, 'telegram: attachment fetch failed');
-            }
-        }
-        return out;
-    }
-    /** Bot API has no history endpoint — only the in-memory snapshot is reachable. */
-    async fetch() { return []; }
-    saveOffset() {
-        try {
-            writeFileSync(this.offsetFile, String(this.pollOffset));
-        }
-        catch (err) {
-            log.warn({ err: errMsg(err) }, 'telegram offset save failed');
-        }
-    }
-    dispatchReaction(r) {
-        if (!r.user || r.user.is_bot)
-            return;
-        const emojis = (xs) => xs.filter((x) => x.type === 'emoji').map(x => x.emoji);
-        const had = new Set(emojis(r.old_reaction));
-        const added = emojis(r.new_reaction).filter(e => !had.has(e));
-        if (!added.length)
-            return;
-        const fromName = r.user.username ? `@${r.user.username}` : r.user.first_name;
-        log.info({ from: fromName, chat: r.chat.id, emojis: added }, 'telegram: reaction');
-        const ts = new Date((r.date ?? Math.floor(Date.now() / 1000)) * 1000).toISOString();
-        for (const emoji of added)
-            this.reactionHandler({
-                id: mintId(), ts, station: 'telegram', line: Line.telegram(r.chat.id),
-                lineName: r.chat.title ?? r.chat.first_name ?? undefined,
-                from: Line.user('telegram', r.user.id), fromName,
-                messageId: String(r.message_id), emoji, isPrivate: r.chat.type === 'private',
-            });
-    }
-    async pollLoop() {
-        const signal = this.pollAbort?.signal;
-        const body = { timeout: 25, allowed_updates: ['message', 'message_reaction'] };
-        while (this.pollAbort && !this.pollAbort.signal.aborted) {
-            try {
-                const updates = await tg('getUpdates', { offset: this.pollOffset, ...body }, { timeoutMs: 60_000, signal });
-                for (const u of updates) {
-                    this.pollOffset = u.update_id + 1;
-                    this.dispatchUpdate(u);
-                }
-                if (updates.length)
-                    this.saveOffset();
-            }
-            catch (err) {
-                if (this.pollAbort?.signal.aborted)
-                    break;
-                log.warn({ err: errMsg(err) }, 'telegram poll error; backing off');
-                await new Promise(r => setTimeout(r, 2000));
-            }
-        }
-    }
-    dispatchUpdate(u) {
-        if (u.message_reaction) {
-            this.dispatchReaction(u.message_reaction);
-            return;
-        }
-        const m = u.message;
-        if (!m?.chat?.id || typeof m.message_id !== 'number' || m.from?.is_bot)
-            return;
-        const text = [m.text ?? m.caption, ...attachmentTags(m)].filter(Boolean).join(' ');
-        if (!text)
-            return;
-        const topicId = m.is_topic_message ? m.message_thread_id : undefined;
-        const fromName = m.from?.username ? `@${m.from.username}` : m.from?.first_name;
-        log.info({ from: fromName, chat: m.chat.id, topic: topicId, text: text.slice(0, 80) }, 'telegram: inbound');
-        if (this.recent.size >= 50) {
-            const first = this.recent.keys().next().value;
-            if (first)
-                this.recent.delete(first);
-        }
-        this.recent.set(`${m.chat.id}:${m.message_id}`, m);
-        this.messageHandler({
-            id: mintId(), ts: new Date((m.date ?? Math.floor(Date.now() / 1000)) * 1000).toISOString(),
-            station: 'telegram', line: Line.telegram(m.chat.id, topicId), messageId: String(m.message_id),
-            lineName: topicId === undefined ? (m.chat.title ?? m.chat.first_name ?? undefined) : undefined,
-            from: Line.user('telegram', m.from?.id ?? 'unknown'), fromName, text, payload: m,
-            isPrivate: m.chat.type === 'private',
-        });
-    }
-}

package/dist/stations/webhook.js

@@ -1,103 +0,0 @@
-/** Receive-only HTTP station. Each registered endpoint = one path `/wh/<id>` → InboundMessage on stdout. */
-import { createHmac, randomUUID, timingSafeEqual } from 'node:crypto';
-import { createServer } from 'node:http';
-import { errMsg, log } from '../log.js';
-import { mintId } from '../history.js';
-import { handleMonitorRequest } from '../monitor.js';
-import { findEndpoint, listEndpoints, webhookPort } from '../webhooks.js';
-import { Line } from './index.js';
-/** Synthesize an `event` tag from common provider-specific headers (GitHub, Intercom). */
-function pickEvent(headers) {
-    return headers['x-github-event'] ?? headers['x-intercom-topic'] ?? 'event';
-}
-/** Constant-time signature check against `X-Hub-Signature-256: sha256=<hex>` (GitHub/Intercom style). */
-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);
-}
-async function readBody(req) {
-    const chunks = [];
-    for await (const c of req)
-        chunks.push(c);
-    return Buffer.concat(chunks);
-}
-export class WebhookStation {
-    name = 'webhook';
-    server = null;
-    handler = null;
-    onMessage(h) { this.handler = h; }
-    start() {
-        const port = webhookPort();
-        return new Promise((resolve, reject) => {
-            this.server = createServer((req, res) => this.handle(req, res).catch(err => {
-                log.warn({ err: errMsg(err) }, 'webhook handler error');
-                if (!res.headersSent)
-                    res.writeHead(500).end();
-            }));
-            this.server.on('error', reject);
-            this.server.listen(port, '127.0.0.1', () => {
-                log.info({ port, endpoints: listEndpoints().length }, 'webhook station ready');
-                resolve();
-            });
-        });
-    }
-    async stop() {
-        const srv = this.server;
-        if (!srv)
-            return;
-        await new Promise(resolve => srv.close(() => resolve()));
-        this.server = null;
-    }
-    async handle(req, res) {
-        /** Read-only monitor endpoints (`/api/state`, `/api/tail`) share this port. */
-        if (handleMonitorRequest(req, res))
-            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 raw = await readBody(req);
-        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);
-        this.handler?.({
-            id: mintId(),
-            ts: new Date().toISOString(),
-            station: 'webhook',
-            line,
-            lineName: endpoint.label,
-            from: line,
-            messageId: headers['x-github-delivery'] || headers['x-request-id'] || randomUUID(),
-            text: `${pickEvent(headers)} ${req.method} ${req.url}`,
-            payload: { headers, body },
-        });
-        res.writeHead(200).end('ok');
-    }
-}

package/dist/webhooks.js

@@ -1,41 +0,0 @@
-/** Webhook endpoint registry: persists `(id, label, secret?)` for each receive endpoint. */
-import { randomBytes } from 'node:crypto';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { STATE_DIR } from './paths.js';
-const FILE = join(STATE_DIR, 'webhooks.json');
-/** Local listener port — `127.0.0.1` only; expose publicly via Cloudflare tunnel. */
-export const webhookPort = () => Number(process.env.METRO_WEBHOOK_PORT) || 8420;
-function read() {
-    if (!existsSync(FILE))
-        return { endpoints: [] };
-    try {
-        return JSON.parse(readFileSync(FILE, 'utf8'));
-    }
-    catch {
-        return { endpoints: [] };
-    }
-}
-function write(s) { writeFileSync(FILE, JSON.stringify(s, null, 2)); }
-export const listEndpoints = () => read().endpoints;
-export const findEndpoint = (id) => read().endpoints.find(e => e.id === id);
-export function addEndpoint(label, secret) {
-    const s = read();
-    /** 16-char URL-safe id (~96 bits — collision-proof for any reasonable count). */
-    const ep = {
-        id: randomBytes(12).toString('base64url'), label, createdAt: new Date().toISOString(),
-        ...(secret ? { secret } : {}),
-    };
-    s.endpoints.push(ep);
-    write(s);
-    return ep;
-}
-export function removeEndpoint(id) {
-    const s = read();
-    const before = s.endpoints.length;
-    s.endpoints = s.endpoints.filter(e => e.id !== id);
-    if (s.endpoints.length === before)
-        return false;
-    write(s);
-    return true;
-}