zardbot-telegram 1.0.0

package/dist/bot/commands/voice.js

@@ -0,0 +1,145 @@
+import { isTtsConfigured, getAvailableVoices } from "../../tts/client.js";
+import { config } from "../../config.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { setCurrentTtsVoice, clearTtsVoice, setTtsEnabled, getCurrentTtsVoice } from "../../settings/manager.js";
+const VOICE_MENU_PAGE_SIZE = 8;
+function parseCallbackData(data) {
+    try {
+        const parsed = JSON.parse(data);
+        if (parsed.action === "select" && parsed.voice) {
+            return { action: "select", voice: parsed.voice };
+        }
+        if (parsed.action === "off") {
+            return { action: "off" };
+        }
+        if (parsed.action === "page" && typeof parsed.page === "number") {
+            return { action: "page", page: parsed.page };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function buildVoiceKeyboard(voices, currentPage, currentVoice) {
+    const totalPages = Math.ceil(voices.length / VOICE_MENU_PAGE_SIZE);
+    const startIdx = currentPage * VOICE_MENU_PAGE_SIZE;
+    const pageVoices = voices.slice(startIdx, startIdx + VOICE_MENU_PAGE_SIZE);
+    const keyboard = [];
+    // Voice buttons
+    for (const voice of pageVoices) {
+        const isSelected = voice.id === currentVoice;
+        const text = isSelected ? `✅ ${voice.name}` : voice.name;
+        keyboard.push([{
+                text,
+                callback_data: JSON.stringify({ action: "select", voice: voice.id }),
+            }]);
+    }
+    // Navigation row
+    const navRow = [];
+    if (currentPage > 0) {
+        navRow.push({
+            text: t("tts.button.prev_page"),
+            callback_data: JSON.stringify({ action: "page", page: currentPage - 1 }),
+        });
+    }
+    if (currentPage < totalPages - 1) {
+        navRow.push({
+            text: t("tts.button.next_page"),
+            callback_data: JSON.stringify({ action: "page", page: currentPage + 1 }),
+        });
+    }
+    if (navRow.length > 0) {
+        keyboard.push(navRow);
+    }
+    // TTS Off button
+    keyboard.push([{
+            text: t("tts.button.off"),
+            callback_data: JSON.stringify({ action: "off" }),
+        }]);
+    return keyboard;
+}
+export async function voiceCommand(ctx) {
+    try {
+        // Check if TTS is configured
+        if (!isTtsConfigured()) {
+            await ctx.reply(t("tts.not_configured"));
+            return;
+        }
+        // Show loading message
+        const loadingMsg = await ctx.reply(t("tts.menu_loading"));
+        // Fetch available voices
+        const voices = await getAvailableVoices();
+        if (voices.length === 0) {
+            await ctx.api.editMessageText(ctx.chat.id, loadingMsg.message_id, t("tts.menu_empty"));
+            return;
+        }
+        const currentVoice = getCurrentTtsVoice() || config.tts.voice || voices[0]?.id;
+        // Edit loading message with voice selection menu
+        await ctx.api.editMessageText(ctx.chat.id, loadingMsg.message_id, t("tts.menu_current", { voice: currentVoice || "default" }), {
+            reply_markup: {
+                inline_keyboard: buildVoiceKeyboard(voices, 0, currentVoice),
+            },
+        });
+    }
+    catch (error) {
+        logger.error("[VoiceCommand] Error:", error);
+        await ctx.reply(t("tts.menu_error"));
+    }
+}
+export async function handleVoiceCallback(ctx) {
+    if (!ctx.callbackQuery || !ctx.callbackQuery.data) {
+        return false;
+    }
+    const callbackData = parseCallbackData(ctx.callbackQuery.data);
+    if (!callbackData) {
+        await ctx.answerCallbackQuery({ text: t("callback.unknown_command") });
+        return false;
+    }
+    try {
+        if (callbackData.action === "off") {
+            setTtsEnabled(false);
+            clearTtsVoice();
+            await ctx.answerCallbackQuery({ text: t("tts.off_success") });
+            await ctx.editMessageText(t("tts.off_success"));
+            return true;
+        }
+        if (callbackData.action === "select" && callbackData.voice) {
+            setCurrentTtsVoice(callbackData.voice);
+            setTtsEnabled(true);
+            await ctx.answerCallbackQuery({ text: t("tts.voice_changed", { voice: callbackData.voice }) });
+            // Update the menu to show selection
+            const voices = await getAvailableVoices();
+            const currentVoice = getCurrentTtsVoice();
+            await ctx.editMessageText(t("tts.menu_current", { voice: currentVoice || "default" }), {
+                reply_markup: {
+                    inline_keyboard: buildVoiceKeyboard(voices, 0, currentVoice),
+                },
+            });
+            return true;
+        }
+        if (callbackData.action === "page" && typeof callbackData.page === "number") {
+            const voices = await getAvailableVoices();
+            const currentVoice = getCurrentTtsVoice();
+            await ctx.editMessageText(t("tts.menu_current", { voice: currentVoice || "default" }), {
+                reply_markup: {
+                    inline_keyboard: buildVoiceKeyboard(voices, callbackData.page, currentVoice),
+                },
+            });
+            await ctx.answerCallbackQuery();
+            return true;
+        }
+    }
+    catch (error) {
+        logger.error("[VoiceCallback] Error:", error);
+        await ctx.answerCallbackQuery({ text: t("tts.voice_error", { error: String(error) }) });
+        return true;
+    }
+    return false;
+}
+// Add navigation button translations
+// These need to be added to en.ts if not present
+export function initTtsButtons() {
+    // This is just a marker - button translations are in en.ts
+}

package/dist/bot/handlers/agent.js

@@ -0,0 +1,118 @@
+import { InlineKeyboard } from "grammy";
+import { selectAgent, getAvailableAgents, fetchCurrentAgent } from "../../agent/manager.js";
+import { getAgentDisplayName, getAgentEmoji } from "../../agent/types.js";
+import { getStoredModel } from "../../model/manager.js";
+import { formatVariantForButton } from "../../variant/manager.js";
+import { logger } from "../../utils/logger.js";
+import { createMainKeyboard } from "../utils/keyboard.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { clearActiveInlineMenu, ensureActiveInlineMenu, replyWithInlineMenu, } from "./inline-menu.js";
+import { t } from "../../i18n/index.js";
+/**
+ * Handle agent selection callback
+ * @param ctx grammY context
+ * @returns true if handled, false otherwise
+ */
+export async function handleAgentSelect(ctx) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || !callbackQuery.data.startsWith("agent:")) {
+        return false;
+    }
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "agent");
+    if (!isActiveMenu) {
+        return true;
+    }
+    logger.debug(`[AgentHandler] Received callback: ${callbackQuery.data}`);
+    try {
+        if (ctx.chat) {
+            keyboardManager.initialize(ctx.api, ctx.chat.id);
+        }
+        if (pinnedMessageManager.getContextLimit() === 0) {
+            await pinnedMessageManager.refreshContextLimit();
+        }
+        const agentName = callbackQuery.data.replace("agent:", "");
+        // Select agent and persist
+        selectAgent(agentName);
+        // Update keyboard manager state
+        keyboardManager.updateAgent(agentName);
+        // Update Reply Keyboard with new agent, current model, and context
+        const currentModel = getStoredModel();
+        const contextInfo = pinnedMessageManager.getContextInfo() ??
+            (pinnedMessageManager.getContextLimit() > 0
+                ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit() }
+                : null);
+        keyboardManager.updateModel(currentModel);
+        if (contextInfo) {
+            keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
+        }
+        const state = keyboardManager.getState();
+        const variantName = state?.variantName ?? formatVariantForButton(currentModel.variant || "default");
+        const keyboard = createMainKeyboard(agentName, currentModel, contextInfo ?? undefined, variantName);
+        const displayName = getAgentDisplayName(agentName);
+        clearActiveInlineMenu("agent_selected");
+        // Send confirmation message with updated keyboard
+        await ctx.answerCallbackQuery({ text: t("agent.changed_callback", { name: displayName }) });
+        await ctx.reply(t("agent.changed_message", { name: displayName }), {
+            reply_markup: keyboard,
+        });
+        // Delete the inline menu message
+        await ctx.deleteMessage().catch(() => { });
+        return true;
+    }
+    catch (err) {
+        clearActiveInlineMenu("agent_select_error");
+        logger.error("[AgentHandler] Error handling agent select:", err);
+        await ctx.answerCallbackQuery({ text: t("agent.change_error_callback") }).catch(() => { });
+        return false;
+    }
+}
+/**
+ * Build inline keyboard with available agents
+ * @param currentAgent Current agent name for highlighting
+ * @returns InlineKeyboard with agent selection buttons
+ */
+export async function buildAgentSelectionMenu(currentAgent) {
+    const keyboard = new InlineKeyboard();
+    const agents = await getAvailableAgents();
+    if (agents.length === 0) {
+        logger.warn("[AgentHandler] No available agents found");
+        return keyboard;
+    }
+    // Add button for each agent
+    agents.forEach((agent) => {
+        const emoji = getAgentEmoji(agent.name);
+        const isActive = agent.name === currentAgent;
+        const label = isActive
+            ? `✅ ${emoji} ${agent.name.toUpperCase()}`
+            : `${emoji} ${agent.name.charAt(0).toUpperCase() + agent.name.slice(1)}`;
+        keyboard.text(label, `agent:${agent.name}`).row();
+    });
+    return keyboard;
+}
+/**
+ * Show agent selection menu
+ * @param ctx grammY context
+ */
+export async function showAgentSelectionMenu(ctx) {
+    try {
+        const currentAgent = await fetchCurrentAgent();
+        const keyboard = await buildAgentSelectionMenu(currentAgent);
+        if (keyboard.inline_keyboard.length === 0) {
+            await ctx.reply(t("agent.menu.empty"));
+            return;
+        }
+        const text = currentAgent
+            ? t("agent.menu.current", { name: getAgentDisplayName(currentAgent) })
+            : t("agent.menu.select");
+        await replyWithInlineMenu(ctx, {
+            menuKind: "agent",
+            text,
+            keyboard,
+        });
+    }
+    catch (err) {
+        logger.error("[AgentHandler] Error showing agent menu:", err);
+        await ctx.reply(t("agent.menu.error"));
+    }
+}

