opencode-telegram-group-topics-bot 0.11.2

package/dist/bot/commands/new.js

@@ -0,0 +1,247 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { classifyPromptSubmitError } from "../../opencode/prompt-submit-error.js";
+import { setCurrentSession } from "../../session/manager.js";
+import { ingestSessionInfoForCache } from "../../session/cache-manager.js";
+import { TOPIC_SESSION_STATUS, getCurrentProject, setCurrentAgent, setCurrentModel, setCurrentProject, } from "../../settings/manager.js";
+import { clearAllInteractionState } from "../../interaction/cleanup.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { keyboardManager } from "../../keyboard/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 { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { safeBackgroundTask } from "../../utils/safe-background-task.js";
+import { GENERAL_TOPIC_THREAD_ID, GLOBAL_SCOPE_KEY, SCOPE_CONTEXT, createScopeKeyFromParams, getScopeFromContext, getThreadSendOptions, isTopicScope, } from "../scope.js";
+import { TOPIC_COLORS } from "../../topic/colors.js";
+import { registerTopicSessionBinding } from "../../topic/manager.js";
+import { syncTopicTitleForSession } from "../../topic/title-sync.js";
+import { formatTopicTitle } from "../../topic/title-format.js";
+import { BOT_I18N_KEY, CHAT_TYPE, TELEGRAM_CHAT_FIELD, TELEGRAM_ERROR_MARKER, } from "../constants.js";
+import { INTERACTION_CLEAR_REASON } from "../../interaction/constants.js";
+import { buildTopicMessageLink } from "../utils/topic-link.js";
+const NEW_COMMAND_TOPIC_SYNC = {
+    TITLE_POLL_ATTEMPTS: 8,
+    TITLE_POLL_DELAY_MS: 2000,
+};
+function parseNewCommandPrompt(ctx) {
+    const text = ctx.message?.text ?? "";
+    const parts = text.trim().split(/\s+/);
+    if (parts.length <= 1) {
+        return "";
+    }
+    return parts.slice(1).join(" ");
+}
+function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function pollSessionTitleAndSyncTopic(ctx, sessionId, directory) {
+    for (let attempt = 0; attempt < NEW_COMMAND_TOPIC_SYNC.TITLE_POLL_ATTEMPTS; attempt++) {
+        await wait(NEW_COMMAND_TOPIC_SYNC.TITLE_POLL_DELAY_MS);
+        const { data, error } = await opencodeClient.session.get({
+            sessionID: sessionId,
+            directory,
+        });
+        if (error || !data?.title) {
+            continue;
+        }
+        try {
+            const synced = await syncTopicTitleForSession(ctx.api, sessionId, data.title);
+            if (synced) {
+                return;
+            }
+        }
+        catch (renameError) {
+            logger.debug("[Bot] Failed to sync topic title during /new polling", {
+                sessionId,
+                error: renameError,
+            });
+            return;
+        }
+    }
+}
+function isGeneralForumScope(ctx) {
+    const scope = getScopeFromContext(ctx);
+    const isForumEnabled = ctx.chat?.type === CHAT_TYPE.SUPERGROUP &&
+        Reflect.get(ctx.chat, TELEGRAM_CHAT_FIELD.IS_FORUM) === true;
+    return Boolean(isForumEnabled &&
+        scope?.context === SCOPE_CONTEXT.GROUP_GENERAL &&
+        (scope.threadId === null || scope.threadId === GENERAL_TOPIC_THREAD_ID));
+}
+function getErrorText(error) {
+    if (error instanceof Error) {
+        return error.message.toLowerCase();
+    }
+    const description = typeof error === "object" && error !== null ? Reflect.get(error, "description") : null;
+    if (typeof description === "string") {
+        return description.toLowerCase();
+    }
+    return String(error).toLowerCase();
+}
+export function createNewCommand(deps) {
+    return async function newCommand(ctx) {
+        try {
+            const scope = getScopeFromContext(ctx);
+            const scopeKey = scope?.key ?? GLOBAL_SCOPE_KEY;
+            if (isTopicScope(scope)) {
+                await ctx.reply(t(BOT_I18N_KEY.NEW_TOPIC_ONLY_IN_GENERAL));
+                return;
+            }
+            if (!isGeneralForumScope(ctx)) {
+                await ctx.reply(t(BOT_I18N_KEY.NEW_REQUIRES_FORUM_GENERAL));
+                return;
+            }
+            const currentProject = getCurrentProject(scopeKey);
+            if (!currentProject) {
+                await ctx.reply(t("new.project_not_selected"));
+                return;
+            }
+            logger.debug("[Bot] Creating new session for forum topic", {
+                scopeKey,
+                project: currentProject.worktree,
+            });
+            const { data: session, error } = await opencodeClient.session.create({
+                directory: currentProject.worktree,
+            });
+            if (error || !session) {
+                throw error || new Error("No data received from server");
+            }
+            const initialPrompt = parseNewCommandPrompt(ctx);
+            const topicTitle = formatTopicTitle(session.title, session.title);
+            const createdTopic = await ctx.api.createForumTopic(ctx.chat.id, topicTitle, {
+                icon_color: TOPIC_COLORS.BLUE,
+            });
+            const topicThreadId = createdTopic.message_thread_id;
+            const topicScopeKey = createScopeKeyFromParams({
+                chatId: ctx.chat.id,
+                threadId: topicThreadId,
+                context: SCOPE_CONTEXT.GROUP_TOPIC,
+            });
+            const sessionInfo = {
+                id: session.id,
+                title: session.title,
+                directory: currentProject.worktree,
+            };
+            setCurrentProject(currentProject, topicScopeKey);
+            setCurrentSession(sessionInfo, topicScopeKey);
+            setCurrentAgent(getStoredAgent(scopeKey), topicScopeKey);
+            setCurrentModel(getStoredModel(scopeKey), topicScopeKey);
+            registerTopicSessionBinding({
+                scopeKey: topicScopeKey,
+                chatId: ctx.chat.id,
+                threadId: topicThreadId,
+                sessionId: session.id,
+                projectId: currentProject.id,
+                projectWorktree: currentProject.worktree,
+                topicName: topicTitle,
+                status: TOPIC_SESSION_STATUS.ACTIVE,
+            });
+            await deps.ensureEventSubscription(currentProject.worktree);
+            summaryAggregator.setSession(session.id);
+            clearAllInteractionState(INTERACTION_CLEAR_REASON.SESSION_CREATED, topicScopeKey);
+            await ingestSessionInfoForCache(session);
+            if (!pinnedMessageManager.isInitialized(topicScopeKey)) {
+                pinnedMessageManager.initialize(ctx.api, ctx.chat.id, topicScopeKey, topicThreadId);
+            }
+            keyboardManager.initialize(ctx.api, ctx.chat.id, topicScopeKey);
+            try {
+                await pinnedMessageManager.onSessionChange(session.id, session.title, topicScopeKey);
+            }
+            catch (errorOnPinned) {
+                logger.error("[Bot] Error creating pinned message for new topic", errorOnPinned);
+            }
+            if (pinnedMessageManager.getContextLimit(topicScopeKey) === 0) {
+                await pinnedMessageManager.refreshContextLimit(topicScopeKey);
+            }
+            const currentAgent = getStoredAgent(topicScopeKey);
+            const currentModel = getStoredModel(topicScopeKey);
+            const contextInfo = pinnedMessageManager.getContextInfo(topicScopeKey) ??
+                keyboardManager.getContextInfo(topicScopeKey) ??
+                (pinnedMessageManager.getContextLimit(topicScopeKey) > 0
+                    ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit(topicScopeKey) }
+                    : null);
+            const variantName = formatVariantForButton(currentModel.variant || "default");
+            const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo ?? undefined, variantName);
+            const topicReadyMessage = await ctx.api.sendMessage(ctx.chat.id, t(BOT_I18N_KEY.NEW_TOPIC_CREATED, { title: session.title }), {
+                ...getThreadSendOptions(topicThreadId),
+                reply_markup: keyboard,
+            });
+            const topicMessageLink = buildTopicMessageLink(ctx.chat, topicReadyMessage.message_id);
+            const generalReplyText = topicMessageLink
+                ? `${t(BOT_I18N_KEY.NEW_GENERAL_CREATED)}\n${t(BOT_I18N_KEY.NEW_GENERAL_OPEN_LINK, { url: topicMessageLink })}`
+                : t(BOT_I18N_KEY.NEW_TOPIC_CREATE_ERROR);
+            await ctx.reply(generalReplyText, getThreadSendOptions(scope?.threadId ?? null));
+            if (initialPrompt.length > 0) {
+                const promptModel = getStoredModel(topicScopeKey);
+                const promptAgent = getStoredAgent(topicScopeKey);
+                const promptOptions = {
+                    sessionID: session.id,
+                    directory: currentProject.worktree,
+                    parts: [{ type: "text", text: initialPrompt }],
+                    agent: promptAgent,
+                };
+                if (promptModel.providerID && promptModel.modelID) {
+                    promptOptions.model = {
+                        providerID: promptModel.providerID,
+                        modelID: promptModel.modelID,
+                    };
+                    if (promptModel.variant) {
+                        promptOptions.variant = promptModel.variant;
+                    }
+                }
+                safeBackgroundTask({
+                    taskName: "new.session.promptAsync",
+                    task: () => opencodeClient.session.promptAsync(promptOptions),
+                    onSuccess: async ({ error: promptError }) => {
+                        if (!promptError) {
+                            return;
+                        }
+                        const errorType = classifyPromptSubmitError(promptError);
+                        const errorMessageKey = errorType === "busy"
+                            ? "bot.session_busy"
+                            : errorType === "session_not_found"
+                                ? "bot.prompt_send_error_session_not_found"
+                                : "bot.prompt_send_error";
+                        logger.error("[Bot] OpenCode API returned an error for /new promptAsync", {
+                            sessionId: session.id,
+                            promptError,
+                        });
+                        await ctx.api.sendMessage(ctx.chat.id, t(errorMessageKey), {
+                            ...getThreadSendOptions(topicThreadId),
+                        });
+                    },
+                    onError: async (promptError) => {
+                        const errorType = classifyPromptSubmitError(promptError);
+                        const errorMessageKey = errorType === "busy"
+                            ? "bot.session_busy"
+                            : errorType === "session_not_found"
+                                ? "bot.prompt_send_error_session_not_found"
+                                : "bot.prompt_send_error";
+                        logger.error("[Bot] Failed to send promptAsync from /new", {
+                            sessionId: session.id,
+                            promptError,
+                        });
+                        await ctx.api.sendMessage(ctx.chat.id, t(errorMessageKey), {
+                            ...getThreadSendOptions(topicThreadId),
+                        });
+                    },
+                });
+                safeBackgroundTask({
+                    taskName: "new.session.topic_title_sync",
+                    task: () => pollSessionTitleAndSyncTopic(ctx, session.id, currentProject.worktree),
+                });
+            }
+        }
+        catch (error) {
+            logger.error("[Bot] Error creating session/topic", error);
+            const errorText = getErrorText(error);
+            if (errorText.includes(TELEGRAM_ERROR_MARKER.NOT_ENOUGH_RIGHTS_CREATE_TOPIC)) {
+                await ctx.reply(t(BOT_I18N_KEY.NEW_TOPIC_CREATE_NO_RIGHTS));
+                return;
+            }
+            await ctx.reply(t(BOT_I18N_KEY.NEW_TOPIC_CREATE_ERROR));
+        }
+    };
+}

