@grinev/opencode-telegram-bot 0.21.1 → 0.22.0

package/dist/bot/messages/thinking-rendering.js

@@ -0,0 +1,66 @@
+import { t } from "../../i18n/index.js";
+function formatHeader(title) {
+    const fallback = t("bot.thinking");
+    const normalizedTitle = title?.trim();
+    return normalizedTitle ? `${fallback} — ${normalizedTitle}` : fallback;
+}
+function quoteFallbackText(text) {
+    return text
+        .split("\n")
+        .map((line) => `> ${line}`)
+        .join("\n");
+}
+function splitText(text, maxLength) {
+    if (text.length <= maxLength) {
+        return [text];
+    }
+    const chunks = [];
+    for (let offset = 0; offset < text.length; offset += maxLength) {
+        chunks.push(text.slice(offset, offset + maxLength));
+    }
+    return chunks;
+}
+function createThinkingPart(header, text, expandable) {
+    if (!text) {
+        return {
+            text: header,
+            fallbackText: header,
+            source: "entities",
+        };
+    }
+    const renderedText = `${header}\n${text}`;
+    const entity = {
+        type: expandable ? "expandable_blockquote" : "blockquote",
+        offset: header.length + 1,
+        length: text.length,
+    };
+    return {
+        text: renderedText,
+        entities: [entity],
+        fallbackText: `${header}\n${quoteFallbackText(text)}`,
+        source: "entities",
+    };
+}
+export function prepareThinkingStreamingPayload(sections, maxPartLength, options = {}) {
+    const parts = [];
+    const expandable = options.expandable ?? true;
+    for (const section of sections) {
+        const header = formatHeader(section.title);
+        const text = section.text.replace(/\r\n/g, "\n").trimEnd();
+        const textLimit = Math.max(1, maxPartLength - header.length - 1);
+        const chunks = text ? splitText(text, textLimit) : [""];
+        for (const chunk of chunks) {
+            parts.push(createThinkingPart(header, chunk, expandable));
+        }
+    }
+    return parts.length > 0 ? { parts } : null;
+}
+export function makeThinkingPayloadExpandable(payload) {
+    return {
+        ...payload,
+        parts: payload.parts.map((part) => ({
+            ...part,
+            entities: part.entities?.map((entity) => entity.type === "blockquote" ? { ...entity, type: "expandable_blockquote" } : entity),
+        })),
+    };
+}

package/dist/{interaction/guard.js → bot/middleware/interaction-guard-decision.js}

