zardbot-telegram 1.0.0

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

@@ -0,0 +1,101 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { processManager } from "../../process/manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { editBotText } from "../utils/telegram-text.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 editBotText({
+                api: ctx.api,
+                chatId: ctx.chat.id,
+                messageId: statusMessage.message_id,
+                text: t("opencode_start.start_error", { error: error || t("common.unknown_error") }),
+            });
+            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 editBotText({
+                api: ctx.api,
+                chatId: ctx.chat.id,
+                messageId: statusMessage.message_id,
+                text: 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 editBotText({
+            api: ctx.api,
+            chatId: ctx.chat.id,
+            messageId: statusMessage.message_id,
+            text: 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,223 @@
+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 { 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 { clearAllInteractionState } from "../../interaction/cleanup.js";
+import { createMainKeyboard } from "../utils/keyboard.js";
+import { appendInlineMenuCancelButton, ensureActiveInlineMenu, replyWithInlineMenu, } from "../handlers/inline-menu.js";
+import { isForegroundBusy, replyBusyBlocked } from "../utils/busy-guard.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { config } from "../../config.js";
+const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+const PROJECT_PAGE_CALLBACK_PREFIX = "projects:page:";
+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) {
+    const keyboard = new InlineKeyboard();
+    const currentProject = getCurrentProject();
+    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) {
+    const currentProject = getCurrentProject();
+    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),
+    };
+}
+export async function projectsCommand(ctx) {
+    try {
+        if (isForegroundBusy()) {
+            await replyBusyBlocked(ctx);
+            return;
+        }
+        await syncSessionDirectoryCache();
+        const projects = await getProjects();
+        if (projects.length === 0) {
+            await ctx.reply(t("projects.empty"));
+            return;
+        }
+        const { text, keyboard } = buildProjectsMenuView(projects, 0);
+        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 callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data) {
+        return false;
+    }
+    if (isForegroundBusy()) {
+        await replyBusyBlocked(ctx);
+        return true;
+    }
+    const page = parseProjectPageCallback(callbackQuery.data);
+    if (page !== null) {
+        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);
+            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:")) {
+        return false;
+    }
+    const projectId = callbackQuery.data.replace("project:", "");
+    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);
+        clearSession();
+        summaryAggregator.clear();
+        clearAllInteractionState("project_switched");
+        // Clear pinned message when switching projects
+        try {
+            await pinnedMessageManager.clear();
+        }
+        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);
+        }
+        // Refresh context limit for current model
+        await pinnedMessageManager.refreshContextLimit();
+        const contextLimit = pinnedMessageManager.getContextLimit();
+        // Reset context to 0 (no session selected) with current model's limit
+        keyboardManager.updateContext(0, contextLimit);
+        // Get current state for keyboard (with context = 0)
+        const currentAgent = getStoredAgent();
+        const currentModel = getStoredModel();
+        const contextInfo = { tokensUsed: 0, tokensLimit: contextLimit };
+        const variantName = formatVariantForButton(currentModel.variant || "default");
+        const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo, variantName);
+        const projectName = selectedProject.name || selectedProject.worktree;
+        await ctx.answerCallbackQuery();
+        await ctx.reply(t("projects.selected", { project: projectName }), {
+            reply_markup: keyboard,
+        });
+        await ctx.deleteMessage();
+    }
+    catch (error) {
+        clearAllInteractionState("project_select_error");
+        logger.error("[Bot] Error selecting project:", error);
+        await ctx.answerCallbackQuery();
+        await ctx.reply(t("projects.select_error"));
+    }
+    return true;
+}

package/dist/bot/commands/rename.js

