@grinev/opencode-telegram-bot 0.21.1 → 0.22.0

package/dist/bot/handlers/permission.js

@@ -1,235 +0,0 @@
-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/utils/browser-roots.js

@@ -1,140 +0,0 @@
-import path from "node:path";
-import { realpath } from "node:fs/promises";
-import os from "node:os";
-import { logger } from "../../utils/logger.js";
-/**
- * Allowed root directories for the `/open` command.
- *
- * Configured via `OPEN_BROWSER_ROOTS` env var (comma-separated absolute paths).
- * Defaults to `[os.homedir()]` when the variable is not set.
- *
- * All navigation in the directory browser is restricted to stay within one
- * of the configured roots. This prevents the bot from browsing arbitrary
- * locations on the filesystem.
- */
-let resolvedRoots = null;
-function isWindows() {
-    return process.platform === "win32";
-}
-function resolveConfiguredPath(p) {
-    return path.resolve(expandTilde(p));
-}
-/**
- * Expand a leading `~` or `~/` to the user's home directory.
- * Does not handle `~user/` syntax — only the current user's home.
- */
-function expandTilde(p) {
-    if (p === "~") {
-        return os.homedir();
-    }
-    if (p.startsWith("~/") || p.startsWith("~\\")) {
-        return path.join(os.homedir(), p.slice(2));
-    }
-    return p;
-}
-/**
- * Normalize a path for comparison: expand tilde, resolve, then lowercase on Windows.
- */
-function normalizePath(p) {
-    const resolved = resolveConfiguredPath(p);
-    return isWindows() ? resolved.toLowerCase() : resolved;
-}
-/**
- * Initialize (or re-initialize) the allowed browser roots from the raw
- * env string. Each entry is resolved to an absolute path via `path.resolve`.
- *
- * Entries that cannot be resolved are logged and skipped.
- */
-export function initBrowserRoots(raw) {
-    if (!raw || raw.trim() === "") {
-        resolvedRoots = [resolveConfiguredPath(os.homedir())];
-        logger.debug(`[BrowserRoots] No OPEN_BROWSER_ROOTS configured, defaulting to home: ${resolvedRoots[0]}`);
-        return;
-    }
-    const entries = raw
-        .split(",")
-        .map((s) => s.trim())
-        .filter((s) => s.length > 0);
-    const roots = [];
-    for (const entry of entries) {
-        roots.push(resolveConfiguredPath(entry));
-    }
-    if (roots.length === 0) {
-        resolvedRoots = [resolveConfiguredPath(os.homedir())];
-        logger.warn("[BrowserRoots] All configured roots were invalid, falling back to home directory");
-    }
-    else {
-        resolvedRoots = roots;
-        logger.info(`[BrowserRoots] Configured roots: ${roots.join(", ")}`);
-    }
-}
-/**
- * Return the configured browser roots. Lazily initializes from env if
- * `initBrowserRoots` was never called.
- */
-export function getBrowserRoots() {
-    if (resolvedRoots === null) {
-        initBrowserRoots(process.env.OPEN_BROWSER_ROOTS);
-    }
-    return resolvedRoots;
-}
-/**
- * Return the original (non-normalized) root paths for display/navigation.
- * On Windows the display roots are lowercased because `normalizePath` is
- * used during init — this is acceptable for button labels.
- */
-export function getBrowserRootPaths() {
-    return getBrowserRoots();
-}
-/**
- * Check whether a target path is inside one of the allowed roots.
- *
- * Uses `path.resolve` on the target for consistent comparison, then
- * checks that the target equals a root or is a descendant (starts with
- * root + separator).
- *
- * For full symlink-proof validation, callers can optionally resolve the
- * target with `fs.realpath` before calling this function.
- */
-export function isWithinAllowedRoot(targetPath) {
-    const normalizedTarget = normalizePath(targetPath);
-    const roots = getBrowserRoots();
-    for (const root of roots) {
-        const normalizedRoot = normalizePath(root);
-        if (normalizedTarget === normalizedRoot) {
-            return true;
-        }
-        // Check both separators — `path.sep` is always `/` on Unix but a
-        // lowercased Windows path may contain either `\` or `/`.
-        if (normalizedTarget.startsWith(normalizedRoot + "/") ||
-            normalizedTarget.startsWith(normalizedRoot + "\\")) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Like `isWithinAllowedRoot` but resolves symlinks first using `realpath`.
- * Falls back to the plain path if `realpath` fails (e.g. ENOENT).
- */
-export async function isWithinAllowedRootSafe(targetPath) {
-    let resolved = targetPath;
-    try {
-        resolved = await realpath(targetPath);
-    }
-    catch {
-        // Path doesn't exist yet or can't be resolved — use as-is
-    }
-    return isWithinAllowedRoot(resolved);
-}
-/**
- * Check whether a path is exactly one of the allowed roots (not a descendant).
- */
-export function isAllowedRoot(targetPath) {
-    const normalizedTarget = normalizePath(targetPath);
-    return getBrowserRoots().some((root) => normalizePath(root) === normalizedTarget);
-}
-/** Reset state — for testing only. */
-export function __resetBrowserRootsForTests() {
-    resolvedRoots = null;
-}

package/dist/bot/utils/file-tree.js

@@ -1,92 +0,0 @@
-import { promises as fs } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { t } from "../../i18n/index.js";
-export const MAX_ENTRIES_PER_PAGE = 8;
-export function getHomeDirectory() {
-    return os.homedir();
-}
-export function pathToDisplayPath(absolutePath) {
-    const home = getHomeDirectory();
-    if (absolutePath === home) {
-        return "~";
-    }
-    if (absolutePath.startsWith(home + path.sep)) {
-        return "~" + absolutePath.slice(home.length);
-    }
-    return absolutePath;
-}
-export async function scanDirectory(dirPath, page = 0) {
-    try {
-        const entries = await fs.readdir(dirPath, { withFileTypes: true });
-        const subdirs = [];
-        for (const entry of entries) {
-            if (entry.isDirectory() && !entry.name.startsWith(".")) {
-                subdirs.push({
-                    name: entry.name,
-                    fullPath: path.join(dirPath, entry.name),
-                });
-            }
-        }
-        subdirs.sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: "base" }));
-        const parentPath = path.dirname(dirPath);
-        const hasParent = dirPath !== path.parse(dirPath).root;
-        // Clamp page to valid range so stale or crafted callbacks never produce
-        // an out-of-bounds page indicator like "(4/2)".
-        const totalPages = Math.max(1, Math.ceil(subdirs.length / MAX_ENTRIES_PER_PAGE));
-        const safePage = Math.max(0, Math.min(page, totalPages - 1));
-        const start = safePage * MAX_ENTRIES_PER_PAGE;
-        const pageEntries = subdirs.slice(start, start + MAX_ENTRIES_PER_PAGE);
-        return {
-            entries: pageEntries,
-            totalCount: subdirs.length,
-            page: safePage,
-            currentPath: dirPath,
-            displayPath: pathToDisplayPath(dirPath),
-            hasParent,
-            parentPath: hasParent ? parentPath : null,
-        };
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            if ("code" in error) {
-                const code = error.code;
-                if (code === "ENOENT" || code === "ELOOP") {
-                    return { error: `Directory not found: ${dirPath}`, code: "ENOENT" };
-                }
-                if (code === "EACCES" || code === "EPERM") {
-                    return { error: `Permission denied: ${dirPath}`, code: "EACCES" };
-                }
-                if (code === "ENOTDIR") {
-                    return { error: `Not a directory: ${dirPath}`, code: "ENOTDIR" };
-                }
-            }
-        }
-        return {
-            error: error instanceof Error ? error.message : "Unknown error",
-            code: "UNKNOWN",
-        };
-    }
-}
-export function buildEntryLabel(entry) {
-    return `📁 ${entry.name}`;
-}
-export function buildTreeHeader(displayPath, totalCount, page, totalPages) {
-    let header = `📂 ${displayPath}`;
-    if (totalPages > 1) {
-        header += `  (${page + 1}/${totalPages})`;
-    }
-    if (totalCount === 0) {
-        header += `\n${t("open.no_subfolders")}`;
-    }
-    else if (totalCount === 1) {
-        header += `\n${t("open.subfolder_count", { count: String(totalCount) })}`;
-    }
-    else {
-        header += `\n${t("open.subfolders_count", { count: String(totalCount) })}`;
-    }
-    return header;
-}
-export function isScanError(result) {
-    return "error" in result;
-}

