opencode-telegram-group-topics-bot 0.11.2

package/dist/bot/message-patterns.js

@@ -0,0 +1,4 @@
+export const AGENT_MODE_BUTTON_TEXT_PATTERN = /^(📋|🛠️|💬|🔍|📝|📄|📦|🤖)\s.+\sMode$/;
+export const MODEL_BUTTON_TEXT_PATTERN = /^🤖\s(?!.*\sMode$)[\s\S]+$/;
+// Keep support for both legacy "💭" and current "💡" prefix.
+export const VARIANT_BUTTON_TEXT_PATTERN = /^(💡|💭)\s.+$/;

package/dist/bot/middleware/auth.js

@@ -0,0 +1,30 @@
+import { config } from "../../config.js";
+import { logger } from "../../utils/logger.js";
+export async function authMiddleware(ctx, next) {
+    const userId = ctx.from?.id;
+    logger.debug(`[Auth] Checking access: userId=${userId}, allowedUserId=${config.telegram.allowedUserId}, hasCallbackQuery=${!!ctx.callbackQuery}, hasMessage=${!!ctx.message}`);
+    if (userId && userId === config.telegram.allowedUserId) {
+        logger.debug(`[Auth] Access granted for userId=${userId}`);
+        await next();
+    }
+    else {
+        // Silently ignore unauthorized users
+        logger.warn(`Unauthorized access attempt from user ID: ${userId}`);
+        // Actively hide commands for unauthorized users by setting empty command list
+        // Only do this if the chat is NOT the authorized user's chat
+        // (to avoid resetting commands when forwarded messages are received)
+        if (ctx.chat?.id && ctx.chat.id !== config.telegram.allowedUserId) {
+            try {
+                // Set empty commands for this specific chat (more reliable than deleteMyCommands)
+                await ctx.api.setMyCommands([], {
+                    scope: { type: "chat", chat_id: ctx.chat.id },
+                });
+                logger.debug(`[Auth] Set empty commands for unauthorized chat_id=${ctx.chat.id}`);
+            }
+            catch (err) {
+                // Ignore errors
+                logger.debug(`[Auth] Could not set empty commands: ${err}`);
+            }
+        }
+    }
+}

package/dist/bot/middleware/interaction-guard.js

@@ -0,0 +1,80 @@
+import { resolveInteractionGuardDecision } from "../../interaction/guard.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+function getInteractionBlockedMessage(reason, interactionKind) {
+    if (interactionKind === "permission") {
+        switch (reason) {
+            case "command_not_allowed":
+                return t("permission.blocked.command_not_allowed");
+            case "expected_callback":
+            case "expected_command":
+            case "expected_text":
+            default:
+                return t("permission.blocked.expected_reply");
+        }
+    }
+    if (interactionKind === "inline") {
+        switch (reason) {
+            case "command_not_allowed":
+                return t("inline.blocked.command_not_allowed");
+            case "expected_callback":
+            case "expected_command":
+            case "expected_text":
+            default:
+                return t("inline.blocked.expected_choice");
+        }
+    }
+    if (interactionKind === "question") {
+        switch (reason) {
+            case "command_not_allowed":
+                return t("question.blocked.command_not_allowed");
+            case "expected_callback":
+            case "expected_command":
+            case "expected_text":
+            default:
+                return t("question.blocked.expected_answer");
+        }
+    }
+    if (interactionKind === "rename") {
+        switch (reason) {
+            case "command_not_allowed":
+                return t("rename.blocked.command_not_allowed");
+            case "expected_callback":
+            case "expected_command":
+            case "expected_text":
+            default:
+                return t("rename.blocked.expected_name");
+        }
+    }
+    switch (reason) {
+        case "expired":
+            return t("interaction.blocked.expired");
+        case "expected_callback":
+            return t("interaction.blocked.expected_callback");
+        case "expected_command":
+            return t("interaction.blocked.expected_command");
+        case "command_not_allowed":
+            return t("interaction.blocked.command_not_allowed");
+        case "expected_text":
+        default:
+            return t("interaction.blocked.expected_text");
+    }
+}
+export async function interactionGuardMiddleware(ctx, next) {
+    const decision = resolveInteractionGuardDecision(ctx);
+    if (decision.allow) {
+        await next();
+        return;
+    }
+    const message = getInteractionBlockedMessage(decision.reason, decision.state?.kind);
+    logger.debug(`[InteractionGuard] Blocked input: interactionKind=${decision.state?.kind || "none"}, inputType=${decision.inputType}, reason=${decision.reason || "unknown"}, command=${decision.command || "-"}`);
+    if (ctx.callbackQuery) {
+        await ctx.answerCallbackQuery({ text: message }).catch(() => { });
+        return;
+    }
+    if (ctx.chat) {
+        await ctx.reply(message).catch((err) => {
+            logger.error("[InteractionGuard] Failed to send blocked input message:", err);
+        });
+    }
+}

