@grinev/opencode-telegram-bot 0.5.0 → 0.6.1-rc.1

package/.env.example

@@ -39,6 +39,17 @@ OPENCODE_MODEL_ID=big-pickle
 # Bot locale: en or ru (default: en)
 # BOT_LOCALE=en
 
+# Service message batching interval in seconds (thinking + tool calls, default: 5)
+# Recommended: keep >=2 to reduce risk of hitting Telegram rate limits (about 1 message/sec)
+# 0 = send immediately (can hit rate limits if there are many tool calls)
+# SERVICE_MESSAGES_INTERVAL_SEC=5
+
+# Hide thinking indicator messages (default: false)
+# HIDE_THINKING_MESSAGES=false
+
+# Hide tool call service messages (default: false)
+# HIDE_TOOL_CALL_MESSAGES=false
+
 # Code File Settings (optional)
 # Maximum file size in KB to send as document (default: 100)
 # CODE_FILE_MAX_SIZE_KB=100

package/README.md

@@ -5,14 +5,16 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](https://nodejs.org)
 
-Control your [OpenCode](https://opencode.ai) coding agent from your phone. Send tasks, switch models, monitor progress — all through Telegram.
+OpenCode Telegram Bot is a secure Telegram client for [OpenCode](https://opencode.ai) CLI that runs on your local machine.
 
-No open ports, no exposed APIs. The bot runs on your machine alongside OpenCode and communicates exclusively through the Telegram Bot API.
+Run AI coding tasks, monitor progress, switch models, and manage sessions from your phone.
+
+No open ports, no exposed APIs. The bot communicates with your local OpenCode server and the Telegram Bot API only.
+
+Quick start: `npx @grinev/opencode-telegram-bot`
 
 <p align="center">
-  <img src="assets/Screenshot-1.png" width="32%" alt="Sending a coding task and receiving file edit results" />
-  <img src="assets/Screenshot-2.png" width="32%" alt="Live session status with context usage and changed files" />
-  <img src="assets/Screenshot-3.png" width="32%" alt="Switching between AI models from favorites" />
+  <img src="assets/screencast.gif" width="45%" alt="OpenCode Telegram Bot screencast" />
 </p>
 
 ## Features
@@ -122,20 +124,23 @@ When installed via npm, the configuration wizard handles the initial setup. The
 - **Windows:** `%APPDATA%\opencode-telegram-bot\.env`
 - **Linux:** `~/.config/opencode-telegram-bot/.env`
 
-| Variable                   | Description                                  | Required | Default                 |
-| -------------------------- | -------------------------------------------- | :------: | ----------------------- |
-| `TELEGRAM_BOT_TOKEN`       | Bot token from @BotFather                    |   Yes    | —                       |
-| `TELEGRAM_ALLOWED_USER_ID` | Your numeric Telegram user ID                |   Yes    | —                       |
-| `TELEGRAM_PROXY_URL`       | Proxy URL for Telegram API (SOCKS5/HTTP)     |    No    | —                       |
-| `OPENCODE_API_URL`         | OpenCode server URL                          |    No    | `http://localhost:4096` |
-| `OPENCODE_SERVER_USERNAME` | Server auth username                         |    No    | `opencode`              |
-| `OPENCODE_SERVER_PASSWORD` | Server auth password                         |    No    | —                       |
-| `OPENCODE_MODEL_PROVIDER`  | Default model provider                       |   Yes    | `opencode`              |
-| `OPENCODE_MODEL_ID`        | Default model ID                             |   Yes    | `big-pickle`            |
-| `BOT_LOCALE`               | Bot UI language (`en` or `ru`)               |    No    | `en`                    |
-| `SESSIONS_LIST_LIMIT`      | Max sessions shown in `/sessions`            |    No    | `10`                    |
-| `CODE_FILE_MAX_SIZE_KB`    | Max file size (KB) to send as document       |    No    | `100`                   |
-| `LOG_LEVEL`                | Log level (`debug`, `info`, `warn`, `error`) |    No    | `info`                  |
+| Variable                        | Description                                                                                                  | Required | Default                 |
+| ------------------------------- | ------------------------------------------------------------------------------------------------------------ | :------: | ----------------------- |
+| `TELEGRAM_BOT_TOKEN`            | Bot token from @BotFather                                                                                    |   Yes    | —                       |
+| `TELEGRAM_ALLOWED_USER_ID`      | Your numeric Telegram user ID                                                                                |   Yes    | —                       |
+| `TELEGRAM_PROXY_URL`            | Proxy URL for Telegram API (SOCKS5/HTTP)                                                                     |    No    | —                       |
+| `OPENCODE_API_URL`              | OpenCode server URL                                                                                          |    No    | `http://localhost:4096` |
+| `OPENCODE_SERVER_USERNAME`      | Server auth username                                                                                         |    No    | `opencode`              |
+| `OPENCODE_SERVER_PASSWORD`      | Server auth password                                                                                         |    No    | —                       |
+| `OPENCODE_MODEL_PROVIDER`       | Default model provider                                                                                       |   Yes    | `opencode`              |
+| `OPENCODE_MODEL_ID`             | Default model ID                                                                                             |   Yes    | `big-pickle`            |
+| `BOT_LOCALE`                    | Bot UI language (`en` or `ru`)                                                                               |    No    | `en`                    |
+| `SESSIONS_LIST_LIMIT`           | Max sessions shown in `/sessions`                                                                            |    No    | `10`                    |
+| `SERVICE_MESSAGES_INTERVAL_SEC` | Service messages interval (thinking + tool calls); keep `>=2` to avoid Telegram rate limits, `0` = immediate |    No    | `5`                     |
+| `HIDE_THINKING_MESSAGES`        | Hide `💭 Thinking...` service messages                                                                       |    No    | `false`                 |
+| `HIDE_TOOL_CALL_MESSAGES`       | Hide tool-call service messages (`💻 bash ...`, `📖 read ...`, etc.)                                         |    No    | `false`                 |
+| `CODE_FILE_MAX_SIZE_KB`         | Max file size (KB) to send as document                                                                       |    No    | `100`                   |
+| `LOG_LEVEL`                     | Log level (`debug`, `info`, `warn`, `error`)                                                                 |    No    | `info`                  |
 
 > **Keep your `.env` file private.** It contains your bot token. Never commit it to version control.
 

package/dist/bot/commands/new.js

@@ -3,6 +3,7 @@ import { setCurrentSession } from "../../session/manager.js";
 import { ingestSessionInfoForCache } from "../../session/cache-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 { getStoredAgent } from "../../agent/manager.js";
@@ -32,6 +33,7 @@ export async function newCommand(ctx) {
             directory: currentProject.worktree,
         };
         setCurrentSession(sessionInfo);
+        summaryAggregator.clear();
         clearAllInteractionState("session_created");
         await ingestSessionInfoForCache(session);
         // Initialize pinned message manager and create pinned message

package/dist/bot/commands/sessions.js

@@ -3,6 +3,7 @@ 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 { ensureActiveInlineMenu, replyWithInlineMenu } from "../handlers/inline-menu.js";
@@ -84,6 +85,7 @@ export async function handleSessionSelect(ctx) {
             directory: currentProject.worktree,
         };
         setCurrentSession(sessionInfo);
+        summaryAggregator.clear();
         clearAllInteractionState("session_switched");
         await ctx.answerCallbackQuery();
         let loadingMessageId = null;

package/dist/bot/handlers/permission.js

@@ -50,6 +50,33 @@ function clearPermissionInteraction(reason) {
         interactionManager.clear(reason);
     }
 }
+function syncPermissionInteractionState(metadata = {}) {
+    const pendingCount = permissionManager.getPendingCount();
+    if (pendingCount === 0) {
+        clearPermissionInteraction("permission_no_pending_requests");
+        return;
+    }
+    const nextMetadata = {
+        pendingCount,
+        ...metadata,
+    };
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "permission") {
+        interactionManager.transition({
+            expectedInput: "callback",
+            metadata: nextMetadata,
+        });
+        return;
+    }
+    interactionManager.start({
+        kind: "permission",
+        expectedInput: "callback",
+        metadata: nextMetadata,
+    });
+}
+function isPermissionReply(value) {
+    return value === "once" || value === "always" || value === "reject";
+}
 /**
  * Handle permission callback from inline buttons
  */
@@ -71,10 +98,22 @@ export async function handlePermissionCallback(ctx) {
         await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
         return true;
     }
+    const requestID = permissionManager.getRequestID(callbackMessageId);
+    if (!requestID) {
+        await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
+        return true;
+    }
     const parts = data.split(":");
     const action = parts[1];
+    if (!isPermissionReply(action)) {
+        await ctx.answerCallbackQuery({
+            text: t("permission.processing_error_callback"),
+            show_alert: true,
+        });
+        return true;
+    }
     try {
-        await handlePermissionReply(ctx, action);
+        await handlePermissionReply(ctx, action, requestID, callbackMessageId);
     }
     catch (err) {
         logger.error("[PermissionHandler] Error handling callback:", err);
@@ -88,13 +127,12 @@ export async function handlePermissionCallback(ctx) {
 /**
  * Handle permission reply (once/always/reject)
  */
-async function handlePermissionReply(ctx, reply) {
-    const requestID = permissionManager.getRequestID();
+async function handlePermissionReply(ctx, reply, requestID, callbackMessageId) {
     const currentProject = getCurrentProject();
     const currentSession = getCurrentSession();
     const chatId = ctx.chat?.id;
     const directory = currentSession?.directory ?? currentProject?.worktree;
-    if (!requestID || !directory || !chatId) {
+    if (!directory || !chatId) {
         permissionManager.clear();
         clearPermissionInteraction("permission_invalid_runtime_context");
         await ctx.answerCallbackQuery({
@@ -134,30 +172,20 @@ async function handlePermissionReply(ctx, reply) {
             logger.info("[PermissionHandler] Permission reply sent successfully");
         },
     });
-    permissionManager.clear();
-    clearPermissionInteraction("permission_replied");
+    permissionManager.removeByMessageId(callbackMessageId);
+    if (!permissionManager.isActive()) {
+        clearPermissionInteraction("permission_replied");
+        return;
+    }
+    syncPermissionInteractionState({
+        lastRepliedRequestID: requestID,
+    });
 }
 /**
  * Show permission request message with inline buttons
  */
 export async function showPermissionRequest(bot, chatId, request) {
     logger.debug(`[PermissionHandler] Showing permission request: ${request.permission}`);
-    const previousMessageId = permissionManager.getMessageId();
-    const hadActivePermission = permissionManager.isActive();
-    if (hadActivePermission && previousMessageId !== null) {
-        logger.debug(`[PermissionHandler] Replacing active permission request, deleting previous message: ${previousMessageId}`);
-        await bot.deleteMessage(chatId, previousMessageId).catch((err) => {
-            logger.debug("[PermissionHandler] Failed to delete previous permission message:", err);
-        });
-    }
-    permissionManager.startPermission(request);
-    interactionManager.start({
-        kind: "permission",
-        expectedInput: "callback",
-        metadata: {
-            requestID: request.id,
-        },
-    });
     const text = formatPermissionText(request);
     const keyboard = buildPermissionKeyboard();
     try {
@@ -166,18 +194,14 @@ export async function showPermissionRequest(bot, chatId, request) {
             parse_mode: "Markdown",
         });
         logger.debug(`[PermissionHandler] Message sent, messageId=${message.message_id}`);
-        permissionManager.setMessageId(message.message_id);
-        interactionManager.transition({
-            metadata: {
-                requestID: request.id,
-                messageId: message.message_id,
-            },
+        permissionManager.startPermission(request, message.message_id);
+        syncPermissionInteractionState({
+            requestID: request.id,
+            messageId: message.message_id,
         });
         summaryAggregator.stopTypingIndicator();
     }
     catch (err) {
-        permissionManager.clear();
-        clearPermissionInteraction("permission_message_send_failed");
         logger.error("[PermissionHandler] Failed to send permission message:", err);
         throw err;
     }

package/dist/bot/index.js

@@ -36,6 +36,7 @@ import { keyboardManager } from "../keyboard/manager.js";
 import { stopEventListening, subscribeToEvents } from "../opencode/events.js";
 import { summaryAggregator } from "../summary/aggregator.js";
 import { formatSummary, formatToolInfo } from "../summary/formatter.js";
+import { ToolMessageBatcher } from "../summary/tool-message-batcher.js";
 import { opencodeClient } from "../opencode/client.js";
 import { clearSession, getCurrentSession, setCurrentSession } from "../session/manager.js";
 import { ingestSessionInfoForCache } from "../session/cache-manager.js";
@@ -52,6 +53,57 @@ import { t } from "../i18n/index.js";
 let botInstance = null;
 let chatIdInstance = null;
 let commandsInitialized = false;
+const TELEGRAM_DOCUMENT_CAPTION_MAX_LENGTH = 1024;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TEMP_DIR = path.join(__dirname, "..", ".tmp");
+function prepareDocumentCaption(caption) {
+    const normalizedCaption = caption.trim();
+    if (!normalizedCaption) {
+        return "";
+    }
+    if (normalizedCaption.length <= TELEGRAM_DOCUMENT_CAPTION_MAX_LENGTH) {
+        return normalizedCaption;
+    }
+    return `${normalizedCaption.slice(0, TELEGRAM_DOCUMENT_CAPTION_MAX_LENGTH - 3)}...`;
+}
+const toolMessageBatcher = new ToolMessageBatcher({
+    intervalSeconds: 5,
+    sendText: async (sessionId, text) => {
+        if (!botInstance || !chatIdInstance) {
+            return;
+        }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== sessionId) {
+            return;
+        }
+        await botInstance.api.sendMessage(chatIdInstance, text, {
+            disable_notification: true,
+        });
+    },
+    sendFile: async (sessionId, fileData) => {
+        if (!botInstance || !chatIdInstance) {
+            return;
+        }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== sessionId) {
+            return;
+        }
+        const tempFilePath = path.join(TEMP_DIR, fileData.filename);
+        try {
+            logger.debug(`[Bot] Sending code file: ${fileData.filename} (${fileData.buffer.length} bytes, session=${sessionId})`);
+            await fs.mkdir(TEMP_DIR, { recursive: true });
+            await fs.writeFile(tempFilePath, fileData.buffer);
+            await botInstance.api.sendDocument(chatIdInstance, new InputFile(tempFilePath), {
+                caption: fileData.caption,
+                disable_notification: true,
+            });
+        }
+        finally {
+            await fs.unlink(tempFilePath).catch(() => { });
+        }
+    },
+});
 async function ensureCommandsInitialized(ctx, next) {
     if (commandsInitialized || !ctx.from || ctx.from.id !== config.telegram.allowedUserId) {
         await next();
@@ -82,6 +134,10 @@ async function ensureEventSubscription(directory) {
         logger.error("No directory found for event subscription");
         return;
     }
+    toolMessageBatcher.setIntervalSeconds(config.bot.serviceMessagesIntervalSec);
+    summaryAggregator.setOnCleared(() => {
+        toolMessageBatcher.clearAll("summary_aggregator_clear");
+    });
     summaryAggregator.setOnComplete(async (sessionId, messageText) => {
         if (!botInstance || !chatIdInstance) {
             logger.error("Bot or chat ID not available for sending message");
@@ -91,6 +147,7 @@ async function ensureEventSubscription(directory) {
         if (currentSession?.id !== sessionId) {
             return;
         }
+        await toolMessageBatcher.flushSession(sessionId, "assistant_message_completed");
         try {
             const parts = formatSummary(messageText);
             logger.debug(`[Bot] Sending completed message to Telegram (chatId=${chatIdInstance}, parts=${parts.length})`);
@@ -126,42 +183,40 @@ async function ensureEventSubscription(directory) {
             return;
         }
         const currentSession = getCurrentSession();
-        const sessionId = summaryAggregator["currentSessionId"];
-        if (!currentSession || currentSession.id !== sessionId) {
+        if (!currentSession || currentSession.id !== toolInfo.sessionId) {
+            return;
+        }
+        const shouldIncludeToolInfoInFileCaption = toolInfo.hasFileAttachment &&
+            (toolInfo.tool === "write" || toolInfo.tool === "edit" || toolInfo.tool === "apply_patch");
+        if (config.bot.hideToolCallMessages || shouldIncludeToolInfoInFileCaption) {
             return;
         }
         try {
             const message = formatToolInfo(toolInfo);
             if (message) {
-                await botInstance.api.sendMessage(chatIdInstance, message);
+                toolMessageBatcher.enqueue(toolInfo.sessionId, message);
             }
         }
         catch (err) {
             logger.error("Failed to send tool notification to Telegram:", err);
         }
     });
-    summaryAggregator.setOnToolFile(async (fileData) => {
+    summaryAggregator.setOnToolFile(async (fileInfo) => {
         if (!botInstance || !chatIdInstance) {
             logger.error("Bot or chat ID not available for sending file");
             return;
         }
         const currentSession = getCurrentSession();
-        if (!currentSession) {
+        if (!currentSession || currentSession.id !== fileInfo.sessionId) {
             return;
         }
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = path.dirname(__filename);
-        const tempDir = path.join(__dirname, "..", ".tmp");
         try {
-            logger.debug(`[Bot] Sending code file: ${fileData.filename} (${fileData.buffer.length} bytes)`);
-            await fs.mkdir(tempDir, { recursive: true });
-            const tempFilePath = path.join(tempDir, fileData.filename);
-            await fs.writeFile(tempFilePath, fileData.buffer);
-            await botInstance.api.sendDocument(chatIdInstance, new InputFile(tempFilePath), {
-                caption: fileData.caption,
+            const toolMessage = formatToolInfo(fileInfo);
+            const caption = prepareDocumentCaption(toolMessage || fileInfo.fileData.caption);
+            toolMessageBatcher.enqueueFile(fileInfo.sessionId, {
+                ...fileInfo.fileData,
+                caption,
             });
-            await fs.unlink(tempFilePath);
-            logger.debug(`[Bot] Temporary file deleted: ${fileData.filename}`);
         }
         catch (err) {
             logger.error("Failed to send file to Telegram:", err);
@@ -172,6 +227,10 @@ async function ensureEventSubscription(directory) {
             logger.error("Bot or chat ID not available for showing questions");
             return;
         }
+        const currentSession = getCurrentSession();
+        if (currentSession) {
+            await toolMessageBatcher.flushSession(currentSession.id, "question_asked");
+        }
         if (questionManager.isActive()) {
             logger.warn("[Bot] Replacing active poll with a new one");
             const previousMessageIds = questionManager.getMessageIds();
@@ -202,17 +261,23 @@ async function ensureEventSubscription(directory) {
             logger.error("Bot or chat ID not available for showing permission request");
             return;
         }
+        await toolMessageBatcher.flushSession(request.sessionID, "permission_asked");
         logger.info(`[Bot] Received permission request from agent: type=${request.permission}, requestID=${request.id}`);
         await showPermissionRequest(botInstance.api, chatIdInstance, request);
     });
-    summaryAggregator.setOnThinking(async () => {
+    summaryAggregator.setOnThinking(async (sessionId) => {
+        if (config.bot.hideThinkingMessages) {
+            return;
+        }
         if (!botInstance || !chatIdInstance) {
             return;
         }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== sessionId) {
+            return;
+        }
         logger.debug("[Bot] Agent started thinking");
-        await botInstance.api.sendMessage(chatIdInstance, t("bot.thinking")).catch((err) => {
-            logger.error("[Bot] Failed to send thinking message:", err);
-        });
+        toolMessageBatcher.enqueue(sessionId, t("bot.thinking"));
     });
     summaryAggregator.setOnTokens(async (tokens) => {
         if (!pinnedMessageManager.isInitialized()) {
@@ -325,6 +390,8 @@ async function resetMismatchedSessionContext() {
 }
 export function createBot() {
     clearAllInteractionState("bot_startup");
+    toolMessageBatcher.setIntervalSeconds(config.bot.serviceMessagesIntervalSec);
+    logger.info(`[ToolBatcher] Service messages interval: ${config.bot.serviceMessagesIntervalSec}s`);
     const botOptions = {};
     if (config.telegram.proxyUrl) {
         const proxyUrl = config.telegram.proxyUrl;

package/dist/config.js

@@ -20,6 +20,20 @@ function getOptionalPositiveIntEnvVar(key, defaultValue) {
     }
     return parsedValue;
 }
+function getOptionalNonNegativeIntEnvVarFromKeys(keys, defaultValue) {
+    for (const key of keys) {
+        const value = getEnvVar(key, false);
+        if (!value) {
+            continue;
+        }
+        const parsedValue = Number.parseInt(value, 10);
+        if (Number.isNaN(parsedValue) || parsedValue < 0) {
+            return defaultValue;
+        }
+        return parsedValue;
+    }
+    return defaultValue;
+}
 function getOptionalLocaleEnvVar(key, defaultValue) {
     const value = getEnvVar(key, false);
     if (!value) {
@@ -34,6 +48,20 @@ function getOptionalLocaleEnvVar(key, defaultValue) {
     }
     return defaultValue;
 }
+function getOptionalBooleanEnvVar(key, defaultValue) {
+    const value = getEnvVar(key, false);
+    if (!value) {
+        return defaultValue;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return false;
+    }
+    return defaultValue;
+}
 export const config = {
     telegram: {
         token: getEnvVar("TELEGRAM_BOT_TOKEN"),
@@ -55,6 +83,9 @@ export const config = {
     bot: {
         sessionsListLimit: getOptionalPositiveIntEnvVar("SESSIONS_LIST_LIMIT", 10),
         locale: getOptionalLocaleEnvVar("BOT_LOCALE", "en"),
+        serviceMessagesIntervalSec: getOptionalNonNegativeIntEnvVarFromKeys(["SERVICE_MESSAGES_INTERVAL_SEC", "TOOL_MESSAGES_INTERVAL_SEC"], 5),
+        hideThinkingMessages: getOptionalBooleanEnvVar("HIDE_THINKING_MESSAGES", false),
+        hideToolCallMessages: getOptionalBooleanEnvVar("HIDE_TOOL_CALL_MESSAGES", false),
     },
     files: {
         maxFileSizeKb: parseInt(getEnvVar("CODE_FILE_MAX_SIZE_KB", false) || "100", 10),

package/dist/permission/manager.js

@@ -1,83 +1,99 @@
 import { logger } from "../utils/logger.js";
 class PermissionManager {
     state = {
-        request: null,
-        messageId: null,
-        isActive: false,
+        requestsByMessageId: new Map(),
     };
     /**
-     * Start a new permission request
+     * Register a new permission request message
      */
-    startPermission(request) {
-        logger.debug(`[PermissionManager] startPermission: id=${request.id}, permission=${request.permission}`);
-        if (this.state.isActive) {
-            logger.warn("[PermissionManager] Permission already active, replacing");
-            this.clear();
+    startPermission(request, messageId) {
+        logger.debug(`[PermissionManager] startPermission: id=${request.id}, permission=${request.permission}, messageId=${messageId}`);
+        if (this.state.requestsByMessageId.has(messageId)) {
+            logger.warn(`[PermissionManager] Message ID already tracked, replacing: ${messageId}`);
         }
-        logger.info(`[PermissionManager] New permission request: type=${request.permission}, patterns=${request.patterns.join(", ")}`);
-        this.state = {
-            request,
-            messageId: null,
-            isActive: true,
-        };
-    }
-    /**
-     * Get current permission request
-     */
-    getRequest() {
-        return this.state.request;
+        this.state.requestsByMessageId.set(messageId, request);
+        logger.info(`[PermissionManager] New permission request: type=${request.permission}, patterns=${request.patterns.join(", ")}, pending=${this.state.requestsByMessageId.size}`);
     }
     /**
-     * Get request ID for API reply
+     * Get permission request by Telegram message ID
      */
-    getRequestID() {
-        return this.state.request?.id ?? null;
+    getRequest(messageId) {
+        if (messageId === null) {
+            return null;
+        }
+        return this.state.requestsByMessageId.get(messageId) ?? null;
     }
     /**
-     * Get permission type (bash, edit, etc.)
+     * Get request ID for API reply by Telegram message ID
      */
-    getPermissionType() {
-        return this.state.request?.permission ?? null;
+    getRequestID(messageId) {
+        return this.getRequest(messageId)?.id ?? null;
     }
     /**
-     * Get patterns (commands/files)
+     * Get permission type (bash, edit, etc.) by message ID
      */
-    getPatterns() {
-        return this.state.request?.patterns ?? [];
+    getPermissionType(messageId) {
+        return this.getRequest(messageId)?.permission ?? null;
     }
     /**
-     * Set Telegram message ID for later deletion
+     * Get patterns (commands/files) by message ID
      */
-    setMessageId(messageId) {
-        this.state.messageId = messageId;
+    getPatterns(messageId) {
+        return this.getRequest(messageId)?.patterns ?? [];
     }
     /**
      * Check if callback message ID belongs to active permission request
      */
     isActiveMessage(messageId) {
-        return (this.state.isActive && this.state.messageId !== null && messageId === this.state.messageId);
+        return messageId !== null && this.state.requestsByMessageId.has(messageId);
     }
     /**
-     * Get Telegram message ID
+     * Get latest Telegram message ID
      */
     getMessageId() {
-        return this.state.messageId;
+        const messageIds = this.getMessageIds();
+        if (messageIds.length === 0) {
+            return null;
+        }
+        return messageIds[messageIds.length - 1];
+    }
+    /**
+     * Get Telegram message IDs for all active requests
+     */
+    getMessageIds() {
+        return Array.from(this.state.requestsByMessageId.keys());
+    }
+    /**
+     * Remove permission request by Telegram message ID
+     */
+    removeByMessageId(messageId) {
+        const request = this.getRequest(messageId);
+        if (!request || messageId === null) {
+            return null;
+        }
+        this.state.requestsByMessageId.delete(messageId);
+        logger.debug(`[PermissionManager] Removed permission request: id=${request.id}, messageId=${messageId}, pending=${this.state.requestsByMessageId.size}`);
+        return request;
+    }
+    /**
+     * Get number of active permission requests
+     */
+    getPendingCount() {
+        return this.state.requestsByMessageId.size;
     }
     /**
-     * Check if permission request is active
+     * Check if there are active permission requests
      */
     isActive() {
-        return this.state.isActive;
+        return this.state.requestsByMessageId.size > 0;
     }
     /**
      * Clear state after reply
      */
     clear() {
-        logger.debug("[PermissionManager] Clearing permission state");
+        logger.debug(`[PermissionManager] Clearing permission state: pending=${this.state.requestsByMessageId.size}`);
         this.state = {
-            request: null,
-            messageId: null,
-            isActive: false,
+            requestsByMessageId: new Map(),
         };
     }
 }