@grinev/opencode-telegram-bot 0.21.1 → 0.21.2

package/dist/bot/{commands/commands.js → callbacks/command-catalog-callback-handler.js}

@@ -1,64 +1,19 @@
-import { InlineKeyboard } from "grammy";
-import { opencodeClient } from "../../opencode/client.js";
-import { getCurrentProject } from "../../settings/manager.js";
-import { clearSession, getCurrentSession, setCurrentSession, } from "../../session/manager.js";
-import { ingestSessionInfoForCache } from "../../session/cache-manager.js";
-import { interactionManager } from "../../interaction/manager.js";
-import { summaryAggregator } from "../../summary/aggregator.js";
-import { getStoredAgent, resolveProjectAgent } from "../../agent/manager.js";
-import { getStoredModel } from "../../model/manager.js";
+import { config } from "../../config.js";
+import { clearSession, getCurrentSession, setCurrentSession, } from "../../app/services/session-service.js";
+import { ingestSessionInfoForCache } from "../../app/services/session-cache-service.js";
+import { interactionManager } from "../../app/managers/interaction-manager.js";
+import { summaryAggregator } from "../../app/managers/summary-aggregation-manager.js";
+import { getStoredAgent, resolveProjectAgent } from "../../app/services/agent-selection-service.js";
+import { getStoredModel } from "../../app/services/model-selection-service.js";
 import { safeBackgroundTask } from "../../utils/safe-background-task.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