package/dist/bot/middleware/unknown-command.js

@@ -0,0 +1,22 @@
+import { extractCommandName, isKnownCommand } from "../utils/commands.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+export async function unknownCommandMiddleware(ctx, next) {
+    const text = ctx.message?.text;
+    if (!text) {
+        await next();
+        return;
+    }
+    const commandName = extractCommandName(text);
+    if (!commandName) {
+        await next();
+        return;
+    }
+    if (isKnownCommand(commandName)) {
+        await next();
+        return;
+    }
+    const commandToken = text.trim().split(/\s+/)[0];
+    logger.debug(`[Bot] Unknown slash command received: ${commandToken}`);
+    await ctx.reply(t("bot.unknown_command", { command: commandToken }));
+}

package/dist/bot/scope.js

@@ -0,0 +1,222 @@
+import { CHAT_TYPE } from "./constants.js";
+export const GLOBAL_SCOPE_KEY = "global";
+export const SCOPE_CONTEXT = {
+    DM: "dm",
+    GROUP_GENERAL: "group-general",
+    GROUP_TOPIC: "group-topic",
+};
+const DM_SCOPE_PREFIX = "dm:";
+const GROUP_SCOPE_PREFIX = "chat:";
+export const GENERAL_TOPIC_THREAD_ID = 1;
+function isKnownChatType(type) {
+    return (type === CHAT_TYPE.PRIVATE ||
+        type === CHAT_TYPE.GROUP ||
+        type === CHAT_TYPE.SUPERGROUP ||
+        type === CHAT_TYPE.CHANNEL);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function toNullableThreadId(value) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        return null;
+    }
+    return value;
+}
+function normalizeContextForLegacyInput(chatId, threadId, chatType) {
+    if (chatType === CHAT_TYPE.PRIVATE) {
+        return {
+            chatId,
+            context: SCOPE_CONTEXT.DM,
+        };
+    }
+    if (threadId === null) {
+        return {
+            chatId,
+            context: SCOPE_CONTEXT.GROUP_GENERAL,
+        };
+    }
+    return {
+        chatId,
+        threadId,
+        context: threadId === GENERAL_TOPIC_THREAD_ID
+            ? SCOPE_CONTEXT.GROUP_GENERAL
+            : SCOPE_CONTEXT.GROUP_TOPIC,
+    };
+}
+function buildScopeKey(params) {
+    if (params.context === SCOPE_CONTEXT.DM) {
+        return `${DM_SCOPE_PREFIX}${params.chatId}`;
+    }
+    if (typeof params.threadId === "number") {
+        return `${params.chatId}:${params.threadId}`;
+    }
+    return `${GROUP_SCOPE_PREFIX}${params.chatId}`;
+}
+export function parseScopeKey(scopeKey) {
+    if (!scopeKey || scopeKey === GLOBAL_SCOPE_KEY) {
+        return null;
+    }
+    const directTopicMatch = /^(-?\d+):(\d+)$/.exec(scopeKey);
+    if (directTopicMatch) {
+        const chatId = Number.parseInt(directTopicMatch[1], 10);
+        const threadId = Number.parseInt(directTopicMatch[2], 10);
+        return {
+            chatId,
+            threadId,
+            context: threadId === GENERAL_TOPIC_THREAD_ID
+                ? SCOPE_CONTEXT.GROUP_GENERAL
+                : SCOPE_CONTEXT.GROUP_TOPIC,
+        };
+    }
+    const legacyTopicMatch = /^chat:(-?\d+):(\d+)$/.exec(scopeKey);
+    if (legacyTopicMatch) {
+        const chatId = Number.parseInt(legacyTopicMatch[1], 10);
+        const threadId = Number.parseInt(legacyTopicMatch[2], 10);
+        return {
+            chatId,
+            threadId,
+            context: threadId === GENERAL_TOPIC_THREAD_ID
+                ? SCOPE_CONTEXT.GROUP_GENERAL
+                : SCOPE_CONTEXT.GROUP_TOPIC,
+        };
+    }
+    const dmMatch = /^dm:(\d+)$/.exec(scopeKey);
+    if (dmMatch) {
+        return {
+            chatId: Number.parseInt(dmMatch[1], 10),
+            context: SCOPE_CONTEXT.DM,
+        };
+    }
+    const groupGeneralMatch = /^chat:(-?\d+)$/.exec(scopeKey);
+    if (groupGeneralMatch) {
+        return {
+            chatId: Number.parseInt(groupGeneralMatch[1], 10),
+            context: SCOPE_CONTEXT.GROUP_GENERAL,
+        };
+    }
+    return null;
+}
+export function createScopeKey(chatId, threadId, chatType) {
+    if (!chatType && threadId === null) {
+        return GLOBAL_SCOPE_KEY;
+    }
+    return buildScopeKey(normalizeContextForLegacyInput(chatId, threadId, chatType));
+}
+export function createScopeKeyFromParams(params) {
+    return buildScopeKey(params);
+}
+function extractThreadIdFromMessage(message) {
+    const parsed = toNullableThreadId(message.message_thread_id);
+    if (parsed !== null) {
+        return parsed;
+    }
+    if (message.is_topic_message) {
+        return GENERAL_TOPIC_THREAD_ID;
+    }
+    return null;
+}
+function getContextPayloadThreadId(ctx) {
+    if (ctx.message) {
+        return extractThreadIdFromMessage(ctx.message);
+    }
+    if (ctx.callbackQuery && "message" in ctx.callbackQuery) {
+        return extractThreadIdFromMessage(ctx.callbackQuery.message);
+    }
+    const callbackMessage = isObject(ctx.callbackQuery)
+        ? Reflect.get(ctx.callbackQuery, "message")
+        : undefined;
+    if (isObject(callbackMessage)) {
+        return toNullableThreadId(Reflect.get(callbackMessage, "message_thread_id"));
+    }
+    return null;
+}
+function resolveScopeContext(chatType, threadId) {
+    if (chatType === CHAT_TYPE.PRIVATE) {
+        return SCOPE_CONTEXT.DM;
+    }
+    if (threadId === null || threadId === GENERAL_TOPIC_THREAD_ID) {
+        return SCOPE_CONTEXT.GROUP_GENERAL;
+    }
+    return SCOPE_CONTEXT.GROUP_TOPIC;
+}
+export function getScopeFromContext(ctx) {
+    if (!ctx.chat) {
+        return null;
+    }
+    const threadId = getContextPayloadThreadId(ctx);
+    const chatType = isKnownChatType(ctx.chat.type) ? ctx.chat.type : undefined;
+    if (!chatType) {
+        if (threadId === null) {
+            return null;
+        }
+        const fallbackContext = threadId === GENERAL_TOPIC_THREAD_ID
+            ? SCOPE_CONTEXT.GROUP_GENERAL
+            : SCOPE_CONTEXT.GROUP_TOPIC;
+        return {
+            key: createScopeKeyFromParams({
+                chatId: ctx.chat.id,
+                threadId,
+                context: fallbackContext,
+            }),
+            chatId: ctx.chat.id,
+            threadId,
+            context: fallbackContext,
+        };
+    }
+    const context = resolveScopeContext(chatType, threadId);
+    const key = createScopeKeyFromParams({
+        chatId: ctx.chat.id,
+        threadId: threadId ?? undefined,
+        context,
+    });
+    return {
+        key,
+        chatId: ctx.chat.id,
+        threadId,
+        context,
+    };
+}
+export function getScopeKeyFromContext(ctx) {
+    return getScopeFromContext(ctx)?.key ?? GLOBAL_SCOPE_KEY;
+}
+export function getScopeFromKey(scopeKey) {
+    const parsed = parseScopeKey(scopeKey);
+    if (!parsed) {
+        return null;
+    }
+    return {
+        key: buildScopeKey(parsed),
+        chatId: parsed.chatId,
+        threadId: typeof parsed.threadId === "number" ? parsed.threadId : null,
+        context: parsed.context,
+    };
+}
+export function getThreadIdFromScopeKey(scopeKey) {
+    return getScopeFromKey(scopeKey)?.threadId ?? null;
+}
+export function getMessageThreadId(threadId) {
+    if (threadId === null || threadId === GENERAL_TOPIC_THREAD_ID) {
+        return null;
+    }
+    return threadId;
+}
+export function getThreadSendOptions(threadId) {
+    const messageThreadId = getMessageThreadId(threadId);
+    if (messageThreadId === null) {
+        return {};
+    }
+    return { message_thread_id: messageThreadId };
+}
+export function getChatActionThreadOptions(threadId) {
+    if (threadId === null) {
+        return {};
+    }
+    return { message_thread_id: threadId };
+}
+export function isGeneralScope(scope) {
+    return scope?.context === SCOPE_CONTEXT.GROUP_GENERAL;
+}
+export function isTopicScope(scope) {
+    return scope?.context === SCOPE_CONTEXT.GROUP_TOPIC;
+}