package/dist/bot/commands/opencode-start.js

@@ -0,0 +1,85 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { processManager } from "../../process/manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+/**
+ * Wait for OpenCode server to become ready by polling health endpoint
+ * @param maxWaitMs Maximum time to wait in milliseconds
+ * @returns true if server became ready, false if timeout
+ */
+async function waitForServerReady(maxWaitMs = 10000) {
+    const startTime = Date.now();
+    const pollInterval = 500;
+    while (Date.now() - startTime < maxWaitMs) {
+        try {
+            const { data, error } = await opencodeClient.global.health();
+            if (!error && data?.healthy) {
+                return true;
+            }
+        }
+        catch {
+            // Server not ready yet
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    return false;
+}
+/**
+ * Command handler for /opencode-start
+ * Starts the OpenCode server process
+ */
+export async function opencodeStartCommand(ctx) {
+    try {
+        // 1. Check if process is already running under our management
+        if (processManager.isRunning()) {
+            const uptime = processManager.getUptime();
+            const uptimeStr = uptime ? Math.floor(uptime / 1000) : 0;
+            await ctx.reply(t("opencode_start.already_running_managed", {
+                pid: processManager.getPID() ?? "-",
+                seconds: uptimeStr,
+            }));
+            return;
+        }
+        // 2. Check if server is accessible (external process)
+        try {
+            const { data, error } = await opencodeClient.global.health();
+            if (!error && data?.healthy) {
+                await ctx.reply(t("opencode_start.already_running_external", {
+                    version: data.version || t("common.unknown"),
+                }));
+                return;
+            }
+        }
+        catch {
+            // Server not accessible, continue with start
+        }
+        // 3. Notify user that we're starting the server
+        const statusMessage = await ctx.reply(t("opencode_start.starting"));
+        // 4. Start the process
+        const { success, error } = await processManager.start();
+        if (!success) {
+            await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("opencode_start.start_error", { error: error || t("common.unknown_error") }), { parse_mode: "Markdown" });
+            return;
+        }
+        // 5. Wait for server to become ready
+        logger.info("[Bot] Waiting for OpenCode server to become ready...");
+        const ready = await waitForServerReady(10000);
+        if (!ready) {
+            await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("opencode_start.started_not_ready", {
+                pid: processManager.getPID() ?? "-",
+            }));
+            return;
+        }
+        // 6. Get server version and send success message
+        const { data: health } = await opencodeClient.global.health();
+        await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("opencode_start.success", {
+            pid: processManager.getPID() ?? "-",
+            version: health?.version || t("common.unknown"),
+        }));
+        logger.info(`[Bot] OpenCode server started successfully, PID=${processManager.getPID()}`);
+    }
+    catch (err) {
+        logger.error("[Bot] Error in /opencode-start command:", err);
+        await ctx.reply(t("opencode_start.error"));
+    }
+}

