zardbot-telegram 1.0.0

package/dist/bot/commands/sessions.js

@@ -0,0 +1,351 @@
+import { InlineKeyboard } from "grammy";
+import { opencodeClient } from "../../opencode/client.js";
+import { setCurrentSession } from "../../session/manager.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { clearAllInteractionState } from "../../interaction/cleanup.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { keyboardManager } from "../../keyboard/manager.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 { safeBackgroundTask } from "../../utils/safe-background-task.js";
+import { config } from "../../config.js";
+import { getDateLocale, t } from "../../i18n/index.js";
+const SESSION_CALLBACK_PREFIX = "session:";
+const SESSION_PAGE_CALLBACK_PREFIX = "session:page:";
+const SESSION_FETCH_EXTRA_COUNT = 1;
+function buildSessionPageCallback(page) {
+    return `${SESSION_PAGE_CALLBACK_PREFIX}${page}`;
+}
+function parseSessionPageCallback(data) {
+    if (!data.startsWith(SESSION_PAGE_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const rawPage = data.slice(SESSION_PAGE_CALLBACK_PREFIX.length);
+    const page = Number(rawPage);
+    if (!Number.isInteger(page) || page < 0) {
+        return null;
+    }
+    return page;
+}
+function parseSessionIdCallback(data) {
+    if (!data.startsWith(SESSION_CALLBACK_PREFIX)) {
+        return null;
+    }
+    if (data.startsWith(SESSION_PAGE_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const sessionId = data.slice(SESSION_CALLBACK_PREFIX.length);
+    return sessionId.length > 0 ? sessionId : null;
+}
+function formatSessionsSelectText(page) {
+    if (page === 0) {
+        return t("sessions.select");
+    }
+    return t("sessions.select_page", { page: page + 1 });
+}
+async function loadSessionPage(directory, page, pageSize) {
+    const startIndex = page * pageSize;
+    const endExclusive = startIndex + pageSize;
+    const { data: sessions, error } = await opencodeClient.session.list({
+        directory,
+        limit: endExclusive + SESSION_FETCH_EXTRA_COUNT,
+        roots: true,
+    });
+    if (error || !sessions) {
+        throw error || new Error("No data received from server");
+    }
+    const hasNext = sessions.length > endExclusive;
+    const pagedSessions = sessions.slice(startIndex, endExclusive);
+    logger.debug(`[Sessions] Loaded page=${page + 1}, startIndex=${startIndex}, endExclusive=${endExclusive}, pageSize=${pageSize}, items=${pagedSessions.length}, hasNext=${hasNext}`);
+    return {
+        sessions: pagedSessions,
+        hasNext,
+        page,
+    };
+}
+function buildSessionsKeyboard(pageData, pageSize) {
+    const keyboard = new InlineKeyboard();
+    const localeForDate = getDateLocale();
+    const pageStartIndex = pageData.page * pageSize;
+    pageData.sessions.forEach((session, index) => {
+        const date = new Date(session.time.created).toLocaleDateString(localeForDate);
+        const label = `${pageStartIndex + index + 1}. ${session.title} (${date})`;
+        keyboard.text(label, `${SESSION_CALLBACK_PREFIX}${session.id}`).row();
+    });
+    if (pageData.page > 0) {
+        keyboard.text(t("sessions.button.prev_page"), buildSessionPageCallback(pageData.page - 1));
+    }
+    if (pageData.hasNext) {
+        keyboard.text(t("sessions.button.next_page"), buildSessionPageCallback(pageData.page + 1));
+    }
+    if (pageData.page > 0 || pageData.hasNext) {
+        keyboard.row();
+    }
+    return keyboard;
+}
+export async function sessionsCommand(ctx) {
+    try {
+        if (isForegroundBusy()) {
+            await replyBusyBlocked(ctx);
+            return;
+        }
+        const pageSize = config.bot.sessionsListLimit;
+        const currentProject = getCurrentProject();
+        if (!currentProject) {
+            await ctx.reply(t("sessions.project_not_selected"));
+            return;
+        }
+        logger.debug(`[Sessions] Fetching sessions for directory: ${currentProject.worktree}`);
+        const firstPage = await loadSessionPage(currentProject.worktree, 0, pageSize);
+        logger.debug(`[Sessions] Found ${firstPage.sessions.length} sessions on page 1`);
+        firstPage.sessions.forEach((session) => {
+            logger.debug(`[Sessions] Session: ${session.title} | ${session.directory}`);
+        });
+        if (firstPage.sessions.length === 0) {
+            await ctx.reply(t("sessions.empty"));
+            return;
+        }
+        const keyboard = buildSessionsKeyboard(firstPage, pageSize);
+        await replyWithInlineMenu(ctx, {
+            menuKind: "session",
+            text: formatSessionsSelectText(firstPage.page),
+            keyboard,
+        });
+    }
+    catch (error) {
+        logger.error("[Sessions] Error fetching sessions:", error);
+        await ctx.reply(t("sessions.fetch_error"));
+    }
+}
+export async function handleSessionSelect(ctx) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || !callbackQuery.data.startsWith(SESSION_CALLBACK_PREFIX)) {
+        return false;
+    }
+    if (isForegroundBusy()) {
+        await replyBusyBlocked(ctx);
+        return true;
+    }
+    const page = parseSessionPageCallback(callbackQuery.data);
+    const sessionId = parseSessionIdCallback(callbackQuery.data);
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "session");
+    if (!isActiveMenu) {
+        return true;
+    }
+    try {
+        const currentProject = getCurrentProject();
+        if (!currentProject) {
+            clearAllInteractionState("session_select_project_missing");
+            await ctx.answerCallbackQuery();
+            await ctx.reply(t("sessions.select_project_first"));
+            return true;
+        }
+        if (page !== null) {
+            try {
+                const pageSize = config.bot.sessionsListLimit;
+                const pageData = await loadSessionPage(currentProject.worktree, page, pageSize);
+                if (pageData.sessions.length === 0) {
+                    await ctx.answerCallbackQuery({ text: t("sessions.page_empty_callback") });
+                    return true;
+                }
+                const keyboard = buildSessionsKeyboard(pageData, pageSize);
+                appendInlineMenuCancelButton(keyboard, "session");
+                await ctx.editMessageText(formatSessionsSelectText(pageData.page), {
+                    reply_markup: keyboard,
+                });
+                await ctx.answerCallbackQuery();
+            }
+            catch (error) {
+                logger.error("[Sessions] Error loading sessions page:", error);
+                await ctx.answerCallbackQuery({ text: t("sessions.page_load_error_callback") });
+            }
+            return true;
+        }
+        if (!sessionId) {
+            await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
+            return true;
+        }
+        const { data: session, error } = await opencodeClient.session.get({
+            sessionID: sessionId,
+            directory: currentProject.worktree,
+        });
+        if (error || !session) {
+            throw error || new Error("Failed to get session details");
+        }
+        logger.info(`[Bot] Session selected: id=${session.id}, title="${session.title}", project=${currentProject.worktree}`);
+        const sessionInfo = {
+            id: session.id,
+            title: session.title,
+            directory: currentProject.worktree,
+        };
+        setCurrentSession(sessionInfo);
+        summaryAggregator.clear();
+        clearAllInteractionState("session_switched");
+        await ctx.answerCallbackQuery();
+        let loadingMessageId = null;
+        if (ctx.chat) {
+            try {
+                const loadingMessage = await ctx.api.sendMessage(ctx.chat.id, t("sessions.loading_context"));
+                loadingMessageId = loadingMessage.message_id;
+            }
+            catch (err) {
+                logger.error("[Sessions] Failed to send loading message:", err);
+            }
+        }
+        // Initialize pinned message manager if not already
+        if (!pinnedMessageManager.isInitialized() && ctx.chat) {
+            pinnedMessageManager.initialize(ctx.api, ctx.chat.id);
+        }
+        // Initialize keyboard manager if not already
+        if (ctx.chat) {
+            keyboardManager.initialize(ctx.api, ctx.chat.id);
+        }
+        try {
+            // Create new pinned message for this session
+            await pinnedMessageManager.onSessionChange(session.id, session.title);
+            // Load context from session history (for existing sessions)
+            // Wait for it to complete so keyboard has correct context
+            await pinnedMessageManager.loadContextFromHistory(session.id, currentProject.worktree);
+        }
+        catch (err) {
+            logger.error("[Bot] Error initializing pinned message:", err);
+        }
+        if (ctx.chat) {
+            const chatId = ctx.chat.id;
+            // Update keyboard with loaded context (callback executes async via setImmediate, so update manually)
+            const contextInfo = pinnedMessageManager.getContextInfo();
+            if (contextInfo) {
+                keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
+            }
+            // Delete loading message
+            if (loadingMessageId) {
+                try {
+                    await ctx.api.deleteMessage(chatId, loadingMessageId);
+                }
+                catch (err) {
+                    logger.debug("[Sessions] Failed to delete loading message:", err);
+                }
+            }
+            // Send session selection confirmation with updated keyboard
+            const keyboard = keyboardManager.getKeyboard();
+            try {
+                await ctx.api.sendMessage(chatId, t("sessions.selected", { title: session.title }), {
+                    reply_markup: keyboard,
+                });
+            }
+            catch (err) {
+                logger.error("[Sessions] Failed to send selection message:", err);
+            }
+            // Send preview asynchronously
+            safeBackgroundTask({
+                taskName: "sessions.sendPreview",
+                task: () => sendSessionPreview(ctx.api, chatId, null, session.title, session.id, currentProject.worktree),
+            });
+        }
+        await ctx.deleteMessage();
+    }
+    catch (error) {
+        clearAllInteractionState("session_select_error");
+        logger.error("[Sessions] Error selecting session:", error);
+        await ctx.answerCallbackQuery();
+        await ctx.reply(t("sessions.select_error"));
+    }
+    return true;
+}
+const PREVIEW_MESSAGES_LIMIT = 6;
+const PREVIEW_ITEM_MAX_LENGTH = 420;
+const TELEGRAM_MESSAGE_LIMIT = 4096;
+function extractTextParts(parts) {
+    const textParts = parts
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text);
+    if (textParts.length === 0) {
+        return null;
+    }
+    const text = textParts.join("").trim();
+    return text.length > 0 ? text : null;
+}
+function truncateText(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    const clipped = text.slice(0, Math.max(0, maxLength - 3)).trimEnd();
+    return `${clipped}...`;
+}
+async function loadSessionPreview(sessionId, directory) {
+    try {
+        const { data: messages, error } = await opencodeClient.session.messages({
+            sessionID: sessionId,
+            directory,
+            limit: PREVIEW_MESSAGES_LIMIT,
+        });
+        if (error || !messages) {
+            logger.warn("[Sessions] Failed to fetch session messages:", error);
+            return [];
+        }
+        const items = messages
+            .map(({ info, parts }) => {
+            const role = info.role;
+            if (role !== "user" && role !== "assistant") {
+                return null;
+            }
+            if (role === "assistant" && info.summary) {
+                return null;
+            }
+            const text = extractTextParts(parts);
+            if (!text) {
+                return null;
+            }
+            const created = info.time?.created ?? 0;
+            return {
+                role,
+                text: truncateText(text, PREVIEW_ITEM_MAX_LENGTH),
+                created,
+            };
+        })
+            .filter((item) => Boolean(item));
+        return items.sort((a, b) => a.created - b.created);
+    }
+    catch (err) {
+        logger.error("[Sessions] Error loading session preview:", err);
+        return [];
+    }
+}
+function formatSessionPreview(_sessionTitle, items) {
+    const lines = [];
+    if (items.length === 0) {
+        lines.push(t("sessions.preview.empty"));
+        return lines.join("\n");
+    }
+    lines.push(t("sessions.preview.title"));
+    items.forEach((item, index) => {
+        const label = item.role === "user" ? t("sessions.preview.you") : t("sessions.preview.agent");
+        lines.push(`${label} ${item.text}`);
+        if (index < items.length - 1) {
+            lines.push("");
+        }
+    });
+    const rawMessage = lines.join("\n");
+    return truncateText(rawMessage, TELEGRAM_MESSAGE_LIMIT);
+}
+async function sendSessionPreview(api, chatId, messageId, sessionTitle, sessionId, directory) {
+    const previewItems = await loadSessionPreview(sessionId, directory);
+    const finalText = formatSessionPreview(sessionTitle, previewItems);
+    if (messageId) {
+        try {
+            await api.editMessageText(chatId, messageId, finalText);
+            return;
+        }
+        catch (err) {
+            logger.warn("[Sessions] Failed to edit preview message, sending new one:", err);
+        }
+    }
+    try {
+        await api.sendMessage(chatId, finalText);
+    }
+    catch (err) {
+        logger.error("[Sessions] Failed to send session preview message:", err);
+    }
+}