-import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
-import { config } from "../../config.js";
-import { assistantRunState } from "../assistant-run-state.js";
-import { attachToSession, detachAttachedSession, markAttachedSessionBusy, markAttachedSessionIdle, } from "../../attach/service.js";
-import { externalUserInputSuppressionManager } from "../../external-input/suppression.js";
-const COMMANDS_CALLBACK_PREFIX = "commands:";
-const COMMANDS_CALLBACK_SELECT_PREFIX = `${COMMANDS_CALLBACK_PREFIX}select:`;
-const COMMANDS_CALLBACK_PAGE_PREFIX = `${COMMANDS_CALLBACK_PREFIX}page:`;
-const COMMANDS_CALLBACK_CANCEL = `${COMMANDS_CALLBACK_PREFIX}cancel`;
-const COMMANDS_CALLBACK_EXECUTE = `${COMMANDS_CALLBACK_PREFIX}execute`;
-const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
-function formatExecutingCommandMessage(commandName, args) {
-    const prefix = t("commands.executing_prefix");
-    const commandText = `/${commandName}`;
-    const argsSuffix = args ? ` ${args}` : "";
-    return {
-        text: `${prefix}\n${commandText}${argsSuffix}`,
-        entities: [
-            {
-                type: "code",
-                offset: prefix.length + 1,
-                length: commandText.length,
-            },
-        ],
-    };
-}
-export function buildCommandPageCallback(page) {
-    return `${COMMANDS_CALLBACK_PAGE_PREFIX}${page}`;
-}
-export function parseCommandPageCallback(data) {
-    if (!data.startsWith(COMMANDS_CALLBACK_PAGE_PREFIX)) {
-        return null;
-    }
-    const rawPage = data.slice(COMMANDS_CALLBACK_PAGE_PREFIX.length);
-    const page = Number(rawPage);
-    if (!Number.isInteger(page) || page < 0) {
-        return null;
-    }
-    return page;
-}
-export function formatCommandsSelectText(page) {
-    if (page === 0) {
-        return t("commands.select");
-    }
-    return t("commands.select_page", { page: page + 1 });
-}
-function normalizeDirectoryForCommandApi(directory) {
-    return directory.replace(/\\/g, "/");
-}
+import { foregroundSessionState } from "../../app/managers/foreground-session-state-manager.js";
+import { assistantRunState } from "../../app/managers/assistant-run-state-manager.js";
+import { attachToSession, detachAttachedSession, markAttachedSessionBusy, markAttachedSessionIdle, } from "../../app/services/attach-service.js";
+import { externalUserInputSuppressionManager } from "../../app/managers/external-input-suppression-manager.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { buildCommandsConfirmKeyboard, buildCommandsListKeyboard, calculateCommandsPaginationRange, COMMANDS_CALLBACK_CANCEL, COMMANDS_CALLBACK_EXECUTE, COMMANDS_CALLBACK_PREFIX, formatCommandsSelectText, formatExecutingCommandMessage, parseCommandPageCallback, parseCommandSelectCallback, } from "../menus/command-catalog-menu.js";
 function getCallbackMessageId(ctx) {
     const message = ctx.callbackQuery?.message;
     if (!message || !("message_id" in message)) {
@@ -67,53 +22,6 @@ function getCallbackMessageId(ctx) {
     const messageId = message.message_id;
     return typeof messageId === "number" ? messageId : null;
 }
-function formatCommandButtonLabel(command) {
-    const description = command.description?.trim() || t("commands.no_description");
-    const rawLabel = `/${command.name} - ${description}`;
-    if (rawLabel.length <= MAX_INLINE_BUTTON_LABEL_LENGTH) {
-        return rawLabel;
-    }
-    return `${rawLabel.slice(0, MAX_INLINE_BUTTON_LABEL_LENGTH - 3)}...`;
-}
-export function calculateCommandsPaginationRange(totalCommands, page, pageSize) {
-    const safePageSize = Math.max(1, pageSize);
-    const totalPages = Math.max(1, Math.ceil(totalCommands / safePageSize));
-    const normalizedPage = Math.min(Math.max(0, page), totalPages - 1);
-    const startIndex = normalizedPage * safePageSize;
-    const endIndex = Math.min(startIndex + safePageSize, totalCommands);
-    return {
-        page: normalizedPage,
-        totalPages,
-        startIndex,
-        endIndex,
-    };
-}
-function buildCommandsListKeyboard(commands, page, pageSize) {
-    const keyboard = new InlineKeyboard();
-    const { page: normalizedPage, totalPages, startIndex, endIndex, } = calculateCommandsPaginationRange(commands.length, page, pageSize);
-    commands.slice(startIndex, endIndex).forEach((command, index) => {
-        const globalIndex = startIndex + index;
-        keyboard
-            .text(formatCommandButtonLabel(command), `${COMMANDS_CALLBACK_SELECT_PREFIX}${globalIndex}`)
-            .row();
-    });
-    if (totalPages > 1) {
-        if (normalizedPage > 0) {
-            keyboard.text(t("commands.button.prev_page"), buildCommandPageCallback(normalizedPage - 1));
-        }
-        if (normalizedPage < totalPages - 1) {
-            keyboard.text(t("commands.button.next_page"), buildCommandPageCallback(normalizedPage + 1));
-        }
-        keyboard.row();
-    }
-    keyboard.text(t("commands.button.cancel"), COMMANDS_CALLBACK_CANCEL);
-    return keyboard;
-}
-function buildCommandsConfirmKeyboard() {
-    return new InlineKeyboard()
-        .text(t("commands.button.execute"), COMMANDS_CALLBACK_EXECUTE)
-        .text(t("commands.button.cancel"), COMMANDS_CALLBACK_CANCEL);
-}
 function parseCommandItems(value) {
     if (!Array.isArray(value)) {
         return null;
@@ -135,7 +43,7 @@ function parseCommandItems(value) {
     }
     return commands;
 }
-function parseCommandsMetadata(state) {
+export function parseCommandsMetadata(state) {
     if (!state || state.kind !== "custom") {
         return null;
     }
@@ -180,40 +88,12 @@ function parseCommandsMetadata(state) {
     }
     return null;
 }
-function clearCommandsInteraction(reason) {
+export function clearCommandsInteraction(reason) {
     const metadata = parseCommandsMetadata(interactionManager.getSnapshot());
     if (metadata) {
         interactionManager.clear(reason);
     }
 }
-async function getCommandList(projectDirectory) {
-    const { data, error } = await opencodeClient.command.list({
-        directory: normalizeDirectoryForCommandApi(projectDirectory),
-    });
-    if (error || !data) {
-        throw error || new Error("No command data received");
-    }
-    return data
-        .filter((command) => {
-        const source = command.source;
-        return (typeof command.name === "string" && command.name.trim().length > 0 && source === "command");
-    })
-        .map((command) => ({
-        name: command.name,
-        description: command.description,
-    }));
-}
-function parseSelectIndex(data) {
-    if (!data.startsWith(COMMANDS_CALLBACK_SELECT_PREFIX)) {
-        return null;
-    }
-    const rawIndex = data.slice(COMMANDS_CALLBACK_SELECT_PREFIX.length);
-    const index = Number(rawIndex);
-    if (!Number.isInteger(index) || index < 0) {
-        return null;
-    }
-    return index;
-}
 async function isSessionBusy(sessionId, directory) {
     try {
         const { data, error } = await opencodeClient.session.status({ directory });
@@ -265,7 +145,7 @@ async function ensureSessionForProject(ctx, projectDirectory) {
     await ctx.reply(t("bot.session_created", { title: session.title }));
     return sessionInfo;
 }
-async function executeCommand(ctx, deps, params) {
+export async function executeCommand(ctx, deps, params) {
     if (!ctx.chat) {
         return;
     }
@@ -342,41 +222,6 @@ async function executeCommand(ctx, deps, params) {
         },
     });
 }
-export async function commandsCommand(ctx) {
-    try {
-        const currentProject = getCurrentProject();
-        if (!currentProject) {
-            await ctx.reply(t("bot.project_not_selected"));
-            return;
-        }
-        const commands = await getCommandList(currentProject.worktree);
-        if (commands.length === 0) {
-            await ctx.reply(t("commands.empty"));
-            return;
-        }
-        const pageSize = config.bot.commandsListLimit;
-        const keyboard = buildCommandsListKeyboard(commands, 0, pageSize);
-        const message = await ctx.reply(formatCommandsSelectText(0), {
-            reply_markup: keyboard,
-        });
-        interactionManager.start({
-            kind: "custom",
-            expectedInput: "callback",
-            metadata: {
-                flow: "commands",
-                stage: "list",
-                messageId: message.message_id,
-                projectDirectory: currentProject.worktree,
-                commands,
-                page: 0,
-            },
-        });
-    }
-    catch (error) {
-        logger.error("[Commands] Error fetching commands list:", error);
-        await ctx.reply(t("commands.fetch_error"));
-    }
-}
 export async function handleCommandsCallback(ctx, deps) {
     const data = ctx.callbackQuery?.data;
     if (!data || !data.startsWith(COMMANDS_CALLBACK_PREFIX)) {
@@ -440,7 +285,7 @@ export async function handleCommandsCallback(ctx, deps) {
             });
             return true;
         }
-        const commandIndex = parseSelectIndex(data);
+        const commandIndex = parseCommandSelectCallback(data);
         if (commandIndex === null || metadata.stage !== "list") {
             await ctx.answerCallbackQuery({ text: t("callback.processing_error"), show_alert: true });
             return true;
@@ -473,28 +318,3 @@ export async function handleCommandsCallback(ctx, deps) {
         return true;
     }
 }
-export async function handleCommandTextArguments(ctx, deps) {
-    const text = ctx.message?.text;
-    if (!text || text.startsWith("/")) {
-        return false;
-    }
-    const metadata = parseCommandsMetadata(interactionManager.getSnapshot());
-    if (!metadata || metadata.stage !== "confirm") {
-        return false;
-    }
-    const argumentsText = text.trim();
-    if (!argumentsText) {
-        await ctx.reply(t("commands.arguments_empty"));
-        return true;
-    }
-    clearCommandsInteraction("commands_arguments_submitted");
-    if (ctx.chat) {
-        await ctx.api.deleteMessage(ctx.chat.id, metadata.messageId).catch(() => { });
-    }
-    await executeCommand(ctx, deps, {
-        projectDirectory: metadata.projectDirectory,
-        commandName: metadata.commandName,
-        argumentsText,
-    });
-    return true;
-}

package/dist/bot/{handlers/context.js → callbacks/context-control-callback-handler.js}

@@ -1,38 +1,9 @@
-import { InlineKeyboard } from "grammy";
-import { getCurrentSession } from "../../session/manager.js";
+import { getStoredModel } from "../../app/services/model-selection-service.js";
 import { opencodeClient } from "../../opencode/client.js";
-import { getStoredModel } from "../../model/manager.js";
-import { clearActiveInlineMenu, ensureActiveInlineMenu, replyWithInlineMenu, } from "./inline-menu.js";
+import { getCurrentSession } from "../../app/services/session-service.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,
-    });
-}
+import { clearActiveInlineMenu, ensureActiveInlineMenu } from "../menus/inline-menu.js";
 /**
  * Handle compact confirmation callback
  * Calls OpenCode API to compact the session

package/dist/bot/callbacks/file-browser-callback-handler.js

@@ -0,0 +1,219 @@
+import { getProjectRoot, isPathWithinDirectory, isWithinAllowedRoot, isWithinProjectRoot, pathToDisplayPath, } from "../../app/services/file-browser-service.js";
+import { isForegroundBusy } from "../../app/services/run-control-service.js";
+import { t } from "../../i18n/index.js";
+import { getProjectByWorktree } from "../../app/services/project-service.js";
+import { upsertSessionDirectory } from "../../app/services/session-cache-service.js";
+import { logger } from "../../utils/logger.js";
+import { replyBusyBlocked } from "../messages/busy-blocked-renderer.js";
+import { ensureActiveInlineMenu, clearActiveInlineMenu } from "../menus/inline-menu.js";
+import { sendDownloadedFile } from "../messages/send-downloaded-file.js";
+import { switchToProject } from "../../app/services/project-switch-service.js";
+import { createProjectSwitchPresentation } from "../services/project-switch-presentation.js";
+import { buildOpenRootsKeyboard, clearLsPathIndex, clearOpenPathIndex, decodeLsBackCallback, decodeLsFileCallback, decodeLsPaginationCallback, decodeLsPathFromCallback, decodeOpenPaginationCallback, decodeOpenPathFromCallback, LS_CALLBACK_DOWNLOAD_PREFIX, LS_CALLBACK_NAV_PREFIX, LS_CALLBACK_PREFIX, OPEN_CALLBACK_NAV_PREFIX, OPEN_CALLBACK_PREFIX, OPEN_CALLBACK_ROOTS, OPEN_CALLBACK_SELECT_PREFIX, renderLsBrowseView, renderLsFileDetailsView, renderOpenBrowseView, } from "../menus/file-browser-menu.js";
+const sessionDirectories = new Map();
+export function clearSessionDirectories() {
+    sessionDirectories.clear();
+}
+export function resolveInitialLsDirectory(userId) {
+    const currentProject = getProjectRoot();
+    if (!currentProject) {
+        return null;
+    }
+    if (userId) {
+        const cachedDirectory = sessionDirectories.get(userId);
+        if (cachedDirectory && isPathWithinDirectory(cachedDirectory, currentProject)) {
+            return cachedDirectory;
+        }
+    }
+    return currentProject;
+}
+export function rememberLsDirectory(userId, directory) {
+    if (userId) {
+        sessionDirectories.set(userId, directory);
+    }
+}
+export async function handleOpenCallback(ctx, deps = {}) {
+    const data = ctx.callbackQuery?.data;
+    if (!data || !data.startsWith(OPEN_CALLBACK_PREFIX)) {
+        return false;
+    }
+    if (isForegroundBusy()) {
+        await replyBusyBlocked(ctx);
+        return true;
+    }
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "open");
+    if (!isActiveMenu) {
+        return true;
+    }
+    try {
+        if (data === OPEN_CALLBACK_ROOTS) {
+            await showOpenRoots(ctx);
+            return true;
+        }
+        const navPath = decodeOpenPathFromCallback(OPEN_CALLBACK_NAV_PREFIX, data);
+        if (navPath !== null) {
+            if (!isWithinAllowedRoot(navPath)) {
+                await ctx.answerCallbackQuery({ text: t("open.access_denied") });
+                return true;
+            }
+            await navigateOpenTo(ctx, navPath);
+            return true;
+        }
+        const pageInfo = decodeOpenPaginationCallback(data);
+        if (pageInfo !== null) {
+            if (!isWithinAllowedRoot(pageInfo.path)) {
+                await ctx.answerCallbackQuery({ text: t("open.access_denied") });
+                return true;
+            }
+            await navigateOpenTo(ctx, pageInfo.path, pageInfo.page);
+            return true;
+        }
+        const selectPath = decodeOpenPathFromCallback(OPEN_CALLBACK_SELECT_PREFIX, data);
+        if (selectPath !== null) {
+            if (!isWithinAllowedRoot(selectPath)) {
+                await ctx.answerCallbackQuery({ text: t("open.access_denied") });
+                return true;
+            }
+            await selectDirectory(ctx, selectPath, deps);
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        logger.error("[Bot] Error handling open callback:", error);
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
+        return true;
+    }
+}
+async function showOpenRoots(ctx) {
+    await ctx.answerCallbackQuery();
+    await ctx.editMessageText(t("open.select_root"), { reply_markup: buildOpenRootsKeyboard() });
+}
+async function navigateOpenTo(ctx, dirPath, page = 0) {
+    const view = await renderOpenBrowseView(dirPath, page);
+    if ("error" in view) {
+        await ctx.answerCallbackQuery({ text: view.error });
+        return;
+    }
+    await ctx.answerCallbackQuery();
+    await ctx.editMessageText(view.text, { reply_markup: view.keyboard });
+}
+async function selectDirectory(ctx, directory, deps = {}) {
+    const displayPath = pathToDisplayPath(directory);
+    try {
+        logger.info(`[Bot] Adding project directory: ${directory}`);
+        await upsertSessionDirectory(directory, Date.now());
+        const projectInfo = await getProjectByWorktree(directory);
+        const selectedProjectInfo = { ...projectInfo, name: displayPath };
+        const replyKeyboard = await switchToProject(ctx, selectedProjectInfo, "open_project_selected", {
+            ensureEventSubscription: deps.ensureEventSubscription,
+            presentation: createProjectSwitchPresentation(),
+        });
+        await ctx.answerCallbackQuery();
+        await ctx.reply(t("open.selected", { project: displayPath }), { reply_markup: replyKeyboard });
+        await ctx.deleteMessage();
+        clearOpenPathIndex();
+        logger.info(`[Bot] Project added and selected: ${displayPath}`);
+    }
+    catch (error) {
+        logger.error("[Bot] Error selecting directory:", error);
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
+        await ctx.reply(t("open.select_error"));
+    }
+}
+export async function handleLsCallback(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data || !data.startsWith(LS_CALLBACK_PREFIX)) {
+        return false;
+    }
+    if (isForegroundBusy()) {
+        await replyBusyBlocked(ctx);
+        return true;
+    }
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "ls");
+    if (!isActiveMenu) {
+        return true;
+    }
+    try {
+        const navPath = decodeLsPathFromCallback(LS_CALLBACK_NAV_PREFIX, data);
+        if (navPath !== null) {
+            if (!isWithinProjectRoot(navPath)) {
+                await ctx.answerCallbackQuery({ text: t("ls.access_denied") });
+                return true;
+            }
+            await navigateLsTo(ctx, navPath);
+            return true;
+        }
+        const pageInfo = decodeLsPaginationCallback(data);
+        if (pageInfo !== null) {
+            if (!isWithinProjectRoot(pageInfo.path)) {
+                await ctx.answerCallbackQuery({ text: t("ls.access_denied") });
+                return true;
+            }
+            await navigateLsTo(ctx, pageInfo.path, pageInfo.page);
+            return true;
+        }
+        const fileInfo = decodeLsFileCallback(data);
+        if (fileInfo !== null) {
+            if (!isWithinProjectRoot(fileInfo.path)) {
+                await ctx.answerCallbackQuery({ text: t("ls.access_denied") });
+                return true;
+            }
+            await showLsFileDetails(ctx, fileInfo.path, fileInfo.page);
+            return true;
+        }
+        const downloadPath = decodeLsPathFromCallback(LS_CALLBACK_DOWNLOAD_PREFIX, data);
+        if (downloadPath !== null) {
+            if (!isWithinProjectRoot(downloadPath)) {
+                await ctx.answerCallbackQuery({ text: t("ls.access_denied") });
+                return true;
+            }
+            await downloadFileAndClose(ctx, downloadPath);
+            return true;
+        }
+        const backInfo = decodeLsBackCallback(data);
+        if (backInfo !== null) {
+            if (!isWithinProjectRoot(backInfo.path)) {
+                await ctx.answerCallbackQuery({ text: t("ls.access_denied") });
+                return true;
+            }
+            await navigateLsTo(ctx, backInfo.path, backInfo.page);
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        logger.error("[Ls] Error handling callback:", error);
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
+        return true;
+    }
+}
+async function navigateLsTo(ctx, dirPath, page = 0) {
+    const view = await renderLsBrowseView(dirPath, page);
+    if ("error" in view) {
+        await ctx.answerCallbackQuery({ text: view.error });
+        return;
+    }
+    rememberLsDirectory(ctx.from?.id, dirPath);
+    await ctx.answerCallbackQuery();
+    await ctx.editMessageText(view.text, { parse_mode: "HTML", reply_markup: view.keyboard });
+}
+async function showLsFileDetails(ctx, filePath, page) {
+    const view = await renderLsFileDetailsView(filePath, page);
+    if ("error" in view) {
+        await ctx.answerCallbackQuery({ text: view.error });
+        return;
+    }
+    await ctx.answerCallbackQuery();
+    await ctx.editMessageText(view.text, { parse_mode: "HTML", reply_markup: view.keyboard });
+}
+async function downloadFileAndClose(ctx, filePath) {
+    await ctx.answerCallbackQuery({ text: t("commands.download.downloading") });
+    const downloaded = await sendDownloadedFile(ctx, filePath, { announce: false });
+    if (!downloaded) {
+        return;
+    }
+    clearActiveInlineMenu("ls_downloaded");
+    clearLsPathIndex();
+    await ctx.deleteMessage().catch(() => { });
+}

package/dist/bot/callbacks/inline-menu-cancel-callback-handler.js

@@ -0,0 +1,32 @@
+import { clearActiveInlineMenu, ensureActiveInlineMenu, INLINE_MENU_CANCEL_PREFIX, isInlineMenuKind, LEGACY_CONTEXT_CANCEL_CALLBACK, } from "../menus/inline-menu.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+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;
+}