package/dist/bot/commands/opencode-stop.js

@@ -0,0 +1,44 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { processManager } from "../../process/manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+/**
+ * Command handler for /opencode-stop
+ * Stops the OpenCode server process
+ */
+export async function opencodeStopCommand(ctx) {
+    try {
+        // 1. Check if process is running under our management
+        if (!processManager.isRunning()) {
+            // Check if there's an external server running
+            try {
+                const { data, error } = await opencodeClient.global.health();
+                if (!error && data?.healthy) {
+                    await ctx.reply(t("opencode_stop.external_running"));
+                    return;
+                }
+            }
+            catch {
+                // Server not accessible
+            }
+            await ctx.reply(t("opencode_stop.not_running"));
+            return;
+        }
+        // 2. Notify user that we're stopping the server
+        const pid = processManager.getPID();
+        const statusMessage = await ctx.reply(t("opencode_stop.stopping", { pid: pid ?? "-" }));
+        // 3. Stop the process
+        const { success, error } = await processManager.stop(5000);
+        if (!success) {
+            await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("opencode_stop.stop_error", { error: error || t("common.unknown_error") }));
+            return;
+        }
+        // 4. Success - process has been stopped
+        await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("opencode_stop.success"));
+        logger.info("[Bot] OpenCode server stopped successfully");
+    }
+    catch (err) {
+        logger.error("[Bot] Error in /opencode-stop command:", err);
+        await ctx.reply(t("opencode_stop.error"));
+    }
+}

