zardbot-telegram 1.0.0

package/dist/bot/handlers/model.js

@@ -0,0 +1,143 @@
+import { InlineKeyboard } from "grammy";
+import { selectModel, fetchCurrentModel, getModelSelectionLists } from "../../model/manager.js";
+import { formatModelForDisplay } from "../../model/types.js";
+import { formatVariantForButton } from "../../variant/manager.js";
+import { logger } from "../../utils/logger.js";
+import { createMainKeyboard } from "../utils/keyboard.js";
+import { getStoredAgent } from "../../agent/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { clearActiveInlineMenu, ensureActiveInlineMenu, replyWithInlineMenu, } from "./inline-menu.js";
+import { t } from "../../i18n/index.js";
+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");
+}
+/**
+ * Handle model selection callback
+ * @param ctx grammY context
+ * @returns true if handled, false otherwise
+ */
+export async function handleModelSelect(ctx) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || !callbackQuery.data.startsWith("model:")) {
+        return false;
+    }
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "model");
+    if (!isActiveMenu) {
+        return true;
+    }
+    logger.debug(`[ModelHandler] Received callback: ${callbackQuery.data}`);
+    try {
+        if (ctx.chat) {
+            keyboardManager.initialize(ctx.api, ctx.chat.id);
+        }
+        // Parse callback data: "model:providerID:modelID"
+        const parts = callbackQuery.data.split(":");
+        if (parts.length < 3) {
+            logger.error(`[ModelHandler] Invalid callback data format: ${callbackQuery.data}`);
+            clearActiveInlineMenu("model_select_invalid_callback");
+            await ctx.answerCallbackQuery({ text: t("model.change_error_callback") }).catch(() => { });
+            return true;
+        }
+        const providerID = parts[1];
+        const modelID = parts.slice(2).join(":"); // Handle model IDs that may contain ":"
+        const modelInfo = {
+            providerID,
+            modelID,
+            variant: "default", // Reset to default when switching models
+        };
+        // Select model and persist
+        selectModel(modelInfo);
+        // Update keyboard manager state (may not be initialized if no session selected)
+        keyboardManager.updateModel(modelInfo);
+        // Refresh context limit for new model
+        await pinnedMessageManager.refreshContextLimit();
+        // Update Reply Keyboard with new model and context
+        const currentAgent = getStoredAgent();
+        const contextInfo = pinnedMessageManager.getContextInfo() ??
+            (pinnedMessageManager.getContextLimit() > 0
+                ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit() }
+                : null);
+        if (contextInfo) {
+            keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
+        }
+        const variantName = formatVariantForButton(modelInfo.variant || "default");
+        const keyboard = createMainKeyboard(currentAgent, modelInfo, contextInfo ?? undefined, variantName);
+        const displayName = formatModelForDisplay(modelInfo.providerID, modelInfo.modelID);
+        clearActiveInlineMenu("model_selected");
+        // Send confirmation message with updated keyboard
+        await ctx.answerCallbackQuery({ text: t("model.changed_callback", { name: displayName }) });
+        await ctx.reply(t("model.changed_message", { name: displayName }), {
+            reply_markup: keyboard,
+        });
+        // Delete the inline menu message
+        await ctx.deleteMessage().catch(() => { });
+        return true;
+    }
+    catch (err) {
+        clearActiveInlineMenu("model_select_error");
+        logger.error("[ModelHandler] Error handling model select:", err);
+        await ctx.answerCallbackQuery({ text: t("model.change_error_callback") }).catch(() => { });
+        return false;
+    }
+}
+/**
+ * Build inline keyboard with favorite and recent models
+ * @param currentModel Current model for highlighting
+ * @returns InlineKeyboard with model selection buttons
+ */
+export async function buildModelSelectionMenu(currentModel, modelLists) {
+    const keyboard = new InlineKeyboard();
+    const lists = modelLists ?? (await getModelSelectionLists());
+    const favorites = lists.favorites;
+    const recent = lists.recent;
+    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;
+        // Inline buttons use full model ID without truncation
+        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
+ * @param ctx grammY context
+ */
+export async function showModelSelectionMenu(ctx) {
+    try {
+        const currentModel = fetchCurrentModel();
+        const modelLists = await getModelSelectionLists();
+        const keyboard = await buildModelSelectionMenu(currentModel, modelLists);
+        if (keyboard.inline_keyboard.length === 0) {
+            await ctx.reply(t("model.menu.empty"));
+            return;
+        }
+        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/handlers/permission.js

@@ -0,0 +1,235 @@
+import { InlineKeyboard } from "grammy";
+import { permissionManager } from "../../permission/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";
+// 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: "📁",
+};
+function getCallbackMessageId(ctx) {
+    const message = ctx.callbackQuery?.message;
+    if (!message || !("message_id" in message)) {
+        return null;
+    }
+    const messageId = message.message_id;
+    return typeof messageId === "number" ? messageId : null;
+}
+function clearPermissionInteraction(reason) {
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "permission") {
+        interactionManager.clear(reason);
+    }
+}
+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,
+    });
+}
+function isPermissionReply(value) {
+    return value === "once" || value === "always" || value === "reject";
+}
+/**
+ * Handle permission callback from inline buttons
+ */
+export async function handlePermissionCallback(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data)
+        return false;
+    if (!data.startsWith("permission:")) {
+        return false;
+    }
+    logger.debug(`[PermissionHandler] Received callback: ${data}`);
+    if (!permissionManager.isActive()) {
+        clearPermissionInteraction("permission_inactive_callback");
+        await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const callbackMessageId = getCallbackMessageId(ctx);
+    if (!permissionManager.isActiveMessage(callbackMessageId)) {
+        await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const requestID = permissionManager.getRequestID(callbackMessageId);
+    if (!requestID) {
+        await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const parts = data.split(":");
+    const action = parts[1];
+    if (!isPermissionReply(action)) {
+        await ctx.answerCallbackQuery({
+            text: t("permission.processing_error_callback"),
+            show_alert: true,
+        });
+        return true;
+    }
+    try {
+        await handlePermissionReply(ctx, action, requestID, callbackMessageId);
+    }
+    catch (err) {
+        logger.error("[PermissionHandler] Error handling callback:", err);
+        await ctx.answerCallbackQuery({
+            text: t("permission.processing_error_callback"),
+            show_alert: true,
+        });
+    }
+    return true;
+}
+/**
+ * Handle permission reply (once/always/reject)
+ */
+async function handlePermissionReply(ctx, reply, requestID, callbackMessageId) {
+    const currentProject = getCurrentProject();
+    const currentSession = getCurrentSession();
+    const chatId = ctx.chat?.id;
+    const directory = currentSession?.directory ?? currentProject?.worktree;
+    if (!directory || !chatId) {
+        permissionManager.clear();
+        clearPermissionInteraction("permission_invalid_runtime_context");
+        await ctx.answerCallbackQuery({
+            text: t("permission.no_active_request_callback"),
+            show_alert: true,
+        });
+        return;
+    }
+    // Reply labels for user feedback
+    const replyLabels = {
+        once: t("permission.reply.once"),
+        always: t("permission.reply.always"),
+        reject: t("permission.reply.reject"),
+    };
+    await ctx.answerCallbackQuery({ text: replyLabels[reply] });
+    // Delete the permission message
+    await ctx.deleteMessage().catch(() => { });
+    // Stop typing indicator since we're responding
+    summaryAggregator.stopTypingIndicator();
+    logger.info(`[PermissionHandler] Sending permission reply: ${reply}, requestID=${requestID}`);
+    // CRITICAL: Fire-and-forget! Do not block the handler
+    safeBackgroundTask({
+        taskName: "permission.reply",
+        task: () => opencodeClient.permission.reply({
+            requestID,
+            directory,
+            reply,
+        }),
+        onSuccess: ({ error }) => {
+            if (error) {
+                logger.error("[PermissionHandler] Failed to send permission reply:", error);
+                if (ctx.api && chatId) {
+                    void ctx.api.sendMessage(chatId, t("permission.send_reply_error")).catch(() => { });
+                }
+                return;
+            }
+            logger.info("[PermissionHandler] Permission reply sent successfully");
+        },
+    });
+    permissionManager.removeByMessageId(callbackMessageId);
+    if (!permissionManager.isActive()) {
+        clearPermissionInteraction("permission_replied");
+        return;
+    }
+    syncPermissionInteractionState({
+        lastRepliedRequestID: requestID,
+    });
+}
+/**
+ * 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/handlers/prompt.js

@@ -0,0 +1,240 @@
+import { opencodeClient } from "../../opencode/client.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 { stopEventListening } from "../../opencode/events.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 { foregroundSessionState } from "../../scheduled-task/foreground-state.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;
+    }
+}
+async function resetMismatchedSessionContext() {
+    stopEventListening();
+    summaryAggregator.clear();
+    foregroundSessionState.clearAll("session_mismatch_reset");
+    clearAllInteractionState("session_mismatch_reset");
+    clearSession();
+    keyboardManager.clearContext();
+    if (!pinnedMessageManager.isInitialized()) {
+        return;
+    }
+    try {
+        await pinnedMessageManager.clear();
+    }
+    catch (err) {
+        logger.error("[Bot] Failed to clear pinned message during session reset:", err);
+    }
+}
+/**
+ * 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 currentProject = getCurrentProject();
+    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 (!pinnedMessageManager.isInitialized()) {
+        pinnedMessageManager.initialize(bot.api, ctx.chat.id);
+    }
+    // Initialize keyboard manager if not already
+    keyboardManager.initialize(bot.api, ctx.chat.id);
+    let currentSession = getCurrentSession();
+    if (currentSession && currentSession.directory !== currentProject.worktree) {
+        logger.warn(`[Bot] Session/project mismatch detected. sessionDirectory=${currentSession.directory}, projectDirectory=${currentProject.worktree}. Resetting session context.`);
+        await resetMismatchedSessionContext();
+        await ctx.reply(t("bot.session_reset_project_mismatch"));
+        return false;
+    }
+    if (!currentSession) {
+        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);
+        await ingestSessionInfoForCache(session);
+        // Create pinned message for new session
+        try {
+            await pinnedMessageManager.onSessionChange(session.id, session.title);
+        }
+        catch (err) {
+            logger.error("[Bot] Error creating pinned message for new session:", err);
+        }
+        const currentAgent = getStoredAgent();
+        const currentModel = getStoredModel();
+        const contextInfo = pinnedMessageManager.getContextInfo();
+        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 (!pinnedMessageManager.getState().messageId) {
+            try {
+                await pinnedMessageManager.onSessionChange(currentSession.id, currentSession.title);
+            }
+            catch (err) {
+                logger.error("[Bot] Error creating pinned message for existing session:", err);
+            }
+        }
+    }
+    await ensureEventSubscription(currentSession.directory);
+    summaryAggregator.setSession(currentSession.id);
+    summaryAggregator.setBotAndChatId(bot, ctx.chat.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();
+        const storedModel = getStoredModel();
+        // 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.prompt (fire-and-forget) with agent=${currentAgent}, fileCount=${fileParts.length}...`);
+        foregroundSessionState.markBusy(currentSession.id);
+        // CRITICAL: DO NOT wait for session.prompt 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.prompt",
+            task: () => opencodeClient.session.prompt(promptOptions),
+            onSuccess: ({ error }) => {
+                if (error) {
+                    foregroundSessionState.markIdle(currentSession.id);
+                    const details = formatErrorDetails(error, 6000);
+                    logger.error("[Bot] OpenCode API returned an error for session.prompt", promptErrorLogContext);
+                    logger.error("[Bot] session.prompt error details:", details);
+                    logger.error("[Bot] session.prompt raw API error object:", error);
+                    // Send user-friendly error via API directly because ctx is no longer available
+                    void bot.api.sendMessage(ctx.chat.id, t("bot.prompt_send_error")).catch(() => { });
+                    return;
+                }
+                logger.info("[Bot] session.prompt completed");
+            },
+            onError: (error) => {
+                foregroundSessionState.markIdle(currentSession.id);
+                const details = formatErrorDetails(error, 6000);
+                logger.error("[Bot] session.prompt background task failed", promptErrorLogContext);
+                logger.error("[Bot] session.prompt background failure details:", details);
+                logger.error("[Bot] session.prompt raw background error object:", error);
+                void bot.api.sendMessage(ctx.chat.id, t("bot.prompt_send_error")).catch(() => { });
+            },
+        });
+        return true;
+    }
+    catch (err) {
+        if (currentSession) {
+            foregroundSessionState.markIdle(currentSession.id);
+        }
+        logger.error("Error in prompt handler:", err);
+        if (interactionManager.getSnapshot()) {
+            clearAllInteractionState("message_handler_error");
+        }
+        await ctx.reply(t("error.generic"));
+        return false;
+    }
+}