@grinev/opencode-telegram-bot 0.1.0-rc.1

package/dist/bot/handlers/agent.js

@@ -0,0 +1,96 @@
+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";
+/**
+ * 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;
+    }
+    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);
+        // Send confirmation message with updated keyboard
+        await ctx.answerCallbackQuery({ text: `Режим изменен: ${displayName}` });
+        await ctx.reply(`✅ Режим изменен на: ${displayName}`, {
+            reply_markup: keyboard,
+        });
+        // Delete the inline menu message
+        await ctx.deleteMessage().catch(() => { });
+        return true;
+    }
+    catch (err) {
+        logger.error("[AgentHandler] Error handling agent select:", err);
+        await ctx.answerCallbackQuery({ text: "Ошибка при смене режима" }).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) {
+    const currentAgent = await fetchCurrentAgent();
+    const keyboard = await buildAgentSelectionMenu(currentAgent);
+    const text = currentAgent
+        ? `Текущий режим: ${getAgentDisplayName(currentAgent)}\n\nВыберите режим:`
+        : "Выберите режим работы:";
+    await ctx.reply(text, { reply_markup: keyboard });
+}

package/dist/bot/handlers/context.js

@@ -0,0 +1,112 @@
+import { InlineKeyboard } from "grammy";
+import { getCurrentSession } from "../../session/manager.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { getStoredModel } from "../../model/manager.js";
+import { logger } from "../../utils/logger.js";
+/**
+ * Build inline keyboard with compact confirmation menu
+ * @returns InlineKeyboard with "Yes" and "Cancel" buttons
+ */
+export function buildCompactConfirmationMenu() {
+    const keyboard = new InlineKeyboard();
+    keyboard.text("✅ Да, сжать контекст", "compact:confirm").row();
+    keyboard.text("❌ Отмена", "compact:cancel").row();
+    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("⚠️ Нет активной сессии. Создайте сессию командой /new");
+        return;
+    }
+    const keyboard = buildCompactConfirmationMenu();
+    await ctx.reply(`📊 Сжатие контекста для сессии "${session.title}"\n\n` +
+        `Это уменьшит использование контекста, удалив старые сообщения из истории. ` +
+        `Текущая задача не будет прервана.\n\n` +
+        `Продолжить?`, { reply_markup: 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;
+    }
+    logger.debug("[ContextHandler] Compact confirmed");
+    try {
+        const session = getCurrentSession();
+        if (!session) {
+            await ctx.answerCallbackQuery({ text: "Сессия не найдена" });
+            await ctx.reply("⚠️ Нет активной сессии");
+            await ctx.deleteMessage().catch(() => { });
+            return true;
+        }
+        // Answer callback query and delete menu immediately
+        await ctx.answerCallbackQuery({ text: "Сжатие контекста..." });
+        await ctx.deleteMessage().catch(() => { });
+        // Send progress message
+        const progressMessage = await ctx.reply("⏳ Сжимаю контекст...");
+        // 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, "❌ Ошибка при сжатии контекста")
+                .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, "✅ Контекст успешно сжат")
+            .catch(() => { });
+        return true;
+    }
+    catch (err) {
+        logger.error("[ContextHandler] Compact exception:", err);
+        await ctx.answerCallbackQuery({ text: "Ошибка" }).catch(() => { });
+        await ctx.reply("❌ Ошибка при сжатии контекста");
+        await ctx.deleteMessage().catch(() => { });
+        return false;
+    }
+}
+/**
+ * Handle compact cancel callback
+ * @param ctx grammY context
+ */
+export async function handleCompactCancel(ctx) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || callbackQuery.data !== "compact:cancel") {
+        return false;
+    }
+    logger.debug("[ContextHandler] Compact cancelled");
+    try {
+        await ctx.answerCallbackQuery({ text: "Отменено" });
+        // Delete the inline menu message
+        await ctx.deleteMessage().catch(() => { });
+        return true;
+    }
+    catch (err) {
+        logger.error("[ContextHandler] Cancel error:", err);
+        return false;
+    }
+}

package/dist/bot/handlers/model.js

