@stage-labs/metro 0.1.0-beta.2 → 0.1.0-beta.4

package/dist/channels/discord.js

@@ -1,8 +1,6 @@
 import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
 import { errMsg, log } from '../log.js';
-// Receive path: discord.js gateway, used by tail.ts only.
-// Send path: raw REST against discord.com/api — no gateway login required,
-// so cli.ts subcommands stay one-shot and fast.
+/** Receive: discord.js gateway. Send: raw REST so non-orchestrator callers stay one-shot. */
 const API_BASE = 'https://discord.com/api/v10';
 function token() {
     const t = process.env.DISCORD_BOT_TOKEN;
@@ -10,7 +8,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,36 +19,34 @@ async function rest(method, path, body, timeoutMs = 30_000) {
         body: body !== undefined ? JSON.stringify(body) : undefined,
         signal: AbortSignal.timeout(timeoutMs),
     });
+    /** 429: honor `retry_after` (seconds) and retry, up to a few hops. */
+    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}`);
     }
-    // 204 No Content for typing/reactions/clear.
     if (res.status === 204)
         return undefined;
     return (await res.json());
 }
-// ---------- Receive path (gateway, discord.js) -----------------------------
 let client = null;
 function getClient() {
     if (client)
         return client;
     client = new Client({
-        intents: [
-            GatewayIntentBits.DirectMessages,
-            GatewayIntentBits.Guilds,
-            GatewayIntentBits.GuildMessages,
-            GatewayIntentBits.MessageContent,
-        ],
-        // DM channels arrive partial; without this messageCreate never fires.
+        intents: [GatewayIntentBits.DirectMessages, GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent],
+        /** DM channels arrive partial; without this messageCreate never fires. */
         partials: [Partials.Channel],
     });
     return client;
 }
 let onInboundHandler = () => { };
-export function onInbound(handler) {
-    onInboundHandler = handler;
-}
+export const onInbound = (handler) => { onInboundHandler = handler; };
 export async function shutdownGateway() {
     if (!client)
         return;
@@ -62,26 +58,20 @@ 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;
-        const tags = [...m.attachments.values()]
-            .map(a => {
-            if (a.contentType?.startsWith('image/'))
-                return '[image]';
-            if (a.contentType?.startsWith('audio/'))
-                return `[audio: ${a.name}]`;
-            return `[file: ${a.name}]`;
-        })
-            .join(' ');
+        /** Forward every human message; orchestrator decides routing. @-mention stays in content. */
+        const tags = [...m.attachments.values()].map(a => a.contentType?.startsWith('image/') ? '[image]'
+            : a.contentType?.startsWith('audio/') ? `[audio: ${a.name}]`
+                : `[file: ${a.name}]`).join(' ');
         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);
@@ -91,58 +81,24 @@ export async function getMe() {
     const me = await rest('GET', '/users/@me');
     return { username: me.username };
 }
+/** SUPPRESS_EMBEDS (1 << 2) — strip link unfurls from every bot message. */
+const SUPPRESS_EMBEDS = 1 << 2;
 export async function sendMessage(channelId, text) {
-    const sent = await rest('POST', `/channels/${channelId}/messages`, { content: text });
+    const sent = await rest('POST', `/channels/${channelId}/messages`, { content: text, flags: SUPPRESS_EMBEDS });
     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 },
-    });
-    return sent.id;
+/** Public thread anchored on `messageId`. Returns the new thread 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 created.id;
 }
 export async function editMessage(channelId, messageId, text) {
-    const sent = await rest('PATCH', `/channels/${channelId}/messages/${messageId}`, { content: text });
+    const sent = await rest('PATCH', `/channels/${channelId}/messages/${messageId}`, { content: text, flags: SUPPRESS_EMBEDS });
     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.
-    return [...msgs].reverse().map(m => ({
-        message_id: m.id,
-        author: m.author.username,
-        text: m.content,
-        timestamp: m.timestamp,
-    }));
+/** Catchup-on-restart: fetch messages newer than `afterMessageId` (cap 100). */
+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 for replay. */
+    return [...msgs].reverse().map(m => ({ message_id: m.id, text: m.content, author_id: m.author.id, author_is_bot: !!m.author.bot }));
 }

package/dist/channels/telegram.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { STATE_DIR } from '../paths.js';
 import { errMsg, log } from '../log.js';
+import { mdToTelegramHtml } from '../helpers/telegram-format.js';
 const API_BASE = 'https://api.telegram.org';
 function token() {
     const t = process.env.TELEGRAM_BOT_TOKEN;
@@ -9,129 +10,180 @@ 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 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.timeout(timeoutMs),
+        signal: AbortSignal.any(signals),
     });
     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;
-}
+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 const 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')) : {};
+        return existsSync(offsetFile) ? Number(readFileSync(offsetFile, 'utf8').trim()) || 0 : 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() {
+    await tg('deleteWebhook', { drop_pending_updates: false }).catch(() => { });
+    const persisted = loadOffset();
+    if (persisted > 0) {
+        pollOffset = persisted;
+        log.info({ offset: pollOffset }, 'telegram polling: resuming from persisted offset');
+    }
+    else {
+        /** First run: anchor on latest update id (-1 returns most recent without consuming). */
+        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),
+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' || m.from?.is_bot)
+        return;
+    const text = messageToText(m);
+    if (!text)
+        return;
+    onInboundHandler({
+        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),
     });
-    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 messageToText(m, chatId) {
+function detectMentionsBot(m) {
+    if (m.chat?.type === 'private')
+        return true;
+    const text = m.text ?? m.caption ?? '';
+    for (const e of m.entities ?? m.caption_entities ?? []) {
+        if (e.type === 'mention' && botUsername) {
+            if (text.substring(e.offset, e.offset + e.length).toLowerCase() === `@${botUsername.toLowerCase()}`)
+                return true;
+        }
+        else if (e.type === 'text_mention' && e.user?.id === botUserId)
+            return true;
+    }
+    return false;
+}
+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' });
-        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.photo?.length || 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;
+/** Create a forum topic; requires `can_manage_topics` admin permission. */
+export async function createForumTopic(chatId, name) {
+    const r = await tg('createForumTopic', { chat_id: chatId, name: name.slice(0, 128) || 'metro' });
+    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));
-        }
+/** Deep link `t.me/c/<id>/<topic>`; strips supergroup's `-100` prefix from chat id. */
+export function topicLink(chatId, topicId) {
+    const id = String(Math.abs(chatId)).replace(/^100/, '');
+    return `https://t.me/c/${id}/${topicId}`;
+}
+const isParseError = (err) => errMsg(err).includes("can't parse entities");
+const NO_PREVIEW = { link_preview_options: { is_disabled: true } };
+/** Send agent-style markdown as Telegram HTML, falling back to plain text on parse errors. */
+export async function sendMessage(chatId, threadId, text, replyToMessageId) {
+    const base = { chat_id: chatId, ...NO_PREVIEW };
+    if (threadId !== undefined)
+        base.message_thread_id = threadId;
+    if (replyToMessageId !== undefined)
+        base.reply_parameters = { message_id: replyToMessageId };
+    try {
+        return (await tg('sendMessage', { ...base, text: mdToTelegramHtml(text), parse_mode: 'HTML' })).message_id;
+    }
+    catch (err) {
+        if (!isParseError(err))
+            throw err;
+        log.warn({ err: errMsg(err) }, 'telegram: HTML rejected, sending plain');
+        return (await tg('sendMessage', { ...base, text })).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) {
+    const base = { chat_id: chatId, message_id: messageId, ...NO_PREVIEW };
+    const swallow = (err) => { if (!errMsg(err).includes('message is not modified'))
+        throw err; };
     try {
-        const text = await messageToText(m, m.chat.id);
-        if (text === null)
-            return;
-        onInboundHandler({ ...base, text });
+        await tg('editMessageText', { ...base, text: mdToTelegramHtml(text), parse_mode: 'HTML' });
     }
     catch (err) {
-        onInboundHandler({ ...base, text: `[message processing failed: ${errMsg(err)}]` });
+        if (errMsg(err).includes('message is not modified'))
+            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) {
+            swallow(e);
+        }
     }
 }