package/dist/bot/handlers/context.js

@@ -0,0 +1,100 @@
+import { InlineKeyboard } from "grammy";
+import { getCurrentSession } from "../../session/manager.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { getStoredModel } from "../../model/manager.js";
+import { clearActiveInlineMenu, ensureActiveInlineMenu, replyWithInlineMenu, } from "./inline-menu.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+/**
+ * Build inline keyboard with compact confirmation menu
+ * @returns InlineKeyboard with confirmation button
+ */
+export function buildCompactConfirmationMenu() {
+    const keyboard = new InlineKeyboard();
+    keyboard.text(t("context.button.confirm"), "compact:confirm");
+    return keyboard;
+}
+/**
+ * Handle context button press (text message from Reply Keyboard)
+ * Shows inline menu with compact confirmation
+ * @param ctx grammY context
+ */
+export async function handleContextButtonPress(ctx) {
+    logger.debug("[ContextHandler] Context button pressed");
+    const session = getCurrentSession();
+    if (!session) {
+        await ctx.reply(t("context.no_active_session"));
+        return;
+    }
+    const keyboard = buildCompactConfirmationMenu();
+    await replyWithInlineMenu(ctx, {
+        menuKind: "context",
+        text: t("context.confirm_text", { title: session.title }),
+        keyboard,
+    });
+}
+/**
+ * Handle compact confirmation callback
+ * Calls OpenCode API to compact the session
+ * @param ctx grammY context
+ */
+export async function handleCompactConfirm(ctx) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || callbackQuery.data !== "compact:confirm") {
+        return false;
+    }
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "context");
+    if (!isActiveMenu) {
+        return true;
+    }
+    logger.debug("[ContextHandler] Compact confirmed");
+    try {
+        const session = getCurrentSession();
+        if (!session) {
+            clearActiveInlineMenu("context_session_missing");
+            await ctx.answerCallbackQuery({ text: t("context.callback_session_not_found") });
+            await ctx.reply(t("context.no_active_session"));
+            await ctx.deleteMessage().catch(() => { });
+            return true;
+        }
+        // Answer callback query and delete menu immediately
+        await ctx.answerCallbackQuery({ text: t("context.callback_compacting") });
+        clearActiveInlineMenu("context_compact_confirmed");
+        await ctx.deleteMessage().catch(() => { });
+        // Send progress message
+        const progressMessage = await ctx.reply(t("context.progress"));
+        // Show typing indicator
+        await ctx.api.sendChatAction(ctx.chat.id, "typing");
+        const storedModel = getStoredModel();
+        logger.debug(`[ContextHandler] Calling summarize with sessionID=${session.id}, directory=${session.directory}, model=${storedModel.providerID}/${storedModel.modelID}`);
+        // Call summarize API (AI compaction)
+        const { error } = await opencodeClient.session.summarize({
+            sessionID: session.id,
+            directory: session.directory,
+            providerID: storedModel.providerID,
+            modelID: storedModel.modelID,
+        });
+        if (error) {
+            logger.error("[ContextHandler] Compact failed:", error);
+            // Update progress message to show error
+            await ctx.api
+                .editMessageText(ctx.chat.id, progressMessage.message_id, t("context.error"))
+                .catch(() => { });
+            return true;
+        }
+        logger.info(`[ContextHandler] Session compacted: ${session.id}`);
+        // Update progress message to show success
+        await ctx.api
+            .editMessageText(ctx.chat.id, progressMessage.message_id, t("context.success"))
+            .catch(() => { });
+        return true;
+    }
+    catch (err) {
+        clearActiveInlineMenu("context_compact_error");
+        logger.error("[ContextHandler] Compact exception:", err);
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error") }).catch(() => { });
+        await ctx.reply(t("context.error"));
+        await ctx.deleteMessage().catch(() => { });
+        return false;
+    }
+}

