opencode-telegram-group-topics-bot 0.11.2

package/dist/bot/handlers/inline-menu.js

@@ -0,0 +1,124 @@
+import { interactionManager } from "../../interaction/manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { getScopeFromContext, getScopeKeyFromContext, getThreadSendOptions } from "../scope.js";
+const INLINE_MENU_CANCEL_PREFIX = "inline:cancel:";
+const LEGACY_CONTEXT_CANCEL_CALLBACK = "compact:cancel";
+const INLINE_MENU_KINDS = ["project", "session", "model", "agent", "variant", "context"];
+function isInlineMenuKind(value) {
+    return INLINE_MENU_KINDS.includes(value);
+}
+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 getActiveInlineMenuMetadata(state) {
+    if (!state || state.kind !== "inline") {
+        return null;
+    }
+    const menuKind = state.metadata.menuKind;
+    const messageId = state.metadata.messageId;
+    if (typeof menuKind !== "string" || !isInlineMenuKind(menuKind)) {
+        return null;
+    }
+    if (typeof messageId !== "number") {
+        return null;
+    }
+    return {
+        menuKind,
+        messageId,
+    };
+}
+function getInlineCancelCallbackData(menuKind) {
+    return `${INLINE_MENU_CANCEL_PREFIX}${menuKind}`;
+}
+export function appendInlineMenuCancelButton(keyboard, menuKind) {
+    while (keyboard.inline_keyboard.length > 0 &&
+        keyboard.inline_keyboard[keyboard.inline_keyboard.length - 1].length === 0) {
+        keyboard.inline_keyboard.pop();
+    }
+    if (keyboard.inline_keyboard.length > 0) {
+        keyboard.row();
+    }
+    keyboard.text(t("inline.button.cancel"), getInlineCancelCallbackData(menuKind));
+    return keyboard;
+}
+export async function replyWithInlineMenu(ctx, options) {
+    const scope = getScopeFromContext(ctx);
+    const scopeKey = scope?.key ?? getScopeKeyFromContext(ctx);
+    const keyboard = appendInlineMenuCancelButton(options.keyboard, options.menuKind);
+    const replyOptions = {
+        reply_markup: keyboard,
+        ...getThreadSendOptions(scope?.threadId ?? null),
+    };
+    if (options.parseMode) {
+        replyOptions.parse_mode = options.parseMode;
+    }
+    const message = await ctx.reply(options.text, replyOptions);
+    interactionManager.start({
+        kind: "inline",
+        expectedInput: "callback",
+        metadata: {
+            menuKind: options.menuKind,
+            messageId: message.message_id,
+        },
+    }, scopeKey);
+    logger.debug(`[InlineMenu] Opened menu: kind=${options.menuKind}, messageId=${message.message_id}`);
+    return message.message_id;
+}
+export async function ensureActiveInlineMenu(ctx, menuKind) {
+    const scopeKey = getScopeKeyFromContext(ctx);
+    const activeMetadata = getActiveInlineMenuMetadata(interactionManager.getSnapshot(scopeKey));
+    const callbackMessageId = getCallbackMessageId(ctx);
+    const isActive = !!activeMetadata &&
+        callbackMessageId !== null &&
+        activeMetadata.menuKind === menuKind &&
+        activeMetadata.messageId === callbackMessageId;
+    if (isActive) {
+        return true;
+    }
+    logger.debug(`[InlineMenu] Stale callback ignored: expectedKind=${menuKind}, activeKind=${activeMetadata?.menuKind || "none"}, callbackMessageId=${callbackMessageId || "none"}, activeMessageId=${activeMetadata?.messageId || "none"}`);
+    await ctx
+        .answerCallbackQuery({ text: t("inline.inactive_callback"), show_alert: true })
+        .catch(() => { });
+    return false;
+}
+export function clearActiveInlineMenu(reason, scopeKey = "global") {
+    const state = interactionManager.getSnapshot(scopeKey);
+    if (state?.kind === "inline") {
+        interactionManager.clear(reason, scopeKey);
+    }
+}
+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}`, getScopeKeyFromContext(ctx));
+    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/handlers/model.js

@@ -0,0 +1,152 @@
+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";
+import { SCOPE_CONTEXT, getScopeFromKey, getScopeKeyFromContext } from "../scope.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 {
+        const scopeKey = getScopeKeyFromContext(ctx);
+        if (ctx.chat) {
+            keyboardManager.initialize(ctx.api, ctx.chat.id, scopeKey);
+        }
+        // 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", scopeKey);
+            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, scopeKey);
+        // Update keyboard manager state (may not be initialized if no session selected)
+        keyboardManager.updateModel(modelInfo, scopeKey);
+        // Refresh context limit for new model
+        await pinnedMessageManager.refreshContextLimit(scopeKey);
+        // Update Reply Keyboard with new model and context
+        const currentAgent = getStoredAgent(scopeKey);
+        const contextInfo = pinnedMessageManager.getContextInfo(scopeKey) ??
+            (pinnedMessageManager.getContextLimit(scopeKey) > 0
+                ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit(scopeKey) }
+                : keyboardManager.getContextInfo(scopeKey));
+        if (contextInfo) {
+            keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit, scopeKey);
+        }
+        const variantName = formatVariantForButton(modelInfo.variant || "default");
+        const scope = getScopeFromKey(scopeKey);
+        const keyboard = createMainKeyboard(currentAgent, modelInfo, contextInfo ?? undefined, variantName, scope?.context === SCOPE_CONTEXT.GROUP_GENERAL
+            ? {
+                contextFirst: true,
+                contextLabel: t("keyboard.general_defaults"),
+            }
+            : undefined);
+        const displayName = formatModelForDisplay(modelInfo.providerID, modelInfo.modelID);
+        clearActiveInlineMenu("model_selected", scopeKey);
+        // 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", getScopeKeyFromContext(ctx));
+        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 scopeKey = getScopeKeyFromContext(ctx);
+        const currentModel = fetchCurrentModel(scopeKey);
+        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,281 @@
+import { InlineKeyboard } from "grammy";
+import { permissionManager } from "../../permission/manager.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { getCurrentSession, getSessionById } from "../../session/manager.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
+import { interactionManager } from "../../interaction/manager.js";
+import { INTERACTION_CLEAR_REASON } from "../../interaction/constants.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { sendMessageWithMarkdownFallback } from "../utils/send-with-markdown-fallback.js";
+import { getScopeFromContext, getScopeKeyFromContext, getThreadSendOptions } from "../scope.js";
+const PERMISSION_CALLBACK = {
+    PREFIX: "permission:",
+    SEPARATOR: ":",
+    ACTION_INDEX: 1,
+    REQUEST_ID_INDEX: 2,
+};
+// 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",
+};
+// Permission type emojis
+const PERMISSION_EMOJIS = {
+    bash: "⚡",
+    edit: "✏️",
+    write: "📝",
+    read: "📖",
+    webfetch: "🌐",
+    websearch: "🔍",
+    glob: "📁",
+    grep: "🔎",
+    list: "📂",
+    task: "⚙️",
+    lsp: "🔧",
+};
+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, scopeKey) {
+    const state = interactionManager.getSnapshot(scopeKey);
+    if (state?.kind === "permission") {
+        interactionManager.clear(reason, scopeKey);
+    }
+}
+function syncPermissionInteractionState(scopeKey, metadata = {}) {
+    const pendingCount = permissionManager.getPendingCount(scopeKey);
+    if (pendingCount === 0) {
+        clearPermissionInteraction(INTERACTION_CLEAR_REASON.PERMISSION_NO_PENDING_REQUESTS, scopeKey);
+        return;
+    }
+    const nextMetadata = {
+        pendingCount,
+        ...metadata,
+    };
+    const state = interactionManager.getSnapshot(scopeKey);
+    if (state?.kind === "permission") {
+        interactionManager.transition({
+            expectedInput: "callback",
+            metadata: nextMetadata,
+        }, scopeKey);
+        return;
+    }
+    interactionManager.start({
+        kind: "permission",
+        expectedInput: "callback",
+        metadata: nextMetadata,
+    }, scopeKey);
+}
+function isPermissionReply(value) {
+    return value === "once" || value === "always" || value === "reject";
+}
+function parsePermissionCallback(data) {
+    if (!data.startsWith(PERMISSION_CALLBACK.PREFIX)) {
+        return null;
+    }
+    const parts = data.split(PERMISSION_CALLBACK.SEPARATOR);
+    const action = parts[PERMISSION_CALLBACK.ACTION_INDEX] ?? "";
+    if (!isPermissionReply(action)) {
+        return null;
+    }
+    const payloadRequestID = parts[PERMISSION_CALLBACK.REQUEST_ID_INDEX] ?? "";
+    const requestIDFromPayload = payloadRequestID.length > 0 ? payloadRequestID : null;
+    return {
+        action,
+        requestIDFromPayload,
+    };
+}
+function resolvePermissionRequest(messageId, requestIDFromPayload, scopeKey) {
+    const requestByMessageId = permissionManager.getRequest(messageId, scopeKey);
+    if (requestByMessageId) {
+        return {
+            messageId,
+            request: requestByMessageId,
+        };
+    }
+    if (!requestIDFromPayload) {
+        return null;
+    }
+    const matchByID = permissionManager.getRequestByID(requestIDFromPayload, scopeKey);
+    if (!matchByID) {
+        return null;
+    }
+    return {
+        messageId: matchByID.messageId,
+        request: matchByID.request,
+    };
+}
+/**
+ * Handle permission callback from inline buttons
+ */
+export async function handlePermissionCallback(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data)
+        return false;
+    const parsedCallback = parsePermissionCallback(data);
+    if (!parsedCallback) {
+        return false;
+    }
+    logger.debug(`[PermissionHandler] Received callback: ${data}`);
+    const scopeKey = getScopeKeyFromContext(ctx);
+    if (!permissionManager.isActive(scopeKey)) {
+        clearPermissionInteraction(INTERACTION_CLEAR_REASON.PERMISSION_INACTIVE_CALLBACK, scopeKey);
+        await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const callbackMessageId = getCallbackMessageId(ctx);
+    const resolvedRequest = resolvePermissionRequest(callbackMessageId, parsedCallback.requestIDFromPayload, scopeKey);
+    if (!resolvedRequest) {
+        await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
+        return true;
+    }
+    try {
+        await handlePermissionReply(ctx, parsedCallback.action, resolvedRequest, scopeKey);
+    }
+    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, resolvedRequest, scopeKey) {
+    const { request, messageId: callbackMessageId } = resolvedRequest;
+    const requestID = request.id;
+    const currentProject = getCurrentProject(scopeKey);
+    const currentSession = getCurrentSession(scopeKey);
+    const cachedSession = getSessionById(request.sessionID);
+    const chatId = ctx.chat?.id;
+    const threadId = getScopeFromContext(ctx)?.threadId ?? null;
+    const directory = (currentSession?.id === request.sessionID ? currentSession.directory : null) ??
+        cachedSession?.directory ??
+        currentProject?.worktree;
+    if (!directory || !chatId) {
+        permissionManager.clear(scopeKey);
+        clearPermissionInteraction(INTERACTION_CLEAR_REASON.PERMISSION_INVALID_RUNTIME_CONTEXT, scopeKey);
+        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] });
+    // Stop typing indicator since we're responding
+    summaryAggregator.stopTypingIndicator(request.sessionID);
+    logger.info(`[PermissionHandler] Sending permission reply: ${reply}, requestID=${requestID}`);
+    const { error } = await opencodeClient.permission.reply({
+        requestID,
+        directory,
+        reply,
+    });
+    if (error) {
+        logger.error("[PermissionHandler] Failed to send permission reply:", error);
+        if (ctx.api) {
+            await ctx.api
+                .sendMessage(chatId, t("permission.send_reply_error"), getThreadSendOptions(threadId))
+                .catch(() => { });
+        }
+        return;
+    }
+    logger.info("[PermissionHandler] Permission reply sent successfully");
+    // Delete the permission message only after successful reply
+    await ctx.deleteMessage().catch(() => { });
+    permissionManager.removeByMessageId(callbackMessageId, scopeKey);
+    if (!permissionManager.isActive(scopeKey)) {
+        clearPermissionInteraction(INTERACTION_CLEAR_REASON.PERMISSION_REPLIED, scopeKey);
+        return;
+    }
+    syncPermissionInteractionState(scopeKey, {
+        lastRepliedRequestID: requestID,
+    });
+}
+/**
+ * Show permission request message with inline buttons
+ */
+export async function showPermissionRequest(bot, chatId, request, scopeKey, threadId) {
+    logger.debug(`[PermissionHandler] Showing permission request: ${request.permission}`);
+    const text = formatPermissionText(request);
+    const keyboard = buildPermissionKeyboard(request.id);
+    try {
+        const message = await sendMessageWithMarkdownFallback({
+            api: bot,
+            chatId,
+            text,
+            options: {
+                reply_markup: keyboard,
+                ...getThreadSendOptions(threadId),
+            },
+            parseMode: "Markdown",
+        });
+        logger.debug(`[PermissionHandler] Message sent, messageId=${message.message_id}`);
+        permissionManager.startPermission(request, message.message_id, scopeKey);
+        syncPermissionInteractionState(scopeKey, {
+            requestID: request.id,
+            messageId: message.message_id,
+        });
+        summaryAggregator.stopTypingIndicator(request.sessionID);
+    }
+    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) => {
+            // Escape backticks for Markdown code
+            const escapedPattern = pattern.replace(/`/g, "\\`");
+            text += `\`${escapedPattern}\`\n`;
+        });
+    }
+    return text;
+}
+/**
+ * Build inline keyboard with permission buttons
+ */
+function buildPermissionKeyboard(requestID) {
+    const keyboard = new InlineKeyboard();
+    keyboard
+        .text(t("permission.button.allow"), `${PERMISSION_CALLBACK.PREFIX}once${PERMISSION_CALLBACK.SEPARATOR}${requestID}`)
+        .row();
+    keyboard
+        .text(t("permission.button.always"), `${PERMISSION_CALLBACK.PREFIX}always${PERMISSION_CALLBACK.SEPARATOR}${requestID}`)
+        .row();
+    keyboard.text(t("permission.button.reject"), `${PERMISSION_CALLBACK.PREFIX}reject${PERMISSION_CALLBACK.SEPARATOR}${requestID}`);
+    return keyboard;
+}