@@ -0,0 +1,115 @@
+import { InlineKeyboard } from "grammy";
+import { selectModel, getFavoriteModels, fetchCurrentModel } from "../../model/manager.js";
+import { formatModelForDisplay } from "../../model/types.js";
+import { formatVariantForButton } from "../../variant/manager.js";
+import { logger } from "../../utils/logger.js";
+import { createMainKeyboard } from "../utils/keyboard.js";
+import { getStoredAgent } from "../../agent/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+/**
+ * Handle model selection callback
+ * @param ctx grammY context
+ * @returns true if handled, false otherwise
+ */
+export async function handleModelSelect(ctx) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || !callbackQuery.data.startsWith("model:")) {
+        return false;
+    }
+    logger.debug(`[ModelHandler] Received callback: ${callbackQuery.data}`);
+    try {
+        if (ctx.chat) {
+            keyboardManager.initialize(ctx.api, ctx.chat.id);
+        }
+        // Parse callback data: "model:providerID:modelID"
+        const parts = callbackQuery.data.split(":");
+        if (parts.length < 3) {
+            logger.error(`[ModelHandler] Invalid callback data format: ${callbackQuery.data}`);
+            return false;
+        }
+        const providerID = parts[1];
+        const modelID = parts.slice(2).join(":"); // Handle model IDs that may contain ":"
+        const modelInfo = {
+            providerID,
+            modelID,
+            variant: "default", // Reset to default when switching models
+        };
+        // Select model and persist
+        selectModel(modelInfo);
+        // Update keyboard manager state (may not be initialized if no session selected)
+        keyboardManager.updateModel(modelInfo);
+        // Refresh context limit for new model
+        await pinnedMessageManager.refreshContextLimit();
+        // Update Reply Keyboard with new model and context
+        const currentAgent = getStoredAgent();
+        const contextInfo = pinnedMessageManager.getContextInfo() ??
+            (pinnedMessageManager.getContextLimit() > 0
+                ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit() }
+                : null);
+        if (contextInfo) {
+            keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
+        }
+        const variantName = formatVariantForButton(modelInfo.variant || "default");
+        const keyboard = createMainKeyboard(currentAgent, modelInfo, contextInfo ?? undefined, variantName);
+        const displayName = formatModelForDisplay(modelInfo.providerID, modelInfo.modelID);
+        // Send confirmation message with updated keyboard
+        await ctx.answerCallbackQuery({ text: `Модель изменена: ${displayName}` });
+        await ctx.reply(`✅ Модель изменена на: ${displayName}`, {
+            reply_markup: keyboard,
+        });
+        // Delete the inline menu message
+        await ctx.deleteMessage().catch(() => { });
+        return true;
+    }
+    catch (err) {
+        logger.error("[ModelHandler] Error handling model select:", err);
+        await ctx.answerCallbackQuery({ text: "Ошибка при смене модели" }).catch(() => { });
+        return false;
+    }
+}
+/**
+ * Build inline keyboard with favorite models
+ * @param currentModel Current model for highlighting
+ * @returns InlineKeyboard with model selection buttons
+ */
+export async function buildModelSelectionMenu(currentModel) {
+    const keyboard = new InlineKeyboard();
+    const favorites = await getFavoriteModels();
+    if (favorites.length === 0) {
+        logger.warn("[ModelHandler] No favorite models found");
+        return keyboard;
+    }
+    // Add button for each favorite model
+    favorites.forEach((model) => {
+        const isActive = currentModel &&
+            model.providerID === currentModel.providerID &&
+            model.modelID === currentModel.modelID;
+        // Inline buttons use full model ID without truncation
+        const label = `${model.providerID}/${model.modelID}`;
+        const labelWithCheck = isActive ? `✅ ${label}` : label;
+        keyboard.text(labelWithCheck, `model:${model.providerID}:${model.modelID}`).row();
+    });
+    return keyboard;
+}
+/**
+ * Show model selection menu
+ * @param ctx grammY context
+ */
+export async function showModelSelectionMenu(ctx) {
+    try {
+        const currentModel = fetchCurrentModel();
+        const keyboard = await buildModelSelectionMenu(currentModel);
+        if (keyboard.inline_keyboard.length === 0) {
+            await ctx.reply("⚠️ Нет доступных моделей");
+            return;
+        }
+        const displayName = formatModelForDisplay(currentModel.providerID, currentModel.modelID);
+        const text = `Текущая модель: ${displayName}\n\nВыберите модель:`;
+        await ctx.reply(text, { reply_markup: keyboard });
+    }
+    catch (err) {
+        logger.error("[ModelHandler] Error showing model menu:", err);
+        await ctx.reply("🔴 Не удалось получить список моделей");
+    }
+}

package/dist/bot/handlers/permission.js