@@ -0,0 +1,139 @@
+import { InlineKeyboard } from "grammy";
+import { opencodeClient } from "../../opencode/client.js";
+import { getCurrentSession, setCurrentSession } from "../../session/manager.js";
+import { renameManager } from "../../rename/manager.js";
+import { interactionManager } from "../../interaction/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+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 clearRenameInteraction(reason) {
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "rename") {
+        interactionManager.clear(reason);
+    }
+}
+export async function renameCommand(ctx) {
+    try {
+        const currentSession = getCurrentSession();
+        if (!currentSession) {
+            await ctx.reply(t("rename.no_session"));
+            return;
+        }
+        const keyboard = new InlineKeyboard().text(t("rename.button.cancel"), "rename:cancel");
+        const message = await ctx.reply(t("rename.prompt", { title: currentSession.title }), {
+            reply_markup: keyboard,
+        });
+        renameManager.startWaiting(currentSession.id, currentSession.directory, currentSession.title);
+        renameManager.setMessageId(message.message_id);
+        interactionManager.start({
+            kind: "rename",
+            expectedInput: "text",
+            metadata: {
+                sessionId: currentSession.id,
+                messageId: message.message_id,
+            },
+        });
+        logger.info(`[RenameCommand] Waiting for new title for session: ${currentSession.id}`);
+    }
+    catch (error) {
+        logger.error("[RenameCommand] Error starting rename flow:", error);
+        await ctx.reply(t("rename.error"));
+    }
+}
+export async function handleRenameCancel(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data || data !== "rename:cancel") {
+        return false;
+    }
+    logger.debug("[RenameHandler] Cancel callback received");
+    if (!renameManager.isWaitingForName()) {
+        clearRenameInteraction("rename_cancel_inactive");
+        await ctx.answerCallbackQuery({ text: t("rename.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const interactionState = interactionManager.getSnapshot();
+    if (interactionState?.kind !== "rename") {
+        renameManager.clear();
+        await ctx.answerCallbackQuery({ text: t("rename.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const callbackMessageId = getCallbackMessageId(ctx);
+    if (!renameManager.isActiveMessage(callbackMessageId)) {
+        await ctx.answerCallbackQuery({ text: t("rename.inactive_callback"), show_alert: true });
+        return true;
+    }
+    renameManager.clear();
+    clearRenameInteraction("rename_cancelled");
+    await ctx.answerCallbackQuery();
+    await ctx.editMessageText(t("rename.cancelled")).catch(() => { });
+    return true;
+}
+export async function handleRenameTextAnswer(ctx) {
+    if (!renameManager.isWaitingForName()) {
+        return false;
+    }
+    const text = ctx.message?.text;
+    if (!text) {
+        return false;
+    }
+    if (text.startsWith("/")) {
+        return false;
+    }
+    const interactionState = interactionManager.getSnapshot();
+    if (interactionState?.kind !== "rename") {
+        renameManager.clear();
+        await ctx.reply(t("rename.inactive"));
+        return true;
+    }
+    const sessionInfo = renameManager.getSessionInfo();
+    if (!sessionInfo) {
+        renameManager.clear();
+        clearRenameInteraction("rename_missing_session_info");
+        return false;
+    }
+    const newTitle = text.trim();
+    if (!newTitle) {
+        await ctx.reply(t("rename.empty_title"));
+        return true;
+    }
+    logger.info(`[RenameHandler] Renaming session ${sessionInfo.sessionId} to: ${newTitle}`);
+    try {
+        const { data: updatedSession, error } = await opencodeClient.session.update({
+            sessionID: sessionInfo.sessionId,
+            directory: sessionInfo.directory,
+            title: newTitle,
+        });
+        if (error || !updatedSession) {
+            throw error || new Error("Failed to update session");
+        }
+        setCurrentSession({
+            id: sessionInfo.sessionId,
+            title: newTitle,
+            directory: sessionInfo.directory,
+        });
+        if (pinnedMessageManager.isInitialized()) {
+            await pinnedMessageManager.onSessionChange(sessionInfo.sessionId, newTitle);
+        }
+        const messageId = renameManager.getMessageId();
+        if (messageId && ctx.chat) {
+            await ctx.api.deleteMessage(ctx.chat.id, messageId).catch(() => { });
+        }
+        await ctx.reply(t("rename.success", { title: newTitle }));
+        logger.info(`[RenameHandler] Session renamed successfully: ${newTitle}`);
+    }
+    catch (error) {
+        logger.error("[RenameHandler] Error renaming session:", error);
+        await ctx.reply(t("rename.error"));
+    }
+    renameManager.clear();
+    clearRenameInteraction("rename_completed");
+    return true;
+}