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

package/dist/stations/discord.js

@@ -1,216 +0,0 @@
-/** Discord station: receive via discord.js gateway; send/edit/react/download/fetch via REST. */
-import { writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
-import { readFile } from 'node:fs/promises';
-import { basename } from 'node:path';
-import { errMsg, log } from '../log.js';
-import { mintId } from '../history.js';
-import { Line, } from './index.js';
-const API_BASE = 'https://discord.com/api/v10';
-const SUPPRESS_EMBEDS = 1 << 2;
-const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
-const token = () => {
-    const t = process.env.DISCORD_BOT_TOKEN;
-    if (!t)
-        throw new Error('DISCORD_BOT_TOKEN is not set');
-    return t;
-};
-async function rest(method, path, body, timeoutMs = 30_000, retriesLeft = 2) {
-    const res = await fetch(`${API_BASE}${path}`, {
-        method,
-        headers: {
-            'Authorization': `Bot ${token()}`,
-            'User-Agent': 'metro (https://github.com/bonustrack/metro, dev)',
-            ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
-        },
-        body: body !== undefined ? JSON.stringify(body) : undefined,
-        signal: AbortSignal.timeout(timeoutMs),
-    });
-    if (res.status === 429 && retriesLeft > 0) {
-        const retryAfter = Number(res.headers.get('retry-after')) || 1;
-        log.debug({ path, retryAfter }, 'discord 429; backing off');
-        await new Promise(r => setTimeout(r, Math.max(retryAfter * 1000, 250)));
-        return rest(method, path, body, timeoutMs, retriesLeft - 1);
-    }
-    if (!res.ok) {
-        const text = await res.text().catch(() => '');
-        throw new Error(`discord ${method} ${path}: ${res.status} ${text}`);
-    }
-    return res.status === 204 ? undefined : (await res.json());
-}
-/** Multipart upload (payload_json + files[N]). Same retry semantics as `rest`. */
-async function restMultipart(method, path, payload, files) {
-    const form = new FormData();
-    form.append('payload_json', JSON.stringify(payload));
-    for (const [i, f] of files.entries()) {
-        form.append(`files[${i}]`, new Blob([new Uint8Array(f.data)]), basename(f.path));
-    }
-    const res = await fetch(`${API_BASE}${path}`, {
-        method,
-        headers: {
-            'Authorization': `Bot ${token()}`,
-            'User-Agent': 'metro (https://github.com/bonustrack/metro, dev)',
-        },
-        body: form, signal: AbortSignal.timeout(60_000),
-    });
-    if (!res.ok) {
-        const t = await res.text().catch(() => '');
-        throw new Error(`discord ${method} ${path}: ${res.status} ${t}`);
-    }
-    return (await res.json());
-}
-const collectFiles = async (opts) => {
-    const paths = [...(opts?.images ?? []), ...(opts?.documents ?? []), ...(opts?.voice ? [opts.voice] : [])];
-    return Promise.all(paths.map(async (p) => ({ path: p, data: await readFile(p) })));
-};
-/** Convert button rows to Discord component arrays (URL buttons only — style=5). */
-const discordButtons = (rows) => rows.map(row => ({
-    type: 1, components: row.map(b => ({ type: 2, style: 5, label: b.text, url: b.url })),
-}));
-const channelOf = (line) => {
-    const id = Line.parseDiscord(line);
-    if (!id)
-        throw new Error(`not a discord line: ${line}`);
-    return id;
-};
-export class DiscordStation {
-    name = 'discord';
-    client = null;
-    messageHandler = () => { };
-    reactionHandler = () => { };
-    onMessage(handler) {
-        this.messageHandler = handler;
-    }
-    onReaction(handler) { this.reactionHandler = handler; }
-    getClient() {
-        return this.client ??= new Client({
-            intents: [
-                GatewayIntentBits.DirectMessages, GatewayIntentBits.Guilds,
-                GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent,
-                GatewayIntentBits.GuildMessageReactions, GatewayIntentBits.DirectMessageReactions,
-            ],
-            partials: [Partials.Channel, Partials.Message, Partials.Reaction],
-        });
-    }
-    async start() {
-        const c = this.getClient();
-        c.on(Events.MessageCreate, m => { void this.handleMessage(m); });
-        c.on(Events.MessageReactionAdd, (r, u) => { void this.handleReaction(r, u); });
-        c.on(Events.Error, err => log.error({ err: errMsg(err) }, 'discord error'));
-        await c.login(process.env.DISCORD_BOT_TOKEN);
-        await new Promise(r => c.once(Events.ClientReady, () => r()));
-    }
-    async stop() {
-        if (!this.client)
-            return;
-        await this.client.destroy();
-        this.client = null;
-    }
-    async getMe() {
-        return rest('GET', '/users/@me');
-    }
-    async send(line, text, opts) {
-        const payload = { content: text, flags: SUPPRESS_EMBEDS };
-        if (opts?.replyTo)
-            payload.message_reference = { message_id: opts.replyTo };
-        if (opts?.buttons?.length)
-            payload.components = discordButtons(opts.buttons);
-        const path = `/channels/${channelOf(line)}/messages`;
-        const files = await collectFiles(opts);
-        const sent = files.length
-            ? await restMultipart('POST', path, payload, files)
-            : await rest('POST', path, payload);
-        return sent.id;
-    }
-    async edit(line, messageId, text, opts) {
-        const payload = { content: text, flags: SUPPRESS_EMBEDS };
-        payload.components = opts?.buttons?.length ? discordButtons(opts.buttons) : [];
-        await rest('PATCH', `/channels/${channelOf(line)}/messages/${messageId}`, payload);
-    }
-    async react(line, messageId, emoji) {
-        const ch = channelOf(line);
-        if (!emoji) {
-            await rest('DELETE', `/channels/${ch}/messages/${messageId}/reactions/@me`);
-            return;
-        }
-        await rest('PUT', `/channels/${ch}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}/@me`);
-    }
-    async download(line, messageId, outDir) {
-        const ch = channelOf(line);
-        const msg = await rest('GET', `/channels/${ch}/messages/${messageId}`);
-        const out = [];
-        for (const [i, a] of (msg.attachments ?? []).entries()) {
-            if (!a.content_type?.startsWith('image/'))
-                continue;
-            if (a.size > MAX_ATTACHMENT_BYTES) {
-                log.warn({ size: a.size, name: a.filename }, 'discord: attachment too large; skipped');
-                continue;
-            }
-            try {
-                const res = await fetch(a.url, { signal: AbortSignal.timeout(30_000) });
-                if (!res.ok)
-                    throw new Error(`status ${res.status}`);
-                const buf = Buffer.from(await res.arrayBuffer());
-                const path = join(outDir, `${messageId}-${i}-${a.filename}`);
-                await writeFile(path, buf);
-                out.push({ path, mediaType: a.content_type });
-            }
-            catch (err) {
-                log.warn({ err: errMsg(err), url: a.url }, 'discord: attachment fetch failed');
-            }
-        }
-        return out;
-    }
-    async fetch(line, limit) {
-        const capped = Math.max(1, Math.min(100, limit | 0));
-        const msgs = await rest('GET', `/channels/${channelOf(line)}/messages?limit=${capped}`);
-        return [...msgs].reverse().map(m => ({
-            messageId: m.id, author: m.author.username, text: m.content, timestamp: m.timestamp,
-        }));
-    }
-    async handleReaction(r, u) {
-        if (u.bot)
-            return;
-        const emoji = r.emoji.name;
-        if (!emoji)
-            return;
-        const channelId = r.message.channelId;
-        const messageId = r.message.id;
-        const username = 'username' in u && u.username ? u.username : undefined;
-        log.info({ from: username, channel: channelId, emoji, messageId }, 'discord: reaction');
-        this.reactionHandler({
-            id: mintId(), ts: new Date().toISOString(),
-            station: 'discord', line: Line.discord(channelId),
-            from: Line.user('discord', u.id), fromName: username,
-            messageId, emoji, isPrivate: r.message.guildId === null,
-        });
-    }
-    async handleMessage(m) {
-        if (m.author.bot)
-            return;
-        const tags = [...m.attachments.values()].map(a => a.contentType?.startsWith('image/') ? '[image]'
-            : a.contentType?.startsWith('audio/') ? `[audio: ${a.name}]` : `[file: ${a.name}]`);
-        const text = [m.content.trim(), ...tags].filter(Boolean).join(' ');
-        if (!text)
-            return;
-        log.info({ from: m.author.username, channel: m.channelId, text: text.slice(0, 80) }, 'discord: inbound');
-        const lineName = m.channel && 'name' in m.channel
-            ? m.channel.name ?? undefined : undefined;
-        const payload = m.toJSON();
-        if (m.reference?.messageId) {
-            try {
-                payload.referencedMessage = (await m.fetchReference()).toJSON();
-            }
-            catch (err) {
-                log.debug({ err: errMsg(err) }, 'discord: fetchReference failed');
-            }
-        }
-        this.messageHandler({
-            id: mintId(), ts: new Date(m.createdTimestamp).toISOString(),
-            station: 'discord', line: Line.discord(m.channelId), lineName,
-            from: Line.user('discord', m.author.id), fromName: m.author.username,
-            messageId: m.id, text, payload, isPrivate: m.guildId === null,
-        });
-    }
-}

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