@grinev/opencode-telegram-bot 0.21.1 → 0.22.0

package/dist/bot/commands/open.js

@@ -1,319 +0,0 @@
-import { InlineKeyboard } from "grammy";
-import path from "node:path";
-import { appendInlineMenuCancelButton, ensureActiveInlineMenu } from "../handlers/inline-menu.js";
-import { interactionManager } from "../../interaction/manager.js";
-import { isForegroundBusy, replyBusyBlocked } from "../utils/busy-guard.js";
-import { pathToDisplayPath, scanDirectory, buildEntryLabel, buildTreeHeader, isScanError, MAX_ENTRIES_PER_PAGE, } from "../utils/file-tree.js";
-import { getBrowserRoots, isWithinAllowedRoot, isAllowedRoot } from "../utils/browser-roots.js";
-import { upsertSessionDirectory } from "../../session/cache-manager.js";
-import { getProjectByWorktree } from "../../project/manager.js";
-import { switchToProject } from "../utils/switch-project.js";
-import { logger } from "../../utils/logger.js";
-import { t } from "../../i18n/index.js";
-const CALLBACK_PREFIX = "open:";
-const CALLBACK_NAV_PREFIX = "open:nav:";
-const CALLBACK_SELECT_PREFIX = "open:sel:";
-const CALLBACK_PAGE_PREFIX = "open:pg:";
-const CALLBACK_ROOTS = "open:roots";
-const MAX_BUTTON_LABEL_LENGTH = 64;
-/**
- * Separator used inside pagination callback data between the encoded path
- * reference and the page number. We avoid `:` because it appears in Windows
- * drive letters (e.g. `C:\`) and is already used as a prefix delimiter.
- */
-const PAGE_SEPARATOR = "|";
-function truncateLabel(label, maxLen = MAX_BUTTON_LABEL_LENGTH) {
-    if (label.length <= maxLen) {
-        return label;
-    }
-    return label.slice(0, Math.max(0, maxLen - 3)) + "...";
-}
-/**
- * Encode a path into callback data. Telegram limits callback_data to 64 bytes.
- * Long absolute paths can exceed this, so we encode them as a compact index
- * when necessary. The index is stored in a module-level map that lives for the
- * duration of the current inline menu interaction.
- */
-const pathIndex = new Map();
-let pathCounter = 0;
-/** Clear the path index. Exported so it can be called on menu cancel/cleanup. */
-export function clearOpenPathIndex() {
-    pathIndex.clear();
-    pathCounter = 0;
-}
-/**
- * @param prefix   Callback-data prefix that precedes the path.
- * @param fullPath Absolute path to encode.
- * @param reserveBytes Extra bytes to reserve for a suffix that will be
- *   appended *after* the returned value (e.g. the page separator + digits in
- *   pagination callbacks). The total callback_data must stay ≤ 64 bytes.
- */
-function encodePathForCallback(prefix, fullPath, reserveBytes = 0) {
-    const naive = `${prefix}${fullPath}`;
-    if (Buffer.byteLength(naive, "utf-8") + reserveBytes <= 64) {
-        return naive;
-    }
-    // Use a short numeric key instead
-    const key = `#${pathCounter++}`;
-    pathIndex.set(key, fullPath);
-    return `${prefix}${key}`;
-}
-function decodePathFromCallback(prefix, data) {
-    if (!data.startsWith(prefix)) {
-        return null;
-    }
-    const raw = data.slice(prefix.length);
-    if (raw.startsWith("#")) {
-        return pathIndex.get(raw) ?? null;
-    }
-    return raw;
-}
-/**
- * Encode a pagination callback. The path part goes through the same 64-byte
- * safe encoding used by nav/select callbacks, followed by a separator and
- * the page number.
- *
- * We reserve bytes for the page suffix so the 64-byte check inside
- * `encodePathForCallback` accounts for the complete final callback length.
- */
-function encodePaginationCallback(currentPath, page) {
-    const pageSuffix = `${PAGE_SEPARATOR}${page}`;
-    const reserveBytes = Buffer.byteLength(pageSuffix, "utf-8");
-    const pathRef = encodePathForCallback(CALLBACK_PAGE_PREFIX, currentPath, reserveBytes);
-    return `${pathRef}${pageSuffix}`;
-}
-/**
- * Decode a pagination callback into { path, page } or null on failure.
- */
-function decodePaginationCallback(data) {
-    if (!data.startsWith(CALLBACK_PAGE_PREFIX)) {
-        return null;
-    }
-    const payload = data.slice(CALLBACK_PAGE_PREFIX.length);
-    const sepIndex = payload.lastIndexOf(PAGE_SEPARATOR);
-    if (sepIndex < 0) {
-        return null;
-    }
-    const pathRef = payload.slice(0, sepIndex);
-    const pageNum = Number.parseInt(payload.slice(sepIndex + 1), 10);
-    if (Number.isNaN(pageNum)) {
-        return null;
-    }
-    // Resolve indexed path references
-    const resolvedPath = pathRef.startsWith("#") ? (pathIndex.get(pathRef) ?? null) : pathRef;
-    if (resolvedPath === null) {
-        return null;
-    }
-    return { path: resolvedPath, page: pageNum };
-}
-function buildBrowseKeyboard(entries, currentPath, hasParent, page, totalCount) {
-    const keyboard = new InlineKeyboard();
-    const totalPages = Math.max(1, Math.ceil(totalCount / MAX_ENTRIES_PER_PAGE));
-    // Directory entries
-    for (const entry of entries) {
-        const label = truncateLabel(buildEntryLabel(entry));
-        keyboard.text(label, encodePathForCallback(CALLBACK_NAV_PREFIX, entry.fullPath)).row();
-    }
-    // Navigation: Up + Back to roots
-    // Suppress "Up" when at an allowed root (don't let user navigate above it)
-    const atRoot = isAllowedRoot(currentPath);
-    const showUp = hasParent && !atRoot;
-    const roots = getBrowserRoots();
-    const showRoots = roots.length > 1;
-    if (showUp || showRoots) {
-        if (showUp) {
-            const parentPath = path.dirname(currentPath);
-            keyboard.text(t("open.back"), encodePathForCallback(CALLBACK_NAV_PREFIX, parentPath));
-        }
-        if (showRoots) {
-            keyboard.text(t("open.roots"), CALLBACK_ROOTS);
-        }
-        keyboard.row();
-    }
-    // Pagination
-    if (totalPages > 1) {
-        if (page > 0) {
-            keyboard.text(t("open.prev_page"), encodePaginationCallback(currentPath, page - 1));
-        }
-        if (page < totalPages - 1) {
-            keyboard.text(t("open.next_page"), encodePaginationCallback(currentPath, page + 1));
-        }
-        keyboard.row();
-    }
-    // Select current folder
-    keyboard
-        .text(t("open.select_current"), encodePathForCallback(CALLBACK_SELECT_PREFIX, currentPath))
-        .row();
-    // Cancel
-    appendInlineMenuCancelButton(keyboard, "open");
-    return keyboard;
-}
-async function renderBrowseView(dirPath, page = 0) {
-    const result = await scanDirectory(dirPath, page);
-    if (isScanError(result)) {
-        return { error: result.error };
-    }
-    const { entries, totalCount, page: clampedPage, currentPath, displayPath, hasParent } = result;
-    const totalPages = Math.max(1, Math.ceil(totalCount / MAX_ENTRIES_PER_PAGE));
-    const header = buildTreeHeader(displayPath, totalCount, clampedPage, totalPages);
-    const keyboard = buildBrowseKeyboard(entries, currentPath, hasParent, clampedPage, totalCount);
-    return { text: header, keyboard };
-}
-function buildRootsKeyboard() {
-    const keyboard = new InlineKeyboard();
-    const roots = getBrowserRoots();
-    for (const root of roots) {
-        const label = truncateLabel(`📂 ${pathToDisplayPath(root)}`);
-        keyboard.text(label, encodePathForCallback(CALLBACK_NAV_PREFIX, root)).row();
-    }
-    appendInlineMenuCancelButton(keyboard, "open");
-    return keyboard;
-}
-export async function openCommand(ctx) {
-    try {
-        if (isForegroundBusy()) {
-            await replyBusyBlocked(ctx);
-            return;
-        }
-        // Reset path index for new interaction
-        clearOpenPathIndex();
-        const roots = getBrowserRoots();
-        let text;
-        let keyboard;
-        if (roots.length === 1) {
-            // Single root — navigate directly into it
-            const view = await renderBrowseView(roots[0]);
-            if ("error" in view) {
-                await ctx.reply(t("open.scan_error", { error: view.error }));
-                return;
-            }
-            text = view.text;
-            keyboard = view.keyboard;
-        }
-        else {
-            // Multiple roots — show root selection
-            text = t("open.select_root");
-            keyboard = buildRootsKeyboard();
-        }
-        const message = await ctx.reply(text, { reply_markup: keyboard });
-        interactionManager.start({
-            kind: "inline",
-            expectedInput: "callback",
-            metadata: {
-                menuKind: "open",
-                messageId: message.message_id,
-            },
-        });
-    }
-    catch (error) {
-        logger.error("[Bot] Error opening directory browser:", error);
-        await ctx.reply(t("open.open_error"));
-    }
-}
-export async function handleOpenCallback(ctx, deps = {}) {
-    const data = ctx.callbackQuery?.data;
-    if (!data || !data.startsWith(CALLBACK_PREFIX)) {
-        return false;
-    }
-    if (isForegroundBusy()) {
-        await replyBusyBlocked(ctx);
-        return true;
-    }
-    const isActiveMenu = await ensureActiveInlineMenu(ctx, "open");
-    if (!isActiveMenu) {
-        return true;
-    }
-    try {
-        // Back to root selection (multi-root mode)
-        if (data === CALLBACK_ROOTS) {
-            await showRoots(ctx);
-            return true;
-        }
-        // Navigate into a directory (including "up")
-        const navPath = decodePathFromCallback(CALLBACK_NAV_PREFIX, data);
-        if (navPath !== null) {
-            if (!isWithinAllowedRoot(navPath)) {
-                await ctx.answerCallbackQuery({ text: t("open.access_denied") });
-                return true;
-            }
-            await navigateTo(ctx, navPath);
-            return true;
-        }
-        // Pagination
-        const pageInfo = decodePaginationCallback(data);
-        if (pageInfo !== null) {
-            if (!isWithinAllowedRoot(pageInfo.path)) {
-                await ctx.answerCallbackQuery({ text: t("open.access_denied") });
-                return true;
-            }
-            await navigateTo(ctx, pageInfo.path, pageInfo.page);
-            return true;
-        }
-        // Select directory as project
-        const selectPath = decodePathFromCallback(CALLBACK_SELECT_PREFIX, data);
-        if (selectPath !== null) {
-            if (!isWithinAllowedRoot(selectPath)) {
-                await ctx.answerCallbackQuery({ text: t("open.access_denied") });
-                return true;
-            }
-            await selectDirectory(ctx, selectPath, deps);
-            return true;
-        }
-        return false;
-    }
-    catch (error) {
-        logger.error("[Bot] Error handling open callback:", error);
-        await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
-        return true;
-    }
-}
-async function showRoots(ctx) {
-    const text = t("open.select_root");
-    const keyboard = buildRootsKeyboard();
-    await ctx.answerCallbackQuery();
-    await ctx.editMessageText(text, { reply_markup: keyboard });
-}
-async function navigateTo(ctx, dirPath, page = 0) {
-    const view = await renderBrowseView(dirPath, page);
-    if ("error" in view) {
-        await ctx.answerCallbackQuery({ text: view.error });
-        return;
-    }
-    await ctx.answerCallbackQuery();
-    await ctx.editMessageText(view.text, {
-        reply_markup: view.keyboard,
-    });
-}
-async function selectDirectory(ctx, directory, deps = {}) {
-    const displayPath = pathToDisplayPath(directory);
-    try {
-        logger.info(`[Bot] Adding project directory: ${directory}`);
-        // Register directory in the session cache first — getProjectByWorktree
-        // needs the entry to exist so it can resolve the project. If the
-        // subsequent switch fails, the entry stays in the cache, which is
-        // acceptable: it's a real directory the user explicitly selected and
-        // will simply appear in /projects for retry.
-        await upsertSessionDirectory(directory, Date.now());
-        const projectInfo = await getProjectByWorktree(directory);
-        const selectedProjectInfo = { ...projectInfo, name: displayPath };
-        const replyKeyboard = deps.ensureEventSubscription
-            ? await switchToProject(ctx, selectedProjectInfo, "open_project_selected", {
-                ensureEventSubscription: deps.ensureEventSubscription,
-            })
-            : await switchToProject(ctx, selectedProjectInfo, "open_project_selected");
-        await ctx.answerCallbackQuery();
-        await ctx.reply(t("open.selected", { project: displayPath }), {
-            reply_markup: replyKeyboard,
-        });
-        // Clean up the inline menu message
-        await ctx.deleteMessage();
-        // Clear path index after selection
-        clearOpenPathIndex();
-        logger.info(`[Bot] Project added and selected: ${displayPath}`);
-    }
-    catch (error) {
-        logger.error("[Bot] Error selecting directory:", error);
-        await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
-        await ctx.reply(t("open.select_error"));
-    }
-}

