@grinev/opencode-telegram-bot 0.19.3 → 0.20.0

package/dist/bot/commands/ls.js

@@ -0,0 +1,445 @@
+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;
+    }
+}

package/dist/bot/commands/open.js

@@ -210,7 +210,7 @@ export async function openCommand(ctx) {
         await ctx.reply(t("open.open_error"));
     }
 }
-export async function handleOpenCallback(ctx) {
+export async function handleOpenCallback(ctx, deps = {}) {
     const data = ctx.callbackQuery?.data;
     if (!data || !data.startsWith(CALLBACK_PREFIX)) {
         return false;
@@ -256,7 +256,7 @@ export async function handleOpenCallback(ctx) {
                 await ctx.answerCallbackQuery({ text: t("open.access_denied") });
                 return true;
             }
-            await selectDirectory(ctx, selectPath);
+            await selectDirectory(ctx, selectPath, deps);
             return true;
         }
         return false;
@@ -284,7 +284,7 @@ async function navigateTo(ctx, dirPath, page = 0) {
         reply_markup: view.keyboard,
     });
 }
-async function selectDirectory(ctx, directory) {
+async function selectDirectory(ctx, directory, deps = {}) {
     const displayPath = pathToDisplayPath(directory);
     try {
         logger.info(`[Bot] Adding project directory: ${directory}`);
@@ -295,7 +295,12 @@ async function selectDirectory(ctx, directory) {
         // will simply appear in /projects for retry.
         await upsertSessionDirectory(directory, Date.now());
         const projectInfo = await getProjectByWorktree(directory);
-        const replyKeyboard = await switchToProject(ctx, { ...projectInfo, name: displayPath }, "open_project_selected");
+        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,

package/dist/bot/commands/projects.js

@@ -148,7 +148,7 @@ export async function projectsCommand(ctx) {
         await ctx.reply(t("projects.fetch_error"));
     }
 }
-export async function handleProjectSelect(ctx) {
+export async function handleProjectSelect(ctx, deps = {}) {
     const callbackQuery = ctx.callbackQuery;
     if (!callbackQuery?.data) {
         return false;
@@ -199,7 +199,11 @@ export async function handleProjectSelect(ctx) {
         }
         const projectName = selectedProject.name || selectedProject.worktree;
         logger.info(`[Bot] Project selected: ${projectName} (id: ${projectId})`);
-        const keyboard = await switchToProject(ctx, selectedProject, "project_switched");
+        const keyboard = deps.ensureEventSubscription
+            ? await switchToProject(ctx, selectedProject, "project_switched", {
+                ensureEventSubscription: deps.ensureEventSubscription,
+            })
+            : await switchToProject(ctx, selectedProject, "project_switched");
         await ctx.answerCallbackQuery();
         await ctx.reply(t("projects.selected", { project: projectName }), {
             reply_markup: keyboard,