@grinev/opencode-telegram-bot 0.21.1 → 0.21.2

package/dist/bot/menus/message-history-menu.js

@@ -0,0 +1,107 @@
+import { InlineKeyboard } from "grammy";
+import { t } from "../../i18n/index.js";
+export const MESSAGES_CALLBACK_PREFIX = "messages:";
+export const MESSAGES_CALLBACK_SELECT_PREFIX = `${MESSAGES_CALLBACK_PREFIX}select:`;
+const MESSAGES_CALLBACK_PAGE_PREFIX = `${MESSAGES_CALLBACK_PREFIX}page:`;
+export const MESSAGES_CALLBACK_REVERT = `${MESSAGES_CALLBACK_PREFIX}revert`;
+export const MESSAGES_CALLBACK_FORK = `${MESSAGES_CALLBACK_PREFIX}fork`;
+export const MESSAGES_CALLBACK_BACK = `${MESSAGES_CALLBACK_PREFIX}back`;
+export const MESSAGES_CALLBACK_CANCEL = `${MESSAGES_CALLBACK_PREFIX}cancel`;
+export const TELEGRAM_MESSAGE_LIMIT = 4096;
+const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+export function truncateMessageHistoryText(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return `${text.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
+function normalizeButtonText(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function formatMessageTime(created) {
+    const date = new Date(created);
+    const hours = date.getHours().toString().padStart(2, "0");
+    const minutes = date.getMinutes().toString().padStart(2, "0");
+    return `${hours}:${minutes}`;
+}
+function formatMessageButtonLabel(message) {
+    const prefix = `[${formatMessageTime(message.created)}] `;
+    const text = normalizeButtonText(message.text);
+    return `${prefix}${truncateMessageHistoryText(text, MAX_INLINE_BUTTON_LABEL_LENGTH - prefix.length)}`;
+}
+export function formatMessagesSelectText(page) {
+    if (page === 0) {
+        return t("messages.select");
+    }
+    return t("messages.select_page", { page: page + 1 });
+}
+export function formatMessageDetailText(message) {
+    const prefix = `[${formatMessageTime(message.created)}]\n\n`;
+    return truncateMessageHistoryText(`${prefix}${message.text}`, TELEGRAM_MESSAGE_LIMIT);
+}
+export function buildMessagePageCallback(page) {
+    return `${MESSAGES_CALLBACK_PAGE_PREFIX}${page}`;
+}
+export function parseMessagePageCallback(data) {
+    if (!data.startsWith(MESSAGES_CALLBACK_PAGE_PREFIX)) {
+        return null;
+    }
+    const rawPage = data.slice(MESSAGES_CALLBACK_PAGE_PREFIX.length);
+    const page = Number(rawPage);
+    if (!Number.isInteger(page) || page < 0) {
+        return null;
+    }
+    return page;
+}
+export function parseMessageSelectCallback(data) {
+    if (!data.startsWith(MESSAGES_CALLBACK_SELECT_PREFIX)) {
+        return null;
+    }
+    const rawIndex = data.slice(MESSAGES_CALLBACK_SELECT_PREFIX.length);
+    const index = Number(rawIndex);
+    if (!Number.isInteger(index) || index < 0) {
+        return null;
+    }
+    return index;
+}
+export function calculateMessagesPaginationRange(totalMessages, page, pageSize) {
+    const safePageSize = Math.max(1, pageSize);
+    const totalPages = Math.max(1, Math.ceil(totalMessages / safePageSize));
+    const normalizedPage = Math.min(Math.max(0, page), totalPages - 1);
+    const startIndex = normalizedPage * safePageSize;
+    const endIndex = Math.min(startIndex + safePageSize, totalMessages);
+    return {
+        page: normalizedPage,
+        totalPages,
+        startIndex,
+        endIndex,
+    };
+}
+export function buildMessagesListKeyboard(messages, page, pageSize) {
+    const keyboard = new InlineKeyboard();
+    const { page: normalizedPage, totalPages, startIndex, endIndex, } = calculateMessagesPaginationRange(messages.length, page, pageSize);
+    messages.slice(startIndex, endIndex).forEach((message, index) => {
+        const globalIndex = startIndex + index;
+        keyboard.text(formatMessageButtonLabel(message), `${MESSAGES_CALLBACK_SELECT_PREFIX}${globalIndex}`).row();
+    });
+    if (totalPages > 1) {
+        if (normalizedPage > 0) {
+            keyboard.text(t("messages.button.prev_page"), buildMessagePageCallback(normalizedPage - 1));
+        }
+        if (normalizedPage < totalPages - 1) {
+            keyboard.text(t("messages.button.next_page"), buildMessagePageCallback(normalizedPage + 1));
+        }
+        keyboard.row();
+    }
+    keyboard.text(t("messages.button.cancel"), MESSAGES_CALLBACK_CANCEL);
+    return keyboard;
+}
+export function buildMessageDetailKeyboard() {
+    return new InlineKeyboard()
+        .text(t("messages.button.revert"), MESSAGES_CALLBACK_REVERT)
+        .row()
+        .text(t("messages.button.fork"), MESSAGES_CALLBACK_FORK)
+        .row()
+        .text(t("messages.button.back"), MESSAGES_CALLBACK_BACK)
+        .text(t("messages.button.cancel"), MESSAGES_CALLBACK_CANCEL);
+}

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

@@ -0,0 +1,66 @@
+import { InlineKeyboard } from "grammy";
+import { fetchCurrentModel, getModelSelectionLists, } from "../../app/services/model-selection-service.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { replyWithInlineMenu } from "./inline-menu.js";
+export const MODEL_SEARCH_CALLBACK = "model:search";
+export const MODEL_SEARCH_AGAIN_CALLBACK = "model:search:again";
+export const MODEL_SEARCH_CANCEL_CALLBACK = "model:search:cancel";
+function buildModelSelectionMenuText(modelLists) {
+    const lines = [t("model.menu.select"), t("model.menu.favorites_title")];
+    if (modelLists.favorites.length === 0) {
+        lines.push(t("model.menu.favorites_empty"));
+    }
+    lines.push(t("model.menu.recent_title"));
+    if (modelLists.recent.length === 0) {
+        lines.push(t("model.menu.recent_empty"));
+    }
+    return lines.join("\n");
+}
+/**
+ * Build inline keyboard with favorite and recent models, plus a search button at the top.
+ */
+export async function buildModelSelectionMenu(currentModel, modelLists) {
+    const keyboard = new InlineKeyboard();
+    const lists = modelLists ?? (await getModelSelectionLists());
+    const favorites = lists.favorites;
+    const recent = lists.recent;
+    // Search button — always present as first row
+    keyboard.text(t("model.search.button"), MODEL_SEARCH_CALLBACK).row();
+    if (favorites.length === 0 && recent.length === 0) {
+        logger.warn("[ModelHandler] No model choices found in favorites/recent");
+        return keyboard;
+    }
+    const addButton = (model, prefix) => {
+        const isActive = currentModel &&
+            model.providerID === currentModel.providerID &&
+            model.modelID === currentModel.modelID;
+        const label = `${prefix} ${model.providerID}/${model.modelID}`;
+        const labelWithCheck = isActive ? `✅ ${label}` : label;
+        keyboard.text(labelWithCheck, `model:${model.providerID}:${model.modelID}`).row();
+    };
+    favorites.forEach((model) => addButton(model, "⭐"));
+    recent.forEach((model) => addButton(model, "🕘"));
+    return keyboard;
+}
+/**
+ * Show model selection menu
+ */
+export async function showModelSelectionMenu(ctx) {
+    try {
+        const currentModel = fetchCurrentModel();
+        const modelLists = await getModelSelectionLists();
+        const keyboard = await buildModelSelectionMenu(currentModel, modelLists);
+        // keyboard always has at least the search button, so length > 0
+        const text = buildModelSelectionMenuText(modelLists);
+        await replyWithInlineMenu(ctx, {
+            menuKind: "model",
+            text,
+            keyboard,
+        });
+    }
+    catch (err) {
+        logger.error("[ModelHandler] Error showing model menu:", err);
+        await ctx.reply(t("model.menu.error"));
+    }
+}

package/dist/bot/menus/permission-menu.js

@@ -0,0 +1,116 @@
+import { InlineKeyboard } from "grammy";
+import { permissionManager } from "../../app/managers/permission-manager.js";
+import { summaryAggregator } from "../../app/managers/summary-aggregation-manager.js";
+import { interactionManager } from "../../app/managers/interaction-manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+// Permission type display names
+const PERMISSION_NAME_KEYS = {
+    bash: "permission.name.bash",
+    edit: "permission.name.edit",
+    write: "permission.name.write",
+    read: "permission.name.read",
+    webfetch: "permission.name.webfetch",
+    websearch: "permission.name.websearch",
+    glob: "permission.name.glob",
+    grep: "permission.name.grep",
+    list: "permission.name.list",
+    task: "permission.name.task",
+    lsp: "permission.name.lsp",
+    external_directory: "permission.name.external_directory",
+};
+// Permission type emojis
+const PERMISSION_EMOJIS = {
+    bash: "⚡",
+    edit: "✏️",
+    write: "📝",
+    read: "📖",
+    webfetch: "🌐",
+    websearch: "🔍",
+    glob: "📁",
+    grep: "🔎",
+    list: "📂",
+    task: "⚙️",
+    lsp: "🔧",
+    external_directory: "📁",
+};
+export function clearPermissionInteraction(reason) {
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "permission") {
+        interactionManager.clear(reason);
+    }
+}
+export 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,
+    });
+}
+/**
+ * Show permission request message with inline buttons
+ */
+export async function showPermissionRequest(bot, chatId, request) {
+    logger.debug(`[PermissionHandler] Showing permission request: ${request.permission}`);
+    const text = formatPermissionText(request);
+    const keyboard = buildPermissionKeyboard();
+    try {
+        const message = await bot.sendMessage(chatId, text, {
+            reply_markup: keyboard,
+        });
+        logger.debug(`[PermissionHandler] Message sent, messageId=${message.message_id}`);
+        permissionManager.startPermission(request, message.message_id);
+        syncPermissionInteractionState({
+            requestID: request.id,
+            messageId: message.message_id,
+        });
+        summaryAggregator.stopTypingIndicator();
+    }
+    catch (err) {
+        logger.error("[PermissionHandler] Failed to send permission message:", err);
+        throw err;
+    }
+}
+/**
+ * Format permission request text
+ */
+function formatPermissionText(request) {
+    const emoji = PERMISSION_EMOJIS[request.permission] || "🔐";
+    const nameKey = PERMISSION_NAME_KEYS[request.permission];
+    const name = nameKey ? t(nameKey) : request.permission;
+    let text = t("permission.header", { emoji, name });
+    // Show patterns (commands/files)
+    if (request.patterns.length > 0) {
+        request.patterns.forEach((pattern) => {
+            text += `• ${pattern}\n`;
+        });
+    }
+    return text;
+}
+/**
+ * Build inline keyboard with permission buttons
+ */
+function buildPermissionKeyboard() {
+    const keyboard = new InlineKeyboard();
+    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/{commands/projects.js → menus/project-selection-menu.js}

@@ -1,17 +1,11 @@
 import { InlineKeyboard } from "grammy";
-import { getCurrentProject } from "../../settings/manager.js";
-import { getGitWorktreeContext } from "../../git/worktree.js";
-import { getProjects } from "../../project/manager.js";
-import { syncSessionDirectoryCache } from "../../session/cache-manager.js";
-import { appendInlineMenuCancelButton, ensureActiveInlineMenu, replyWithInlineMenu, } from "../handlers/inline-menu.js";
-import { switchToProject } from "../utils/switch-project.js";
-import { clearAllInteractionState } from "../../interaction/cleanup.js";
-import { isForegroundBusy, replyBusyBlocked } from "../utils/busy-guard.js";
-import { logger } from "../../utils/logger.js";
+import { getGitWorktreeContext } from "../../app/services/worktree-service.js";
 import { t } from "../../i18n/index.js";
+import { getCurrentProject } from "../../app/stores/settings-store.js";
+import { logger } from "../../utils/logger.js";
 import { config } from "../../config.js";
 const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
-const PROJECT_PAGE_CALLBACK_PREFIX = "projects:page:";
+export const PROJECT_PAGE_CALLBACK_PREFIX = "projects:page:";
 function formatProjectButtonLabel(label, isActive) {
     const prefix = isActive ? "✅ " : "";
     const availableLength = MAX_INLINE_BUTTON_LABEL_LENGTH - prefix.length;
@@ -114,7 +108,7 @@ async function buildProjectsKeyboard(projects, page) {
     }
     return keyboard;
 }
-async function buildProjectsMenuView(projects, page) {
+export async function buildProjectsMenuView(projects, page) {
     const currentProject = getCurrentProject();
     const pageSize = config.bot.projectsListLimit;
     const { page: normalizedPage, totalPages } = calculateProjectsPaginationRange(projects.length, page, pageSize);
@@ -124,97 +118,3 @@ async function buildProjectsMenuView(projects, page) {
         keyboard: await buildProjectsKeyboard(projects, normalizedPage),
     };
 }
-export async function projectsCommand(ctx) {
-    try {
-        if (isForegroundBusy()) {
-            await replyBusyBlocked(ctx);
-            return;
-        }
-        await syncSessionDirectoryCache();
-        const projects = await getProjects();
-        if (projects.length === 0) {
-            await ctx.reply(t("projects.empty"));
-            return;
-        }
-        const { text, keyboard } = await buildProjectsMenuView(projects, 0);
-        await replyWithInlineMenu(ctx, {
-            menuKind: "project",
-            text,
-            keyboard,
-        });
-    }
-    catch (error) {
-        logger.error("[Bot] Error fetching projects:", error);
-        await ctx.reply(t("projects.fetch_error"));
-    }
-}
-export async function handleProjectSelect(ctx, deps = {}) {
-    const callbackQuery = ctx.callbackQuery;
-    if (!callbackQuery?.data) {
-        return false;
-    }
-    const page = parseProjectPageCallback(callbackQuery.data);
-    const isProjectSelection = callbackQuery.data.startsWith("project:");
-    if (page === null && !isProjectSelection) {
-        return false;
-    }
-    if (isForegroundBusy()) {
-        await replyBusyBlocked(ctx);
-        return true;
-    }
-    if (page !== null) {
-        const isActiveMenu = await ensureActiveInlineMenu(ctx, "project");
-        if (!isActiveMenu) {
-            return true;
-        }
-        try {
-            const projects = await getProjects();
-            if (projects.length === 0) {
-                await ctx.answerCallbackQuery();
-                await ctx.reply(t("projects.empty"));
-                return true;
-            }
-            const { text, keyboard } = await buildProjectsMenuView(projects, page);
-            await ctx.answerCallbackQuery();
-            await ctx.editMessageText(text, {
-                reply_markup: appendInlineMenuCancelButton(keyboard, "project"),
-            });
-        }
-        catch (error) {
-            logger.error("[Bot] Error switching projects page:", error);
-            await ctx.answerCallbackQuery({ text: t("projects.page_load_error") });
-        }
-        return true;
-    }
-    const projectId = callbackQuery.data.replace("project:", "");
-    const isActiveMenu = await ensureActiveInlineMenu(ctx, "project");
-    if (!isActiveMenu) {
-        return true;
-    }
-    try {
-        const projects = await getProjects();
-        const selectedProject = projects.find((p) => p.id === projectId);
-        if (!selectedProject) {
-            throw new Error(`Project with id ${projectId} not found`);
-        }
-        const projectName = selectedProject.name || selectedProject.worktree;
-        logger.info(`[Bot] Project selected: ${projectName} (id: ${projectId})`);
-        const keyboard = deps.ensureEventSubscription
-            ? await switchToProject(ctx, selectedProject, "project_switched", {
-                ensureEventSubscription: deps.ensureEventSubscription,
-            })
-            : await switchToProject(ctx, selectedProject, "project_switched");
-        await ctx.answerCallbackQuery();
-        await ctx.reply(t("projects.selected", { project: projectName }), {
-            reply_markup: keyboard,
-        });
-        await ctx.deleteMessage();
-    }
-    catch (error) {
-        clearAllInteractionState("project_select_error");
-        logger.error("[Bot] Error selecting project:", error);
-        await ctx.answerCallbackQuery();
-        await ctx.reply(t("projects.select_error"));
-    }
-    return true;
-}

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

@@ -1,14 +1,14 @@
 import { InlineKeyboard } from "grammy";
-import { questionManager } from "../../question/manager.js";
+import { questionManager } from "../../app/managers/question-manager.js";
 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 { getCurrentProject } from "../../app/stores/settings-store.js";
+import { getCurrentSession } from "../../app/services/session-service.js";
+import { summaryAggregator } from "../../app/managers/summary-aggregation-manager.js";
+import { interactionManager } from "../../app/managers/interaction-manager.js";
 import { logger } from "../../utils/logger.js";
 import { safeBackgroundTask } from "../../utils/safe-background-task.js";
 import { t } from "../../i18n/index.js";
-import { editRenderedBotPart, sendRenderedBotPart } from "../utils/telegram-text.js";
+import { editRenderedBotPart, sendRenderedBotPart } from "../messages/telegram-text.js";
 const MAX_BUTTON_LENGTH = 60;
 const TELEGRAM_MESSAGE_LIMIT = 4096;
 const TRUNCATION_SUFFIX = "…";
@@ -21,13 +21,13 @@ function getCallbackMessageId(ctx) {
     const messageId = message.message_id;
     return typeof messageId === "number" ? messageId : null;
 }
-function clearQuestionInteraction(reason) {
+export function clearQuestionInteraction(reason) {
     const state = interactionManager.getSnapshot();
     if (state?.kind === "question") {
         interactionManager.clear(reason);
     }
 }
-function syncQuestionInteractionState(expectedInput, questionIndex, messageId) {
+export function syncQuestionInteractionState(expectedInput, questionIndex, messageId) {
     const metadata = {
         questionIndex,
         inputMode: expectedInput === "mixed" ? "custom" : "options",
@@ -53,138 +53,7 @@ function syncQuestionInteractionState(expectedInput, questionIndex, messageId) {
         metadata,
     });
 }
-export async function handleQuestionCallback(ctx) {
-    const data = ctx.callbackQuery?.data;
-    if (!data)
-        return false;
-    if (!data.startsWith("question:")) {
-        return false;
-    }
-    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":
-                {
-                    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);
-                break;
-            case "custom":
-                await handleCustomAnswer(ctx, questionIndex);
-                break;
-            case "cancel":
-                await handleCancelPoll(ctx);
-                break;
-            default:
-                await ctx.answerCallbackQuery({
-                    text: t("question.processing_error_callback"),
-                    show_alert: true,
-                });
-                break;
-        }
-    }
-    catch (err) {
-        logger.error("[QuestionHandler] Error handling callback:", err);
-        await ctx.answerCallbackQuery({
-            text: t("question.processing_error_callback"),
-            show_alert: true,
-        });
-    }
-    return true;
-}
-async function handleSelectOption(ctx, questionIndex, optionIndex) {
-    logger.debug(`[QuestionHandler] handleSelectOption: qIndex=${questionIndex}, oIndex=${optionIndex}`);
-    const question = questionManager.getCurrentQuestion();
-    if (!question) {
-        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");
-        await updateQuestionMessage(ctx);
-        await ctx.answerCallbackQuery();
-    }
-    else {
-        logger.debug("[QuestionHandler] Single choice mode, moving to next question");
-        await ctx.answerCallbackQuery();
-        const answer = questionManager.getSelectedAnswer(questionIndex);
-        logger.debug(`[QuestionHandler] Selected answer for question ${questionIndex}: ${answer}`);
-        // Delete the question message before showing the next one
-        await ctx.deleteMessage().catch(() => { });
-        // DO NOT send the answer immediately - move to the next question
-        // All answers will be sent together after the user answers all questions
-        await showNextQuestion(ctx);
-    }
-}
-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({
-            text: t("question.select_one_required_callback"),
-            show_alert: true,
-        });
-        return;
-    }
-    logger.debug(`[QuestionHandler] Submit answer for question ${questionIndex}: ${answer}`);
-    await ctx.answerCallbackQuery();
-    // Delete the question message before showing the next one
-    await ctx.deleteMessage().catch(() => { });
-    // DO NOT send the answer immediately - move to the next question
-    // All answers will be sent together after the user answers all questions
-    await showNextQuestion(ctx);
-}
-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,
-    });
-}
-async function handleCancelPoll(ctx) {
-    questionManager.cancel();
-    clearQuestionInteraction("question_cancelled");
-    await ctx.editMessageText(t("question.cancelled")).catch(() => { });
-    await ctx.answerCallbackQuery();
-    questionManager.clear();
-}
-async function updateQuestionMessage(ctx) {
+export async function updateQuestionMessage(ctx) {
     const question = questionManager.getCurrentQuestion();
     if (!question) {
         logger.debug("[QuestionHandler] updateQuestionMessage: no current question");
@@ -248,32 +117,7 @@ export async function showCurrentQuestion(bot, chatId) {
         throw err;
     }
 }
-export async function handleQuestionTextAnswer(ctx) {
-    const text = ctx.message?.text;
-    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 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
-    await showNextQuestion(ctx);
-}
-async function showNextQuestion(ctx) {
+export async function showNextQuestion(ctx) {
     questionManager.nextQuestion();
     if (!ctx.chat) {
         return;

package/dist/bot/menus/rename-menu.js

@@ -0,0 +1,6 @@
+import { InlineKeyboard } from "grammy";
+import { t } from "../../i18n/index.js";
+export const RENAME_CANCEL_CALLBACK = "rename:cancel";
+export function buildRenameCancelKeyboard() {
+    return new InlineKeyboard().text(t("rename.button.cancel"), RENAME_CANCEL_CALLBACK);
+}

package/dist/bot/menus/scheduled-task-menu.js

@@ -0,0 +1,42 @@
+import { InlineKeyboard } from "grammy";
+import { t } from "../../i18n/index.js";
+import { formatTaskListBadge } from "../../app/formatters/scheduled-task-display-formatter.js";
+export const TASK_RETRY_SCHEDULE_CALLBACK = "task:retry-schedule";
+export const TASK_CANCEL_CALLBACK = "task:cancel";
+export const TASKLIST_CALLBACK_PREFIX = "tasklist:";
+export const TASKLIST_OPEN_PREFIX = `${TASKLIST_CALLBACK_PREFIX}open:`;
+export const TASKLIST_DELETE_PREFIX = `${TASKLIST_CALLBACK_PREFIX}delete:`;
+export const TASKLIST_CANCEL_CALLBACK = `${TASKLIST_CALLBACK_PREFIX}cancel`;
+const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+function truncateText(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return `${text.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
+function formatTaskButtonLabel(task) {
+    const prefix = `[${formatTaskListBadge(task)}]`;
+    const prompt = task.prompt.replace(/\s+/g, " ").trim();
+    return truncateText(`${prefix} ${prompt}`, MAX_INLINE_BUTTON_LABEL_LENGTH);
+}
+export function buildRetryScheduleKeyboard() {
+    return new InlineKeyboard()
+        .text(t("task.button.retry_schedule"), TASK_RETRY_SCHEDULE_CALLBACK)
+        .text(t("task.button.cancel"), TASK_CANCEL_CALLBACK);
+}
+export function buildCancelKeyboard() {
+    return new InlineKeyboard().text(t("task.button.cancel"), TASK_CANCEL_CALLBACK);
+}
+export function buildTaskListKeyboard(tasks) {
+    const keyboard = new InlineKeyboard();
+    tasks.forEach((task) => {
+        keyboard.text(formatTaskButtonLabel(task), `${TASKLIST_OPEN_PREFIX}${task.id}`).row();
+    });
+    keyboard.text(t("tasklist.button.cancel"), TASKLIST_CANCEL_CALLBACK);
+    return keyboard;
+}
+export function buildTaskDetailsKeyboard(taskId) {
+    return new InlineKeyboard()
+        .text(t("tasklist.button.delete"), `${TASKLIST_DELETE_PREFIX}${taskId}`)
+        .text(t("tasklist.button.cancel"), TASKLIST_CANCEL_CALLBACK);
+}