@grinev/opencode-telegram-bot 0.4.0 → 0.5.0

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,20 @@ 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);
+    }
+}
 /**
  * Handle permission callback from inline buttons
  */
@@ -47,6 +62,12 @@ 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;
     }
@@ -74,6 +95,8 @@ async function handlePermissionReply(ctx, reply) {
     const chatId = ctx.chat?.id;
     const directory = currentSession?.directory ?? currentProject?.worktree;
     if (!requestID || !directory || !chatId) {
+        permissionManager.clear();
+        clearPermissionInteraction("permission_invalid_runtime_context");
         await ctx.answerCallbackQuery({
             text: t("permission.no_active_request_callback"),
             show_alert: true,
@@ -112,13 +135,29 @@ async function handlePermissionReply(ctx, reply) {
         },
     });
     permissionManager.clear();
+    clearPermissionInteraction("permission_replied");
 }
 /**
  * Show permission request message with inline buttons
  */
 export async function showPermissionRequest(bot, chatId, request) {
     logger.debug(`[PermissionHandler] Showing permission request: ${request.permission}`);
+    const previousMessageId = permissionManager.getMessageId();
+    const hadActivePermission = permissionManager.isActive();
+    if (hadActivePermission && previousMessageId !== null) {
+        logger.debug(`[PermissionHandler] Replacing active permission request, deleting previous message: ${previousMessageId}`);
+        await bot.deleteMessage(chatId, previousMessageId).catch((err) => {
+            logger.debug("[PermissionHandler] Failed to delete previous permission message:", err);
+        });
+    }
     permissionManager.startPermission(request);
+    interactionManager.start({
+        kind: "permission",
+        expectedInput: "callback",
+        metadata: {
+            requestID: request.id,
+        },
+    });
     const text = formatPermissionText(request);
     const keyboard = buildPermissionKeyboard();
     try {
@@ -128,9 +167,17 @@ export async function showPermissionRequest(bot, chatId, request) {
         });
         logger.debug(`[PermissionHandler] Message sent, messageId=${message.message_id}`);
         permissionManager.setMessageId(message.message_id);
+        interactionManager.transition({
+            metadata: {
+                requestID: request.id,
+                messageId: message.message_id,
+            },
+        });
         summaryAggregator.stopTypingIndicator();
     }
     catch (err) {
+        permissionManager.clear();
+        clearPermissionInteraction("permission_message_send_failed");
         logger.error("[PermissionHandler] Failed to send permission message:", err);
         throw err;
     }
@@ -158,10 +205,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);

package/dist/bot/index.js

@@ -6,6 +6,8 @@ import { SocksProxyAgent } from "socks-proxy-agent";
 import { HttpsProxyAgent } from "https-proxy-agent";
 import { config } from "../config.js";
 import { authMiddleware } from "./middleware/auth.js";
+import { interactionGuardMiddleware } from "./middleware/interaction-guard.js";
+import { unknownCommandMiddleware } from "./middleware/unknown-command.js";
 import { BOT_COMMANDS } from "./commands/definitions.js";
 import { startCommand } from "./commands/start.js";
 import { helpCommand } from "./commands/help.js";
@@ -25,9 +27,11 @@ import { handlePermissionCallback, showPermissionRequest } from "./handlers/perm
 import { handleAgentSelect, showAgentSelectionMenu } from "./handlers/agent.js";
 import { handleModelSelect, showModelSelectionMenu } from "./handlers/model.js";
 import { handleVariantSelect, showVariantSelectionMenu } from "./handlers/variant.js";
-import { handleContextButtonPress, handleCompactConfirm, handleCompactCancel, } from "./handlers/context.js";
+import { handleContextButtonPress, handleCompactConfirm } from "./handlers/context.js";
+import { handleInlineMenuCancel } from "./handlers/inline-menu.js";
 import { questionManager } from "../question/manager.js";
-import { permissionManager } from "../permission/manager.js";
+import { interactionManager } from "../interaction/manager.js";
+import { clearAllInteractionState } from "../interaction/cleanup.js";
 import { keyboardManager } from "../keyboard/manager.js";
 import { stopEventListening, subscribeToEvents } from "../opencode/events.js";
 import { summaryAggregator } from "../summary/aggregator.js";
@@ -168,6 +172,14 @@ async function ensureEventSubscription(directory) {
             logger.error("Bot or chat ID not available for showing questions");
             return;
         }
+        if (questionManager.isActive()) {
+            logger.warn("[Bot] Replacing active poll with a new one");
+            const previousMessageIds = questionManager.getMessageIds();
+            for (const messageId of previousMessageIds) {
+                await botInstance.api.deleteMessage(chatIdInstance, messageId).catch(() => { });
+            }
+            clearAllInteractionState("question_replaced_by_new_poll");
+        }
         logger.info(`[Bot] Received ${questions.length} questions from agent, requestID=${requestID}`);
         questionManager.startQuestions(questions, requestID);
         await showCurrentQuestion(botInstance.api, chatIdInstance);
@@ -183,7 +195,7 @@ async function ensureEventSubscription(directory) {
                 });
             }
         }
