@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/telegram/bot/helpers.js

@@ -1,5 +1,30 @@
 import { formatLocationText } from "../../channels/location.js";
+import { readChannelAllowFromStore } from "../../pairing/pairing-store.js";
+import { firstDefined, normalizeAllowFromWithStore, } from "../bot-access.js";
 const TELEGRAM_GENERAL_TOPIC_ID = 1;
+export async function resolveTelegramGroupAllowFromContext(params) {
+    const resolvedThreadId = resolveTelegramForumThreadId({
+        isForum: params.isForum,
+        messageThreadId: params.messageThreadId,
+    });
+    const storeAllowFrom = await readChannelAllowFromStore("telegram", process.env, params.accountId).catch(() => []);
+    const { groupConfig, topicConfig } = params.resolveTelegramGroupConfig(params.chatId, resolvedThreadId);
+    const groupAllowOverride = firstDefined(topicConfig?.allowFrom, groupConfig?.allowFrom);
+    const effectiveGroupAllow = normalizeAllowFromWithStore({
+        allowFrom: groupAllowOverride ?? params.groupAllowFrom,
+        storeAllowFrom,
+    });
+    const hasGroupAllowOverride = typeof groupAllowOverride !== "undefined";
+    return {
+        resolvedThreadId,
+        storeAllowFrom,
+        groupConfig,
+        topicConfig,
+        groupAllowOverride,
+        effectiveGroupAllow,
+        hasGroupAllowOverride,
+    };
+}
 /**
  * Resolve the thread ID for Telegram forum topics.
  * For non-forum groups, returns undefined even if messageThreadId is present
@@ -38,30 +63,28 @@ export function resolveTelegramThreadSpec(params) {
 }
 /**
  * Build thread params for Telegram API calls (messages, media).
+ *
+ * IMPORTANT: Thread IDs behave differently based on chat type:
+ * - DMs (private chats): Include message_thread_id when present (DM topics)
+ * - Forum topics: Skip thread_id=1 (General topic), include others
+ * - Regular groups: Thread IDs are ignored by Telegram
+ *
  * General forum topic (id=1) must be treated like a regular supergroup send:
  * Telegram rejects sendMessage/sendMedia with message_thread_id=1 ("thread not found").
  *
- * Accepts either a TelegramThreadSpec (preferred) or a raw messageThreadId number
- * for backward compatibility with callers that haven't migrated yet.
+ * @param thread - Thread specification with ID and scope
+ * @returns API params object or undefined if thread_id should be omitted
  */