@@ -1,7 +1,14 @@
-import { interactionManager } from "./manager.js";
-import { allowsBusyInteraction, isBusyAllowedCommand } from "./busy.js";
-import { foregroundSessionState } from "../scheduled-task/foreground-state.js";
-import { attachManager } from "../attach/manager.js";
+import { interactionManager } from "../../app/managers/interaction-manager.js";
+import { foregroundSessionState } from "../../app/managers/foreground-session-state-manager.js";
+import { attachManager } from "../../app/managers/attach-manager.js";
+const BUSY_ALLOWED_COMMANDS = ["/abort", "/detach", "/status", "/help"];
+const BUSY_ALLOWED_COMMAND_SET = new Set(BUSY_ALLOWED_COMMANDS);
+function isBusyAllowedCommand(command) {
+    return Boolean(command && BUSY_ALLOWED_COMMAND_SET.has(command));
+}
+function allowsBusyInteraction(kind) {
+    return kind === "question" || kind === "permission";
+}
 function normalizeIncomingCommand(text) {
     const trimmed = text.trim();
     if (!trimmed.startsWith("/")) {

package/dist/bot/middleware/interaction-guard.js

@@ -1,5 +1,5 @@
-import { resolveInteractionGuardDecision } from "../../interaction/guard.js";
-import { reconcileForegroundBusyState } from "../utils/busy-guard.js";
+import { resolveInteractionGuardDecision } from "./interaction-guard-decision.js";
+import { reconcileForegroundBusyState } from "../../app/services/run-control-service.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 function getInteractionBlockedMessage(reason, interactionKind) {

package/dist/bot/middleware/unknown-command.js

@@ -1,4 +1,4 @@
-import { extractCommandName, isKnownCommand } from "../utils/commands.js";
+import { extractCommandName, isKnownCommand } from "../routers/command-utils.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 export async function unknownCommandMiddleware(ctx, next) {

package/dist/{pinned/format.js → bot/pinned/pinned-message-format.js}

@@ -1,5 +1,4 @@
-import { t } from "../i18n/index.js";
-export const DEFAULT_CONTEXT_LIMIT = 200000;
+import { t } from "../../i18n/index.js";
 export function formatTokenCount(count) {
     if (count >= 1000000) {
         return `${(count / 1000000).toFixed(1)}M`;

package/dist/{pinned/manager.js → bot/pinned/pinned-message-manager.js}

@@ -1,13 +1,13 @@
-import { logger } from "../utils/logger.js";
-import { opencodeClient } from "../opencode/client.js";
-import { getGitWorktreeContext } from "../git/worktree.js";
-import { getCurrentSession } from "../session/manager.js";
-import { getCurrentProject, getPinnedMessageId, setPinnedMessageId, clearPinnedMessageId, } from "../settings/manager.js";
-import { getStoredModel } from "../model/manager.js";
-import { getModelContextLimit } from "../model/context-limit.js";
-import { isExpectedOpencodeUnavailableError } from "../utils/opencode-error.js";
-import { t } from "../i18n/index.js";
-import { DEFAULT_CONTEXT_LIMIT, formatContextLine, formatCostLine, formatModelDisplayName, } from "./format.js";
+import { logger } from "../../utils/logger.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { getGitWorktreeContext } from "../../app/services/worktree-service.js";
+import { getCurrentSession } from "../../app/services/session-service.js";
+import { getCurrentProject, getPinnedMessageId, setPinnedMessageId, clearPinnedMessageId, } from "../../app/stores/settings-store.js";
+import { DEFAULT_CONTEXT_LIMIT, getModelContextLimit, } from "../../app/services/model-context-limit-service.js";
+import { getStoredModel } from "../../app/services/model-selection-service.js";
+import { isExpectedOpencodeUnavailableError } from "../../utils/opencode-error.js";
+import { t } from "../../i18n/index.js";
+import { formatContextLine, formatCostLine, formatModelDisplayName, } from "./pinned-message-format.js";
 class PinnedMessageManager {
     api = null;
     chatId = null;

package/dist/bot/pinned/pinned-message-types.js

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

package/dist/{summary → bot/render}/markdown-to-telegram-v2.js

@@ -1,5 +1,5 @@
-import { parseTelegramBlocks } from "../telegram/render/block-parser.js";
-import { normalizeMarkdownForTelegramRendering } from "../telegram/render/markdown-normalizer.js";
+import { parseTelegramBlocks } from "./block-parser.js";
+import { normalizeMarkdownForTelegramRendering } from "./markdown-normalizer.js";
 /**
  * Escapes characters reserved in Telegram MarkdownV2.
  * These must be escaped everywhere except when used as syntactic delimiters

package/dist/bot/render/types.js

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

package/dist/bot/routers/command-router.js

@@ -0,0 +1,73 @@
+import { config } from "../../config.js";
+import { settingsCommand } from "../commands/settings-command.js";
+import { opencodeStartCommand } from "../commands/opencode-start-command.js";
+import { opencodeStopCommand } from "../commands/opencode-stop-command.js";
+import { projectsCommand } from "../commands/projects-command.js";
+import { worktreeCommand } from "../commands/worktree-command.js";
+import { openCommand } from "../commands/open-command.js";
+import { lsCommand } from "../commands/ls-command.js";
+import { sessionsCommand } from "../commands/sessions-command.js";
+import { messagesCommand } from "../commands/messages-command.js";
+import { newCommand } from "../commands/new-command.js";
+import { abortCommand } from "../commands/abort-command.js";
+import { detachCommand } from "../commands/detach-command.js";
+import { taskCommand } from "../commands/task-command.js";
+import { taskListCommand } from "../commands/tasklist-command.js";
+import { renameCommand } from "../commands/rename-command.js";
+import { commandsCommand } from "../commands/command-catalog-command.js";
+import { skillsCommand } from "../commands/skills-catalog-command.js";
+import { mcpsCommand } from "../commands/mcp-catalog-command.js";
+import { startCommand } from "../commands/start-command.js";
+import { helpCommand } from "../commands/help-command.js";
+import { statusCommand } from "../commands/status-command.js";
+import { BOT_COMMANDS } from "../commands/definitions.js";
+import { logger } from "../../utils/logger.js";
+let commandsInitialized = false;
+export async function ensureCommandsInitialized(ctx, next) {
+    if (commandsInitialized || !ctx.from || ctx.from.id !== config.telegram.allowedUserId) {
+        await next();
+        return;
+    }
+    if (!ctx.chat) {
+        logger.warn("[Bot] Cannot initialize commands: chat context is missing");
+        await next();
+        return;
+    }
+    try {
+        await ctx.api.setMyCommands(BOT_COMMANDS, {
+            scope: {
+                type: "chat",
+                chat_id: ctx.chat.id,
+            },
+        });
+        commandsInitialized = true;
+        logger.debug(`[Bot] Commands initialized for authorized user (chat_id=${ctx.chat.id})`);
+    }
+    catch (err) {
+        logger.error("[Bot] Failed to set commands:", err);
+    }
+    await next();
+}
+export function registerCommandRouter(bot, deps) {
+    bot.command("start", startCommand);
+    bot.command("help", helpCommand);
+    bot.command("status", statusCommand);
+    bot.command("settings", settingsCommand);
+    bot.command("opencode_start", opencodeStartCommand);
+    bot.command("opencode_stop", opencodeStopCommand);
+    bot.command("projects", projectsCommand);
+    bot.command("worktree", worktreeCommand);
+    bot.command("open", openCommand);
+    bot.command("ls", lsCommand);
+    bot.command("sessions", sessionsCommand);
+    bot.command("messages", messagesCommand);
+    bot.command("new", (ctx) => newCommand(ctx, { bot, ensureEventSubscription: deps.ensureEventSubscription }));
+    bot.command("abort", abortCommand);
+    bot.command("detach", detachCommand);
+    bot.command("task", taskCommand);
+    bot.command("tasklist", taskListCommand);
+    bot.command("rename", renameCommand);
+    bot.command("commands", commandsCommand);
+    bot.command("skills", skillsCommand);
+    bot.command("mcps", mcpsCommand);
+}

package/dist/bot/routers/message-router.js

@@ -0,0 +1,150 @@
+import { interactionManager } from "../../app/managers/interaction-manager.js";
+import { questionManager } from "../../app/managers/question-manager.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+import { handleTaskTextInput } from "../commands/task-command.js";
+import { handleModelSearchTextInput, } from "../callbacks/model-selection-callback-handler.js";
+import { handleQuestionTextAnswer } from "../callbacks/question-callback-handler.js";
+import { handleRenameTextAnswer } from "../callbacks/rename-callback-handler.js";
+import { handleContextButtonPress } from "../menus/context-control-menu.js";
+import { showAgentSelectionMenu } from "../menus/agent-selection-menu.js";
+import { showModelSelectionMenu } from "../menus/model-selection-menu.js";
+import { showVariantSelectionMenu } from "../menus/variant-selection-menu.js";
+import { AGENT_MODE_BUTTON_TEXT_PATTERN, MODEL_BUTTON_TEXT_PATTERN, VARIANT_BUTTON_TEXT_PATTERN, } from "../message-patterns.js";
+import { handleDocumentMessage } from "../handlers/document-handler.js";
+import { createMediaGroupAttachmentMiddleware } from "../handlers/media-group-handler.js";
+import { handlePhotoMessage } from "../handlers/photo-handler.js";
+import { processUserPrompt } from "../handlers/prompt.js";
+import { handleCatalogTextArguments } from "../handlers/text-message-handler.js";
+import { handleVoiceMessage } from "../handlers/voice-handler.js";
+import { unknownCommandMiddleware } from "../middleware/unknown-command.js";
+async function blockMenuWhileInteractionActive(ctx) {
+    const activeInteraction = interactionManager.getSnapshot();
+    if (!activeInteraction) {
+        return false;
+    }
+    logger.debug(`[Bot] Blocking menu open while interaction active: kind=${activeInteraction.kind}, expectedInput=${activeInteraction.expectedInput}`);
+    await ctx.reply(t("interaction.blocked.finish_current"));
+    return true;
+}
+export function registerMessageRouter(bot, deps) {
+    bot.on("message:text", unknownCommandMiddleware);
+    bot.hears(AGENT_MODE_BUTTON_TEXT_PATTERN, async (ctx) => {
+        logger.debug(`[Bot] Agent button pressed: ${ctx.message?.text}`);
+        try {
+            if (await blockMenuWhileInteractionActive(ctx)) {
+                return;
+            }
+            await showAgentSelectionMenu(ctx);
+        }
+        catch (err) {
+            logger.error("[Bot] Error showing agent menu:", err);
+            await ctx.reply(t("error.load_agents"));
+        }
+    });
+    bot.hears(MODEL_BUTTON_TEXT_PATTERN, async (ctx) => {
+        logger.debug(`[Bot] Model button pressed: ${ctx.message?.text}`);
+        try {
+            if (await blockMenuWhileInteractionActive(ctx)) {
+                return;
+            }
+            await showModelSelectionMenu(ctx);
+        }
+        catch (err) {
+            logger.error("[Bot] Error showing model menu:", err);
+            await ctx.reply(t("error.load_models"));
+        }
+    });
+    bot.hears(/^📊(?:\s|$)/, async (ctx) => {
+        logger.debug(`[Bot] Context button pressed: ${ctx.message?.text}`);
+        try {
+            if (await blockMenuWhileInteractionActive(ctx)) {
+                return;
+            }
+            await handleContextButtonPress(ctx);
+        }
+        catch (err) {
+            logger.error("[Bot] Error handling context button:", err);
+            await ctx.reply(t("error.context_button"));
+        }
+    });
+    bot.hears(VARIANT_BUTTON_TEXT_PATTERN, async (ctx) => {
+        logger.debug(`[Bot] Variant button pressed: ${ctx.message?.text}`);
+        try {
+            if (await blockMenuWhileInteractionActive(ctx)) {
+                return;
+            }
+            await showVariantSelectionMenu(ctx);
+        }
+        catch (err) {
+            logger.error("[Bot] Error showing variant menu:", err);
+            await ctx.reply(t("error.load_variants"));
+        }
+    });
+    bot.on("message:text", async (ctx, next) => {
+        const text = ctx.message?.text;
+        if (text) {
+            const isCommand = text.startsWith("/");
+            logger.debug(`[Bot] Received text message: ${isCommand ? `command="${text}"` : `prompt (length=${text.length})`}, chatId=${ctx.chat.id}`);
+        }
+        await next();
+    });
+    const voicePromptDeps = { bot, ensureEventSubscription: deps.ensureEventSubscription };
+    bot.on("message:voice", async (ctx) => {
+        logger.debug(`[Bot] Received voice message, chatId=${ctx.chat.id}`);
+        deps.setTelegramContext(bot, ctx.chat.id);
+        await handleVoiceMessage(ctx, voicePromptDeps);
+    });
+    bot.on("message:audio", async (ctx) => {
+        logger.debug(`[Bot] Received audio message, chatId=${ctx.chat.id}`);
+        deps.setTelegramContext(bot, ctx.chat.id);
+        await handleVoiceMessage(ctx, voicePromptDeps);
+    });
+    bot.on("message", createMediaGroupAttachmentMiddleware({
+        bot,
+        ensureEventSubscription: deps.ensureEventSubscription,
+    }));
+    bot.on("message:photo", async (ctx) => {
+        logger.debug(`[Bot] Received photo message, chatId=${ctx.chat.id}`);
+        deps.setTelegramContext(bot, ctx.chat.id);
+        await handlePhotoMessage(ctx, { bot, ensureEventSubscription: deps.ensureEventSubscription });
+    });
+    bot.on("message:document", async (ctx) => {
+        logger.debug(`[Bot] Received document message, chatId=${ctx.chat.id}`);
+        deps.setTelegramContext(bot, ctx.chat.id);
+        await handleDocumentMessage(ctx, { bot, ensureEventSubscription: deps.ensureEventSubscription });
+    });
+    bot.on("message:text", async (ctx) => {
+        const text = ctx.message?.text;
+        if (!text) {
+            return;
+        }
+        deps.setTelegramContext(bot, ctx.chat.id);
+        if (text.startsWith("/")) {
+            return;
+        }
+        if (questionManager.isActive()) {
+            await handleQuestionTextAnswer(ctx);
+            return;
+        }
+        const handledTask = await handleTaskTextInput(ctx);
+        if (handledTask) {
+            return;
+        }
+        const handledModelSearchText = await handleModelSearchTextInput(ctx);
+        if (handledModelSearchText) {
+            return;
+        }
+        const handledRename = await handleRenameTextAnswer(ctx);
+        if (handledRename) {
+            return;
+        }
+        const promptDeps = { bot, ensureEventSubscription: deps.ensureEventSubscription };
+        const handledCatalogTextArgs = await handleCatalogTextArguments(ctx, promptDeps);
+        if (handledCatalogTextArgs) {
+            return;
+        }
+        await processUserPrompt(ctx, text, promptDeps);
+        logger.debug("[Bot] message:text handler completed (prompt sent in background)");
+    });
+}

package/dist/bot/services/attach-presentation.js

@@ -0,0 +1,40 @@
+import { keyboardManager } from "../keyboards/keyboard-manager.js";
+import { showPermissionRequest } from "../menus/permission-menu.js";
+import { showCurrentQuestion } from "../menus/question-menu.js";
+import { pinnedMessageManager } from "../pinned/pinned-message-manager.js";
+export function createAttachPresentation() {
+    return {
+        async ensurePinnedSession({ api, chatId, session, forceFullRestore = false }) {
+            if (!pinnedMessageManager.isInitialized()) {
+                pinnedMessageManager.initialize(api, chatId);
+            }
+            keyboardManager.initialize(api, chatId);
+            const pinnedState = pinnedMessageManager.getState();
+            if (pinnedState.sessionId === session.id && pinnedState.messageId) {
+                if (forceFullRestore) {
+                    await pinnedMessageManager.loadContextFromHistory(session.id, session.directory);
+                }
+                return;
+            }
+            if (pinnedState.messageId && pinnedState.sessionId === null) {
+                await pinnedMessageManager.restoreExistingSession(session.id, session.title);
+            }
+            else {
+                await pinnedMessageManager.onSessionChange(session.id, session.title);
+            }
+            await pinnedMessageManager.loadContextFromHistory(session.id, session.directory);
+            const contextInfo = pinnedMessageManager.getContextInfo();
+            if (contextInfo) {
+                keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
+            }
+        },
+        async syncAttachState(attached, busy) {
+            if (!pinnedMessageManager.isInitialized()) {
+                return;
+            }
+            await pinnedMessageManager.setAttachState(attached, busy);
+        },
+        showCurrentQuestion,
+        showPermissionRequest,
+    };
+}