package/dist/bot/commands/tts.js

@@ -1,13 +0,0 @@
-import { isTtsConfigured } from "../../tts/client.js";
-import { isTtsEnabled, setTtsEnabled } from "../../settings/manager.js";
-import { t } from "../../i18n/index.js";
-export async function ttsCommand(ctx) {
-    const enabled = !isTtsEnabled();
-    if (enabled && !isTtsConfigured()) {
-        await ctx.reply(t("tts.not_configured"));
-        return;
-    }
-    setTtsEnabled(enabled);
-    const message = enabled ? t("tts.enabled") : t("tts.disabled");
-    await ctx.reply(message);
-}

package/dist/bot/commands/worktree.js

@@ -1,201 +0,0 @@
-import { InlineKeyboard } from "grammy";
-import { config } from "../../config.js";
-import { getGitWorktreeContext } from "../../git/worktree.js";
-import { clearAllInteractionState } from "../../interaction/cleanup.js";
-import { getProjectByWorktree } from "../../project/manager.js";
-import { upsertSessionDirectory } from "../../session/cache-manager.js";
-import { getCurrentProject } from "../../settings/manager.js";
-import { logger } from "../../utils/logger.js";
-import { t } from "../../i18n/index.js";
-import { appendInlineMenuCancelButton, ensureActiveInlineMenu, replyWithInlineMenu, } from "../handlers/inline-menu.js";
-import { switchToProject } from "../utils/switch-project.js";
-import { isForegroundBusy, replyBusyBlocked } from "../utils/busy-guard.js";
-import { buildProjectButtonLabel, calculateProjectsPaginationRange } from "./projects.js";
-const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
-const WORKTREE_CALLBACK_PREFIX = "worktree:";
-const WORKTREE_PAGE_CALLBACK_PREFIX = "worktree:page:";
-function formatWorktreeButtonLabel(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))}...`;
-}
-function buildWorktreeButtonLabel(index, entry) {
-    return buildProjectButtonLabel(index, entry.path);
-}
-function parseWorktreePageCallback(data) {
-    if (!data.startsWith(WORKTREE_PAGE_CALLBACK_PREFIX)) {
-        return null;
-    }
-    const rawPage = data.slice(WORKTREE_PAGE_CALLBACK_PREFIX.length);
-    if (!/^\d+$/.test(rawPage)) {
-        return null;
-    }
-    return Number.parseInt(rawPage, 10);
-}
-function parseWorktreeIndexCallback(data) {
-    if (!data.startsWith(WORKTREE_CALLBACK_PREFIX) ||
-        data.startsWith(WORKTREE_PAGE_CALLBACK_PREFIX)) {
-        return null;
-    }
-    const rawIndex = data.slice(WORKTREE_CALLBACK_PREFIX.length);
-    if (!/^\d+$/.test(rawIndex)) {
-        return null;
-    }
-    return Number.parseInt(rawIndex, 10);
-}
-function buildWorktreeMenuText(page, totalPages) {
-    const baseText = t("worktree.select_with_current");
-    if (totalPages <= 1) {
-        return baseText;
-    }
-    return `${baseText}\n\n${t("projects.page_indicator", {
-        current: String(page + 1),
-        total: String(totalPages),
-    })}`;
-}
-function buildWorktreeKeyboard(worktrees, page) {
-    const keyboard = new InlineKeyboard();
-    const pageSize = config.bot.projectsListLimit;
-    const { page: normalizedPage, totalPages, startIndex, endIndex, } = calculateProjectsPaginationRange(worktrees.length, page, pageSize);
-    worktrees.slice(startIndex, endIndex).forEach((entry, index) => {
-        const label = buildWorktreeButtonLabel(startIndex + index, entry);
-        keyboard
-            .text(formatWorktreeButtonLabel(label, entry.isCurrent), `${WORKTREE_CALLBACK_PREFIX}${startIndex + index}`)
-            .row();
-    });
-    if (totalPages > 1) {
-        if (normalizedPage > 0) {
-            keyboard.text(t("projects.prev_page"), `${WORKTREE_PAGE_CALLBACK_PREFIX}${normalizedPage - 1}`);
-        }
-        if (normalizedPage < totalPages - 1) {
-            keyboard.text(t("projects.next_page"), `${WORKTREE_PAGE_CALLBACK_PREFIX}${normalizedPage + 1}`);
-        }
-    }
-    return keyboard;
-}
-function buildWorktreeMenuView(worktrees, page) {
-    const { page: normalizedPage, totalPages } = calculateProjectsPaginationRange(worktrees.length, page, config.bot.projectsListLimit);
-    return {
-        text: buildWorktreeMenuText(normalizedPage, totalPages),
-        keyboard: buildWorktreeKeyboard(worktrees, normalizedPage),
-    };
-}
-async function loadCurrentWorktreeContext() {
-    const currentProject = getCurrentProject();
-    if (!currentProject) {
-        return { currentProject: null, context: null };
-    }
-    const context = await getGitWorktreeContext(currentProject.worktree);
-    return { currentProject, context };
-}
-export async function worktreeCommand(ctx) {
-    try {
-        if (isForegroundBusy()) {
-            await replyBusyBlocked(ctx);
-            return;
-        }
-        const { currentProject, context } = await loadCurrentWorktreeContext();
-        if (!currentProject) {
-            await ctx.reply(t("worktree.project_not_selected"));
-            return;
-        }
-        if (!context) {
-            await ctx.reply(t("worktree.not_git_repo"));
-            return;
-        }
-        if (context.worktrees.length === 0) {
-            await ctx.reply(t("worktree.empty"));
-            return;
-        }
-        const { text, keyboard } = buildWorktreeMenuView(context.worktrees, 0);
-        await replyWithInlineMenu(ctx, {
-            menuKind: "worktree",
-            text,
-            keyboard,
-        });
-    }
-    catch (error) {
-        logger.error("[Bot] Error loading worktrees:", error);
-        await ctx.reply(t("worktree.fetch_error"));
-    }
-}
-export async function handleWorktreeCallback(ctx, deps = {}) {
-    const callbackQuery = ctx.callbackQuery;
-    if (!callbackQuery?.data || !callbackQuery.data.startsWith(WORKTREE_CALLBACK_PREFIX)) {
-        return false;
-    }
-    if (isForegroundBusy()) {
-        await replyBusyBlocked(ctx);
-        return true;
-    }
-    const page = parseWorktreePageCallback(callbackQuery.data);
-    const index = parseWorktreeIndexCallback(callbackQuery.data);
-    const isActiveMenu = await ensureActiveInlineMenu(ctx, "worktree");
-    if (!isActiveMenu) {
-        return true;
-    }
-    try {
-        const { currentProject, context } = await loadCurrentWorktreeContext();
-        if (!currentProject) {
-            clearAllInteractionState("worktree_project_missing");
-            await ctx.answerCallbackQuery();
-            await ctx.reply(t("worktree.project_not_selected"));
-            return true;
-        }
-        if (!context) {
-            clearAllInteractionState("worktree_git_context_missing");
-            await ctx.answerCallbackQuery({ text: t("worktree.not_git_repo_callback") });
-            return true;
-        }
-        if (page !== null) {
-            if (context.worktrees.length === 0) {
-                await ctx.answerCallbackQuery({ text: t("worktree.page_empty_callback") });
-                return true;
-            }
-            const { text, keyboard } = buildWorktreeMenuView(context.worktrees, page);
-            await ctx.answerCallbackQuery();
-            await ctx.editMessageText(text, {
-                reply_markup: appendInlineMenuCancelButton(keyboard, "worktree"),
-            });
-            return true;
-        }
-        if (index === null) {
-            await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
-            return true;
-        }
-        const selectedWorktree = context.worktrees[index];
-        if (!selectedWorktree) {
-            await ctx.answerCallbackQuery({ text: t("worktree.selection_missing_callback") });
-            return true;
-        }
-        if (selectedWorktree.isCurrent) {
-            await ctx.answerCallbackQuery({ text: t("worktree.already_selected_callback") });
-            return true;
-        }
-        logger.info(`[Bot] Worktree selected: ${selectedWorktree.path}`);
-        await upsertSessionDirectory(selectedWorktree.path, Date.now());
-        const projectInfo = await getProjectByWorktree(selectedWorktree.path);
-        const selectedProjectInfo = { ...projectInfo, name: selectedWorktree.path };
-        const replyKeyboard = deps.ensureEventSubscription
-            ? await switchToProject(ctx, selectedProjectInfo, "worktree_switched", {
-                ensureEventSubscription: deps.ensureEventSubscription,
-            })
-            : await switchToProject(ctx, selectedProjectInfo, "worktree_switched");
-        await ctx.answerCallbackQuery();
-        await ctx.reply(t("worktree.selected", { worktree: selectedWorktree.path }), {
-            reply_markup: replyKeyboard,
-        });
-        await ctx.deleteMessage();
-        return true;
-    }
-    catch (error) {
-        logger.error("[Bot] Error handling worktree callback:", error);
-        clearAllInteractionState("worktree_select_error");
-        await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
-        await ctx.reply(t("worktree.select_error"));
-        return true;
-    }
-}