package/dist/bot/handlers/document.js

@@ -0,0 +1,65 @@
+import { config } from "../../config.js";
+import { processUserPrompt } from "./prompt.js";
+import { downloadTelegramFile, toDataUri, isTextMimeType, isFileSizeAllowed, } from "../utils/file-download.js";
+import { getModelCapabilities, supportsInput } from "../../model/capabilities.js";
+import { getStoredModel } from "../../model/manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+export async function handleDocumentMessage(ctx, deps) {
+    const downloadFile = deps.downloadFile ?? downloadTelegramFile;
+    const getCapabilities = deps.getModelCapabilities ?? getModelCapabilities;
+    const getStored = deps.getStoredModel ?? getStoredModel;
+    const processPrompt = deps.processPrompt ?? processUserPrompt;
+    const doc = ctx.message?.document;
+    if (!doc) {
+        return;
+    }
+    const caption = ctx.message.caption || "";
+    const mimeType = doc.mime_type || "";
+    const filename = doc.file_name || "document";
+    try {
+        if (isTextMimeType(mimeType)) {
+            if (!isFileSizeAllowed(doc.file_size, config.files.maxFileSizeKb)) {
+                logger.warn(`[Document] Text file too large: ${filename} (${doc.file_size} bytes > ${config.files.maxFileSizeKb}KB)`);
+                await ctx.reply(t("bot.text_file_too_large", { maxSizeKb: String(config.files.maxFileSizeKb) }));
+                return;
+            }
+            await ctx.reply(t("bot.file_downloading"));
+            const downloadedFile = await downloadFile(ctx.api, doc.file_id);
+            const textContent = downloadedFile.buffer.toString("utf-8");
+            const promptWithFile = `--- Content of ${filename} ---\n${textContent}\n--- End of file ---\n\n${caption}`;
+            logger.info(`[Document] Sending text file (${downloadedFile.buffer.length} bytes, ${filename}) as prompt`);
+            await processPrompt(ctx, promptWithFile, deps);
+            return;
+        }
+        if (mimeType === "application/pdf") {
+            const storedModel = getStored();
+            const capabilities = await getCapabilities(storedModel.providerID, storedModel.modelID);
+            if (!supportsInput(capabilities, "pdf")) {
+                logger.warn(`[Document] Model ${storedModel.providerID}/${storedModel.modelID} doesn't support PDF input`);
+                await ctx.reply(t("bot.model_no_pdf"));
+                if (caption.trim().length > 0) {
+                    await processPrompt(ctx, caption, deps);
+                }
+                return;
+            }
+            await ctx.reply(t("bot.file_downloading"));
+            const downloadedFile = await downloadFile(ctx.api, doc.file_id);
+            const dataUri = toDataUri(downloadedFile.buffer, mimeType);
+            const filePart = {
+                type: "file",
+                mime: mimeType,
+                filename: filename,
+                url: dataUri,
+            };
+            logger.info(`[Document] Sending PDF (${downloadedFile.buffer.length} bytes, ${filename}) with prompt`);
+            await processPrompt(ctx, caption, deps, [filePart]);
+            return;
+        }
+        logger.debug(`[Document] Unsupported document MIME type: ${mimeType}, ignoring`);
+    }
+    catch (err) {
+        logger.error("[Document] Error handling document message:", err);
+        await ctx.reply(t("bot.file_download_error"));
+    }
+}

