opencode-telegram-group-topics-bot 0.11.2

package/dist/bot/handlers/prompt.js

@@ -0,0 +1,263 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { classifyPromptSubmitError } from "../../opencode/prompt-submit-error.js";
+import { clearSession, getCurrentSession, setCurrentSession } from "../../session/manager.js";
+import { ingestSessionInfoForCache } from "../../session/cache-manager.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { getStoredAgent } from "../../agent/manager.js";
+import { getStoredModel } from "../../model/manager.js";
+import { formatVariantForButton } from "../../variant/manager.js";
+import { createMainKeyboard } from "../utils/keyboard.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
+import { interactionManager } from "../../interaction/manager.js";
+import { clearAllInteractionState } from "../../interaction/cleanup.js";
+import { safeBackgroundTask } from "../../utils/safe-background-task.js";
+import { formatErrorDetails } from "../../utils/error-format.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { GLOBAL_SCOPE_KEY, SCOPE_CONTEXT, getScopeFromContext, getThreadSendOptions, } from "../scope.js";
+import { BOT_I18N_KEY, CHAT_TYPE } from "../constants.js";
+import { INTERACTION_CLEAR_REASON } from "../../interaction/constants.js";
+import { getTopicBindingByScopeKey } from "../../topic/manager.js";
+/** Module-level references for async callbacks that don't have ctx. */
+let botInstance = null;
+let chatIdInstance = null;
+export function getPromptBotInstance() {
+    return botInstance;
+}
+export function getPromptChatId() {
+    return chatIdInstance;
+}
+async function isSessionBusy(sessionId, directory) {
+    try {
+        const { data, error } = await opencodeClient.session.status({ directory });
+        if (error || !data) {
+            logger.warn("[Bot] Failed to check session status before prompt:", error);
+            return false;
+        }
+        const sessionStatus = data[sessionId];
+        if (!sessionStatus) {
+            return false;
+        }
+        logger.debug(`[Bot] Current session status before prompt: ${sessionStatus.type || "unknown"}`);
+        return sessionStatus.type === "busy";
+    }
+    catch (err) {
+        logger.warn("[Bot] Error checking session status before prompt:", err);
+        return false;
+    }
+}
+function resetMismatchedSessionContextForScope(scopeKey) {
+    clearAllInteractionState(INTERACTION_CLEAR_REASON.SESSION_MISMATCH_RESET, scopeKey);
+    clearSession(scopeKey);
+}
+/**
+ * Processes a user prompt: ensures project/session, subscribes to events, and sends
+ * the prompt to OpenCode. Used by text, voice, and photo message handlers.
+ *
+ * @param ctx - Grammy context
+ * @param text - Text content of the prompt
+ * @param deps - Dependencies (bot and event subscription)
+ * @param fileParts - Optional file parts (for photo/document attachments)
+ * @returns true if the prompt was dispatched, false if it was blocked/failed early.
+ */
+export async function processUserPrompt(ctx, text, deps, fileParts = []) {
+    const { bot, ensureEventSubscription } = deps;
+    const scope = getScopeFromContext(ctx);
+    const scopeKey = scope?.key ?? GLOBAL_SCOPE_KEY;
+    const usePinned = ctx.chat?.type !== CHAT_TYPE.PRIVATE;
+    const currentProject = getCurrentProject(scopeKey);
+    if (!currentProject) {
+        await ctx.reply(t("bot.project_not_selected"));
+        return false;
+    }
+    botInstance = bot;
+    chatIdInstance = ctx.chat.id;
+    // Initialize pinned message manager if not already
+    if (usePinned && !pinnedMessageManager.isInitialized(scopeKey)) {
+        pinnedMessageManager.initialize(bot.api, ctx.chat.id, scopeKey, scope?.threadId ?? null);
+    }
+    // Initialize keyboard manager if not already
+    keyboardManager.initialize(bot.api, ctx.chat.id, scopeKey);
+    let currentSession = getCurrentSession(scopeKey);
+    if (scope?.context === SCOPE_CONTEXT.GROUP_TOPIC && !getTopicBindingByScopeKey(scopeKey)) {
+        await ctx.reply(t(BOT_I18N_KEY.TOPIC_UNBOUND), getThreadSendOptions(scope.threadId));
+        return false;
+    }
+    if (currentSession && currentSession.directory !== currentProject.worktree) {
+        logger.warn(`[Bot] Session/project mismatch detected. sessionDirectory=${currentSession.directory}, projectDirectory=${currentProject.worktree}. Resetting session context.`);
+        resetMismatchedSessionContextForScope(scopeKey);
+        await ctx.reply(t("bot.session_reset_project_mismatch"));
+        return false;
+    }
+    if (!currentSession) {
+        if (scope?.context === SCOPE_CONTEXT.GROUP_TOPIC) {
+            await ctx.reply(t(BOT_I18N_KEY.TOPIC_UNBOUND), getThreadSendOptions(scope.threadId));
+            return false;
+        }
+        await ctx.reply(t("bot.creating_session"));
+        const { data: session, error } = await opencodeClient.session.create({
+            directory: currentProject.worktree,
+        });
+        if (error || !session) {
+            await ctx.reply(t("bot.create_session_error"));
+            return false;
+        }
+        logger.info(`[Bot] Created new session: id=${session.id}, title="${session.title}", project=${currentProject.worktree}`);
+        currentSession = {
+            id: session.id,
+            title: session.title,
+            directory: currentProject.worktree,
+        };
+        setCurrentSession(currentSession, scopeKey);
+        await ingestSessionInfoForCache(session);
+        // Create pinned message for new session
+        if (usePinned) {
+            try {
+                await pinnedMessageManager.onSessionChange(session.id, session.title, scopeKey);
+            }
+            catch (err) {
+                logger.error("[Bot] Error creating pinned message for new session:", err);
+            }
+        }
+        if (usePinned && pinnedMessageManager.getContextLimit(scopeKey) === 0) {
+            await pinnedMessageManager.refreshContextLimit(scopeKey);
+        }
+        const currentAgent = getStoredAgent(scopeKey);
+        const currentModel = getStoredModel(scopeKey);
+        const contextInfo = (usePinned ? pinnedMessageManager.getContextInfo(scopeKey) : null) ??
+            keyboardManager.getContextInfo(scopeKey) ??
+            (usePinned && pinnedMessageManager.getContextLimit(scopeKey) > 0
+                ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit(scopeKey) }
+                : null);
+        const variantName = formatVariantForButton(currentModel.variant || "default");
+        const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo ?? undefined, variantName);
+        await ctx.reply(t("bot.session_created", { title: session.title }), {
+            reply_markup: keyboard,
+        });
+    }
+    else {
+        logger.info(`[Bot] Using existing session: id=${currentSession.id}, title="${currentSession.title}"`);
+        // Ensure pinned message exists for existing session
+        if (usePinned && !pinnedMessageManager.getState(scopeKey).messageId) {
+            try {
+                await pinnedMessageManager.onSessionChange(currentSession.id, currentSession.title, scopeKey);
+            }
+            catch (err) {
+                logger.error("[Bot] Error creating pinned message for existing session:", err);
+            }
+        }
+    }
+    await ensureEventSubscription(currentSession.directory);
+    summaryAggregator.setSession(currentSession.id);
+    const sessionIsBusy = await isSessionBusy(currentSession.id, currentSession.directory);
+    if (sessionIsBusy) {
+        logger.info(`[Bot] Ignoring new prompt: session ${currentSession.id} is busy`);
+        await ctx.reply(t("bot.session_busy"));
+        return false;
+    }
+    try {
+        const currentAgent = getStoredAgent(scopeKey);
+        const storedModel = getStoredModel(scopeKey);
+        // Build parts array with text and files
+        const parts = [];
+        // Add text part if present
+        if (text.trim().length > 0) {
+            parts.push({ type: "text", text });
+        }
+        // Add file parts
+        parts.push(...fileParts);
+        // If no text and files exist, use a placeholder
+        if (parts.length === 0 || (parts.length > 0 && parts.every((p) => p.type === "file"))) {
+            if (fileParts.length > 0) {
+                // Files without text - add a minimal system prompt
+                parts.unshift({ type: "text", text: "See attached file" });
+            }
+        }
+        const promptOptions = {
+            sessionID: currentSession.id,
+            directory: currentSession.directory,
+            parts,
+            agent: currentAgent,
+        };
+        // Use stored model (from settings or config)
+        if (storedModel.providerID && storedModel.modelID) {
+            promptOptions.model = {
+                providerID: storedModel.providerID,
+                modelID: storedModel.modelID,
+            };
+            // Add variant if specified
+            if (storedModel.variant) {
+                promptOptions.variant = storedModel.variant;
+            }
+        }
+        const promptErrorLogContext = {
+            sessionId: currentSession.id,
+            directory: currentSession.directory,
+            agent: currentAgent || "default",
+            modelProvider: storedModel.providerID || "default",
+            modelId: storedModel.modelID || "default",
+            variant: storedModel.variant || "default",
+            promptLength: text.length,
+            fileCount: fileParts.length,
+        };
+        logger.info(`[Bot] Calling session.promptAsync (fire-and-forget) with agent=${currentAgent}, fileCount=${fileParts.length}...`);
+        // CRITICAL: DO NOT wait for session.promptAsync to complete.
+        // If we wait, the handler will not finish and grammY will not call getUpdates,
+        // which blocks receiving button callback_query updates.
+        // The processing result will arrive via SSE events.
+        safeBackgroundTask({
+            taskName: "session.promptAsync",
+            task: () => opencodeClient.session.promptAsync(promptOptions),
+            onSuccess: ({ error }) => {
+                if (error) {
+                    const details = formatErrorDetails(error, 6000);
+                    const errorType = classifyPromptSubmitError(error);
+                    logger.error("[Bot] OpenCode API returned an error for session.promptAsync", promptErrorLogContext);
+                    logger.error("[Bot] session.promptAsync error details:", details);
+                    logger.error("[Bot] session.promptAsync raw API error object:", error);
+                    const errorMessageKey = errorType === "busy"
+                        ? "bot.session_busy"
+                        : errorType === "session_not_found"
+                            ? "bot.prompt_send_error_session_not_found"
+                            : "bot.prompt_send_error";
+                    // Send user-friendly error via API directly because ctx is no longer available
+                    void bot.api
+                        .sendMessage(ctx.chat.id, t(errorMessageKey), {
+                        ...getThreadSendOptions(scope?.threadId ?? null),
+                    })
+                        .catch(() => { });
+                    return;
+                }
+                logger.info("[Bot] session.promptAsync accepted");
+            },
+            onError: (error) => {
+                const details = formatErrorDetails(error, 6000);
+                const errorType = classifyPromptSubmitError(error);
+                logger.error("[Bot] session.promptAsync background task failed", promptErrorLogContext);
+                logger.error("[Bot] session.promptAsync background failure details:", details);
+                logger.error("[Bot] session.promptAsync raw background error object:", error);
+                const errorMessageKey = errorType === "busy"
+                    ? "bot.session_busy"
+                    : errorType === "session_not_found"
+                        ? "bot.prompt_send_error_session_not_found"
+                        : "bot.prompt_send_error";
+                void bot.api
+                    .sendMessage(ctx.chat.id, t(errorMessageKey), {
+                    ...getThreadSendOptions(scope?.threadId ?? null),
+                })
+                    .catch(() => { });
+            },
+        });
+        return true;
+    }
+    catch (err) {
+        logger.error("Error in prompt handler:", err);
+        if (interactionManager.getSnapshot(scopeKey)) {
+            clearAllInteractionState(INTERACTION_CLEAR_REASON.MESSAGE_HANDLER_ERROR, scopeKey);
+        }
+        await ctx.reply(t("error.generic"));
+        return false;
+    }
+}