package/dist/bot/commands/start.js

@@ -0,0 +1,43 @@
+import { createMainKeyboard } from "../utils/keyboard.js";
+import { getStoredAgent } from "../../agent/manager.js";
+import { getStoredModel } from "../../model/manager.js";
+import { formatVariantForButton } from "../../variant/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { clearSession } from "../../session/manager.js";
+import { clearProject } from "../../settings/manager.js";
+import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
+import { abortCurrentOperation } from "./abort.js";
+import { t } from "../../i18n/index.js";
+export async function startCommand(ctx) {
+    if (ctx.chat) {
+        if (!pinnedMessageManager.isInitialized()) {
+            pinnedMessageManager.initialize(ctx.api, ctx.chat.id);
+        }
+        keyboardManager.initialize(ctx.api, ctx.chat.id);
+    }
+    await abortCurrentOperation(ctx, { notifyUser: false });
+    foregroundSessionState.clearAll("start_command_reset");
+    clearSession();
+    clearProject();
+    keyboardManager.clearContext();
+    await pinnedMessageManager.clear();
+    if (pinnedMessageManager.getContextLimit() === 0) {
+        await pinnedMessageManager.refreshContextLimit();
+    }
+    // Get current agent, model, and context
+    const currentAgent = getStoredAgent();
+    const currentModel = getStoredModel();
+    const variantName = formatVariantForButton(currentModel.variant || "default");
+    const contextInfo = pinnedMessageManager.getContextInfo() ??
+        (pinnedMessageManager.getContextLimit() > 0
+            ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit() }
+            : null);
+    keyboardManager.updateAgent(currentAgent);
+    keyboardManager.updateModel(currentModel);
+    if (contextInfo) {
+        keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
+    }
+    const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo ?? undefined, variantName);
+    await ctx.reply(t("start.welcome"), { reply_markup: keyboard });
+}

