@grinev/opencode-telegram-bot 0.21.0 → 0.21.2

package/dist/{keyboard/manager.js → bot/keyboards/keyboard-manager.js}

@@ -1,9 +1,9 @@
-import { createMainKeyboard } from "../bot/utils/keyboard.js";
-import { getStoredAgent } from "../agent/manager.js";
-import { getStoredModel } from "../model/manager.js";
-import { formatVariantForButton } from "../variant/manager.js";
-import { logger } from "../utils/logger.js";
-import { t } from "../i18n/index.js";
+import { createMainKeyboard } from "./main-reply-keyboard.js";
+import { getStoredAgent } from "../../app/services/agent-selection-service.js";
+import { getStoredModel } from "../../app/services/model-selection-service.js";
+import { formatVariantForButton } from "../../app/services/variant-selection-service.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
 /**
  * Keyboard Manager - manages Reply Keyboard state and updates
  * Singleton pattern

package/dist/bot/keyboards/keyboard-types.js

@@ -0,0 +1 @@
+export {};

package/dist/bot/{utils/keyboard.js → keyboards/main-reply-keyboard.js}

@@ -1,6 +1,6 @@
 import { Keyboard } from "grammy";
-import { getAgentButtonLabel } from "../../agent/types.js";
-import { formatModelForButton } from "../../model/types.js";
+import { getAgentButtonLabel } from "../../app/types/agent.js";
+import { formatModelForButton } from "../../app/types/model.js";
 import { t } from "../../i18n/index.js";
 /**
  * Format token count for display (e.g., 150000 -> "150K", 1500000 -> "1.5M")

package/dist/bot/menus/agent-selection-menu.js

@@ -0,0 +1,54 @@
+import { InlineKeyboard } from "grammy";
+import { fetchCurrentAgent, getAvailableAgents } from "../../app/services/agent-selection-service.js";
+import { getAgentDisplayName } from "../../app/types/agent.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { replyWithInlineMenu } from "./inline-menu.js";
+/**
+ * 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 isActive = agent.name === currentAgent;
+        const label = isActive
+            ? `✅ ${getAgentDisplayName(agent.name)}`
+            : getAgentDisplayName(agent.name);
+        keyboard.text(label, `agent:${agent.name}`).row();
+    });
+    return keyboard;
+}
+/**
+ * Show agent selection menu
+ * @param ctx grammY context
+ */
+export async function showAgentSelectionMenu(ctx) {
+    try {
+        const currentAgent = await fetchCurrentAgent();
+        const keyboard = await buildAgentSelectionMenu(currentAgent);
+        if (keyboard.inline_keyboard.length === 0) {
+            await ctx.reply(t("agent.menu.empty"));
+            return;
+        }
+        const text = currentAgent
+            ? t("agent.menu.current", { name: getAgentDisplayName(currentAgent) })
+            : t("agent.menu.select");
+        await replyWithInlineMenu(ctx, {
+            menuKind: "agent",
+            text,
+            keyboard,
+        });
+    }
+    catch (err) {
+        logger.error("[AgentHandler] Error showing agent menu:", err);
+        await ctx.reply(t("agent.menu.error"));
+    }
+}

package/dist/bot/menus/command-catalog-menu.js

@@ -0,0 +1,101 @@
+import { InlineKeyboard } from "grammy";
+import { t } from "../../i18n/index.js";
+export const COMMANDS_CALLBACK_PREFIX = "commands:";
+export const COMMANDS_CALLBACK_SELECT_PREFIX = `${COMMANDS_CALLBACK_PREFIX}select:`;
+const COMMANDS_CALLBACK_PAGE_PREFIX = `${COMMANDS_CALLBACK_PREFIX}page:`;
+export const COMMANDS_CALLBACK_CANCEL = `${COMMANDS_CALLBACK_PREFIX}cancel`;
+export const COMMANDS_CALLBACK_EXECUTE = `${COMMANDS_CALLBACK_PREFIX}execute`;
+const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+export 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 parseCommandSelectCallback(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;
+}
+export function formatCommandsSelectText(page) {
+    if (page === 0) {
+        return t("commands.select");
+    }
+    return t("commands.select_page", { page: page + 1 });
+}
+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,
+    };
+}
+export 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;
+}
+export function buildCommandsConfirmKeyboard() {
+    return new InlineKeyboard()
+        .text(t("commands.button.execute"), COMMANDS_CALLBACK_EXECUTE)
+        .text(t("commands.button.cancel"), COMMANDS_CALLBACK_CANCEL);
+}

