@grinev/opencode-telegram-bot 0.21.1 → 0.21.2

package/dist/bot/services/project-switch-presentation.js

@@ -0,0 +1,26 @@
+import { keyboardManager } from "../keyboards/keyboard-manager.js";
+import { createMainKeyboard } from "../keyboards/main-reply-keyboard.js";
+import { pinnedMessageManager } from "../pinned/pinned-message-manager.js";
+export function createProjectSwitchPresentation() {
+    return {
+        async clearPinnedMessage() {
+            await pinnedMessageManager.clear();
+        },
+        initializeKeyboard(ctx) {
+            if (ctx.chat) {
+                keyboardManager.initialize(ctx.api, ctx.chat.id);
+            }
+        },
+        async refreshContextLimit() {
+            await pinnedMessageManager.refreshContextLimit();
+            return pinnedMessageManager.getContextLimit();
+        },
+        updateKeyboardContext(contextInfo) {
+            keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
+        },
+        updateKeyboardAgent(agent) {
+            keyboardManager.updateAgent(agent);
+        },
+        createMainKeyboard,
+    };
+}

package/dist/cli.js

@@ -81,7 +81,7 @@ async function runStartCommand(mode, daemon) {
     const { ensureRuntimeConfigForStart } = await import("./runtime/bootstrap.js");
     await ensureRuntimeConfigForStart();
     if (daemon) {
-        const { startBotDaemon } = await import("./service/manager.js");
+        const { startBotDaemon } = await import("./runtime/service/manager.js");
         const result = await startBotDaemon(modeResult.mode);
         const cleanupMessage = formatServiceCleanupMessage(result.cleanupReason);
         const runtimePaths = getRuntimePaths();
@@ -115,7 +115,7 @@ async function runStartCommand(mode, daemon) {
     }
     const { initializeLogger } = await import("./utils/logger.js");
     await initializeLogger();
-    const { startBotApp } = await import("./app/start-bot-app.js");
+    const { startBotApp } = await import("./app/bootstrap/start-bot-app.js");
     await startBotApp();
     return EXIT_SUCCESS;
 }
@@ -129,7 +129,7 @@ async function runConfigCommand() {
 }
 async function runStatusCommand() {
     setRuntimeMode("installed");
-    const { getBotServiceStatus } = await import("./service/manager.js");
+    const { getBotServiceStatus } = await import("./runtime/service/manager.js");
     const runtimePaths = getRuntimePaths();
     const status = await getBotServiceStatus();
     writeOptionalLine(formatServiceCleanupMessage(status.cleanupReason));
@@ -150,7 +150,7 @@ async function runStatusCommand() {
 }
 async function runStopCommand() {
     setRuntimeMode("installed");
-    const { stopBotDaemon } = await import("./service/manager.js");
+    const { stopBotDaemon } = await import("./runtime/service/manager.js");
     const result = await stopBotDaemon();
     writeOptionalLine(formatServiceCleanupMessage(result.cleanupReason));
     if (!result.success) {

package/dist/config.js

@@ -61,7 +61,7 @@ function getOptionalMessageFormatModeEnvVar(key, defaultValue) {
     }
     return defaultValue;
 }
-const VALID_TTS_PROVIDERS = ["openai", "google"];
+const VALID_TTS_PROVIDERS = ["openai", "google", "elevenlabs"];
 function getOptionalTtsProviderEnvVar(key, defaultValue) {
     const value = getEnvVar(key, false);
     if (!value) {
@@ -121,6 +121,7 @@ export const config = {
         commandsListLimit: getOptionalPositiveIntEnvVar("COMMANDS_LIST_LIMIT", 10),
         taskLimit: getOptionalPositiveIntEnvVar("TASK_LIMIT", 10),
         scheduledTaskExecutionTimeoutMinutes: getOptionalPositiveIntEnvVar("SCHEDULED_TASK_EXECUTION_TIMEOUT_MINUTES", 120),
+        scheduledTaskNotificationsSilent: getOptionalBooleanEnvVar("SCHEDULED_TASK_DISABLE_NOTIFICATION", false),
         responseStreamThrottleMs: getOptionalPositiveIntEnvVar("RESPONSE_STREAM_THROTTLE_MS", 1000),
         responseStreamingMode: getOptionalStreamingModeEnvVar("RESPONSE_STREAMING_MODE", "edit"),
         bashToolDisplayMaxLength: getOptionalPositiveIntEnvVar("BASH_TOOL_DISPLAY_MAX_LENGTH", 128),
@@ -146,12 +147,17 @@ export const config = {
     },
     tts: (() => {
         const provider = getOptionalTtsProviderEnvVar("TTS_PROVIDER", "openai");
-        const defaultVoice = provider === "google" ? "en-US-Studio-O" : "alloy";
+        const defaultVoice = provider === "google"
+            ? "en-US-Studio-O"
+            : provider === "elevenlabs"
+                ? "21m00Tcm4TlvDq8ikWAM"
+                : "alloy";
+        const defaultModel = provider === "elevenlabs" ? "eleven_flash_v2_5" : "gpt-4o-mini-tts";
         return {
             apiUrl: getEnvVar("TTS_API_URL", false),
             apiKey: getEnvVar("TTS_API_KEY", false),
             provider,
-            model: getEnvVar("TTS_MODEL", false) || "gpt-4o-mini-tts",
+            model: getEnvVar("TTS_MODEL", false) || defaultModel,
             voice: getEnvVar("TTS_VOICE", false) || defaultVoice,
         };
     })(),

package/dist/index.js

@@ -14,7 +14,7 @@ async function main() {
     setRuntimeMode(modeResult.mode);
     const { initializeLogger } = await import("./utils/logger.js");
     await initializeLogger();
-    const { startBotApp } = await import("./app/start-bot-app.js");
+    const { startBotApp } = await import("./app/bootstrap/start-bot-app.js");
     await startBotApp();
 }
 void main().catch((error) => {

package/dist/opencode/ready-refresh.js

@@ -1,5 +1,5 @@
-import { reconcileStoredModelSelection } from "../model/manager.js";
-import { warmupSessionDirectoryCache } from "../session/cache-manager.js";
+import { reconcileStoredModelSelection } from "../app/services/model-selection-service.js";
+import { warmupSessionDirectoryCache } from "../app/services/session-cache-service.js";
 import { logger } from "../utils/logger.js";
 import { opencodeClient } from "./client.js";
 import { opencodeReadyLifecycle } from "./ready-lifecycle.js";

package/dist/{service → runtime/service}/manager.js

@@ -3,8 +3,8 @@ import fsPromises from "node:fs/promises";
 import path from "node:path";
 import { exec, spawn } from "node:child_process";
 import { promisify } from "node:util";
-import { getRuntimePaths } from "../runtime/paths.js";
-import { buildServiceChildEnv } from "./runtime.js";
+import { getRuntimePaths } from "../paths.js";
+import { buildServiceChildEnv } from "./env.js";
 const execAsync = promisify(exec);
 const SERVICE_STATE_FILE_NAME = "bot-service.json";
 const PROCESS_EXIT_POLL_MS = 100;

package/dist/runtime/service/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.21.1",
+  "version": "0.21.2",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",

package/dist/bot/commands/ls.js

@@ -1,445 +0,0 @@
-import { InlineKeyboard } from "grammy";
-import path from "node:path";
-import { promises as fs } from "node:fs";
-import os from "node:os";
-import { appendInlineMenuCancelButton, clearActiveInlineMenu, ensureActiveInlineMenu, } from "../handlers/inline-menu.js";
-import { interactionManager } from "../../interaction/manager.js";
-import { isForegroundBusy, replyBusyBlocked } from "../utils/busy-guard.js";
-import { getCurrentProject } from "../../settings/manager.js";
-import { sendDownloadedFile } from "../utils/send-downloaded-file.js";
-import { formatFileSize } from "../utils/file-download.js";
-import { logger } from "../../utils/logger.js";
-import { t } from "../../i18n/index.js";
-const CALLBACK_PREFIX = "ls:";
-const CALLBACK_NAV_PREFIX = "ls:nav:";
-const CALLBACK_FILE_PREFIX = "ls:file:";
-const CALLBACK_DOWNLOAD_PREFIX = "ls:download:";
-const CALLBACK_BACK_PREFIX = "ls:back:";
-const CALLBACK_PAGE_PREFIX = "ls:pg:";
-const PAGE_SEPARATOR = "|";
-const MAX_ENTRIES_PER_PAGE = 8;
-const MAX_BUTTON_LABEL_LENGTH = 64;
-const sessionDirectories = new Map();
-const pathIndex = new Map();
-let pathCounter = 0;
-function escapeHtml(text) {
-    return text
-        .replace(/&/g, "&")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;")
-        .replace(/\"/g, "&quot;")
-        .replace(/'/g, "&#39;");
-}
-function truncateLabel(label, maxLen = MAX_BUTTON_LABEL_LENGTH) {
-    if (label.length <= maxLen) {
-        return label;
-    }
-    return `${label.slice(0, Math.max(0, maxLen - 3))}...`;
-}
-function pathToDisplayPath(absolutePath) {
-    const home = os.homedir();
-    if (absolutePath === home) {
-        return "~";
-    }
-    if (absolutePath.startsWith(home + path.sep)) {
-        return `~${absolutePath.slice(home.length)}`;
-    }
-    return absolutePath;
-}
-function usesWindowsPath(filePath) {
-    return /^[A-Za-z]:[\\/]/.test(filePath) || filePath.startsWith("\\\\");
-}
-function getPathApi(filePath) {
-    return usesWindowsPath(filePath) ? path.win32 : path.posix;
-}
-function joinPath(parentPath, childName) {
-    return getPathApi(parentPath).join(parentPath, childName);
-}
-function getBaseName(filePath) {
-    return getPathApi(filePath).basename(filePath);
-}
-function getParentPath(filePath) {
-    return getPathApi(filePath).dirname(filePath);
-}
-function getRootPath(filePath) {
-    return getPathApi(filePath).parse(filePath).root;
-}
-function isSamePath(leftPath, rightPath) {
-    return getPathApi(rightPath).relative(rightPath, leftPath) === "";
-}
-function buildEntryLabel(entry) {
-    return `${entry.type === "directory" ? "📁" : "📄"} ${entry.name}`;
-}
-function isPathWithinDirectory(targetPath, directoryPath) {
-    const pathApi = getPathApi(directoryPath);
-    const relativePath = pathApi.relative(directoryPath, targetPath);
-    return relativePath === "" || (!relativePath.startsWith("..") && !pathApi.isAbsolute(relativePath));
-}
-function getProjectRoot() {
-    return getCurrentProject()?.worktree ?? null;
-}
-function isWithinProjectRoot(targetPath) {
-    const projectRoot = getProjectRoot();
-    return projectRoot !== null && isPathWithinDirectory(targetPath, projectRoot);
-}
-function isProjectRoot(targetPath) {
-    const projectRoot = getProjectRoot();
-    return projectRoot !== null && isSamePath(targetPath, projectRoot);
-}
-function buildLsHeader(displayPath, totalCount, page, totalPages) {
-    let header = `📁 ${t("ls.header")}\n<code>${escapeHtml(displayPath)}</code>`;
-    if (totalPages > 1) {
-        header += `\n(${page + 1}/${totalPages})`;
-    }
-    header += `\n${t("ls.total", { count: totalCount })}`;
-    return header;
-}
-function buildFileDetailsText(fileDetails) {
-    return (`📄 ${t("ls.file.header")}\n<code>${escapeHtml(fileDetails.name)}</code>\n` +
-        `${t("commands.download.size")}: ${formatFileSize(fileDetails.size)}\n` +
-        `${t("commands.download.modified")}: ${fileDetails.modified.toLocaleDateString()}`);
-}
-function encodePathForCallback(prefix, fullPath, reserveBytes = 0) {
-    const naive = `${prefix}${fullPath}`;
-    if (Buffer.byteLength(naive, "utf-8") + reserveBytes <= 64) {
-        return naive;
-    }
-    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;
-}
-function encodePathWithPageCallback(prefix, fullPath, page) {
-    const pageSuffix = `${PAGE_SEPARATOR}${page}`;
-    const reserveBytes = Buffer.byteLength(pageSuffix, "utf-8");
-    const pathRef = encodePathForCallback(prefix, fullPath, reserveBytes);
-    return `${pathRef}${pageSuffix}`;
-}
-function decodePathWithPageCallback(data, prefix) {
-    if (!data.startsWith(prefix)) {
-        return null;
-    }
-    const payload = data.slice(prefix.length);
-    const separatorIndex = payload.lastIndexOf(PAGE_SEPARATOR);
-    if (separatorIndex < 0) {
-        return null;
-    }
-    const pathRef = payload.slice(0, separatorIndex);
-    const page = Number.parseInt(payload.slice(separatorIndex + 1), 10);
-    if (Number.isNaN(page)) {
-        return null;
-    }
-    const resolvedPath = pathRef.startsWith("#") ? (pathIndex.get(pathRef) ?? null) : pathRef;
-    if (resolvedPath === null) {
-        return null;
-    }
-    return { path: resolvedPath, page };
-}
-function encodePaginationCallback(currentPath, page) {
-    return encodePathWithPageCallback(CALLBACK_PAGE_PREFIX, currentPath, page);
-}
-function decodePaginationCallback(data) {
-    return decodePathWithPageCallback(data, CALLBACK_PAGE_PREFIX);
-}
-function encodeFileCallback(fullPath, page) {
-    return encodePathWithPageCallback(CALLBACK_FILE_PREFIX, fullPath, page);
-}
-function decodeFileCallback(data) {
-    return decodePathWithPageCallback(data, CALLBACK_FILE_PREFIX);
-}
-function encodeBackCallback(directoryPath, page) {
-    return encodePathWithPageCallback(CALLBACK_BACK_PREFIX, directoryPath, page);
-}
-function decodeBackCallback(data) {
-    return decodePathWithPageCallback(data, CALLBACK_BACK_PREFIX);
-}
-async function scanDirectory(dirPath, page = 0) {
-    try {
-        if (!isWithinProjectRoot(dirPath)) {
-            return { error: t("ls.access_denied") };
-        }
-        const dirEntries = await fs.readdir(dirPath, { withFileTypes: true });
-        const entries = dirEntries
-            .map((entry) => ({
-            name: entry.name,
-            fullPath: joinPath(dirPath, entry.name),
-            type: entry.isDirectory() ? "directory" : "file",
-        }))
-            .sort((left, right) => {
-            if (left.type !== right.type) {
-                return left.type === "directory" ? -1 : 1;
-            }
-            return left.name.localeCompare(right.name, undefined, { sensitivity: "base" });
-        });
-        const totalPages = Math.max(1, Math.ceil(entries.length / MAX_ENTRIES_PER_PAGE));
-        const safePage = Math.max(0, Math.min(page, totalPages - 1));
-        const startIndex = safePage * MAX_ENTRIES_PER_PAGE;
-        return {
-            entries: entries.slice(startIndex, startIndex + MAX_ENTRIES_PER_PAGE),
-            totalCount: entries.length,
-            currentPath: dirPath,
-            displayPath: pathToDisplayPath(dirPath),
-            hasParent: dirPath !== getRootPath(dirPath),
-            page: safePage,
-        };
-    }
-    catch (error) {
-        return {
-            error: `${t("ls.scan_error")}: ${error instanceof Error ? error.message : "Unknown error"}`,
-        };
-    }
-}
-function buildBrowseKeyboard(entries, currentPath, hasParent, page, totalCount) {
-    const keyboard = new InlineKeyboard();
-    const totalPages = Math.max(1, Math.ceil(totalCount / MAX_ENTRIES_PER_PAGE));
-    for (const entry of entries) {
-        const label = truncateLabel(buildEntryLabel(entry));
-        const callbackData = entry.type === "directory"
-            ? encodePathForCallback(CALLBACK_NAV_PREFIX, entry.fullPath)
-            : encodeFileCallback(entry.fullPath, page);
-        keyboard.text(label, callbackData).row();
-    }
-    if (hasParent && !isProjectRoot(currentPath)) {
-        keyboard.text(t("open.back"), encodePathForCallback(CALLBACK_NAV_PREFIX, getParentPath(currentPath))).row();
-    }
-    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();
-    }
-    appendInlineMenuCancelButton(keyboard, "ls");
-    return keyboard;
-}
-function buildFileDetailsKeyboard(filePath, page) {
-    const keyboard = new InlineKeyboard();
-    const parentPath = getParentPath(filePath);
-    keyboard.text(t("ls.file.download"), encodePathForCallback(CALLBACK_DOWNLOAD_PREFIX, filePath));
-    keyboard.text(t("ls.file.back"), encodeBackCallback(parentPath, page));
-    keyboard.row();
-    appendInlineMenuCancelButton(keyboard, "ls");
-    return keyboard;
-}
-function hasBrowseActions(currentPath, hasParent, totalCount) {
-    if (totalCount > 0) {
-        return true;
-    }
-    return hasParent && !isProjectRoot(currentPath);
-}
-async function renderBrowseView(dirPath, page = 0) {
-    const result = await scanDirectory(dirPath, page);
-    if ("error" in result) {
-        return result;
-    }
-    const totalPages = Math.max(1, Math.ceil(result.totalCount / MAX_ENTRIES_PER_PAGE));
-    return {
-        text: buildLsHeader(result.displayPath, result.totalCount, result.page, totalPages),
-        hasActions: hasBrowseActions(result.currentPath, result.hasParent, result.totalCount),
-        keyboard: buildBrowseKeyboard(result.entries, result.currentPath, result.hasParent, result.page, result.totalCount),
-    };
-}
-async function getFileDetails(filePath) {
-    try {
-        if (!isWithinProjectRoot(filePath)) {
-            return { error: t("ls.access_denied") };
-        }
-        const stat = await fs.stat(filePath);
-        if (!stat.isFile()) {
-            return { error: t("commands.download.not_file") };
-        }
-        return {
-            name: getBaseName(filePath),
-            fullPath: filePath,
-            size: stat.size,
-            modified: stat.mtime,
-        };
-    }
-    catch (error) {
-        return {
-            error: `${t("ls.scan_error")}: ${error instanceof Error ? error.message : "Unknown error"}`,
-        };
-    }
-}
-async function renderFileDetailsView(filePath, page) {
-    const fileDetails = await getFileDetails(filePath);
-    if ("error" in fileDetails) {
-        return fileDetails;
-    }
-    return {
-        text: buildFileDetailsText(fileDetails),
-        keyboard: buildFileDetailsKeyboard(fileDetails.fullPath, page),
-    };
-}
-function resolveInitialDirectory(userId) {
-    const currentProject = getProjectRoot();
-    if (!currentProject) {
-        return null;
-    }
-    if (userId) {
-        const cachedDirectory = sessionDirectories.get(userId);
-        if (cachedDirectory && isPathWithinDirectory(cachedDirectory, currentProject)) {
-            return cachedDirectory;
-        }
-    }
-    return currentProject;
-}
-export function clearLsPathIndex() {
-    pathIndex.clear();
-    pathCounter = 0;
-}
-export function clearSessionDirectories() {
-    sessionDirectories.clear();
-}
-export async function lsCommand(ctx) {
-    if (isForegroundBusy()) {
-        await replyBusyBlocked(ctx);
-        return;
-    }
-    clearLsPathIndex();
-    const projectRoot = getProjectRoot();
-    if (!projectRoot) {
-        await ctx.reply(t("bot.project_not_selected"));
-        return;
-    }
-    const args = typeof ctx.match === "string" ? ctx.match.trim() : undefined;
-    const targetDir = args || resolveInitialDirectory(ctx.from?.id);
-    if (!targetDir) {
-        await ctx.reply(t("bot.project_not_selected"));
-        return;
-    }
-    if (!isWithinProjectRoot(targetDir)) {
-        await ctx.reply(`❌ ${t("ls.access_denied")}`);
-        return;
-    }
-    const view = await renderBrowseView(targetDir);
-    if ("error" in view) {
-        await ctx.reply(`❌ ${view.error}`);
-        return;
-    }
-    if (ctx.from) {
-        sessionDirectories.set(ctx.from.id, targetDir);
-    }
-    if (!view.hasActions) {
-        await ctx.reply(view.text, { parse_mode: "HTML" });
-        return;
-    }
-    const message = await ctx.reply(view.text, { parse_mode: "HTML", reply_markup: view.keyboard });
-    interactionManager.start({
-        kind: "inline",
-        expectedInput: "callback",
-        metadata: {
-            menuKind: "ls",
-            messageId: message.message_id,
-        },
-    });
-}
-async function navigateTo(ctx, dirPath, page = 0) {
-    const view = await renderBrowseView(dirPath, page);
-    if ("error" in view) {
-        await ctx.answerCallbackQuery({ text: view.error });
-        return;
-    }
-    if (ctx.from) {
-        sessionDirectories.set(ctx.from.id, dirPath);
-    }
-    await ctx.answerCallbackQuery();
-    await ctx.editMessageText(view.text, { parse_mode: "HTML", reply_markup: view.keyboard });
-}
-async function showFileDetails(ctx, filePath, page) {
-    const view = await renderFileDetailsView(filePath, page);
-    if ("error" in view) {
-        await ctx.answerCallbackQuery({ text: view.error });
-        return;
-    }
-    await ctx.answerCallbackQuery();
-    await ctx.editMessageText(view.text, { parse_mode: "HTML", reply_markup: view.keyboard });
-}
-async function downloadFileAndClose(ctx, filePath) {
-    await ctx.answerCallbackQuery({ text: t("commands.download.downloading") });
-    const downloaded = await sendDownloadedFile(ctx, filePath, { announce: false });
-    if (!downloaded) {
-        return;
-    }
-    clearActiveInlineMenu("ls_downloaded");
-    clearLsPathIndex();
-    await ctx.deleteMessage().catch(() => { });
-}
-export async function handleLsCallback(ctx) {
-    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, "ls");
-    if (!isActiveMenu) {
-        return true;
-    }
-    try {
-        const navPath = decodePathFromCallback(CALLBACK_NAV_PREFIX, data);
-        if (navPath !== null) {
-            if (!isWithinProjectRoot(navPath)) {
-                await ctx.answerCallbackQuery({ text: t("ls.access_denied") });
-                return true;
-            }
-            await navigateTo(ctx, navPath);
-            return true;
-        }
-        const pageInfo = decodePaginationCallback(data);
-        if (pageInfo !== null) {
-            if (!isWithinProjectRoot(pageInfo.path)) {
-                await ctx.answerCallbackQuery({ text: t("ls.access_denied") });
-                return true;
-            }
-            await navigateTo(ctx, pageInfo.path, pageInfo.page);
-            return true;
-        }
-        const fileInfo = decodeFileCallback(data);
-        if (fileInfo !== null) {
-            if (!isWithinProjectRoot(fileInfo.path)) {
-                await ctx.answerCallbackQuery({ text: t("ls.access_denied") });
-                return true;
-            }
-            await showFileDetails(ctx, fileInfo.path, fileInfo.page);
-            return true;
-        }
-        const downloadPath = decodePathFromCallback(CALLBACK_DOWNLOAD_PREFIX, data);
-        if (downloadPath !== null) {
-            if (!isWithinProjectRoot(downloadPath)) {
-                await ctx.answerCallbackQuery({ text: t("ls.access_denied") });
-                return true;
-            }
-            await downloadFileAndClose(ctx, downloadPath);
-            return true;
-        }
-        const backInfo = decodeBackCallback(data);
-        if (backInfo !== null) {
-            if (!isWithinProjectRoot(backInfo.path)) {
-                await ctx.answerCallbackQuery({ text: t("ls.access_denied") });
-                return true;
-            }
-            await navigateTo(ctx, backInfo.path, backInfo.page);
-            return true;
-        }
-        return false;
-    }
-    catch (error) {
-        logger.error("[Ls] Error handling callback:", error);
-        await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
-        return true;
-    }
-}