package/dist/bot/commands/status.js

@@ -0,0 +1,95 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { getCurrentSession } from "../../session/manager.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { fetchCurrentAgent } from "../../agent/manager.js";
+import { getAgentDisplayName } from "../../agent/types.js";
+import { fetchCurrentModel } from "../../model/manager.js";
+import { processManager } from "../../process/manager.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { sendBotText } from "../utils/telegram-text.js";
+export async function statusCommand(ctx) {
+    try {
+        const { data, error } = await opencodeClient.global.health();
+        if (error || !data) {
+            throw error || new Error("No data received from server");
+        }
+        let message = `${t("status.header_running")}\n\n`;
+        const healthLabel = data.healthy ? t("status.health.healthy") : t("status.health.unhealthy");
+        message += `${t("status.line.health", { health: healthLabel })}\n`;
+        if (data.version) {
+            message += `${t("status.line.version", { version: data.version })}\n`;
+        }
+        // Add process management information
+        if (processManager.isRunning()) {
+            const uptime = processManager.getUptime();
+            const uptimeStr = uptime ? Math.floor(uptime / 1000) : 0;
+            message += `${t("status.line.managed_yes")}\n`;
+            message += `${t("status.line.pid", { pid: processManager.getPID() ?? "-" })}\n`;
+            message += `${t("status.line.uptime_sec", { seconds: uptimeStr })}\n`;
+        }
+        else {
+            message += `${t("status.line.managed_no")}\n`;
+        }
+        // Add agent mode information
+        const currentAgent = await fetchCurrentAgent();
+        const agentDisplay = currentAgent
+            ? getAgentDisplayName(currentAgent)
+            : t("status.agent_not_set");
+        message += `${t("status.line.mode", { mode: agentDisplay })}\n`;
+        // Add model information
+        const currentModel = fetchCurrentModel();
+        const modelDisplay = `🤖 ${currentModel.providerID}/${currentModel.modelID}`;
+        message += `${t("status.line.model", { model: modelDisplay })}\n`;
+        const currentProject = getCurrentProject();
+        if (currentProject) {
+            const projectName = currentProject.name || currentProject.worktree;
+            message += `\n${t("status.project_selected", { project: projectName })}\n`;
+        }
+        else {
+            message += `\n${t("status.project_not_selected")}\n`;
+            message += t("status.project_hint");
+        }
+        const currentSession = getCurrentSession();
+        if (currentSession) {
+            message += `\n${t("status.session_selected", { title: currentSession.title })}\n`;
+        }
+        else {
+            message += `\n${t("status.session_not_selected")}\n`;
+            message += t("status.session_hint");
+        }
+        if (ctx.chat) {
+            if (!pinnedMessageManager.isInitialized()) {
+                pinnedMessageManager.initialize(ctx.api, ctx.chat.id);
+            }
+            // Fetch context limit if not yet loaded (e.g. fresh bot start)
+            if (pinnedMessageManager.getContextLimit() === 0) {
+                await pinnedMessageManager.refreshContextLimit();
+            }
+            keyboardManager.initialize(ctx.api, ctx.chat.id);
+        }
+        // Sync current context (tokens used + limit) into keyboard state
+        const contextInfo = pinnedMessageManager.getContextInfo();
+        if (contextInfo) {
+            keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
+        }
+        const keyboard = keyboardManager.getKeyboard();
+        if (ctx.chat) {
+            await sendBotText({
+                api: ctx.api,
+                chatId: ctx.chat.id,
+                text: message,
+                options: { reply_markup: keyboard },
+            });
+        }
+        else {
+            await ctx.reply(message, { reply_markup: keyboard });
+        }
+    }
+    catch (error) {
+        logger.error("[Bot] Error checking server status:", error);
+        await ctx.reply(t("status.server_unavailable"));
+    }
+}