package/dist/bot/telegram-constants.js

@@ -0,0 +1,3 @@
+export const TELEGRAM_CHAT_ACTION = {
+    TYPING: "typing",
+};

package/dist/bot/telegram-rate-limiter.js

@@ -0,0 +1,263 @@
+import { logger } from "../utils/logger.js";
+import { createScopeKeyFromParams } from "./scope.js";
+const GLOBAL_MIN_INTERVAL_MS = 40;
+const PER_CHAT_MIN_INTERVAL_MS = 1100;
+const GROUP_WINDOW_MS = 60_000;
+const GROUP_LIMIT_PER_WINDOW = 20;
+const RATE_LIMITED_METHODS = new Set([
+    "sendMessage",
+    "editMessageText",
+    "sendDocument",
+    "sendPhoto",
+    "sendAudio",
+    "sendVoice",
+    "sendVideo",
+    "sendAnimation",
+    "sendMediaGroup",
+]);
+function parseChatId(payload) {
+    if (!payload || typeof payload !== "object") {
+        return null;
+    }
+    const value = Reflect.get(payload, "chat_id");
+    if (typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function parseThreadId(payload) {
+    if (!payload || typeof payload !== "object") {
+        return null;
+    }
+    const value = Reflect.get(payload, "message_thread_id");
+    return typeof value === "number" ? value : null;
+}
+function scopeKeyFromPayload(payload) {
+    const chatId = parseChatId(payload);
+    if (chatId === null) {
+        return null;
+    }
+    if (chatId > 0) {
+        return createScopeKeyFromParams({
+            chatId,
+            context: "dm",
+        });
+    }
+    const threadId = parseThreadId(payload);
+    if (threadId !== null) {
+        return createScopeKeyFromParams({
+            chatId,
+            threadId,
+            context: threadId === 1 ? "group-general" : "group-topic",
+        });
+    }
+    return createScopeKeyFromParams({
+        chatId,
+        context: "group-general",
+    });
+}
+function isGroupLikeChat(chatId) {
+    return chatId !== null && chatId < 0;
+}
+function getRetryAfterMs(error) {
+    if (!error || typeof error !== "object") {
+        return null;
+    }
+    const params = Reflect.get(error, "parameters");
+    if (!params || typeof params !== "object") {
+        return null;
+    }
+    const retryAfter = Reflect.get(params, "retry_after");
+    if (typeof retryAfter !== "number" || retryAfter <= 0) {
+        return null;
+    }
+    return retryAfter * 1000;
+}
+function sleep(ms) {
+    if (ms <= 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export class TelegramRateLimiter {
+    queue = [];
+    processing = false;
+    lastGlobalSentAt = 0;
+    lastSentAtByChat = new Map();
+    groupWindowByChat = new Map();
+    activeScopeKey = null;
+    setActiveScopeKey(scopeKey) {
+        this.activeScopeKey = scopeKey;
+    }
+    enqueue(method, payload, run) {
+        if (!RATE_LIMITED_METHODS.has(method)) {
+            return run();
+        }
+        const chatId = parseChatId(payload);
+        const job = {
+            method,
+            scopeKey: scopeKeyFromPayload(payload),
+            chatId,
+            isGroupLike: isGroupLikeChat(chatId),
+            notBefore: 0,
+            run,
+            resolve: () => undefined,
+            reject: () => undefined,
+        };
+        const promise = new Promise((resolve, reject) => {
+            job.resolve = resolve;
+            job.reject = reject;
+        });
+        this.queue.push(job);
+        if (this.queue.length > 25) {
+            logger.debug(`[RateLimiter] Outbound queue depth=${this.queue.length}`);
+        }
+        this.ensureProcessing();
+        return promise;
+    }
+    ensureProcessing() {
+        if (this.processing) {
+            return;
+        }
+        this.processing = true;
+        void this.processLoop();
+    }
+    findNextIndex(now) {
+        let prioritizedReadyIndex = -1;
+        let firstReadyIndex = -1;
+        let minWaitMs = Number.POSITIVE_INFINITY;
+        let minWaitIndex = 0;
+        const seenScopeKeys = new Set();
+        for (let index = 0; index < this.queue.length; index++) {
+            const job = this.queue[index];
+            // Keep strict in-order delivery per scope.
+            // If a scope already has an earlier queued job, skip later jobs for the same scope
+            // until the head-of-line job is processed.
+            if (job.scopeKey) {
+                if (seenScopeKeys.has(job.scopeKey)) {
+                    continue;
+                }
+                seenScopeKeys.add(job.scopeKey);
+            }
+            const waitMs = this.getWaitMs(job, now);
+            if (waitMs <= 0) {
+                if (this.activeScopeKey &&
+                    prioritizedReadyIndex < 0 &&
+                    job.scopeKey === this.activeScopeKey) {
+                    prioritizedReadyIndex = index;
+                }
+                if (firstReadyIndex < 0) {
+                    firstReadyIndex = index;
+                }
+                continue;
+            }
+            if (waitMs < minWaitMs) {
+                minWaitMs = waitMs;
+                minWaitIndex = index;
+            }
+        }
+        if (prioritizedReadyIndex >= 0) {
+            return { index: prioritizedReadyIndex, waitMs: 0 };
+        }
+        if (firstReadyIndex >= 0) {
+            return { index: firstReadyIndex, waitMs: 0 };
+        }
+        return {
+            index: minWaitIndex,
+            waitMs: Number.isFinite(minWaitMs) ? Math.max(1, minWaitMs) : 1,
+        };
+    }
+    pruneGroupWindow(chatId, now) {
+        const current = this.groupWindowByChat.get(chatId) ?? [];
+        const pruned = current.filter((ts) => now - ts < GROUP_WINDOW_MS);
+        this.groupWindowByChat.set(chatId, pruned);
+        return pruned;
+    }
+    getWaitMs(job, now = Date.now()) {
+        const waits = [];
+        waits.push(job.notBefore - now);
+        waits.push(this.lastGlobalSentAt + GLOBAL_MIN_INTERVAL_MS - now);
+        if (job.chatId !== null) {
+            const lastPerChat = this.lastSentAtByChat.get(job.chatId) ?? 0;
+            waits.push(lastPerChat + PER_CHAT_MIN_INTERVAL_MS - now);
+        }
+        if (job.isGroupLike && job.chatId !== null) {
+            const timestamps = this.pruneGroupWindow(job.chatId, now);
+            if (timestamps.length >= GROUP_LIMIT_PER_WINDOW) {
+                waits.push(timestamps[0] + GROUP_WINDOW_MS - now);
+            }
+        }
+        return Math.max(0, ...waits);
+    }
+    markSent(job) {
+        const now = Date.now();
+        this.lastGlobalSentAt = now;
+        if (job.chatId !== null) {
+            this.lastSentAtByChat.set(job.chatId, now);
+        }
+        if (job.isGroupLike && job.chatId !== null) {
+            const timestamps = this.pruneGroupWindow(job.chatId, now);
+            timestamps.push(now);
+            this.groupWindowByChat.set(job.chatId, timestamps);
+        }
+    }
+    async executeJob(job) {
+        try {
+            const result = await job.run();
+            this.markSent(job);
+            job.resolve(result);
+            return "done";
+        }
+        catch (error) {
+            const retryAfterMs = getRetryAfterMs(error);
+            if (!retryAfterMs) {
+                job.reject(error);
+                return "done";
+            }
+            const cappedDelay = Math.min(retryAfterMs + 100, 10_000);
+            job.notBefore = Date.now() + cappedDelay;
+            logger.warn(`[RateLimiter] Telegram 429 for ${job.method}; requeue in ${cappedDelay}ms (queue=${this.queue.length + 1})`);
+            return "retry";
+        }
+    }
+    requeueRetryJob(job) {
+        if (!job.scopeKey) {
+            this.queue.push(job);
+            return;
+        }
+        const sameScopeIndex = this.queue.findIndex((queued) => queued.scopeKey === job.scopeKey);
+        if (sameScopeIndex < 0) {
+            this.queue.push(job);
+            return;
+        }
+        this.queue.splice(sameScopeIndex, 0, job);
+    }
+    async processLoop() {
+        try {
+            while (this.queue.length > 0) {
+                const now = Date.now();
+                const selection = this.findNextIndex(now);
+                if (selection.waitMs > 0) {
+                    await sleep(selection.waitMs);
+                    continue;
+                }
+                const index = selection.index;
+                const [job] = this.queue.splice(index, 1);
+                const outcome = await this.executeJob(job);
+                if (outcome === "retry") {
+                    this.requeueRetryJob(job);
+                }
+            }
+        }
+        finally {
+            this.processing = false;
+            if (this.queue.length > 0) {
+                this.ensureProcessing();
+            }
+        }
+    }
+}

package/dist/bot/utils/commands.js

@@ -0,0 +1,21 @@
+import { BOT_COMMANDS } from "../commands/definitions.js";
+const KNOWN_COMMANDS = new Set(["start", ...BOT_COMMANDS.map((item) => item.command)]);
+export function extractCommandName(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("/")) {
+        return null;
+    }
+    const token = trimmed.split(/\s+/)[0];
+    const withoutSlash = token.slice(1);
+    if (!withoutSlash) {
+        return null;
+    }
+    const withoutMention = withoutSlash.split("@")[0].toLowerCase();
+    if (!withoutMention) {
+        return null;
+    }
+    return withoutMention;
+}
+export function isKnownCommand(commandName) {
+    return KNOWN_COMMANDS.has(commandName);
+}