package/dist/bot/utils/send-tts-response.js

@@ -1,37 +0,0 @@
-import { InputFile } from "grammy";
-import { consumePromptResponseMode } from "../handlers/prompt.js";
-import { isTtsConfigured, synthesizeSpeech } from "../../tts/client.js";
-import { t } from "../../i18n/index.js";
-import { logger } from "../../utils/logger.js";
-const MAX_TTS_INPUT_CHARS = 4_000;
-export async function sendTtsResponseForSession({ api, sessionId, chatId, text, consumeResponseMode: consumeResponseModeImpl = consumePromptResponseMode, isTtsConfigured: isTtsConfiguredImpl = isTtsConfigured, synthesizeSpeech: synthesizeSpeechImpl = synthesizeSpeech, }) {
-    const responseMode = consumeResponseModeImpl(sessionId);
-    if (responseMode !== "text_and_tts") {
-        return false;
-    }
-    const normalizedText = text.trim();
-    if (!normalizedText) {
-        return false;
-    }
-    if (!isTtsConfiguredImpl()) {
-        logger.info(`[TTS] Skipping audio reply for session ${sessionId}: TTS is not configured`);
-        return false;
-    }
-    if (normalizedText.length > MAX_TTS_INPUT_CHARS) {
-        logger.warn(`[TTS] Skipping audio reply for session ${sessionId}: text length ${normalizedText.length} exceeds limit ${MAX_TTS_INPUT_CHARS}`);
-        return false;
-    }
-    try {
-        const speech = await synthesizeSpeechImpl(normalizedText);
-        await api.sendAudio(chatId, new InputFile(speech.buffer, speech.filename));
-        logger.info(`[TTS] Sent audio reply for session ${sessionId}`);
-        return true;
-    }
-    catch (error) {
-        logger.warn(`[TTS] Failed to send audio reply for session ${sessionId}`, error);
-        await api.sendMessage(chatId, t("tts.failed")).catch((sendError) => {
-            logger.warn(`[TTS] Failed to send audio error message for session ${sessionId}`, sendError);
-        });
-        return false;
-    }
-}