package/dist/bot/handlers/question.js

@@ -0,0 +1,285 @@
+import { InlineKeyboard } from "grammy";
+import { questionManager } from "../../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 { logger } from "../../utils/logger.js";
+import { safeBackgroundTask } from "../../utils/safe-background-task.js";
+import { t } from "../../i18n/index.js";
+import { getScopeKeyFromContext, getThreadSendOptions } from "../scope.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, scopeKey) {
+    const state = interactionManager.getSnapshot(scopeKey);
+    if (state?.kind === "question") {
+        interactionManager.clear(reason, scopeKey);
+    }
+}
+function syncQuestionInteractionState(expectedInput, questionIndex, messageId, scopeKey) {
+    const metadata = {
+        questionIndex,
+        inputMode: expectedInput === "mixed" ? "custom" : "options",
+    };
+    const requestID = questionManager.getRequestID(scopeKey);
+    if (requestID) {
+        metadata.requestID = requestID;
+    }
+    if (messageId !== null) {
+        metadata.messageId = messageId;
+    }
+    const state = interactionManager.getSnapshot(scopeKey);
+    if (state?.kind === "question") {
+        interactionManager.transition({
+            expectedInput,
+            metadata,
+        }, scopeKey);
+        return;
+    }
+    interactionManager.start({
+        kind: "question",
+        expectedInput,
+        metadata,
+    }, scopeKey);
+}
+export async function handleQuestionCallback(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data || !data.startsWith("question:")) {
+        return false;
+    }
+    const scopeKey = getScopeKeyFromContext(ctx);
+    const callbackMessageId = getCallbackMessageId(ctx);
+    if (!questionManager.isActive(scopeKey) ||
+        !questionManager.isActiveMessage(callbackMessageId, scopeKey)) {
+        clearQuestionInteraction("question_inactive_callback", scopeKey);
+        await ctx.answerCallbackQuery({ text: t("question.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const parts = data.split(":");
+    const action = parts[1];
+    const questionIndex = Number.parseInt(parts[2], 10);
+    if (Number.isNaN(questionIndex) || questionIndex !== questionManager.getCurrentIndex(scopeKey)) {
+        await ctx.answerCallbackQuery({ text: t("question.inactive_callback"), show_alert: true });
+        return true;
+    }
+    if (action === "cancel") {
+        questionManager.cancel(scopeKey);
+        clearQuestionInteraction("question_cancelled", scopeKey);
+        await ctx.editMessageText(t("question.cancelled")).catch(() => { });
+        await ctx.answerCallbackQuery();
+        questionManager.clear(scopeKey);
+        return true;
+    }
+    if (action === "custom") {
+        questionManager.startCustomInput(questionIndex, scopeKey);
+        syncQuestionInteractionState("mixed", questionIndex, questionManager.getActiveMessageId(scopeKey), scopeKey);
+        await ctx.answerCallbackQuery({ text: t("question.enter_custom_callback"), show_alert: true });
+        return true;
+    }
+    if (action === "select") {
+        const optionIndex = Number.parseInt(parts[3], 10);
+        if (Number.isNaN(optionIndex)) {
+            await ctx.answerCallbackQuery({
+                text: t("question.processing_error_callback"),
+                show_alert: true,
+            });
+            return true;
+        }
+        questionManager.selectOption(questionIndex, optionIndex, scopeKey);
+        const question = questionManager.getCurrentQuestion(scopeKey);
+        if (!question) {
+            return true;
+        }
+        if (question.multiple) {
+            await updateQuestionMessage(ctx, scopeKey);
+            await ctx.answerCallbackQuery();
+            return true;
+        }
+        await ctx.answerCallbackQuery();
+        await ctx.deleteMessage().catch(() => { });
+        await showNextQuestion(ctx, scopeKey);
+        return true;
+    }
+    if (action === "submit") {
+        const answer = questionManager.getSelectedAnswer(questionIndex, scopeKey);
+        if (!answer) {
+            await ctx.answerCallbackQuery({
+                text: t("question.select_one_required_callback"),
+                show_alert: true,
+            });
+            return true;
+        }
+        await ctx.answerCallbackQuery();
+        await ctx.deleteMessage().catch(() => { });
+        await showNextQuestion(ctx, scopeKey);
+        return true;
+    }
+    await ctx.answerCallbackQuery({
+        text: t("question.processing_error_callback"),
+        show_alert: true,
+    });
+    return true;
+}
+async function updateQuestionMessage(ctx, scopeKey) {
+    const question = questionManager.getCurrentQuestion(scopeKey);
+    if (!question) {
+        return;
+    }
+    await ctx
+        .editMessageText(formatQuestionText(question, scopeKey), {
+        reply_markup: buildQuestionKeyboard(question, questionManager.getSelectedOptions(questionManager.getCurrentIndex(scopeKey), scopeKey), scopeKey),
+        parse_mode: "Markdown",
+    })
+        .catch(() => { });
+}
+export async function showCurrentQuestion(bot, chatId, scopeKey, threadId) {
+    const question = questionManager.getCurrentQuestion(scopeKey);
+    if (!question) {
+        await showPollSummary(bot, chatId, scopeKey, threadId);
+        return;
+    }
+    const message = await bot.sendMessage(chatId, formatQuestionText(question, scopeKey), {
+        reply_markup: buildQuestionKeyboard(question, questionManager.getSelectedOptions(questionManager.getCurrentIndex(scopeKey), scopeKey), scopeKey),
+        parse_mode: "Markdown",
+        ...getThreadSendOptions(threadId),
+    });
+    questionManager.addMessageId(message.message_id, scopeKey);
+    questionManager.setActiveMessageId(message.message_id, scopeKey);
+    syncQuestionInteractionState("callback", questionManager.getCurrentIndex(scopeKey), questionManager.getActiveMessageId(scopeKey), scopeKey);
+    summaryAggregator.stopTypingIndicator();
+}
+export async function handleQuestionTextAnswer(ctx) {
+    const text = ctx.message?.text;
+    if (!text)
+        return;
+    const scopeKey = getScopeKeyFromContext(ctx);
+    const currentIndex = questionManager.getCurrentIndex(scopeKey);
+    if (!questionManager.isWaitingForCustomInput(currentIndex, scopeKey)) {
+        await ctx.reply(t("question.use_custom_button_first"));
+        return;
+    }
+    questionManager.setCustomAnswer(currentIndex, text, scopeKey);
+    questionManager.clearCustomInput(scopeKey);
+    const activeMessageId = questionManager.getActiveMessageId(scopeKey);
+    if (activeMessageId !== null && ctx.chat) {
+        await ctx.api.deleteMessage(ctx.chat.id, activeMessageId).catch(() => { });
+    }
+    await showNextQuestion(ctx, scopeKey);
+}
+async function showNextQuestion(ctx, scopeKey) {
+    questionManager.nextQuestion(scopeKey);
+    if (!ctx.chat) {
+        return;
+    }
+    const threadId = typeof ctx.message?.message_thread_id === "number" ? ctx.message.message_thread_id : null;
+    if (questionManager.hasNextQuestion(scopeKey)) {
+        await showCurrentQuestion(ctx.api, ctx.chat.id, scopeKey, threadId);
+    }
+    else {
+        await showPollSummary(ctx.api, ctx.chat.id, scopeKey, threadId);
+    }
+}
+async function showPollSummary(bot, chatId, scopeKey, threadId) {
+    const answers = questionManager.getAllAnswers(scopeKey);
+    await sendAllAnswersToAgent(bot, chatId, scopeKey, threadId);
+    if (answers.length === 0) {
+        await bot.sendMessage(chatId, t("question.completed_no_answers"), getThreadSendOptions(threadId));
+    }
+    else {
+        await bot.sendMessage(chatId, formatAnswersSummary(answers), getThreadSendOptions(threadId));
+    }
+    clearQuestionInteraction("question_completed", scopeKey);
+    questionManager.clear(scopeKey);
+}
+async function sendAllAnswersToAgent(bot, chatId, scopeKey, threadId) {
+    const currentProject = getCurrentProject(scopeKey);
+    const currentSession = getCurrentSession(scopeKey);
+    const requestID = questionManager.getRequestID(scopeKey);
+    const totalQuestions = questionManager.getTotalQuestions(scopeKey);
+    const directory = currentSession?.directory ?? currentProject?.worktree;
+    if (!directory) {
+        await bot.sendMessage(chatId, t("question.no_active_project"), getThreadSendOptions(threadId));
+        return;
+    }
+    if (!requestID) {
+        await bot.sendMessage(chatId, t("question.no_active_request"), getThreadSendOptions(threadId));
+        return;
+    }
+    const allAnswers = [];
+    for (let i = 0; i < totalQuestions; i++) {
+        const answer = questionManager.getCustomAnswer(i, scopeKey) ||
+            questionManager.getSelectedAnswer(i, scopeKey) ||
+            "";
+        allAnswers.push(answer ? answer.split("\n").filter((part) => part.trim()) : []);
+    }
+    safeBackgroundTask({
+        taskName: "question.reply",
+        task: () => opencodeClient.question.reply({
+            requestID,
+            directory,
+            answers: allAnswers,
+        }),
+        onSuccess: ({ error }) => {
+            if (error) {
+                logger.error("[QuestionHandler] Failed to send answers via question.reply:", error);
+                void bot
+                    .sendMessage(chatId, t("question.send_answers_error"), getThreadSendOptions(threadId))
+                    .catch(() => { });
+            }
+        },
+    });
+}
+function formatQuestionText(question, scopeKey) {
+    const currentIndex = questionManager.getCurrentIndex(scopeKey);
+    const totalQuestions = questionManager.getTotalQuestions(scopeKey);
+    const progressText = totalQuestions > 0 ? `${currentIndex + 1}/${totalQuestions}` : "";
+    const headerTitle = [progressText, question.header].filter(Boolean).join(" ");
+    const header = headerTitle ? `**${headerTitle}**\n\n` : "";
+    const multiple = question.multiple ? t("question.multi_hint") : "";
+    return `${header}${question.question}${multiple}`;
+}
+function buildQuestionKeyboard(question, selectedOptions, scopeKey) {
+    const keyboard = new InlineKeyboard();
+    const questionIndex = questionManager.getCurrentIndex(scopeKey);
+    question.options.forEach((option, index) => {
+        const isSelected = selectedOptions.has(index);
+        const icon = isSelected ? "✅ " : "";
+        const buttonText = formatButtonText(option.label, option.description, icon);
+        keyboard.text(buttonText, `question:select:${questionIndex}:${index}`).row();
+    });
+    if (question.multiple) {
+        keyboard.text(t("question.button.submit"), `question:submit:${questionIndex}`).row();
+    }
+    keyboard.text(t("question.button.custom"), `question:custom:${questionIndex}`).row();
+    keyboard.text(t("question.button.cancel"), `question:cancel:${questionIndex}`);
+    return keyboard;
+}
+function formatButtonText(label, description, icon) {
+    let text = `${icon}${label}`;
+    if (description && icon === "") {
+        text += ` - ${description}`;
+    }
+    if (text.length > MAX_BUTTON_LENGTH) {
+        text = text.substring(0, MAX_BUTTON_LENGTH - 3) + "...";
+    }
+    return text;
+}
+function formatAnswersSummary(answers) {
+    let summary = t("question.summary.title");
+    answers.forEach((item, index) => {
+        summary += t("question.summary.question", {
+            index: index + 1,
+            question: item.question,
+        });
+        summary += t("question.summary.answer", { answer: item.answer });
+    });
+    return summary;
+}