opencode-telegram-group-topics-bot 0.11.2

package/dist/bot/handlers/variant.js

@@ -0,0 +1,147 @@
+import { InlineKeyboard } from "grammy";
+import { getAvailableVariants, getCurrentVariant, setCurrentVariant, formatVariantForDisplay, formatVariantForButton, } from "../../variant/manager.js";
+import { getStoredModel } from "../../model/manager.js";
+import { getStoredAgent } from "../../agent/manager.js";
+import { logger } from "../../utils/logger.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { createMainKeyboard } from "../utils/keyboard.js";
+import { clearActiveInlineMenu, ensureActiveInlineMenu, replyWithInlineMenu, } from "./inline-menu.js";
+import { t } from "../../i18n/index.js";
+import { SCOPE_CONTEXT, getScopeFromKey, getScopeKeyFromContext } from "../scope.js";
+/**
+ * Handle variant selection callback
+ * @param ctx grammY context
+ * @returns true if handled, false otherwise
+ */
+export async function handleVariantSelect(ctx) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || !callbackQuery.data.startsWith("variant:")) {
+        return false;
+    }
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "variant");
+    if (!isActiveMenu) {
+        return true;
+    }
+    logger.debug(`[VariantHandler] Received callback: ${callbackQuery.data}`);
+    try {
+        const scopeKey = getScopeKeyFromContext(ctx);
+        if (ctx.chat) {
+            keyboardManager.initialize(ctx.api, ctx.chat.id, scopeKey);
+        }
+        if (pinnedMessageManager.getContextLimit(scopeKey) === 0) {
+            await pinnedMessageManager.refreshContextLimit(scopeKey);
+        }
+        // Parse callback data: "variant:variantId"
+        const variantId = callbackQuery.data.replace("variant:", "");
+        // Get current model
+        const currentModel = getStoredModel(scopeKey);
+        if (!currentModel.providerID || !currentModel.modelID) {
+            logger.error("[VariantHandler] No model selected");
+            await ctx.answerCallbackQuery({ text: t("variant.model_not_selected_callback") });
+            return false;
+        }
+        // Set variant
+        setCurrentVariant(variantId, scopeKey);
+        // Re-read model after variant update
+        const updatedModel = getStoredModel(scopeKey);
+        // Update keyboard manager state
+        keyboardManager.updateModel(updatedModel, scopeKey);
+        keyboardManager.updateVariant(variantId, scopeKey);
+        // Build keyboard with correct context info
+        const currentAgent = getStoredAgent(scopeKey);
+        const contextInfo = pinnedMessageManager.getContextInfo(scopeKey) ??
+            (pinnedMessageManager.getContextLimit(scopeKey) > 0
+                ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit(scopeKey) }
+                : keyboardManager.getContextInfo(scopeKey));
+        if (contextInfo) {
+            keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit, scopeKey);
+        }
+        const variantName = formatVariantForButton(variantId);
+        const scope = getScopeFromKey(scopeKey);
+        const keyboard = createMainKeyboard(currentAgent, updatedModel, contextInfo ?? undefined, variantName, scope?.context === SCOPE_CONTEXT.GROUP_GENERAL
+            ? {
+                contextFirst: true,
+                contextLabel: t("keyboard.general_defaults"),
+            }
+            : undefined);
+        // Send confirmation message with updated keyboard
+        const displayName = formatVariantForDisplay(variantId);
+        clearActiveInlineMenu("variant_selected", scopeKey);
+        await ctx.answerCallbackQuery({ text: t("variant.changed_callback", { name: displayName }) });
+        await ctx.reply(t("variant.changed_message", { name: displayName }), {
+            reply_markup: keyboard,
+        });
+        // Delete the inline menu message
+        await ctx.deleteMessage().catch(() => { });
+        return true;
+    }
+    catch (err) {
+        clearActiveInlineMenu("variant_select_error", getScopeKeyFromContext(ctx));
+        logger.error("[VariantHandler] Error handling variant select:", err);
+        await ctx.answerCallbackQuery({ text: t("variant.change_error_callback") }).catch(() => { });
+        return false;
+    }
+}
+/**
+ * Build inline keyboard with available variants
+ * @param currentVariant Current variant for highlighting
+ * @param providerID Provider ID
+ * @param modelID Model ID
+ * @returns InlineKeyboard with variant selection buttons
+ */
+export async function buildVariantSelectionMenu(currentVariant, providerID, modelID) {
+    const keyboard = new InlineKeyboard();
+    const variants = await getAvailableVariants(providerID, modelID);
+    if (variants.length === 0) {
+        logger.warn("[VariantHandler] No variants found");
+        return keyboard;
+    }
+    // Filter only active variants (not disabled)
+    const activeVariants = variants.filter((v) => !v.disabled);
+    if (activeVariants.length === 0) {
+        logger.warn("[VariantHandler] No active variants found");
+        // If no active variants, show default at least
+        keyboard.text(`✅ ${formatVariantForDisplay("default")}`, "variant:default").row();
+        return keyboard;
+    }
+    // Add button for each variant (one per row)
+    activeVariants.forEach((variant) => {
+        const isActive = variant.id === currentVariant;
+        const label = formatVariantForDisplay(variant.id);
+        const labelWithCheck = isActive ? `✅ ${label}` : label;
+        keyboard.text(labelWithCheck, `variant:${variant.id}`).row();
+    });
+    return keyboard;
+}
+/**
+ * Show variant selection menu
+ * @param ctx grammY context
+ */
+export async function showVariantSelectionMenu(ctx) {
+    try {
+        const scopeKey = getScopeKeyFromContext(ctx);
+        const currentModel = getStoredModel(scopeKey);
+        if (!currentModel.providerID || !currentModel.modelID) {
+            await ctx.reply(t("variant.select_model_first"));
+            return;
+        }
+        const currentVariant = getCurrentVariant(scopeKey);
+        const keyboard = await buildVariantSelectionMenu(currentVariant, currentModel.providerID, currentModel.modelID);
+        if (keyboard.inline_keyboard.length === 0) {
+            await ctx.reply(t("variant.menu.empty"));
+            return;
+        }
+        const displayName = formatVariantForDisplay(currentVariant);
+        const text = t("variant.menu.current", { name: displayName });
+        await replyWithInlineMenu(ctx, {
+            menuKind: "variant",
+            text,
+            keyboard,
+        });
+    }
+    catch (err) {
+        logger.error("[VariantHandler] Error showing variant menu:", err);
+        await ctx.reply(t("variant.menu.error"));
+    }
+}