package/dist/bot/utils/switch-project.js

@@ -1,45 +0,0 @@
-import { setCurrentProject } from "../../settings/manager.js";
-import { clearSession } from "../../session/manager.js";
-import { summaryAggregator } from "../../summary/aggregator.js";
-import { pinnedMessageManager } from "../../pinned/manager.js";
-import { keyboardManager } from "../../keyboard/manager.js";
-import { detachAttachedSession } from "../../attach/service.js";
-import { stopEventListening } from "../../opencode/events.js";
-import { backgroundSessionTracker } from "../../background-session/tracker.js";
-import { getStoredAgent, resolveProjectAgent } from "../../agent/manager.js";
-import { getStoredModel } from "../../model/manager.js";
-import { formatVariantForButton } from "../../variant/manager.js";
-import { clearAllInteractionState } from "../../interaction/cleanup.js";
-import { createMainKeyboard } from "./keyboard.js";
-import { logger } from "../../utils/logger.js";
-import { config } from "../../config.js";
-export async function switchToProject(ctx, project, reason, options = {}) {
-    detachAttachedSession(reason);
-    stopEventListening();
-    backgroundSessionTracker.clear();
-    setCurrentProject(project);
-    clearSession();
-    summaryAggregator.clear();
-    clearAllInteractionState(reason);
-    try {
-        await pinnedMessageManager.clear();
-    }
-    catch (err) {
-        logger.error("[Bot] Error clearing pinned message:", err);
-    }
-    if (ctx.chat) {
-        keyboardManager.initialize(ctx.api, ctx.chat.id);
-    }
-    await pinnedMessageManager.refreshContextLimit();
-    const contextLimit = pinnedMessageManager.getContextLimit();
-    keyboardManager.updateContext(0, contextLimit);
-    const currentAgent = await resolveProjectAgent(getStoredAgent());
-    const currentModel = getStoredModel();
-    const contextInfo = { tokensUsed: 0, tokensLimit: contextLimit };
-    const variantName = formatVariantForButton(currentModel.variant || "default");
-    keyboardManager.updateAgent(currentAgent);
-    if (config.bot.trackBackgroundSessions && options.ensureEventSubscription) {
-        await options.ensureEventSubscription(project.worktree);
-    }
-    return createMainKeyboard(currentAgent, currentModel, contextInfo, variantName);
-}

