@stage-labs/metro 0.1.0-beta.9 → 0.1.0-beta.90

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,213 +0,0 @@
-/** Telegram station: long-poll bot API; sends agent-style 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;
-}
-const CAPS = {
-    in: ['text', 'image'], out: ['text'],
-    features: ['reply', 'send', 'edit', 'react', 'download', 'fetch'],
-};
-export class TelegramStation {
-    name = 'telegram';
-    capabilities = CAPS;
-    pollOffset = 0;
-    pollAbort = null;
-    messageHandler = () => { };
-    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; }
-    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');
-        }
-    }
-    async pollLoop() {
-        const signal = this.pollAbort?.signal;
-        const body = { timeout: 25, allowed_updates: ['message'] };
-        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) {
-        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,
-        });
-    }
-}

package/dist/stations/webhook.js

@@ -1,100 +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 { findEndpoint, listEndpoints } from '../webhooks.js';
-import { Line } from './index.js';
-const DEFAULT_PORT = 8420;
-/** 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;
-    port() { return Number(process.env.METRO_WEBHOOK_PORT) || DEFAULT_PORT; }
-    onMessage(h) { this.handler = h; }
-    start() {
-        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(this.port(), '127.0.0.1', () => {
-                log.info({ port: this.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) {
-        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/tunnel.js

@@ -1,66 +0,0 @@
-/** Cloudflared tunnel manager. Prefers token-from-env so a missing local credentials JSON does not block startup. */
-import { spawn, spawnSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { STATE_DIR } from './paths.js';
-import { errMsg, log } from './log.js';
-const FILE = join(STATE_DIR, 'tunnel.json');
-const RESTART_DELAY_MS = 2_000;
-export const loadTunnelConfig = () => existsSync(FILE)
-    ? JSON.parse(readFileSync(FILE, 'utf8'))
-    : null;
-export function saveTunnelConfig(c) { writeFileSync(FILE, JSON.stringify(c, null, 2)); }
-/** Fetch the tunnel's auth token. Null when CLI is unavailable, not logged in, or no such tunnel. */
-function fetchTunnelToken(name) {
-    const r = spawnSync('cloudflared', ['tunnel', 'token', name], { encoding: 'utf8' });
-    if (r.status !== 0)
-        return null;
-    const token = r.stdout.trim();
-    return token.length > 0 ? token : null;
-}
-export class Tunnel {
-    cfg;
-    port;
-    child = null;
-    closed = false;
-    token = null;
-    tokenResolved = false;
-    constructor(cfg, port) {
-        this.cfg = cfg;
-        this.port = port;
-    }
-    get hostname() { return this.cfg.hostname; }
-    start() {
-        if (this.closed)
-            return;
-        if (!this.tokenResolved) {
-            this.token = fetchTunnelToken(this.cfg.name);
-            this.tokenResolved = true;
-        }
-        const mode = this.token ? 'token' : 'named';
-        log.info({ name: this.cfg.name, hostname: this.cfg.hostname, port: this.port, mode }, 'cloudflared tunnel starting');
-        /** `--no-autoupdate` is a global cloudflared flag — must come before the `tunnel` subcommand. */
-        const args = ['--no-autoupdate', 'tunnel', 'run', '--url', `http://127.0.0.1:${this.port}`];
-        /** Token form resolves the tunnel from TUNNEL_TOKEN so the trailing name arg must be omitted. */
-        if (!this.token)
-            args.push(this.cfg.name);
-        const env = this.token
-            ? { ...process.env, TUNNEL_TOKEN: this.token }
-            : process.env;
-        this.child = spawn('cloudflared', args, { stdio: ['ignore', 'pipe', 'pipe'], env });
-        this.child.stderr?.on('data', d => log.debug({ cloudflared: d.toString().trim() }, 'cloudflared'));
-        this.child.on('exit', code => {
-            this.child = null;
-            if (this.closed)
-                return;
-            log.warn({ code }, 'cloudflared exited; restarting');
-            setTimeout(() => this.start(), RESTART_DELAY_MS);
-        });
-        this.child.on('error', err => log.warn({ err: errMsg(err) }, 'cloudflared spawn error'));
-    }
-    stop() {
-        this.closed = true;
-        this.child?.kill();
-        this.child = null;
-    }
-}

package/dist/webhooks.js

@@ -1,40 +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');
-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);
-/** Mint a 16-char URL-safe random id (~96 bits of entropy — collision-proof for any reasonable count). */
-const mintEndpointId = () => randomBytes(12).toString('base64url');
-export function addEndpoint(label, secret) {
-    const s = read();
-    const ep = {
-        id: mintEndpointId(), 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;
-}