-        questionManager.clear();
+        clearAllInteractionState("question_error");
     });
     summaryAggregator.setOnPermission(async (request) => {
         if (!botInstance || !chatIdInstance) {
@@ -298,8 +310,7 @@ async function isSessionBusy(sessionId, directory) {
 async function resetMismatchedSessionContext() {
     stopEventListening();
     summaryAggregator.clear();
-    questionManager.clear();
-    permissionManager.clear();
+    clearAllInteractionState("session_mismatch_reset");
     clearSession();
     keyboardManager.clearContext();
     if (!pinnedMessageManager.isInitialized()) {
@@ -313,6 +324,7 @@ async function resetMismatchedSessionContext() {
     }
 }
 export function createBot() {
+    clearAllInteractionState("bot_startup");
     const botOptions = {};
     if (config.telegram.proxyUrl) {
         const proxyUrl = config.telegram.proxyUrl;
@@ -365,6 +377,16 @@ export function createBot() {
     });
     bot.use(authMiddleware);
     bot.use(ensureCommandsInitialized);
+    bot.use(interactionGuardMiddleware);
+    const blockMenuWhileInteractionActive = async (ctx) => {
+        const activeInteraction = interactionManager.getSnapshot();
+        if (!activeInteraction) {
+            return false;
+        }
+        logger.debug(`[Bot] Blocking menu open while interaction active: kind=${activeInteraction.kind}, expectedInput=${activeInteraction.expectedInput}`);
+        await ctx.reply(t("interaction.blocked.finish_current"));
+        return true;
+    };
     bot.command("start", startCommand);
     bot.command("help", helpCommand);
     bot.command("status", statusCommand);
@@ -377,10 +399,12 @@ export function createBot() {
     bot.command("model", handleModelCommand);
     bot.command("stop", stopCommand);
     bot.command("rename", renameCommand);
+    bot.on("message:text", unknownCommandMiddleware);
     bot.on("callback_query:data", async (ctx) => {
         logger.debug(`[Bot] Received callback_query:data: ${ctx.callbackQuery?.data}`);
         logger.debug(`[Bot] Callback context: from=${ctx.from?.id}, chat=${ctx.chat?.id}`);
         try {
+            const handledInlineCancel = await handleInlineMenuCancel(ctx);
             const handledSession = await handleSessionSelect(ctx);
             const handledProject = await handleProjectSelect(ctx);
             const handledQuestion = await handleQuestionCallback(ctx);
@@ -389,10 +413,10 @@ export function createBot() {
             const handledModel = await handleModelSelect(ctx);
             const handledVariant = await handleVariantSelect(ctx);
             const handledCompactConfirm = await handleCompactConfirm(ctx);
-            const handledCompactCancel = await handleCompactCancel(ctx);
             const handledRenameCancel = await handleRenameCancel(ctx);
-            logger.debug(`[Bot] Callback handled: session=${handledSession}, project=${handledProject}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compact=${handledCompactConfirm || handledCompactCancel}, rename=${handledRenameCancel}`);
-            if (!handledSession &&
+            logger.debug(`[Bot] Callback handled: inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, rename=${handledRenameCancel}`);
+            if (!handledInlineCancel &&
+                !handledSession &&
                 !handledProject &&
                 !handledQuestion &&
                 !handledPermission &&
@@ -400,7 +424,6 @@ export function createBot() {
                 !handledModel &&
                 !handledVariant &&
                 !handledCompactConfirm &&
-                !handledCompactCancel &&
                 !handledRenameCancel) {
                 logger.debug("Unknown callback query:", ctx.callbackQuery?.data);
                 await ctx.answerCallbackQuery({ text: t("callback.unknown_command") });
@@ -408,6 +431,7 @@ export function createBot() {
         }
         catch (err) {
             logger.error("[Bot] Error handling callback:", err);
+            clearAllInteractionState("callback_handler_error");
             await ctx.answerCallbackQuery({ text: t("callback.processing_error") }).catch(() => { });
         }
     });
@@ -415,6 +439,9 @@ export function createBot() {
     bot.hears(/^(📋|🛠️|💬|🔍|📝|📄|📦|🤖) \w+ Mode$/, async (ctx) => {
         logger.debug(`[Bot] Agent mode button pressed: ${ctx.message?.text}`);
         try {
+            if (await blockMenuWhileInteractionActive(ctx)) {
+                return;
+            }
             await showAgentSelectionMenu(ctx);
         }
         catch (err) {
@@ -427,6 +454,9 @@ export function createBot() {
     bot.hears(MODEL_BUTTON_TEXT_PATTERN, async (ctx) => {
         logger.debug(`[Bot] Model button pressed: ${ctx.message?.text}`);
         try {
+            if (await blockMenuWhileInteractionActive(ctx)) {
+                return;
+            }
             await showModelSelectionMenu(ctx);
         }
         catch (err) {
@@ -438,6 +468,9 @@ export function createBot() {
     bot.hears(/^📊(?:\s|$)/, async (ctx) => {
         logger.debug(`[Bot] Context button pressed: ${ctx.message?.text}`);
         try {
+            if (await blockMenuWhileInteractionActive(ctx)) {
+                return;
+            }
             await handleContextButtonPress(ctx);
         }
         catch (err) {
@@ -450,6 +483,9 @@ export function createBot() {
     bot.hears(VARIANT_BUTTON_TEXT_PATTERN, async (ctx) => {
         logger.debug(`[Bot] Variant button pressed: ${ctx.message?.text}`);
         try {
+            if (await blockMenuWhileInteractionActive(ctx)) {
+                return;
+            }
             await showVariantSelectionMenu(ctx);
         }
         catch (err) {
@@ -628,12 +664,16 @@ export function createBot() {
         }
         catch (err) {
             logger.error("Error in prompt handler:", err);
+            if (interactionManager.getSnapshot()) {
+                clearAllInteractionState("message_handler_error");
+            }
             await ctx.reply(t("error.generic"));
         }
         logger.debug("[Bot] message:text handler completed (prompt sent in background)");
     });
     bot.catch((err) => {
         logger.error("[Bot] Unhandled error in bot:", err);
+        clearAllInteractionState("bot_unhandled_error");
         if (err.ctx) {
             logger.error("[Bot] Error context - update type:", err.ctx.update ? Object.keys(err.ctx.update) : "unknown");
         }

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/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);
+}