package/dist/bot/utils/telegram-file-url.js

@@ -1,11 +0,0 @@
-import { config } from "../../config.js";
-const DEFAULT_TELEGRAM_API_ROOT = "https://api.telegram.org";
-export function telegramFileUrlBase() {
-    const apiRoot = config.telegram.apiRoot
-        ? config.telegram.apiRoot.replace(/\/+$/, "")
-        : DEFAULT_TELEGRAM_API_ROOT;
-    return `${apiRoot}/file/bot`;
-}
-export function buildTelegramFileUrl(filePath) {
-    return `${telegramFileUrlBase()}${config.telegram.token}/${filePath}`;
-}

package/dist/interaction/busy.js

@@ -1,8 +0,0 @@
-export const BUSY_ALLOWED_COMMANDS = ["/abort", "/detach", "/status", "/help"];
-const BUSY_ALLOWED_COMMAND_SET = new Set(BUSY_ALLOWED_COMMANDS);
-export function isBusyAllowedCommand(command) {
-    return Boolean(command && BUSY_ALLOWED_COMMAND_SET.has(command));
-}
-export function allowsBusyInteraction(kind) {
-    return kind === "question" || kind === "permission";
-}

package/dist/interaction/cleanup.js

@@ -1,32 +0,0 @@
-import { permissionManager } from "../permission/manager.js";
-import { questionManager } from "../question/manager.js";
-import { renameManager } from "../rename/manager.js";
-import { taskCreationManager } from "../scheduled-task/creation-manager.js";
-import { interactionManager } from "./manager.js";
-import { logger } from "../utils/logger.js";
-export function clearAllInteractionState(reason) {
-    const questionActive = questionManager.isActive();
-    const permissionActive = permissionManager.isActive();
-    const renameActive = renameManager.isWaitingForName();
-    const taskCreationActive = taskCreationManager.isActive();
-    const interactionSnapshot = interactionManager.getSnapshot();
-    questionManager.clear();
-    permissionManager.clear();
-    renameManager.clear();
-    taskCreationManager.clear();
-    interactionManager.clear(reason);
-    const hasAnyActiveState = questionActive ||
-        permissionActive ||
-        renameActive ||
-        taskCreationActive ||
-        interactionSnapshot !== null;
-    const message = `[InteractionCleanup] Cleared state: reason=${reason}, ` +
-        `questionActive=${questionActive}, permissionActive=${permissionActive}, ` +
-        `renameActive=${renameActive}, taskCreationActive=${taskCreationActive}, ` +
-        `interactionKind=${interactionSnapshot?.kind || "none"}`;
-    if (hasAnyActiveState) {
-        logger.info(message);
-        return;
-    }
-    logger.debug(message);
-}