package/dist/bot/menus/context-control-menu.js

@@ -0,0 +1,33 @@
+import { InlineKeyboard } from "grammy";
+import { getCurrentSession } from "../../app/services/session-service.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { replyWithInlineMenu } from "./inline-menu.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,
+    });
+}

package/dist/bot/menus/file-browser-menu.js

@@ -0,0 +1,265 @@
+import { InlineKeyboard } from "grammy";
+import path from "node:path";
+import { formatFileSize } from "../../app/services/file-download-service.js";
+import { buildEntryLabel, buildTreeHeader, getBrowserRoots, getFileDetails, getParentPath, isAllowedRoot, isProjectRoot, MAX_ENTRIES_PER_PAGE, pathToDisplayPath, scanDirectory, scanLsDirectory, } from "../../app/services/file-browser-service.js";
+import { t } from "../../i18n/index.js";
+import { appendInlineMenuCancelButton } from "./inline-menu.js";
+export const OPEN_CALLBACK_PREFIX = "open:";
+export const OPEN_CALLBACK_NAV_PREFIX = "open:nav:";
+export const OPEN_CALLBACK_SELECT_PREFIX = "open:sel:";
+export const OPEN_CALLBACK_PAGE_PREFIX = "open:pg:";
+export const OPEN_CALLBACK_ROOTS = "open:roots";
+export const LS_CALLBACK_PREFIX = "ls:";
+export const LS_CALLBACK_NAV_PREFIX = "ls:nav:";
+export const LS_CALLBACK_FILE_PREFIX = "ls:file:";
+export const LS_CALLBACK_DOWNLOAD_PREFIX = "ls:download:";
+export const LS_CALLBACK_BACK_PREFIX = "ls:back:";
+export const LS_CALLBACK_PAGE_PREFIX = "ls:pg:";
+const PAGE_SEPARATOR = "|";
+const MAX_BUTTON_LABEL_LENGTH = 64;
+const openPathIndex = new Map();
+const lsPathIndex = new Map();
+let openPathCounter = 0;
+let lsPathCounter = 0;
+export function clearOpenPathIndex() {
+    openPathIndex.clear();
+    openPathCounter = 0;
+}
+export function clearLsPathIndex() {
+    lsPathIndex.clear();
+    lsPathCounter = 0;
+}
+function truncateLabel(label, maxLen = MAX_BUTTON_LABEL_LENGTH) {
+    if (label.length <= maxLen) {
+        return label;
+    }
+    return `${label.slice(0, Math.max(0, maxLen - 3))}...`;
+}
+function encodePathForCallback(pathIndex, nextCounter, prefix, fullPath, reserveBytes = 0) {
+    const naive = `${prefix}${fullPath}`;
+    if (Buffer.byteLength(naive, "utf-8") + reserveBytes <= 64) {
+        return naive;
+    }
+    const key = `#${nextCounter()}`;
+    pathIndex.set(key, fullPath);
+    return `${prefix}${key}`;
+}
+function decodePathFromCallback(pathIndex, prefix, data) {
+    if (!data.startsWith(prefix)) {
+        return null;
+    }
+    const raw = data.slice(prefix.length);
+    if (raw.startsWith("#")) {
+        return pathIndex.get(raw) ?? null;
+    }
+    return raw;
+}
+export function encodeOpenPathForCallback(prefix, fullPath, reserveBytes = 0) {
+    return encodePathForCallback(openPathIndex, () => openPathCounter++, prefix, fullPath, reserveBytes);
+}
+export function decodeOpenPathFromCallback(prefix, data) {
+    return decodePathFromCallback(openPathIndex, prefix, data);
+}
+export function encodeLsPathForCallback(prefix, fullPath, reserveBytes = 0) {
+    return encodePathForCallback(lsPathIndex, () => lsPathCounter++, prefix, fullPath, reserveBytes);
+}
+export function decodeLsPathFromCallback(prefix, data) {
+    return decodePathFromCallback(lsPathIndex, prefix, data);
+}
+function encodeOpenPaginationCallback(currentPath, page) {
+    const pageSuffix = `${PAGE_SEPARATOR}${page}`;
+    const reserveBytes = Buffer.byteLength(pageSuffix, "utf-8");
+    return `${encodeOpenPathForCallback(OPEN_CALLBACK_PAGE_PREFIX, currentPath, reserveBytes)}${pageSuffix}`;
+}
+export function decodeOpenPaginationCallback(data) {
+    return decodePathWithPageCallback(openPathIndex, data, OPEN_CALLBACK_PAGE_PREFIX);
+}
+function encodeLsPathWithPageCallback(prefix, fullPath, page) {
+    const pageSuffix = `${PAGE_SEPARATOR}${page}`;
+    const reserveBytes = Buffer.byteLength(pageSuffix, "utf-8");
+    return `${encodeLsPathForCallback(prefix, fullPath, reserveBytes)}${pageSuffix}`;
+}
+export function decodeLsPathWithPageCallback(data, prefix) {
+    return decodePathWithPageCallback(lsPathIndex, data, prefix);
+}
+function decodePathWithPageCallback(pathIndex, data, prefix) {
+    if (!data.startsWith(prefix)) {
+        return null;
+    }
+    const payload = data.slice(prefix.length);
+    const separatorIndex = payload.lastIndexOf(PAGE_SEPARATOR);
+    if (separatorIndex < 0) {
+        return null;
+    }
+    const pathRef = payload.slice(0, separatorIndex);
+    const page = Number.parseInt(payload.slice(separatorIndex + 1), 10);
+    if (Number.isNaN(page)) {
+        return null;
+    }
+    const resolvedPath = pathRef.startsWith("#") ? (pathIndex.get(pathRef) ?? null) : pathRef;
+    if (resolvedPath === null) {
+        return null;
+    }
+    return { path: resolvedPath, page };
+}
+function buildOpenBrowseKeyboard(entries, currentPath, hasParent, page, totalCount) {
+    const keyboard = new InlineKeyboard();
+    const totalPages = Math.max(1, Math.ceil(totalCount / MAX_ENTRIES_PER_PAGE));
+    for (const entry of entries) {
+        const label = truncateLabel(buildEntryLabel(entry));
+        keyboard.text(label, encodeOpenPathForCallback(OPEN_CALLBACK_NAV_PREFIX, entry.fullPath)).row();
+    }
+    const atRoot = isAllowedRoot(currentPath);
+    const showUp = hasParent && !atRoot;
+    const showRoots = getBrowserRoots().length > 1;
+    if (showUp || showRoots) {
+        if (showUp) {
+            const parentPath = path.dirname(currentPath);
+            keyboard.text(t("open.back"), encodeOpenPathForCallback(OPEN_CALLBACK_NAV_PREFIX, parentPath));
+        }
+        if (showRoots) {
+            keyboard.text(t("open.roots"), OPEN_CALLBACK_ROOTS);
+        }
+        keyboard.row();
+    }
+    if (totalPages > 1) {
+        if (page > 0) {
+            keyboard.text(t("open.prev_page"), encodeOpenPaginationCallback(currentPath, page - 1));
+        }
+        if (page < totalPages - 1) {
+            keyboard.text(t("open.next_page"), encodeOpenPaginationCallback(currentPath, page + 1));
+        }
+        keyboard.row();
+    }
+    keyboard
+        .text(t("open.select_current"), encodeOpenPathForCallback(OPEN_CALLBACK_SELECT_PREFIX, currentPath))
+        .row();
+    appendInlineMenuCancelButton(keyboard, "open");
+    return keyboard;
+}
+export async function renderOpenBrowseView(dirPath, page = 0) {
+    const result = await scanDirectory(dirPath, page);
+    if ("error" in result) {
+        return { error: result.error };
+    }
+    const totalPages = Math.max(1, Math.ceil(result.totalCount / MAX_ENTRIES_PER_PAGE));
+    return {
+        text: buildTreeHeader(result.displayPath, result.totalCount, result.page, totalPages),
+        keyboard: buildOpenBrowseKeyboard(result.entries, result.currentPath, result.hasParent, result.page, result.totalCount),
+    };
+}
+export function buildOpenRootsKeyboard() {
+    const keyboard = new InlineKeyboard();
+    for (const root of getBrowserRoots()) {
+        const label = truncateLabel(`📂 ${pathToDisplayPath(root)}`);
+        keyboard.text(label, encodeOpenPathForCallback(OPEN_CALLBACK_NAV_PREFIX, root)).row();
+    }
+    appendInlineMenuCancelButton(keyboard, "open");
+    return keyboard;
+}
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/\"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+function buildLsEntryLabel(entry) {
+    return `${entry.type === "directory" ? "📁" : "📄"} ${entry.name}`;
+}
+function buildLsHeader(displayPath, totalCount, page, totalPages) {
+    let header = `📁 ${t("ls.header")}\n<code>${escapeHtml(displayPath)}</code>`;
+    if (totalPages > 1) {
+        header += `\n(${page + 1}/${totalPages})`;
+    }
+    header += `\n${t("ls.total", { count: totalCount })}`;
+    return header;
+}
+function buildFileDetailsText(fileDetails) {
+    return (`📄 ${t("ls.file.header")}\n<code>${escapeHtml(fileDetails.name)}</code>\n` +
+        `${t("commands.download.size")}: ${formatFileSize(fileDetails.size)}\n` +
+        `${t("commands.download.modified")}: ${fileDetails.modified.toLocaleDateString()}`);
+}
+function encodeLsPaginationCallback(currentPath, page) {
+    return encodeLsPathWithPageCallback(LS_CALLBACK_PAGE_PREFIX, currentPath, page);
+}
+export function decodeLsPaginationCallback(data) {
+    return decodeLsPathWithPageCallback(data, LS_CALLBACK_PAGE_PREFIX);
+}
+function encodeLsFileCallback(fullPath, page) {
+    return encodeLsPathWithPageCallback(LS_CALLBACK_FILE_PREFIX, fullPath, page);
+}
+export function decodeLsFileCallback(data) {
+    return decodeLsPathWithPageCallback(data, LS_CALLBACK_FILE_PREFIX);
+}
+function encodeLsBackCallback(directoryPath, page) {
+    return encodeLsPathWithPageCallback(LS_CALLBACK_BACK_PREFIX, directoryPath, page);
+}
+export function decodeLsBackCallback(data) {
+    return decodeLsPathWithPageCallback(data, LS_CALLBACK_BACK_PREFIX);
+}
+function buildLsBrowseKeyboard(entries, currentPath, hasParent, page, totalCount) {
+    const keyboard = new InlineKeyboard();
+    const totalPages = Math.max(1, Math.ceil(totalCount / MAX_ENTRIES_PER_PAGE));
+    for (const entry of entries) {
+        const label = truncateLabel(buildLsEntryLabel(entry));
+        const callbackData = entry.type === "directory"
+            ? encodeLsPathForCallback(LS_CALLBACK_NAV_PREFIX, entry.fullPath)
+            : encodeLsFileCallback(entry.fullPath, page);
+        keyboard.text(label, callbackData).row();
+    }
+    if (hasParent && !isProjectRoot(currentPath)) {
+        keyboard
+            .text(t("open.back"), encodeLsPathForCallback(LS_CALLBACK_NAV_PREFIX, getParentPath(currentPath)))
+            .row();
+    }
+    if (totalPages > 1) {
+        if (page > 0) {
+            keyboard.text(t("open.prev_page"), encodeLsPaginationCallback(currentPath, page - 1));
+        }
+        if (page < totalPages - 1) {
+            keyboard.text(t("open.next_page"), encodeLsPaginationCallback(currentPath, page + 1));
+        }
+        keyboard.row();
+    }
+    appendInlineMenuCancelButton(keyboard, "ls");
+    return keyboard;
+}
+function buildLsFileDetailsKeyboard(filePath, page) {
+    const keyboard = new InlineKeyboard();
+    const parentPath = getParentPath(filePath);
+    keyboard.text(t("ls.file.download"), encodeLsPathForCallback(LS_CALLBACK_DOWNLOAD_PREFIX, filePath));
+    keyboard.text(t("ls.file.back"), encodeLsBackCallback(parentPath, page));
+    keyboard.row();
+    appendInlineMenuCancelButton(keyboard, "ls");
+    return keyboard;
+}
+function hasBrowseActions(currentPath, hasParent, totalCount) {
+    if (totalCount > 0) {
+        return true;
+    }
+    return hasParent && !isProjectRoot(currentPath);
+}
+export async function renderLsBrowseView(dirPath, page = 0) {
+    const result = await scanLsDirectory(dirPath, page);
+    if ("error" in result) {
+        return result;
+    }
+    const totalPages = Math.max(1, Math.ceil(result.totalCount / MAX_ENTRIES_PER_PAGE));
+    return {
+        text: buildLsHeader(result.displayPath, result.totalCount, result.page, totalPages),
+        hasActions: hasBrowseActions(result.currentPath, result.hasParent, result.totalCount),
+        keyboard: buildLsBrowseKeyboard(result.entries, result.currentPath, result.hasParent, result.page, result.totalCount),
+    };
+}
+export async function renderLsFileDetailsView(filePath, page) {
+    const fileDetails = await getFileDetails(filePath);
+    if ("error" in fileDetails) {
+        return fileDetails;
+    }
+    return {
+        text: buildFileDetailsText(fileDetails),
+        keyboard: buildLsFileDetailsKeyboard(fileDetails.fullPath, page),
+    };
+}