package/dist/bot/handlers/voice.js

@@ -0,0 +1,173 @@
+import http from "node:http";
+import https from "node:https";
+import { URL } from "node:url";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { SocksProxyAgent } from "socks-proxy-agent";
+import { config } from "../../config.js";
+import { isSttConfigured, transcribeAudio } from "../../stt/client.js";
+import { processUserPrompt } from "./prompt.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+const TELEGRAM_DOWNLOAD_TIMEOUT_MS = 30_000;
+const TELEGRAM_DOWNLOAD_MAX_REDIRECTS = 3;
+let telegramDownloadAgent;
+function getTelegramDownloadAgent() {
+    if (telegramDownloadAgent !== undefined) {
+        return telegramDownloadAgent || undefined;
+    }
+    const proxyUrl = config.telegram.proxyUrl.trim();
+    if (!proxyUrl) {
+        telegramDownloadAgent = null;
+        return undefined;
+    }
+    telegramDownloadAgent = proxyUrl.startsWith("socks")
+        ? new SocksProxyAgent(proxyUrl)
+        : new HttpsProxyAgent(proxyUrl);
+    logger.info(`[Voice] Using Telegram download proxy: ${proxyUrl.replace(/\/\/.*@/, "//***@")}`);
+    return telegramDownloadAgent;
+}
+async function downloadTelegramFileByUrl(url, redirectDepth = 0) {
+    return new Promise((resolve, reject) => {
+        const targetUrl = new URL(url);
+        const requestModule = targetUrl.protocol === "http:" ? http : https;
+        const request = requestModule.get(targetUrl, { agent: getTelegramDownloadAgent() }, (response) => {
+            const statusCode = response.statusCode ?? 0;
+            if (statusCode >= 300 && statusCode < 400 && response.headers.location) {
+                response.resume();
+                if (redirectDepth >= TELEGRAM_DOWNLOAD_MAX_REDIRECTS) {
+                    reject(new Error("Too many redirects while downloading Telegram file"));
+                    return;
+                }
+                const redirectUrl = new URL(response.headers.location, targetUrl).toString();
+                void downloadTelegramFileByUrl(redirectUrl, redirectDepth + 1)
+                    .then(resolve)
+                    .catch(reject);
+                return;
+            }
+            if (statusCode < 200 || statusCode >= 300) {
+                response.resume();
+                reject(new Error(`Telegram file download failed with HTTP ${statusCode}`));
+                return;
+            }
+            const chunks = [];
+            response.on("data", (chunk) => {
+                chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+            });
+            response.on("end", () => {
+                resolve(Buffer.concat(chunks));
+            });
+            response.on("error", reject);
+        });
+        request.on("error", reject);
+        request.setTimeout(TELEGRAM_DOWNLOAD_TIMEOUT_MS, () => {
+            request.destroy(new Error(`Telegram file download timed out after ${TELEGRAM_DOWNLOAD_TIMEOUT_MS}ms`));
+        });
+    });
+}
+/**
+ * Downloads the audio file from Telegram servers.
+ *
+ * @returns Buffer with file content, or null on failure
+ */
+async function downloadTelegramFile(ctx, fileId) {
+    try {
+        const file = await ctx.api.getFile(fileId);
+        if (!file.file_path) {
+            logger.error("[Voice] Telegram getFile returned no file_path");
+            return null;
+        }
+        const fileUrl = `https://api.telegram.org/file/bot${ctx.api.token}/${file.file_path}`;
+        logger.debug(`[Voice] Downloading file: ${file.file_path} (${file.file_size ?? "?"} bytes)`);
+        const buffer = await downloadTelegramFileByUrl(fileUrl);
+        // Extract filename from file_path (e.g., "voice/file_123.oga" -> "file_123.oga")
+        let filename = file.file_path.split("/").pop() || "audio.ogg";
+        if (filename.endsWith(".oga")) {
+            filename = filename.slice(0, -4) + ".ogg";
+        }
+        logger.debug(`[Voice] Downloaded file: ${filename} (${buffer.length} bytes)`);
+        return { buffer, filename };
+    }
+    catch (err) {
+        logger.error("[Voice] Error downloading file from Telegram:", err);
+        return null;
+    }
+}
+/**
+ * Creates the voice message handler function.
+ *
+ * The factory pattern is used so that `bot` and `ensureEventSubscription` dependencies
+ * can be injected from createBot() without circular imports.
+ */
+export function createVoiceHandler(deps) {
+    return async (ctx) => {
+        await handleVoiceMessage(ctx, deps);
+    };
+}
+/**
+ * Handles incoming voice and audio messages:
+ * 1. Checks if STT is configured
+ * 2. Downloads the audio file from Telegram
+ * 3. Sends "recognizing..." status message
+ * 4. Calls STT API
+ * 5. Shows recognized text
+ * 6. Passes text to processUserPrompt
+ */
+export async function handleVoiceMessage(ctx, deps) {
+    const sttConfigured = deps.isSttConfigured ?? isSttConfigured;
+    const downloadFile = deps.downloadTelegramFile ?? downloadTelegramFile;
+    const transcribe = deps.transcribeAudio ?? transcribeAudio;
+    const processPrompt = deps.processPrompt ?? processUserPrompt;
+    // Determine file_id from voice or audio message
+    const voice = ctx.message?.voice;
+    const audio = ctx.message?.audio;
+    const fileId = voice?.file_id ?? audio?.file_id;
+    if (!fileId) {
+        logger.warn("[Voice] Received voice/audio message with no file_id");
+        return;
+    }
+    // Check if STT is configured
+    if (!sttConfigured()) {
+        await ctx.reply(t("stt.not_configured"));
+        return;
+    }
+    // Send "recognizing..." status message (will be edited later)
+    const statusMessage = await ctx.reply(t("stt.recognizing"));
+    try {
+        // Download the audio file from Telegram
+        const fileData = await downloadFile(ctx, fileId);
+        if (!fileData) {
+            await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("stt.error", { error: "download failed" }));
+            return;
+        }
+        // Transcribe the audio
+        const result = await transcribe(fileData.buffer, fileData.filename);
+        const recognizedText = result.text.trim();
+        if (!recognizedText) {
+            await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("stt.empty_result"));
+            return;
+        }
+        // Show the recognized text by editing the status message.
+        // IMPORTANT: even if this edit fails (e.g. Telegram message length limits),
+        // we still send the recognized text to OpenCode as a prompt.
+        try {
+            await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("stt.recognized", { text: recognizedText }));
+        }
+        catch (editError) {
+            logger.warn("[Voice] Failed to edit status message with recognized text:", editError);
+        }
+        logger.info(`[Voice] Transcribed audio: ${recognizedText.length} chars`);
+        // Process the recognized text as a prompt
+        await processPrompt(ctx, recognizedText, deps);
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "unknown error";
+        logger.error("[Voice] Error processing voice message:", err);
+        try {
+            await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("stt.error", { error: errorMessage }));
+        }
+        catch {
+            // If we can't edit the status message, try sending a new one
+            await ctx.reply(t("stt.error", { error: errorMessage })).catch(() => { });
+        }
+    }
+}