@grinev/opencode-telegram-bot 0.4.0 → 0.6.0

package/dist/bot/handlers/model.js

@@ -7,6 +7,7 @@ import { createMainKeyboard } from "../utils/keyboard.js";
 import { getStoredAgent } from "../../agent/manager.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 model selection callback
@@ -18,6 +19,10 @@ export async function handleModelSelect(ctx) {
     if (!callbackQuery?.data || !callbackQuery.data.startsWith("model:")) {
         return false;
     }
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "model");
+    if (!isActiveMenu) {
+        return true;
+    }
     logger.debug(`[ModelHandler] Received callback: ${callbackQuery.data}`);
     try {
         if (ctx.chat) {
@@ -27,7 +32,9 @@ export async function handleModelSelect(ctx) {
         const parts = callbackQuery.data.split(":");
         if (parts.length < 3) {
             logger.error(`[ModelHandler] Invalid callback data format: ${callbackQuery.data}`);
-            return false;
+            clearActiveInlineMenu("model_select_invalid_callback");
+            await ctx.answerCallbackQuery({ text: t("model.change_error_callback") }).catch(() => { });
+            return true;
         }
         const providerID = parts[1];
         const modelID = parts.slice(2).join(":"); // Handle model IDs that may contain ":"
@@ -54,6 +61,7 @@ export async function handleModelSelect(ctx) {
         const variantName = formatVariantForButton(modelInfo.variant || "default");
         const keyboard = createMainKeyboard(currentAgent, modelInfo, contextInfo ?? undefined, variantName);
         const displayName = formatModelForDisplay(modelInfo.providerID, modelInfo.modelID);
+        clearActiveInlineMenu("model_selected");
         // Send confirmation message with updated keyboard
         await ctx.answerCallbackQuery({ text: t("model.changed_callback", { name: displayName }) });
         await ctx.reply(t("model.changed_message", { name: displayName }), {
@@ -64,6 +72,7 @@ export async function handleModelSelect(ctx) {
         return true;
     }
     catch (err) {
+        clearActiveInlineMenu("model_select_error");
         logger.error("[ModelHandler] Error handling model select:", err);
         await ctx.answerCallbackQuery({ text: t("model.change_error_callback") }).catch(() => { });
         return false;
@@ -107,7 +116,11 @@ export async function showModelSelectionMenu(ctx) {
         }
         const displayName = formatModelForDisplay(currentModel.providerID, currentModel.modelID);
         const text = t("model.menu.current", { name: displayName });
-        await ctx.reply(text, { reply_markup: keyboard });
+        await replyWithInlineMenu(ctx, {
+            menuKind: "model",
+            text,
+            keyboard,
+        });
     }
     catch (err) {
         logger.error("[ModelHandler] Error showing model menu:", err);

package/dist/bot/handlers/permission.js

@@ -4,6 +4,7 @@ import { opencodeClient } from "../../opencode/client.js";
 import { getCurrentProject } from "../../settings/manager.js";
 import { getCurrentSession } from "../../session/manager.js";
 import { summaryAggregator } from "../../summary/aggregator.js";
+import { interactionManager } from "../../interaction/manager.js";
 import { logger } from "../../utils/logger.js";
 import { safeBackgroundTask } from "../../utils/safe-background-task.js";
 import { t } from "../../i18n/index.js";
@@ -35,6 +36,47 @@ const PERMISSION_EMOJIS = {
     task: "⚙️",
     lsp: "🔧",
 };
+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 clearPermissionInteraction(reason) {
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "permission") {
+        interactionManager.clear(reason);
+    }
+}
+function syncPermissionInteractionState(metadata = {}) {
+    const pendingCount = permissionManager.getPendingCount();
+    if (pendingCount === 0) {
+        clearPermissionInteraction("permission_no_pending_requests");
+        return;
+    }
+    const nextMetadata = {
+        pendingCount,
+        ...metadata,
+    };
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "permission") {
+        interactionManager.transition({
+            expectedInput: "callback",
+            metadata: nextMetadata,
+        });
+        return;
+    }
+    interactionManager.start({
+        kind: "permission",
+        expectedInput: "callback",
+        metadata: nextMetadata,
+    });
+}
+function isPermissionReply(value) {
+    return value === "once" || value === "always" || value === "reject";
+}
 /**
  * Handle permission callback from inline buttons
  */
@@ -47,13 +89,31 @@ export async function handlePermissionCallback(ctx) {
     }
     logger.debug(`[PermissionHandler] Received callback: ${data}`);
     if (!permissionManager.isActive()) {
+        clearPermissionInteraction("permission_inactive_callback");
+        await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const callbackMessageId = getCallbackMessageId(ctx);
+    if (!permissionManager.isActiveMessage(callbackMessageId)) {
+        await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const requestID = permissionManager.getRequestID(callbackMessageId);
+    if (!requestID) {
         await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
         return true;
     }
     const parts = data.split(":");
     const action = parts[1];
+    if (!isPermissionReply(action)) {
+        await ctx.answerCallbackQuery({
+            text: t("permission.processing_error_callback"),
+            show_alert: true,
+        });
+        return true;
+    }
     try {
-        await handlePermissionReply(ctx, action);
+        await handlePermissionReply(ctx, action, requestID, callbackMessageId);
     }
     catch (err) {
         logger.error("[PermissionHandler] Error handling callback:", err);
@@ -67,13 +127,14 @@ export async function handlePermissionCallback(ctx) {
 /**
  * Handle permission reply (once/always/reject)
  */
-async function handlePermissionReply(ctx, reply) {
-    const requestID = permissionManager.getRequestID();
+async function handlePermissionReply(ctx, reply, requestID, callbackMessageId) {
     const currentProject = getCurrentProject();
     const currentSession = getCurrentSession();
     const chatId = ctx.chat?.id;
     const directory = currentSession?.directory ?? currentProject?.worktree;
-    if (!requestID || !directory || !chatId) {
+    if (!directory || !chatId) {
+        permissionManager.clear();
+        clearPermissionInteraction("permission_invalid_runtime_context");
         await ctx.answerCallbackQuery({
             text: t("permission.no_active_request_callback"),
             show_alert: true,
@@ -111,14 +172,20 @@ async function handlePermissionReply(ctx, reply) {
             logger.info("[PermissionHandler] Permission reply sent successfully");
         },
     });
-    permissionManager.clear();
+    permissionManager.removeByMessageId(callbackMessageId);
+    if (!permissionManager.isActive()) {
+        clearPermissionInteraction("permission_replied");
+        return;
+    }
+    syncPermissionInteractionState({
+        lastRepliedRequestID: requestID,
+    });
 }
 /**
  * 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 {
@@ -127,7 +194,11 @@ export async function showPermissionRequest(bot, chatId, request) {
             parse_mode: "Markdown",
         });
         logger.debug(`[PermissionHandler] Message sent, messageId=${message.message_id}`);
-        permissionManager.setMessageId(message.message_id);
+        permissionManager.startPermission(request, message.message_id);
+        syncPermissionInteractionState({
+            requestID: request.id,
+            messageId: message.message_id,
+        });
         summaryAggregator.stopTypingIndicator();
     }
     catch (err) {
@@ -158,10 +229,8 @@ function formatPermissionText(request) {
  */
 function buildPermissionKeyboard() {
     const keyboard = new InlineKeyboard();
-    // Single row with all 3 buttons
-    keyboard
-        .text(t("permission.button.allow"), "permission:once")
-        .text(t("permission.button.always"), "permission:always")
-        .text(t("permission.button.reject"), "permission:reject");
+    keyboard.text(t("permission.button.allow"), "permission:once").row();
+    keyboard.text(t("permission.button.always"), "permission:always").row();
+    keyboard.text(t("permission.button.reject"), "permission:reject");
     return keyboard;
 }

package/dist/bot/handlers/question.js

@@ -4,10 +4,51 @@ import { opencodeClient } from "../../opencode/client.js";
 import { getCurrentProject } from "../../settings/manager.js";
 import { getCurrentSession } from "../../session/manager.js";
 import { summaryAggregator } from "../../summary/aggregator.js";
+import { interactionManager } from "../../interaction/manager.js";
 import { logger } from "../../utils/logger.js";
 import { safeBackgroundTask } from "../../utils/safe-background-task.js";
 import { t } from "../../i18n/index.js";
 const MAX_BUTTON_LENGTH = 60;
+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 clearQuestionInteraction(reason) {
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "question") {
+        interactionManager.clear(reason);
+    }
+}
+function syncQuestionInteractionState(expectedInput, questionIndex, messageId) {
+    const metadata = {
+        questionIndex,
+        inputMode: expectedInput === "mixed" ? "custom" : "options",
+    };
+    const requestID = questionManager.getRequestID();
+    if (requestID) {
+        metadata.requestID = requestID;
+    }
+    if (messageId !== null) {
+        metadata.messageId = messageId;
+    }
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "question") {
+        interactionManager.transition({
+            expectedInput,
+            metadata,
+        });
+        return;
+    }
+    interactionManager.start({
+        kind: "question",
+        expectedInput,
+        metadata,
+    });
+}
 export async function handleQuestionCallback(ctx) {
     const data = ctx.callbackQuery?.data;
     if (!data)
@@ -17,16 +58,36 @@ export async function handleQuestionCallback(ctx) {
     }
     logger.debug(`[QuestionHandler] Received callback: ${data}`);
     if (!questionManager.isActive()) {
+        clearQuestionInteraction("question_inactive_callback");
+        await ctx.answerCallbackQuery({ text: t("question.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const callbackMessageId = getCallbackMessageId(ctx);
+    if (!questionManager.isActiveMessage(callbackMessageId)) {
         await ctx.answerCallbackQuery({ text: t("question.inactive_callback"), show_alert: true });
         return true;
     }
     const parts = data.split(":");
     const action = parts[1];
     const questionIndex = parseInt(parts[2], 10);
+    if (Number.isNaN(questionIndex) || questionIndex !== questionManager.getCurrentIndex()) {
+        await ctx.answerCallbackQuery({ text: t("question.inactive_callback"), show_alert: true });
+        return true;
+    }
     try {
         switch (action) {
             case "select":
-                await handleSelectOption(ctx, questionIndex, parseInt(parts[3], 10));
+                {
+                    const optionIndex = parseInt(parts[3], 10);
+                    if (Number.isNaN(optionIndex)) {
+                        await ctx.answerCallbackQuery({
+                            text: t("question.processing_error_callback"),
+                            show_alert: true,
+                        });
+                        break;
+                    }
+                    await handleSelectOption(ctx, questionIndex, optionIndex);
+                }
                 break;
             case "submit":
                 await handleSubmitAnswer(ctx, questionIndex);
@@ -37,6 +98,12 @@ export async function handleQuestionCallback(ctx) {
             case "cancel":
                 await handleCancelPoll(ctx);
                 break;
+            default:
+                await ctx.answerCallbackQuery({
+                    text: t("question.processing_error_callback"),
+                    show_alert: true,
+                });
+                break;
         }
     }
     catch (err) {
@@ -55,6 +122,10 @@ async function handleSelectOption(ctx, questionIndex, optionIndex) {
         logger.debug("[QuestionHandler] No current question");
         return;
     }
+    if (questionManager.isWaitingForCustomInput(questionIndex)) {
+        questionManager.clearCustomInput();
+        syncQuestionInteractionState("callback", questionIndex, questionManager.getActiveMessageId());
+    }
     questionManager.selectOption(questionIndex, optionIndex);
     if (question.multiple) {
         logger.debug("[QuestionHandler] Multiple choice mode, updating message");
@@ -74,6 +145,10 @@ async function handleSelectOption(ctx, questionIndex, optionIndex) {
     }
 }
 async function handleSubmitAnswer(ctx, questionIndex) {
+    if (questionManager.isWaitingForCustomInput(questionIndex)) {
+        questionManager.clearCustomInput();
+        syncQuestionInteractionState("callback", questionIndex, questionManager.getActiveMessageId());
+    }
     const answer = questionManager.getSelectedAnswer(questionIndex);
     if (!answer) {
         await ctx.answerCallbackQuery({
@@ -90,7 +165,9 @@ async function handleSubmitAnswer(ctx, questionIndex) {
     // All answers will be sent together after the user answers all questions
     await showNextQuestion(ctx);
 }
-async function handleCustomAnswer(ctx, _questionIndex) {
+async function handleCustomAnswer(ctx, questionIndex) {
+    questionManager.startCustomInput(questionIndex);
+    syncQuestionInteractionState("mixed", questionIndex, questionManager.getActiveMessageId());
     await ctx.answerCallbackQuery({
         text: t("question.enter_custom_callback"),
         show_alert: true,
@@ -98,8 +175,10 @@ async function handleCustomAnswer(ctx, _questionIndex) {
 }
 async function handleCancelPoll(ctx) {
     questionManager.cancel();
-    await ctx.editMessageText(t("question.cancelled"));
+    clearQuestionInteraction("question_cancelled");
+    await ctx.editMessageText(t("question.cancelled")).catch(() => { });
     await ctx.answerCallbackQuery();
+    questionManager.clear();
 }
 async function updateQuestionMessage(ctx) {
     const question = questionManager.getCurrentQuestion();
@@ -137,9 +216,13 @@ export async function showCurrentQuestion(bot, chatId) {
         });
         logger.debug(`[QuestionHandler] Message sent, messageId=${message.message_id}`);
         questionManager.addMessageId(message.message_id);
+        questionManager.setActiveMessageId(message.message_id);
+        syncQuestionInteractionState("callback", questionManager.getCurrentIndex(), questionManager.getActiveMessageId());
         summaryAggregator.stopTypingIndicator();
     }
     catch (err) {
+        questionManager.clear();
+        clearQuestionInteraction("question_message_send_failed");
         logger.error("[QuestionHandler] Failed to send question message:", err);
         throw err;
     }
@@ -149,17 +232,21 @@ export async function handleQuestionTextAnswer(ctx) {
     if (!text)
         return;
     const currentIndex = questionManager.getCurrentIndex();
+    if (!questionManager.isWaitingForCustomInput(currentIndex)) {
+        await ctx.reply(t("question.use_custom_button_first"));
+        return;
+    }
     if (questionManager.hasCustomAnswer(currentIndex)) {
         await ctx.reply(t("question.answer_already_received"));
         return;
     }
     logger.debug(`[QuestionHandler] Custom text answer for question ${currentIndex}: ${text}`);
     questionManager.setCustomAnswer(currentIndex, text);
+    questionManager.clearCustomInput();
     // Delete the previous question message
-    const messageIds = questionManager.getMessageIds();
-    if (messageIds.length > 0 && ctx.chat) {
-        const lastMessageId = messageIds[messageIds.length - 1];
-        await ctx.api.deleteMessage(ctx.chat.id, lastMessageId).catch(() => { });
+    const activeMessageId = questionManager.getActiveMessageId();
+    if (activeMessageId !== null && ctx.chat) {
+        await ctx.api.deleteMessage(ctx.chat.id, activeMessageId).catch(() => { });
     }
     // DO NOT send the answer immediately - move to the next question
     // All answers will be sent together after the user answers all questions
@@ -190,6 +277,7 @@ async function showPollSummary(bot, chatId) {
         const summary = formatAnswersSummary(answers);
         await bot.sendMessage(chatId, summary);
     }
+    clearQuestionInteraction("question_completed");
     questionManager.clear();
     logger.debug("[QuestionHandler] Poll completed and cleared");
 }
@@ -271,10 +359,10 @@ function buildQuestionKeyboard(question, selectedOptions) {
         keyboard.text(buttonText, callbackData).row();
     });
     if (question.multiple) {
-        keyboard.text(t("question.button.submit"), `question:submit:${questionIndex}`);
+        keyboard.text(t("question.button.submit"), `question:submit:${questionIndex}`).row();
         logger.debug(`[QuestionHandler] Added submit button`);
     }
-    keyboard.text(t("question.button.custom"), `question:custom:${questionIndex}`);
+    keyboard.text(t("question.button.custom"), `question:custom:${questionIndex}`).row();
     logger.debug(`[QuestionHandler] Added custom answer button`);
     keyboard.text(t("question.button.cancel"), `question:cancel:${questionIndex}`);
     logger.debug(`[QuestionHandler] Added cancel button`);

package/dist/bot/handlers/variant.js

@@ -6,6 +6,7 @@ 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";
 /**
  * Handle variant selection callback
@@ -17,6 +18,10 @@ export async function handleVariantSelect(ctx) {
     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 {
         if (ctx.chat) {
@@ -54,6 +59,7 @@ export async function handleVariantSelect(ctx) {
         const keyboard = createMainKeyboard(currentAgent, updatedModel, contextInfo ?? undefined, variantName);
         // Send confirmation message with updated keyboard
         const displayName = formatVariantForDisplay(variantId);
+        clearActiveInlineMenu("variant_selected");
         await ctx.answerCallbackQuery({ text: t("variant.changed_callback", { name: displayName }) });
         await ctx.reply(t("variant.changed_message", { name: displayName }), {
             reply_markup: keyboard,
@@ -63,6 +69,7 @@ export async function handleVariantSelect(ctx) {
         return true;
     }
     catch (err) {
+        clearActiveInlineMenu("variant_select_error");
         logger.error("[VariantHandler] Error handling variant select:", err);
         await ctx.answerCallbackQuery({ text: t("variant.change_error_callback") }).catch(() => { });
         return false;
@@ -118,7 +125,11 @@ export async function showVariantSelectionMenu(ctx) {
         }
         const displayName = formatVariantForDisplay(currentVariant);
         const text = t("variant.menu.current", { name: displayName });
-        await ctx.reply(text, { reply_markup: keyboard });
+        await replyWithInlineMenu(ctx, {
+            menuKind: "variant",
+            text,
+            keyboard,
+        });
     }
     catch (err) {
         logger.error("[VariantHandler] Error showing variant menu:", err);