package/dist/bot/{handlers → menus}/inline-menu.js

@@ -1,8 +1,8 @@
-import { interactionManager } from "../../interaction/manager.js";
+import { interactionManager } from "../../app/managers/interaction-manager.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
-const INLINE_MENU_CANCEL_PREFIX = "inline:cancel:";
-const LEGACY_CONTEXT_CANCEL_CALLBACK = "compact:cancel";
+export const INLINE_MENU_CANCEL_PREFIX = "inline:cancel:";
+export const LEGACY_CONTEXT_CANCEL_CALLBACK = "compact:cancel";
 const INLINE_MENU_KINDS = [
     "project",
     "session",
@@ -14,7 +14,7 @@ const INLINE_MENU_KINDS = [
     "ls",
     "worktree",
 ];
-function isInlineMenuKind(value) {
+export function isInlineMenuKind(value) {
     return INLINE_MENU_KINDS.includes(value);
 }
 function getCallbackMessageId(ctx) {
@@ -98,32 +98,3 @@ export function clearActiveInlineMenu(reason) {
         interactionManager.clear(reason);
     }
 }
-export async function handleInlineMenuCancel(ctx) {
-    const data = ctx.callbackQuery?.data;
-    if (!data) {
-        return false;
-    }
-    let menuKind = null;
-    if (data === LEGACY_CONTEXT_CANCEL_CALLBACK) {
-        menuKind = "context";
-    }
-    else if (data.startsWith(INLINE_MENU_CANCEL_PREFIX)) {
-        const rawKind = data.slice(INLINE_MENU_CANCEL_PREFIX.length);
-        if (!isInlineMenuKind(rawKind)) {
-            return false;
-        }
-        menuKind = rawKind;
-    }
-    else {
-        return false;
-    }
-    const isActive = await ensureActiveInlineMenu(ctx, menuKind);
-    if (!isActive) {
-        return true;
-    }
-    clearActiveInlineMenu(`inline_menu_cancel:${menuKind}`);
-    await ctx.answerCallbackQuery({ text: t("inline.cancelled_callback") }).catch(() => { });
-    await ctx.deleteMessage().catch(() => { });
-    logger.debug(`[InlineMenu] Menu cancelled: kind=${menuKind}`);
-    return true;
-}

package/dist/bot/menus/mcp-catalog-menu.js

@@ -0,0 +1,97 @@
+import { InlineKeyboard } from "grammy";
+import { t } from "../../i18n/index.js";
+export const MCPS_CALLBACK_PREFIX = "mcps:";
+export const MCPS_CALLBACK_SELECT_PREFIX = `${MCPS_CALLBACK_PREFIX}select:`;
+export const MCPS_CALLBACK_TOGGLE = `${MCPS_CALLBACK_PREFIX}toggle`;
+export const MCPS_CALLBACK_BACK = `${MCPS_CALLBACK_PREFIX}back`;
+export const MCPS_CALLBACK_CANCEL = `${MCPS_CALLBACK_PREFIX}cancel`;
+const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+function getStatusLabel(status) {
+    switch (status.status) {
+        case "connected":
+            return t("mcps.status.connected");
+        case "disabled":
+            return t("mcps.status.disabled");
+        case "failed":
+            return t("mcps.status.failed");
+        case "needs_auth":
+            return t("mcps.status.needs_auth");
+        case "needs_client_registration":
+            return t("mcps.status.needs_client_registration");
+        default:
+            return t("common.unknown");
+    }
+}
+function getStatusEmoji(status) {
+    switch (status.status) {
+        case "connected":
+            return "🟢";
+        case "disabled":
+            return "🔴";
+        case "failed":
+            return "⚠️";
+        case "needs_auth":
+            return "🔒";
+        case "needs_client_registration":
+            return "🔒";
+        default:
+            return "❓";
+    }
+}
+function formatMcpButtonLabel(server) {
+    const rawLabel = `${getStatusEmoji(server.status)} ${server.name}`;
+    if (rawLabel.length <= MAX_INLINE_BUTTON_LABEL_LENGTH) {
+        return rawLabel;
+    }
+    return `${rawLabel.slice(0, MAX_INLINE_BUTTON_LABEL_LENGTH - 3)}...`;
+}
+export function parseMcpSelectCallback(data) {
+    if (!data.startsWith(MCPS_CALLBACK_SELECT_PREFIX)) {
+        return null;
+    }
+    const index = Number(data.slice(MCPS_CALLBACK_SELECT_PREFIX.length));
+    if (!Number.isInteger(index) || index < 0) {
+        return null;
+    }
+    return index;
+}
+export function buildMcpsListKeyboard(servers) {
+    const keyboard = new InlineKeyboard();
+    servers.forEach((server, index) => {
+        keyboard.text(formatMcpButtonLabel(server), `${MCPS_CALLBACK_SELECT_PREFIX}${index}`).row();
+    });
+    keyboard.text(t("inline.button.cancel"), MCPS_CALLBACK_CANCEL);
+    return keyboard;
+}
+export function buildMcpsDetailKeyboard(server) {
+    const keyboard = new InlineKeyboard();
+    let hasToggleButton = false;
+    if (server.status.status === "connected") {
+        keyboard.text(t("mcps.button.disable"), MCPS_CALLBACK_TOGGLE);
+        hasToggleButton = true;
+    }
+    else if (server.status.status === "disabled" || server.status.status === "failed") {
+        keyboard.text(t("mcps.button.enable"), MCPS_CALLBACK_TOGGLE);
+        hasToggleButton = true;
+    }
+    if (hasToggleButton) {
+        keyboard.row();
+    }
+    keyboard.text(t("mcps.button.back"), MCPS_CALLBACK_BACK);
+    keyboard.text(t("inline.button.cancel"), MCPS_CALLBACK_CANCEL);
+    return keyboard;
+}
+export function buildMcpsDetailText(server) {
+    const lines = [];
+    lines.push(t("mcps.detail.title", { name: server.name }));
+    lines.push("");
+    lines.push(t("mcps.detail.status", { status: getStatusLabel(server.status) }));
+    if (server.status.status === "failed" || server.status.status === "needs_client_registration") {
+        lines.push(t("mcps.detail.error", { error: server.status.error }));
+    }
+    if (server.status.status === "needs_auth" || server.status.status === "needs_client_registration") {
+        lines.push("");
+        lines.push(t("mcps.auth_required"));
+    }
+    return lines.join("\n");
+}