package/dist/bot/commands/projects.js

@@ -0,0 +1,304 @@
+import { InlineKeyboard } from "grammy";
+import { setCurrentProject, getCurrentProject } from "../../settings/manager.js";
+import { getProjects } from "../../project/manager.js";
+import { syncSessionDirectoryCache } from "../../session/cache-manager.js";
+import { clearSession } from "../../session/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { getStoredAgent } from "../../agent/manager.js";
+import { getStoredModel } from "../../model/manager.js";
+import { formatVariantForButton } from "../../variant/manager.js";
+import { clearAllInteractionState } from "../../interaction/cleanup.js";
+import { INTERACTION_CLEAR_REASON } from "../../interaction/constants.js";
+import { createMainKeyboard } from "../utils/keyboard.js";
+import { appendInlineMenuCancelButton, ensureActiveInlineMenu, replyWithInlineMenu, } from "../handlers/inline-menu.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { config } from "../../config.js";
+import { GLOBAL_SCOPE_KEY, SCOPE_CONTEXT, getScopeFromContext, getScopeFromKey, getScopeKeyFromContext, getThreadSendOptions, } from "../scope.js";
+import { getTopicBindingsByChat } from "../../topic/manager.js";
+import { BOT_I18N_KEY, TELEGRAM_CHAT_FIELD } from "../constants.js";
+const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+const PROJECT_PAGE_CALLBACK_PREFIX = "projects:page:";
+const PROJECT_SELECT_CALLBACK_PREFIX = "project:";
+function formatProjectButtonLabel(label, isActive) {
+    const prefix = isActive ? "✅ " : "";
+    const availableLength = MAX_INLINE_BUTTON_LABEL_LENGTH - prefix.length;
+    if (label.length <= availableLength) {
+        return `${prefix}${label}`;
+    }
+    return `${prefix}${label.slice(0, Math.max(0, availableLength - 3))}...`;
+}
+export function getProjectFolderName(worktree) {
+    const normalized = worktree.replace(/[\\/]+$/g, "");
+    if (!normalized) {
+        return worktree;
+    }
+    const segments = normalized.split(/[\\/]/).filter(Boolean);
+    return segments.at(-1) ?? normalized;
+}
+export function buildProjectButtonLabel(index, worktree) {
+    const folderName = getProjectFolderName(worktree);
+    return `${index + 1}. ${folderName} [${worktree}]`;
+}
+export function parseProjectPageCallback(data) {
+    if (!data.startsWith(PROJECT_PAGE_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const rawPage = data.slice(PROJECT_PAGE_CALLBACK_PREFIX.length);
+    if (!/^\d+$/.test(rawPage)) {
+        return null;
+    }
+    return Number.parseInt(rawPage, 10);
+}
+export function calculateProjectsPaginationRange(totalProjects, page, pageSize) {
+    const safePageSize = Math.max(1, pageSize);
+    const totalPages = Math.max(1, Math.ceil(totalProjects / safePageSize));
+    const normalizedPage = Math.min(Math.max(0, page), totalPages - 1);
+    const startIndex = normalizedPage * safePageSize;
+    const endIndex = Math.min(startIndex + safePageSize, totalProjects);
+    return {
+        page: normalizedPage,
+        totalPages,
+        startIndex,
+        endIndex,
+    };
+}
+function buildProjectsMenuText(currentProjectName, page, totalPages) {
+    const baseText = currentProjectName
+        ? t("projects.select_with_current", {
+            project: currentProjectName,
+        })
+        : t("projects.select");
+    if (totalPages <= 1) {
+        return baseText;
+    }
+    return `${baseText}\n\n${t("projects.page_indicator", {
+        current: String(page + 1),
+        total: String(totalPages),
+    })}`;
+}
+function buildProjectsKeyboard(projects, page, scopeKey) {
+    const keyboard = new InlineKeyboard();
+    const currentProject = getCurrentProject(scopeKey);
+    const pageSize = config.bot.projectsListLimit;
+    const { page: normalizedPage, totalPages, startIndex, endIndex, } = calculateProjectsPaginationRange(projects.length, page, pageSize);
+    projects.slice(startIndex, endIndex).forEach((project, index) => {
+        const isActive = currentProject &&
+            (project.id === currentProject.id || project.worktree === currentProject.worktree);
+        const label = buildProjectButtonLabel(startIndex + index, project.worktree);
+        const labelWithCheck = formatProjectButtonLabel(label, Boolean(isActive));
+        keyboard.text(labelWithCheck, `project:${project.id}`).row();
+    });
+    if (totalPages > 1) {
+        if (normalizedPage > 0) {
+            keyboard.text(t("projects.prev_page"), `${PROJECT_PAGE_CALLBACK_PREFIX}${normalizedPage - 1}`);
+        }
+        if (normalizedPage < totalPages - 1) {
+            keyboard.text(t("projects.next_page"), `${PROJECT_PAGE_CALLBACK_PREFIX}${normalizedPage + 1}`);
+        }
+    }
+    return keyboard;
+}
+function buildProjectsMenuView(projects, page, scopeKey) {
+    const currentProject = getCurrentProject(scopeKey);
+    const pageSize = config.bot.projectsListLimit;
+    const { page: normalizedPage, totalPages } = calculateProjectsPaginationRange(projects.length, page, pageSize);
+    const currentProjectName = currentProject?.name || currentProject?.worktree || null;
+    return {
+        text: buildProjectsMenuText(currentProjectName, normalizedPage, totalPages),
+        keyboard: buildProjectsKeyboard(projects, normalizedPage, scopeKey),
+    };
+}
+function clearInteractionWithScope(reason, scopeKey) {
+    if (scopeKey === GLOBAL_SCOPE_KEY) {
+        clearAllInteractionState(reason);
+        return;
+    }
+    clearAllInteractionState(reason, scopeKey);
+}
+function getConfiguredProjectName(scopeKey, chatId) {
+    const currentProject = getCurrentProject(scopeKey);
+    if (currentProject?.name) {
+        return currentProject.name;
+    }
+    if (currentProject?.worktree) {
+        return currentProject.worktree;
+    }
+    const topicBinding = getTopicBindingsByChat(chatId).find((binding) => Boolean(binding.projectWorktree));
+    return topicBinding?.projectWorktree ?? t("pinned.unknown");
+}
+function getProjectLockState(ctx, scopeKey) {
+    if (!ctx.chat) {
+        return { locked: false };
+    }
+    const scope = getScopeFromContext(ctx);
+    if (scope?.context === SCOPE_CONTEXT.GROUP_TOPIC) {
+        return {
+            locked: true,
+            messageKey: BOT_I18N_KEY.PROJECTS_LOCKED_TOPIC_SCOPE,
+        };
+    }
+    const isForumEnabled = Reflect.get(ctx.chat, TELEGRAM_CHAT_FIELD.IS_FORUM) === true;
+    if (!isForumEnabled) {
+        return { locked: false };
+    }
+    const hasTopicBindings = getTopicBindingsByChat(ctx.chat.id).length > 0;
+    if (!hasTopicBindings) {
+        return { locked: false };
+    }
+    return {
+        locked: true,
+        messageKey: BOT_I18N_KEY.PROJECTS_LOCKED_GROUP_PROJECT,
+        projectName: getConfiguredProjectName(scopeKey, ctx.chat.id),
+    };
+}
+export async function projectsCommand(ctx) {
+    try {
+        const scopeKey = getScopeKeyFromContext(ctx);
+        const lockState = getProjectLockState(ctx, scopeKey);
+        if (lockState.locked) {
+            const message = lockState.messageKey === BOT_I18N_KEY.PROJECTS_LOCKED_GROUP_PROJECT
+                ? t(BOT_I18N_KEY.PROJECTS_LOCKED_GROUP_PROJECT, {
+                    project: lockState.projectName ?? t("pinned.unknown"),
+                })
+                : t(BOT_I18N_KEY.PROJECTS_LOCKED_TOPIC_SCOPE);
+            await ctx.reply(message, getThreadSendOptions(getScopeFromContext(ctx)?.threadId ?? null));
+            return;
+        }
+        await syncSessionDirectoryCache();
+        const projects = await getProjects();
+        if (projects.length === 0) {
+            await ctx.reply(t("projects.empty"));
+            return;
+        }
+        const { text, keyboard } = buildProjectsMenuView(projects, 0, scopeKey);
+        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) {
+    const scopeKey = getScopeKeyFromContext(ctx);
+    const usePinned = ctx.chat?.type !== "private";
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data) {
+        return false;
+    }
+    const page = parseProjectPageCallback(callbackQuery.data);
+    if (page !== null) {
+        const lockState = getProjectLockState(ctx, scopeKey);
+        if (lockState.locked) {
+            await ctx.answerCallbackQuery({
+                text: t(BOT_I18N_KEY.PROJECTS_LOCKED_CALLBACK),
+                show_alert: true,
+            });
+            return true;
+        }
+        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 } = buildProjectsMenuView(projects, page, scopeKey);
+            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;
+    }
+    if (!callbackQuery.data.startsWith(PROJECT_SELECT_CALLBACK_PREFIX)) {
+        return false;
+    }
+    const lockState = getProjectLockState(ctx, scopeKey);
+    if (lockState.locked) {
+        await ctx.answerCallbackQuery({
+            text: t(BOT_I18N_KEY.PROJECTS_LOCKED_CALLBACK),
+            show_alert: true,
+        });
+        return true;
+    }
+    const projectId = callbackQuery.data.replace(PROJECT_SELECT_CALLBACK_PREFIX, "");
+    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`);
+        }
+        logger.info(`[Bot] Project selected: ${selectedProject.name || selectedProject.worktree} (id: ${projectId})`);
+        setCurrentProject(selectedProject, scopeKey);
+        clearSession(scopeKey);
+        clearInteractionWithScope(INTERACTION_CLEAR_REASON.PROJECT_SWITCHED, scopeKey);
+        // Clear pinned message when switching projects
+        if (usePinned) {
+            try {
+                await pinnedMessageManager.clear(scopeKey);
+            }
+            catch (err) {
+                logger.error("[Bot] Error clearing pinned message:", err);
+            }
+        }
+        // Initialize keyboard manager if not already
+        if (ctx.chat) {
+            keyboardManager.initialize(ctx.api, ctx.chat.id, scopeKey);
+        }
+        // Refresh context limit for current model
+        if (usePinned) {
+            await pinnedMessageManager.refreshContextLimit(scopeKey);
+        }
+        const contextLimit = usePinned ? pinnedMessageManager.getContextLimit(scopeKey) : 0;
+        // Reset context to 0 (no session selected) with current model's limit
+        if (contextLimit > 0) {
+            keyboardManager.updateContext(0, contextLimit, scopeKey);
+        }
+        else {
+            keyboardManager.clearContext(scopeKey);
+        }
+        // Get current state for keyboard (with context = 0)
+        const currentAgent = getStoredAgent(scopeKey);
+        const currentModel = getStoredModel(scopeKey);
+        const contextInfo = { tokensUsed: 0, tokensLimit: contextLimit };
+        const variantName = formatVariantForButton(currentModel.variant || "default");
+        const scope = getScopeFromKey(scopeKey);
+        const scopedKeyboard = createMainKeyboard(currentAgent, currentModel, contextInfo, variantName, scope?.context === SCOPE_CONTEXT.GROUP_GENERAL
+            ? {
+                contextFirst: true,
+                contextLabel: t("keyboard.general_defaults"),
+            }
+            : undefined);
+        const projectName = selectedProject.name || selectedProject.worktree;
+        await ctx.answerCallbackQuery();
+        await ctx.reply(t("projects.selected", { project: projectName }), {
+            reply_markup: scopedKeyboard,
+        });
+        await ctx.deleteMessage();
+    }
+    catch (error) {
+        clearInteractionWithScope(INTERACTION_CLEAR_REASON.PROJECT_SELECT_ERROR, scopeKey);
+        logger.error("[Bot] Error selecting project:", error);
+        await ctx.answerCallbackQuery();
+        await ctx.reply(t("projects.select_error"));
+    }
+    return true;
+}