-export function buildTelegramThreadParams(threadOrId) {
-    if (threadOrId == null) {
+export function buildTelegramThreadParams(thread) {
+    if (thread?.id == null) {
         return undefined;
     }
-    // Legacy call: raw number
-    if (typeof threadOrId === "number") {
-        const normalized = Math.trunc(threadOrId);
-        if (normalized === TELEGRAM_GENERAL_TOPIC_ID) {
-            return undefined;
-        }
-        return { message_thread_id: normalized };
-    }
-    // New call: TelegramThreadSpec
-    if (!threadOrId.id) {
-        return undefined;
+    const normalized = Math.trunc(thread.id);
+    if (thread.scope === "dm") {
+        return normalized > 0 ? { message_thread_id: normalized } : undefined;
     }
-    const normalized = Math.trunc(threadOrId.id);
-    if (normalized === TELEGRAM_GENERAL_TOPIC_ID && threadOrId.scope === "forum") {
+    // Telegram rejects message_thread_id=1 for General forum topic
+    if (normalized === TELEGRAM_GENERAL_TOPIC_ID) {
         return undefined;
     }
     return { message_thread_id: normalized };
@@ -78,8 +101,9 @@ export function buildTypingThreadParams(messageThreadId) {
 }
 export function resolveTelegramStreamMode(telegramCfg) {
     const raw = telegramCfg?.streamMode?.trim().toLowerCase();
-    if (raw === "off" || raw === "partial" || raw === "block")
+    if (raw === "off" || raw === "partial" || raw === "block") {
         return raw;
+    }
     return "partial";
 }
 export function buildTelegramGroupPeerId(chatId, messageThreadId) {
@@ -106,6 +130,27 @@ export function buildSenderName(msg) {
         msg.from?.username;
     return name || undefined;
 }
+export function resolveTelegramMediaPlaceholder(msg) {
+    if (!msg) {
+        return undefined;
+    }
+    if (msg.photo) {
+        return "<media:image>";
+    }
+    if (msg.video || msg.video_note) {
+        return "<media:video>";
+    }
+    if (msg.audio || msg.voice) {
+        return "<media:audio>";
+    }
+    if (msg.document) {
+        return "<media:document>";
+    }
+    if (msg.sticker) {
+        return "<media:sticker>";
+    }
+    return undefined;
+}
 export function buildSenderLabel(msg, senderId) {
     const name = buildSenderName(msg);
     const username = msg.from?.username ? `@${msg.from.username}` : undefined;
@@ -119,41 +164,49 @@ export function buildSenderLabel(msg, senderId) {
     const normalizedSenderId = senderId != null && `${senderId}`.trim() ? `${senderId}`.trim() : undefined;
     const fallbackId = normalizedSenderId ?? (msg.from?.id != null ? String(msg.from.id) : undefined);
     const idPart = fallbackId ? `id:${fallbackId}` : undefined;
-    if (label && idPart)
+    if (label && idPart) {
         return `${label} ${idPart}`;
-    if (label)
+    }
+    if (label) {
         return label;
+    }
     return idPart ?? "id:unknown";
 }
 export function buildGroupLabel(msg, chatId, messageThreadId) {
     const title = msg.chat?.title;
     const topicSuffix = messageThreadId != null ? ` topic:${messageThreadId}` : "";
-    if (title)
+    if (title) {
         return `${title} id:${chatId}${topicSuffix}`;
+    }
     return `group:${chatId}${topicSuffix}`;
 }
 export function hasBotMention(msg, botUsername) {
     const text = (msg.text ?? msg.caption ?? "").toLowerCase();
-    if (text.includes(`@${botUsername}`))
+    if (text.includes(`@${botUsername}`)) {
         return true;
+    }
     const entities = msg.entities ?? msg.caption_entities ?? [];
     for (const ent of entities) {
-        if (ent.type !== "mention")
+        if (ent.type !== "mention") {
             continue;
+        }
         const slice = (msg.text ?? msg.caption ?? "").slice(ent.offset, ent.offset + ent.length);
-        if (slice.toLowerCase() === `@${botUsername}`)
+        if (slice.toLowerCase() === `@${botUsername}`) {
             return true;
+        }
     }
     return false;
 }
 export function expandTextLinks(text, entities) {
-    if (!text || !entities?.length)
+    if (!text || !entities?.length) {
         return text;
+    }
     const textLinks = entities
         .filter((entity) => entity.type === "text_link" && Boolean(entity.url))
         .toSorted((a, b) => b.offset - a.offset);
-    if (textLinks.length === 0)
+    if (textLinks.length === 0) {
         return text;
+    }
     let result = text;
     for (const entity of textLinks) {
         const linkText = text.slice(entity.offset, entity.offset + entity.length);
@@ -164,17 +217,18 @@ export function expandTextLinks(text, entities) {
     return result;
 }
 export function resolveTelegramReplyId(raw) {
-    if (!raw)
+    if (!raw) {
         return undefined;
+    }
     const parsed = Number(raw);
-    if (!Number.isFinite(parsed))
+    if (!Number.isFinite(parsed)) {
         return undefined;
+    }
     return parsed;
 }
 export function describeReplyTarget(msg) {
     const reply = msg.reply_to_message;
-    const externalReply = msg
-        .external_reply;
+    const externalReply = msg.external_reply;
     const quoteText = msg.quote?.text ??
         externalReply?.quote?.text;
     let body = "";
@@ -190,19 +244,8 @@ export function describeReplyTarget(msg) {
         const replyBody = (replyLike.text ?? replyLike.caption ?? "").trim();
         body = replyBody;
         if (!body) {
-            if (replyLike.photo) {
-                body = "<media:image>";
-            }
-            else if (replyLike.video) {
-                body = "<media:video>";
-            }
-            else if (replyLike.audio || replyLike.voice) {
-                body = "<media:audio>";
-            }
-            else if (replyLike.document) {
-                body = "<media:document>";
-            }
-            else {
+            body = resolveTelegramMediaPlaceholder(replyLike) ?? "";
+            if (!body) {
                 const locationData = extractTelegramLocation(replyLike);
                 if (locationData) {
                     body = formatLocationText(locationData);
@@ -225,23 +268,24 @@ export function describeReplyTarget(msg) {
 function normalizeForwardedUserLabel(user) {
     const name = [user.first_name, user.last_name].filter(Boolean).join(" ").trim();
     const username = user.username?.trim() || undefined;
-    const id = user.id != null ? String(user.id) : undefined;
+    const id = String(user.id);
     const display = (name && username
         ? `${name} (@${username})`
-        : name || (username ? `@${username}` : undefined)) || (id ? `user:${id}` : undefined);
+        : name || (username ? `@${username}` : undefined)) || `user:${id}`;
     return { display, name: name || undefined, username, id };
 }
 function normalizeForwardedChatLabel(chat, fallbackKind) {
     const title = chat.title?.trim() || undefined;
     const username = chat.username?.trim() || undefined;
-    const id = chat.id != null ? String(chat.id) : undefined;
-    const display = title || (username ? `@${username}` : undefined) || (id ? `${fallbackKind}:${id}` : undefined);
+    const id = String(chat.id);
+    const display = title || (username ? `@${username}` : undefined) || `${fallbackKind}:${id}`;
     return { display, title, username, id };
 }
 function buildForwardedContextFromUser(params) {
     const { display, name, username, id } = normalizeForwardedUserLabel(params.user);
-    if (!display)
+    if (!display) {
         return null;
+    }
     return {
         from: display,
         date: params.date,
@@ -253,8 +297,9 @@ function buildForwardedContextFromUser(params) {
 }
 function buildForwardedContextFromHiddenName(params) {
     const trimmed = params.name?.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return null;
+    }
     return {
         from: trimmed,
         date: params.date,
@@ -263,10 +308,11 @@ function buildForwardedContextFromHiddenName(params) {
     };
 }
 function buildForwardedContextFromChat(params) {
-    const fallbackKind = params.type === "channel" || params.type === "legacy_channel" ? "channel" : "chat";
+    const fallbackKind = params.type === "channel" ? "channel" : "chat";
     const { display, title, username, id } = normalizeForwardedChatLabel(params.chat, fallbackKind);
-    if (!display)
+    if (!display) {
         return null;
+    }
     const signature = params.signature?.trim() || undefined;
     const from = signature ? `${display} (${signature})` : display;
     const chatType = (params.chat.type?.trim() || undefined);
@@ -282,83 +328,51 @@ function buildForwardedContextFromChat(params) {
         fromMessageId: params.messageId,
     };
 }
-function resolveForwardOrigin(origin, signature) {
-    if (origin.type === "user" && origin.sender_user) {
-        return buildForwardedContextFromUser({
-            user: origin.sender_user,
-            date: origin.date,
-            type: "user",
-        });
-    }
-    if (origin.type === "hidden_user") {
-        return buildForwardedContextFromHiddenName({
-            name: origin.sender_user_name,
-            date: origin.date,
-            type: "hidden_user",
-        });
+function resolveForwardOrigin(origin) {
+    switch (origin.type) {
+        case "user":
+            return buildForwardedContextFromUser({
+                user: origin.sender_user,
+                date: origin.date,
+                type: "user",
+            });
+        case "hidden_user":
+            return buildForwardedContextFromHiddenName({
+                name: origin.sender_user_name,
+                date: origin.date,
+                type: "hidden_user",
+            });
+        case "chat":
+            return buildForwardedContextFromChat({
+                chat: origin.sender_chat,
+                date: origin.date,
+                type: "chat",
+                signature: origin.author_signature,
+            });
+        case "channel":
+            return buildForwardedContextFromChat({
+                chat: origin.chat,
+                date: origin.date,
+                type: "channel",
+                signature: origin.author_signature,
+                messageId: origin.message_id,
+            });
+        default:
+            // Exhaustiveness guard: if Grammy adds a new MessageOrigin variant,
+            // TypeScript will flag this assignment as an error.
+            origin;
+            return null;
     }
-    if (origin.type === "chat" && origin.sender_chat) {
-        return buildForwardedContextFromChat({
-            chat: origin.sender_chat,
-            date: origin.date,
-            type: "chat",
-            signature,
-        });
-    }
-    if (origin.type === "channel" && origin.chat) {
-        return buildForwardedContextFromChat({
-            chat: origin.chat,
-            date: origin.date,
-            type: "channel",
-            signature,
-        });
-    }
-    return null;
 }
-/**
- * Extract forwarded message origin info from Telegram message.
- * Supports both new forward_origin API and legacy forward_from/forward_from_chat fields.
- */
+/** Extract forwarded message origin info from Telegram message. */
 export function normalizeForwardedContext(msg) {
-    const forwardMsg = msg;
-    const signature = forwardMsg.forward_signature?.trim() || undefined;
-    if (forwardMsg.forward_origin) {
-        const originContext = resolveForwardOrigin(forwardMsg.forward_origin, signature);
-        if (originContext)
-            return originContext;
-    }
-    if (forwardMsg.forward_from_chat) {
-        const legacyType = forwardMsg.forward_from_chat.type === "channel" ? "legacy_channel" : "legacy_chat";
-        const legacyContext = buildForwardedContextFromChat({
-            chat: forwardMsg.forward_from_chat,
-            date: forwardMsg.forward_date,
-            type: legacyType,
-            signature,
-        });
-        if (legacyContext)
-            return legacyContext;
-    }
-    if (forwardMsg.forward_from) {
-        const legacyContext = buildForwardedContextFromUser({
-            user: forwardMsg.forward_from,
-            date: forwardMsg.forward_date,
-            type: "legacy_user",
-        });
-        if (legacyContext)
-            return legacyContext;
+    if (!msg.forward_origin) {
+        return null;
     }
-    const hiddenContext = buildForwardedContextFromHiddenName({
-        name: forwardMsg.forward_sender_name,
-        date: forwardMsg.forward_date,
-        type: "legacy_hidden_user",
-    });
-    if (hiddenContext)
-        return hiddenContext;
-    return null;
+    return resolveForwardOrigin(msg.forward_origin);
 }
 export function extractTelegramLocation(msg) {
-    const msgWithLocation = msg;
-    const { venue, location } = msgWithLocation;
+    const { venue, location } = msg;
     if (venue) {
         return {
             latitude: venue.location.latitude,