@stage-labs/metro 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/channels/discord.js

@@ -1,8 +1,8 @@
 import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
 import { errMsg, log } from '../log.js';
-// Receive path: discord.js gateway, used by tail.ts only.
+// Receive path: discord.js gateway, owned by the orchestrator.
 // Send path: raw REST against discord.com/api — no gateway login required,
-// so cli.ts subcommands stay one-shot and fast.
+// so callers outside the orchestrator (e.g. cli.ts validation) stay one-shot.
 const API_BASE = 'https://discord.com/api/v10';
 function token() {
     const t = process.env.DISCORD_BOT_TOKEN;
@@ -10,7 +10,7 @@ function token() {
         throw new Error('DISCORD_BOT_TOKEN is not set');
     return t;
 }
-async function rest(method, path, body, timeoutMs = 30_000) {
+async function rest(method, path, body, timeoutMs = 30_000, retriesLeft = 2) {
     const res = await fetch(`${API_BASE}${path}`, {
         method,
         headers: {
@@ -21,6 +21,15 @@ async function rest(method, path, body, timeoutMs = 30_000) {
         body: body !== undefined ? JSON.stringify(body) : undefined,
         signal: AbortSignal.timeout(timeoutMs),
     });
+    // 429: honor Discord's retry_after (seconds) and try again, up to a few
+    // hops. Common during streaming edits when the agent emits deltas faster
+    // than the per-channel edit cap.
+    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}`);
@@ -62,13 +71,10 @@ export async function startGateway() {
     c.on(Events.MessageCreate, m => {
         if (m.author.bot)
             return;
-        // Guild messages: only forward when the bot is mentioned. DMs always pass.
-        // The bot's own @-mention is preserved in `m.content` — stripping it would
-        // lose mid-sentence position ("Wdyt @Metro is this good?" → "Wdyt is this
-        // good?") and silently drop bare-mention pings. The agent recognizes
-        // `<@bot_id>` and acts on the request as a whole.
-        if (m.guildId && c.user && !m.mentions.has(c.user.id))
-            return;
+        // Forward every human message; the orchestrator decides what to route
+        // where (scoped thread vs new bootstrap mention vs ignore). The bot's
+        // own @-mention is preserved in `m.content` so the orchestrator can
+        // make that decision from the same payload.
         const tags = [...m.attachments.values()]
             .map(a => {
             if (a.contentType?.startsWith('image/'))
@@ -81,7 +87,13 @@ export async function startGateway() {
         const text = [m.content, tags].filter(Boolean).join(' ').trim();
         if (!text)
             return;
-        onInboundHandler({ channel_id: m.channelId, message_id: m.id, text });
+        onInboundHandler({
+            channel_id: m.channelId,
+            message_id: m.id,
+            text,
+            in_guild: !!m.guildId,
+            mentions_bot: c.user ? m.mentions.has(c.user.id) : false,
+        });
     });
     c.on(Events.Error, err => log.error({ err: errMsg(err) }, 'discord error'));
     await c.login(process.env.DISCORD_BOT_TOKEN);
@@ -95,54 +107,36 @@ export async function sendMessage(channelId, text) {
     const sent = await rest('POST', `/channels/${channelId}/messages`, { content: text });
     return sent.id;
 }
-export async function replyToMessage(channelId, messageId, text) {
-    const sent = await rest('POST', `/channels/${channelId}/messages`, {
-        content: text,
-        message_reference: { message_id: messageId, fail_if_not_exists: false },
+/**
+ * Create a public thread anchored to an existing message. The user's
+ * @-mention becomes the thread's starter, so the thread is visually
+ * tied to the request that opened it. Returns the new thread's channel id.
+ */
+export async function createThreadFromMessage(channelId, messageId, name) {
+    const created = await rest('POST', `/channels/${channelId}/messages/${messageId}/threads`, {
+        name,
+        auto_archive_duration: 1440,
     });
-    return sent.id;
+    return created.id;
 }
 export async function editMessage(channelId, messageId, text) {
     const sent = await rest('PATCH', `/channels/${channelId}/messages/${messageId}`, { content: text });
     return sent.id;
 }
-export async function sendTyping(channelId) {
-    await rest('POST', `/channels/${channelId}/typing`);
-}
-export async function setReaction(channelId, messageId, emoji) {
-    if (emoji) {
-        await rest('PUT', `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}/@me`);
-        return;
-    }
-    // Clear only the bot's own reactions (matches Telegram's clear semantics).
-    const msg = await rest('GET', `/channels/${channelId}/messages/${messageId}`);
-    for (const r of msg.reactions ?? []) {
-        if (!r.me || !r.emoji.name)
-            continue;
-        await rest('DELETE', `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(r.emoji.name)}/@me`);
-    }
-}
-export async function fetchAttachments(channelId, messageId) {
-    const msg = await rest('GET', `/channels/${channelId}/messages/${messageId}`);
-    const out = [];
-    for (const a of msg.attachments) {
-        if (!a.content_type?.startsWith('image/'))
-            continue;
-        const res = await fetch(a.url, { signal: AbortSignal.timeout(30_000) });
-        if (!res.ok)
-            throw new Error(`discord: download ${a.url}: ${res.status}`);
-        out.push({ data: Buffer.from(await res.arrayBuffer()).toString('base64'), mime: a.content_type });
-    }
-    return out;
-}
-export async function fetchRecentMessages(channelId, limit) {
-    const n = Math.min(Math.max(limit, 1), 100);
-    const msgs = await rest('GET', `/channels/${channelId}/messages?limit=${n}`);
-    // Discord returns newest-first; reverse for chronological.
+/**
+ * Fetch all messages newer than `afterMessageId` in a channel. Used for
+ * catchup-on-restart so messages sent while metro was down still get a
+ * reply once it comes back. Caps at 100 messages — anything older than
+ * that during downtime is dropped on the floor.
+ */
+export async function fetchMessagesSince(channelId, afterMessageId) {
+    const msgs = await rest('GET', `/channels/${channelId}/messages?after=${afterMessageId}&limit=100`);
+    // Discord returns newest-first; flip to chronological so replay order
+    // matches what the user actually typed.
     return [...msgs].reverse().map(m => ({
         message_id: m.id,
-        author: m.author.username,
         text: m.content,
-        timestamp: m.timestamp,
+        author_id: m.author.id,
+        author_is_bot: !!m.author.bot,
     }));
 }

package/dist/channels/telegram.js

@@ -9,129 +9,201 @@ function token() {
         throw new Error('TELEGRAM_BOT_TOKEN is not set');
     return t;
 }
-export async function tg(method, body, timeoutMs = 30_000) {
+async function tg(method, body, opts = {}) {
+    const timeout = opts.timeoutMs ?? 30_000;
+    const signals = [AbortSignal.timeout(timeout)];
+    if (opts.signal)
+        signals.push(opts.signal);
+    const signal = AbortSignal.any(signals);
     const res = await fetch(`${API_BASE}/bot${token()}/${method}`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(body),
-        signal: AbortSignal.timeout(timeoutMs),
+        signal,
     });
     const json = (await res.json());
     if (!json.ok)
         throw new Error(`telegram ${method}: ${json.description ?? 'unknown error'}`);
     return json.result;
 }
-export function buildSendBody(chatId, text, opts) {
-    const body = { chat_id: chatId, text };
-    if (opts.parseMode)
-        body.parse_mode = opts.parseMode;
-    if (opts.disableLinkPreview)
-        body.link_preview_options = { is_disabled: true };
-    if (opts.buttons?.length)
-        body.reply_markup = { inline_keyboard: opts.buttons };
-    return body;
-}
+// ---------- Identity (cached after getMe) ----------------------------------
+let botUsername = null;
+let botUserId = null;
 export async function getMe() {
-    return tg('getMe', {});
+    const me = await tg('getMe', {});
+    botUsername = me.username;
+    botUserId = me.id;
+    return me;
 }
-const CACHE_MAX = 200;
-const cacheFile = join(STATE_DIR, 'telegram-attachments.json');
-function readCache() {
+let onInboundHandler = () => { };
+export function onInbound(handler) {
+    onInboundHandler = handler;
+}
+const offsetFile = join(STATE_DIR, 'telegram-offset.json');
+let pollOffset = 0;
+let pollAbort = null;
+function loadOffset() {
     try {
-        return existsSync(cacheFile) ? JSON.parse(readFileSync(cacheFile, 'utf8')) : {};
+        if (!existsSync(offsetFile))
+            return 0;
+        return Number(readFileSync(offsetFile, 'utf8').trim()) || 0;
     }
-    catch (err) {
-        log.warn({ err: errMsg(err) }, 'telegram attachment cache read failed');
-        return {};
+    catch {
+        return 0;
     }
 }
-function cacheAttachment(chatId, messageId, att) {
+function saveOffset(o) {
     try {
-        const data = readCache();
-        const key = `${chatId}:${messageId}`;
-        data[key] = [...(data[key] ?? []), att];
-        const keys = Object.keys(data);
-        for (const stale of keys.slice(0, Math.max(0, keys.length - CACHE_MAX)))
-            delete data[stale];
-        writeFileSync(cacheFile, JSON.stringify(data, null, 2));
+        writeFileSync(offsetFile, String(o));
     }
     catch (err) {
-        log.warn({ err: errMsg(err) }, 'telegram attachment cache write failed');
+        log.warn({ err: errMsg(err) }, 'telegram offset save failed');
     }
 }
-export function getCachedAttachments(chatId, messageId) {
-    return readCache()[`${chatId}:${messageId}`] ?? [];
+export async function startPolling() {
+    // A registered webhook short-circuits getUpdates — clear it defensively.
+    await tg('deleteWebhook', { drop_pending_updates: false }).catch(() => { });
+    const persisted = loadOffset();
+    if (persisted > 0) {
+        // Resume from where we left off — telegram queues updates for ~24h, so
+        // any messages sent while metro was down come back through this poll.
+        pollOffset = persisted;
+        log.info({ offset: pollOffset }, 'telegram polling: resuming from persisted offset');
+    }
+    else {
+        // First-ever run: skip historical backlog by anchoring on the latest
+        // update id (-1 returns just the most recent one without consuming it).
+        const initial = await tg('getUpdates', { offset: -1, timeout: 0 });
+        pollOffset = initial.length ? initial[0].update_id + 1 : 0;
+        saveOffset(pollOffset);
+        log.info({ offset: pollOffset }, 'telegram polling: starting fresh');
+    }
+    pollAbort = new AbortController();
+    void pollLoop();
 }
-export async function downloadAttachment(fileId, mime) {
-    const file = await tg('getFile', { file_id: fileId });
-    const res = await fetch(`${API_BASE}/file/bot${token()}/${file.file_path}`, {
-        signal: AbortSignal.timeout(30_000),
-    });
-    if (!res.ok)
-        throw new Error(`download failed: ${res.status}`);
-    const buf = Buffer.from(await res.arrayBuffer());
-    // Trust the cached mime — it's the authoritative one from the message
-    // metadata (`image/jpeg` for photos, the document's mime_type for files).
-    // The Telegram CDN often returns `application/octet-stream` as Content-Type,
-    // which would otherwise wipe out our extension classification downstream.
-    return { data: buf.toString('base64'), mime };
+async function pollLoop() {
+    const abortSignal = pollAbort?.signal;
+    while (pollAbort && !pollAbort.signal.aborted) {
+        try {
+            const updates = await tg('getUpdates', { offset: pollOffset, timeout: 25 }, { timeoutMs: 60_000, signal: abortSignal });
+            for (const u of updates) {
+                pollOffset = u.update_id + 1;
+                await dispatchUpdate(u);
+            }
+            if (updates.length)
+                saveOffset(pollOffset);
+        }
+        catch (err) {
+            if (pollAbort?.signal.aborted)
+                break;
+            log.warn({ err: errMsg(err) }, 'telegram poll error; backing off');
+            await new Promise(r => setTimeout(r, 2000));
+        }
+    }
+    log.info('telegram polling stopped');
+}
+export async function shutdownPolling() {
+    pollAbort?.abort();
+    pollAbort = null;
+}
+async function dispatchUpdate(u) {
+    const m = u.message;
+    if (!m?.chat?.id || typeof m.message_id !== 'number') {
+        log.trace({ update_id: u.update_id }, 'telegram: non-message update');
+        return;
+    }
+    if (m.from?.is_bot) {
+        log.trace({ chat: m.chat.id }, 'telegram: skipping bot author');
+        return;
+    }
+    const text = await messageToText(m);
+    if (!text) {
+        log.trace({ chat: m.chat.id }, 'telegram: no text/caption');
+        return;
+    }
+    const msg = {
+        chat_id: m.chat.id,
+        message_id: m.message_id,
+        message_thread_id: m.is_topic_message ? m.message_thread_id : undefined,
+        text,
+        is_private: m.chat.type === 'private',
+        is_forum_topic: !!m.is_topic_message,
+        in_forum: !!m.chat.is_forum,
+        mentions_bot: detectMentionsBot(m),
+    };
+    log.debug({
+        chat: msg.chat_id,
+        topic: msg.message_thread_id,
+        is_private: msg.is_private,
+        is_forum_topic: msg.is_forum_topic,
+        in_forum: msg.in_forum,
+        mentions_bot: msg.mentions_bot,
+    }, 'telegram: inbound');
+    onInboundHandler(msg);
 }
-async function messageToText(m, chatId) {
+function detectMentionsBot(m) {
+    // In DMs, every message to the bot is implicitly addressed to it.
+    if (m.chat?.type === 'private')
+        return true;
+    const text = m.text ?? m.caption ?? '';
+    const entities = m.entities ?? m.caption_entities ?? [];
+    for (const e of entities) {
+        if (e.type === 'mention' && botUsername) {
+            const slice = text.substring(e.offset, e.offset + e.length);
+            if (slice.toLowerCase() === `@${botUsername.toLowerCase()}`)
+                return true;
+        }
+        else if (e.type === 'text_mention' && e.user?.id === botUserId) {
+            return true;
+        }
+    }
+    return false;
+}
+async function messageToText(m) {
     if (m.text)
         return m.text;
     const caption = m.caption ?? '';
-    if (m.photo?.length) {
-        const photo = m.photo[m.photo.length - 1];
-        cacheAttachment(chatId, m.message_id, { file_id: photo.file_id, mime: 'image/jpeg' });
+    if (m.photo?.length)
         return [caption, '[image]'].filter(Boolean).join(' ');
-    }
-    if (m.document?.mime_type?.startsWith('image/')) {
-        cacheAttachment(chatId, m.message_id, { file_id: m.document.file_id, mime: m.document.mime_type });
+    if (m.document?.mime_type?.startsWith('image/'))
         return [caption, '[image]'].filter(Boolean).join(' ');
-    }
     if (m.voice)
         return [caption, '[voice]'].filter(Boolean).join(' ');
     if (m.audio)
         return [caption, '[audio]'].filter(Boolean).join(' ');
     return caption || null;
 }
-let onInboundHandler = () => { };
-export function onInbound(handler) {
-    onInboundHandler = handler;
+// ---------- Outbound (REST) ------------------------------------------------
+/**
+ * Create a new forum topic in a supergroup. Returns the topic's
+ * message_thread_id. Requires the bot to be an admin with the
+ * `can_manage_topics` privilege.
+ */
+export async function createForumTopic(chatId, name) {
+    // Telegram caps topic names at 128 chars.
+    const trimmedName = name.slice(0, 128) || 'metro';
+    const r = await tg('createForumTopic', {
+        chat_id: chatId,
+        name: trimmedName,
+    });
+    return r.message_thread_id;
 }
-export async function startPolling() {
-    // A registered webhook short-circuits getUpdates — clear it defensively.
-    await tg('deleteWebhook', { drop_pending_updates: false }).catch(() => { });
-    let offset = 0;
-    const initial = await tg('getUpdates', { timeout: 0 });
-    if (initial.length)
-        offset = initial[initial.length - 1].update_id + 1;
-    while (true) {
-        try {
-            const updates = await tg('getUpdates', { offset, timeout: 50 }, 60_000);
-            for (const u of updates) {
-                offset = u.update_id + 1;
-                void dispatchUpdate(u);
-            }
-        }
-        catch (err) {
-            log.error({ err: errMsg(err) }, 'telegram poll error');
-            await new Promise(r => setTimeout(r, 1000));
-        }
-    }
+export async function sendMessage(chatId, threadId, text) {
+    const body = { chat_id: chatId, text };
+    if (threadId !== undefined)
+        body.message_thread_id = threadId;
+    const r = await tg('sendMessage', body);
+    return r.message_id;
 }
-async function dispatchUpdate(u) {
-    const m = u.message;
-    if (!m?.chat?.id || typeof m.message_id !== 'number')
-        return;
-    const base = { chat_id: m.chat.id, message_id: m.message_id };
+export async function editMessageText(chatId, messageId, text) {
     try {
-        const text = await messageToText(m, m.chat.id);
-        if (text === null)
-            return;
-        onInboundHandler({ ...base, text });
+        await tg('editMessageText', { chat_id: chatId, message_id: messageId, text });
     }
     catch (err) {
-        onInboundHandler({ ...base, text: `[message processing failed: ${errMsg(err)}]` });
+        // Telegram rejects edits that match the existing content — ignore that
+        // specific case so debounced no-op flushes don't surface as errors.
+        if (errMsg(err).includes('message is not modified'))
+            return;
+        throw err;
     }
 }