@@ -0,0 +1,158 @@
+import { InlineKeyboard } from "grammy";
+import { permissionManager } from "../../permission/manager.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
+import { logger } from "../../utils/logger.js";
+import { safeBackgroundTask } from "../../utils/safe-background-task.js";
+// Permission type display names
+const PERMISSION_NAMES = {
+    bash: "Bash",
+    edit: "Edit",
+    write: "Write",
+    read: "Read",
+    webfetch: "Web Fetch",
+    websearch: "Web Search",
+    glob: "File Search",
+    grep: "Content Search",
+    list: "List Directory",
+    task: "Task",
+    lsp: "LSP",
+};
+// Permission type emojis
+const PERMISSION_EMOJIS = {
+    bash: "⚡",
+    edit: "✏️",
+    write: "📝",
+    read: "📖",
+    webfetch: "🌐",
+    websearch: "🔍",
+    glob: "📁",
+    grep: "🔎",
+    list: "📂",
+    task: "⚙️",
+    lsp: "🔧",
+};
+/**
+ * Handle permission callback from inline buttons
+ */
+export async function handlePermissionCallback(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data)
+        return false;
+    if (!data.startsWith("permission:")) {
+        return false;
+    }
+    logger.debug(`[PermissionHandler] Received callback: ${data}`);
+    if (!permissionManager.isActive()) {
+        await ctx.answerCallbackQuery({ text: "Запрос разрешения неактивен", show_alert: true });
+        return true;
+    }
+    const parts = data.split(":");
+    const action = parts[1];
+    try {
+        await handlePermissionReply(ctx, action);
+    }
+    catch (err) {
+        logger.error("[PermissionHandler] Error handling callback:", err);
+        await ctx.answerCallbackQuery({ text: "Ошибка при обработке", show_alert: true });
+    }
+    return true;
+}
+/**
+ * Handle permission reply (once/always/reject)
+ */
+async function handlePermissionReply(ctx, reply) {
+    const requestID = permissionManager.getRequestID();
+    const currentProject = getCurrentProject();
+    const chatId = ctx.chat?.id;
+    if (!requestID || !currentProject || !chatId) {
+        await ctx.answerCallbackQuery({ text: "Ошибка: нет активного запроса", show_alert: true });
+        return;
+    }
+    // Reply labels for user feedback
+    const replyLabels = {
+        once: "Разрешено однократно",
+        always: "Разрешено всегда",
+        reject: "Отклонено",
+    };
+    await ctx.answerCallbackQuery({ text: replyLabels[reply] });
+    // Delete the permission message
+    await ctx.deleteMessage().catch(() => { });
+    // Stop typing indicator since we're responding
+    summaryAggregator.stopTypingIndicator();
+    logger.info(`[PermissionHandler] Sending permission reply: ${reply}, requestID=${requestID}`);
+    // CRITICAL: Fire-and-forget! Do not block the handler
+    safeBackgroundTask({
+        taskName: "permission.reply",
+        task: () => opencodeClient.permission.reply({
+            requestID,
+            directory: currentProject.worktree,
+            reply,
+        }),
+        onSuccess: ({ error }) => {
+            if (error) {
+                logger.error("[PermissionHandler] Failed to send permission reply:", error);
+                if (ctx.api && chatId) {
+                    void ctx.api
+                        .sendMessage(chatId, "❌ Не удалось отправить ответ на запрос разрешения")
+                        .catch(() => { });
+                }
+                return;
+            }
+            logger.info("[PermissionHandler] Permission reply sent successfully");
+        },
+    });
+    permissionManager.clear();
+}
+/**
+ * Show permission request message with inline buttons
+ */
+export async function showPermissionRequest(bot, chatId, request) {
+    logger.debug(`[PermissionHandler] Showing permission request: ${request.permission}`);
+    permissionManager.startPermission(request);
+    const text = formatPermissionText(request);
+    const keyboard = buildPermissionKeyboard();
+    try {
+        const message = await bot.sendMessage(chatId, text, {
+            reply_markup: keyboard,
+            parse_mode: "Markdown",
+        });
+        logger.debug(`[PermissionHandler] Message sent, messageId=${message.message_id}`);
+        permissionManager.setMessageId(message.message_id);
+        summaryAggregator.stopTypingIndicator();
+    }
+    catch (err) {
+        logger.error("[PermissionHandler] Failed to send permission message:", err);
+        throw err;
+    }
+}
+/**
+ * Format permission request text
+ */
+function formatPermissionText(request) {
+    const emoji = PERMISSION_EMOJIS[request.permission] || "🔐";
+    const name = PERMISSION_NAMES[request.permission] || request.permission;
+    let text = `${emoji} **Запрос разрешения: ${name}**\n\n`;
+    // Show patterns (commands/files)
+    if (request.patterns.length > 0) {
+        request.patterns.forEach((pattern) => {
+            // Escape backticks for Markdown code
+            const escapedPattern = pattern.replace(/`/g, "\\`");
+            text += `\`${escapedPattern}\`\n`;
+        });
+    }
+    return text;
+}
+/**
+ * Build inline keyboard with permission buttons
+ */
+function buildPermissionKeyboard() {
+    const keyboard = new InlineKeyboard();
+    // Single row with all 3 buttons
+    keyboard
+        .text("✅ Разрешить", "permission:once")
+        .text("🔓 Всегда", "permission:always")
+        .text("❌ Отклонить", "permission:reject");
+    return keyboard;
+}