package/dist/bot/handlers/inline-menu.js

@@ -0,0 +1,119 @@
+import { interactionManager } from "../../interaction/manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+const INLINE_MENU_CANCEL_PREFIX = "inline:cancel:";
+const LEGACY_CONTEXT_CANCEL_CALLBACK = "compact:cancel";
+const INLINE_MENU_KINDS = ["project", "session", "model", "agent", "variant", "context"];
+function isInlineMenuKind(value) {
+    return INLINE_MENU_KINDS.includes(value);
+}
+function getCallbackMessageId(ctx) {
+    const message = ctx.callbackQuery?.message;
+    if (!message || !("message_id" in message)) {
+        return null;
+    }
+    const messageId = message.message_id;
+    return typeof messageId === "number" ? messageId : null;
+}
+function getActiveInlineMenuMetadata(state) {
+    if (!state || state.kind !== "inline") {
+        return null;
+    }
+    const menuKind = state.metadata.menuKind;
+    const messageId = state.metadata.messageId;
+    if (typeof menuKind !== "string" || !isInlineMenuKind(menuKind)) {
+        return null;
+    }
+    if (typeof messageId !== "number") {
+        return null;
+    }
+    return {
+        menuKind,
+        messageId,
+    };
+}
+function getInlineCancelCallbackData(menuKind) {
+    return `${INLINE_MENU_CANCEL_PREFIX}${menuKind}`;
+}
+export function appendInlineMenuCancelButton(keyboard, menuKind) {
+    while (keyboard.inline_keyboard.length > 0 &&
+        keyboard.inline_keyboard[keyboard.inline_keyboard.length - 1].length === 0) {
+        keyboard.inline_keyboard.pop();
+    }
+    if (keyboard.inline_keyboard.length > 0) {
+        keyboard.row();
+    }
+    keyboard.text(t("inline.button.cancel"), getInlineCancelCallbackData(menuKind));
+    return keyboard;
+}
+export async function replyWithInlineMenu(ctx, options) {
+    const keyboard = appendInlineMenuCancelButton(options.keyboard, options.menuKind);
+    const replyOptions = {
+        reply_markup: keyboard,
+    };
+    if (options.parseMode) {
+        replyOptions.parse_mode = options.parseMode;
+    }
+    const message = await ctx.reply(options.text, replyOptions);
+    interactionManager.start({
+        kind: "inline",
+        expectedInput: "callback",
+        metadata: {
+            menuKind: options.menuKind,
+            messageId: message.message_id,
+        },
+    });
+    logger.debug(`[InlineMenu] Opened menu: kind=${options.menuKind}, messageId=${message.message_id}`);
+    return message.message_id;
+}
+export async function ensureActiveInlineMenu(ctx, menuKind) {
+    const activeMetadata = getActiveInlineMenuMetadata(interactionManager.getSnapshot());
+    const callbackMessageId = getCallbackMessageId(ctx);
+    const isActive = !!activeMetadata &&
+        callbackMessageId !== null &&
+        activeMetadata.menuKind === menuKind &&
+        activeMetadata.messageId === callbackMessageId;
+    if (isActive) {
+        return true;
+    }
+    logger.debug(`[InlineMenu] Stale callback ignored: expectedKind=${menuKind}, activeKind=${activeMetadata?.menuKind || "none"}, callbackMessageId=${callbackMessageId || "none"}, activeMessageId=${activeMetadata?.messageId || "none"}`);
+    await ctx
+        .answerCallbackQuery({ text: t("inline.inactive_callback"), show_alert: true })
+        .catch(() => { });
+    return false;
+}
+export function clearActiveInlineMenu(reason) {
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "inline") {
+        interactionManager.clear(reason);
+    }
+}
+export async function handleInlineMenuCancel(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data) {
+        return false;
+    }
+    let menuKind = null;
+    if (data === LEGACY_CONTEXT_CANCEL_CALLBACK) {
+        menuKind = "context";
+    }
+    else if (data.startsWith(INLINE_MENU_CANCEL_PREFIX)) {
+        const rawKind = data.slice(INLINE_MENU_CANCEL_PREFIX.length);
+        if (!isInlineMenuKind(rawKind)) {
+            return false;
+        }
+        menuKind = rawKind;
+    }
+    else {
+        return false;
+    }
+    const isActive = await ensureActiveInlineMenu(ctx, menuKind);
+    if (!isActive) {
+        return true;
+    }
+    clearActiveInlineMenu(`inline_menu_cancel:${menuKind}`);
+    await ctx.answerCallbackQuery({ text: t("inline.cancelled_callback") }).catch(() => { });
+    await ctx.deleteMessage().catch(() => { });
+    logger.debug(`[InlineMenu] Menu cancelled: kind=${menuKind}`);
+    return true;
+}