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

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

package/dist/bot/index.js

@@ -53,9 +53,23 @@ 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,
-    sendMessage: async (sessionId, text) => {
+    sendText: async (sessionId, text) => {
         if (!botInstance || !chatIdInstance) {
             return;
         }
@@ -67,6 +81,28 @@ const toolMessageBatcher = new ToolMessageBatcher({
             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) {
@@ -142,9 +178,6 @@ async function ensureEventSubscription(directory) {
         }
     });
     summaryAggregator.setOnTool(async (toolInfo) => {
-        if (config.bot.hideToolCallMessages) {
-            return;
-        }
         if (!botInstance || !chatIdInstance) {
             logger.error("Bot or chat ID not available for sending tool notification");
             return;
@@ -153,6 +186,11 @@ async function ensureEventSubscription(directory) {
         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) {
@@ -163,29 +201,22 @@ async function ensureEventSubscription(directory) {
             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,
-                disable_notification: true,
+            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);

package/dist/summary/aggregator.js

@@ -298,9 +298,10 @@ class SummaryAggregator {
             }
             if ("status" in state && state.status === "completed") {
                 logger.debug(`[Aggregator] Tool completed: callID=${part.callID}, tool=${part.tool}`, JSON.stringify(state, null, 2));
-                const notifiedKey = `notified-${part.callID}`;
-                if (!this.processedToolStates.has(notifiedKey)) {
-                    this.processedToolStates.add(notifiedKey);
+                const completedKey = `completed-${part.callID}`;
+                if (!this.processedToolStates.has(completedKey)) {
+                    this.processedToolStates.add(completedKey);
+                    const preparedFileContext = this.prepareToolFileContext(part.tool, input, title, state.metadata);
                     const toolData = {
                         sessionId: part.sessionID,
                         messageId: messageID,
@@ -310,103 +311,105 @@ class SummaryAggregator {
                         input,
                         title,
                         metadata: state.metadata,
+                        hasFileAttachment: !!preparedFileContext.fileData,
                     };
                     logger.debug(`[Aggregator] Sending tool notification to Telegram: tool=${part.tool}, title=${title || "N/A"}`);
                     if (this.onToolCallback) {
                         this.onToolCallback(toolData);
                     }
-                }
-            }
-            if ("status" in state && state.status === "completed") {
-                const fileKey = `file-${part.callID}`;
-                if (!this.processedToolStates.has(fileKey)) {
-                    this.processedToolStates.add(fileKey);
-                    if (part.tool === "write" && input && "content" in input && "filePath" in input) {
-                        const filePath = normalizePathForDisplay(input.filePath);
-                        const fileData = prepareCodeFile(input.content, filePath, "write");
-                        if (fileData && this.onToolFileCallback) {
-                            logger.debug(`[Aggregator] Sending write file: ${fileData.filename} (${fileData.buffer.length} bytes)`);
-                            this.onToolFileCallback(fileData);
-                        }
-                        // Notify about file change for pinned message
-                        if (this.onFileChangeCallback) {
-                            const lines = input.content.split("\n").length;
-                            this.onFileChangeCallback({
-                                file: filePath,
-                                additions: lines,
-                                deletions: 0,
-                            });
-                        }
-                    }
-                    else if (part.tool === "edit" &&
-                        state.metadata &&
-                        "diff" in state.metadata &&
-                        "filediff" in state.metadata) {
-                        const filediff = state.metadata.filediff;
-                        const filePath = filediff.file ? normalizePathForDisplay(filediff.file) : undefined;
-                        const diff = state.metadata.diff;
-                        if (filePath && diff) {
-                            const fileData = prepareCodeFile(diff, filePath, "edit");
-                            if (fileData && this.onToolFileCallback) {
-                                logger.debug(`[Aggregator] Sending ${part.tool} file: ${fileData.filename} (${fileData.buffer.length} bytes)`);
-                                this.onToolFileCallback(fileData);
-                            }
-                            // Notify about file change for pinned message
-                            if (this.onFileChangeCallback) {
-                                this.onFileChangeCallback({
-                                    file: filePath,
-                                    additions: filediff.additions || 0,
-                                    deletions: filediff.deletions || 0,
-                                });
-                            }
-                        }
+                    if (preparedFileContext.fileData && this.onToolFileCallback) {
+                        logger.debug(`[Aggregator] Sending ${part.tool} file: ${preparedFileContext.fileData.filename} (${preparedFileContext.fileData.buffer.length} bytes)`);
+                        this.onToolFileCallback({
+                            ...toolData,
+                            hasFileAttachment: true,
+                            fileData: preparedFileContext.fileData,
+                        });
                     }
-                    else if (part.tool === "apply_patch") {
-                        const metadata = state.metadata;
-                        const filePathFromInput = input && typeof input.filePath === "string"
-                            ? normalizePathForDisplay(input.filePath)
-                            : input && typeof input.path === "string"
-                                ? normalizePathForDisplay(input.path)
-                                : "";
-                        const filePathFromTitle = title ? extractFirstUpdatedFileFromTitle(title) : "";
-                        const filePath = (metadata?.filediff?.file && normalizePathForDisplay(metadata.filediff.file)) ||
-                            filePathFromInput ||
-                            normalizePathForDisplay(filePathFromTitle);
-                        const diffText = typeof metadata?.diff === "string"
-                            ? metadata.diff
-                            : input && typeof input.patchText === "string"
-                                ? input.patchText
-                                : "";
-                        if (filePath && diffText) {
-                            const fileData = prepareCodeFile(diffText, filePath, "edit");
-                            if (fileData && this.onToolFileCallback) {
-                                logger.debug(`[Aggregator] Sending apply_patch file: ${fileData.filename} (${fileData.buffer.length} bytes)`);
-                                this.onToolFileCallback(fileData);
-                            }
-                        }
-                        if (filePath && this.onFileChangeCallback) {
-                            if (metadata?.filediff) {
-                                this.onFileChangeCallback({
-                                    file: filePath,
-                                    additions: metadata.filediff.additions || 0,
-                                    deletions: metadata.filediff.deletions || 0,
-                                });
-                            }
-                            else if (diffText) {
-                                const changes = countDiffChangesFromText(diffText);
-                                this.onFileChangeCallback({
-                                    file: filePath,
-                                    additions: changes.additions,
-                                    deletions: changes.deletions,
-                                });
-                            }
-                        }
+                    if (preparedFileContext.fileChange && this.onFileChangeCallback) {
+                        this.onFileChangeCallback(preparedFileContext.fileChange);
                     }
                 }
             }
         }
         this.lastUpdated = Date.now();
     }
+    prepareToolFileContext(tool, input, title, metadata) {
+        if (tool === "write" && input) {
+            const filePath = typeof input.filePath === "string" ? normalizePathForDisplay(input.filePath) : "";
+            const hasContent = typeof input.content === "string";
+            const content = hasContent ? input.content : "";
+            if (!filePath || !hasContent) {
+                return { fileData: null, fileChange: null };
+            }
+            return {
+                fileData: prepareCodeFile(content, filePath, "write"),
+                fileChange: {
+                    file: filePath,
+                    additions: content.split("\n").length,
+                    deletions: 0,
+                },
+            };
+        }
+        if (tool === "edit" && metadata) {
+            const editMetadata = metadata;
+            const filePath = editMetadata.filediff?.file
+                ? normalizePathForDisplay(editMetadata.filediff.file)
+                : "";
+            const diffText = typeof editMetadata.diff === "string" ? editMetadata.diff : "";
+            if (!filePath || !diffText) {
+                return { fileData: null, fileChange: null };
+            }
+            return {
+                fileData: prepareCodeFile(diffText, filePath, "edit"),
+                fileChange: {
+                    file: filePath,
+                    additions: editMetadata.filediff?.additions || 0,
+                    deletions: editMetadata.filediff?.deletions || 0,
+                },
+            };
+        }
+        if (tool === "apply_patch") {
+            const patchMetadata = metadata;
+            const filePathFromInput = input && typeof input.filePath === "string"
+                ? normalizePathForDisplay(input.filePath)
+                : input && typeof input.path === "string"
+                    ? normalizePathForDisplay(input.path)
+                    : "";
+            const filePathFromTitle = title ? extractFirstUpdatedFileFromTitle(title) : "";
+            const filePath = (patchMetadata?.filediff?.file && normalizePathForDisplay(patchMetadata.filediff.file)) ||
+                filePathFromInput ||
+                normalizePathForDisplay(filePathFromTitle);
+            const diffText = typeof patchMetadata?.diff === "string"
+                ? patchMetadata.diff
+                : input && typeof input.patchText === "string"
+                    ? input.patchText
+                    : "";
+            if (!filePath) {
+                return { fileData: null, fileChange: null };
+            }
+            const fileChange = patchMetadata?.filediff
+                ? {
+                    file: filePath,
+                    additions: patchMetadata.filediff.additions || 0,
+                    deletions: patchMetadata.filediff.deletions || 0,
+                }
+                : diffText
+                    ? (() => {
+                        const changes = countDiffChangesFromText(diffText);
+                        return {
+                            file: filePath,
+                            additions: changes.additions,
+                            deletions: changes.deletions,
+                        };
+                    })()
+                    : null;
+            return {
+                fileData: diffText ? prepareCodeFile(diffText, filePath, "edit") : null,
+                fileChange,
+            };
+        }
+        return { fileData: null, fileChange: null };
+    }
     hashString(str) {
         let hash = 0;
         for (let i = 0; i < str.length; i++) {

package/dist/summary/tool-message-batcher.js

@@ -13,13 +13,16 @@ function normalizeIntervalSeconds(value) {
 }
 export class ToolMessageBatcher {
     intervalSeconds;
-    sendMessage;
+    sendText;
+    sendFile;
     queues = new Map();
     timers = new Map();
+    sessionTasks = new Map();
     generation = 0;
     constructor(options) {
         this.intervalSeconds = normalizeIntervalSeconds(options.intervalSeconds);
-        this.sendMessage = options.sendMessage;
+        this.sendText = options.sendText;
+        this.sendFile = options.sendFile;
     }
     setIntervalSeconds(nextIntervalSeconds) {
         const normalized = normalizeIntervalSeconds(nextIntervalSeconds);
@@ -47,29 +50,34 @@ export class ToolMessageBatcher {
         }
         if (this.intervalSeconds === 0) {
             const expectedGeneration = this.generation;
-            logger.debug(`[ToolBatcher] Sending immediate message: session=${sessionId}`);
-            void this.sendMessageSafe(sessionId, normalizedMessage, "immediate", expectedGeneration);
+            logger.debug(`[ToolBatcher] Sending immediate text message: session=${sessionId}`);
+            void this.enqueueTask(sessionId, () => this.sendTextSafe(sessionId, normalizedMessage, "immediate", expectedGeneration));
             return;
         }
         const queue = this.queues.get(sessionId) ?? [];
-        queue.push(normalizedMessage);
+        queue.push({ kind: "text", text: normalizedMessage });
         this.queues.set(sessionId, queue);
-        logger.debug(`[ToolBatcher] Queued message: session=${sessionId}, queueSize=${queue.length}, interval=${this.intervalSeconds}s`);
+        logger.debug(`[ToolBatcher] Queued text message: session=${sessionId}, queueSize=${queue.length}, interval=${this.intervalSeconds}s`);
         this.ensureTimer(sessionId);
     }
-    async flushSession(sessionId, reason) {
-        const expectedGeneration = this.generation;
-        this.clearTimer(sessionId);
-        const queuedMessages = this.queues.get(sessionId);
-        if (!queuedMessages || queuedMessages.length === 0) {
+    enqueueFile(sessionId, fileData) {
+        if (!sessionId) {
             return;
         }
-        this.queues.delete(sessionId);
-        const batches = this.packMessages(queuedMessages);
-        logger.debug(`[ToolBatcher] Flushing ${queuedMessages.length} tool messages as ${batches.length} Telegram messages (session=${sessionId}, reason=${reason})`);
-        for (const batchMessage of batches) {
-            await this.sendMessageSafe(sessionId, batchMessage, reason, expectedGeneration);
+        if (this.intervalSeconds === 0) {
+            const expectedGeneration = this.generation;
+            logger.debug(`[ToolBatcher] Sending immediate file message: session=${sessionId}`);
+            void this.enqueueTask(sessionId, () => this.sendFileSafe(sessionId, fileData, "immediate", expectedGeneration));
+            return;
         }
+        const queue = this.queues.get(sessionId) ?? [];
+        queue.push({ kind: "file", fileData });
+        this.queues.set(sessionId, queue);
+        logger.debug(`[ToolBatcher] Queued file message: session=${sessionId}, queueSize=${queue.length}, interval=${this.intervalSeconds}s`);
+        this.ensureTimer(sessionId);
+    }
+    async flushSession(sessionId, reason) {
+        await this.enqueueTask(sessionId, () => this.flushSessionInternal(sessionId, reason));
     }
     async flushAll(reason) {
         for (const sessionId of Array.from(this.timers.keys())) {
@@ -121,17 +129,86 @@ export class ToolMessageBatcher {
         }, this.intervalSeconds * 1000);
         this.timers.set(sessionId, timer);
     }
-    async sendMessageSafe(sessionId, text, reason, expectedGeneration) {
+    enqueueTask(sessionId, task) {
+        const previousTask = this.sessionTasks.get(sessionId) ?? Promise.resolve();
+        const nextTask = previousTask
+            .catch(() => undefined)
+            .then(task)
+            .finally(() => {
+            if (this.sessionTasks.get(sessionId) === nextTask) {
+                this.sessionTasks.delete(sessionId);
+            }
+        });
+        this.sessionTasks.set(sessionId, nextTask);
+        return nextTask;
+    }
+    async flushSessionInternal(sessionId, reason) {
+        const expectedGeneration = this.generation;
+        this.clearTimer(sessionId);
+        const queuedItems = this.queues.get(sessionId);
+        if (!queuedItems || queuedItems.length === 0) {
+            return;
+        }
+        this.queues.delete(sessionId);
+        const flushItems = this.buildFlushItems(queuedItems);
+        logger.debug(`[ToolBatcher] Flushing ${queuedItems.length} queued items as ${flushItems.length} Telegram sends (session=${sessionId}, reason=${reason})`);
+        for (const item of flushItems) {
+            if (item.kind === "text") {
+                await this.sendTextSafe(sessionId, item.text, reason, expectedGeneration);
+            }
+            else {
+                await this.sendFileSafe(sessionId, item.fileData, reason, expectedGeneration);
+            }
+        }
+    }
+    async sendTextSafe(sessionId, text, reason, expectedGeneration) {
         if (this.generation !== expectedGeneration) {
-            logger.debug(`[ToolBatcher] Dropping stale tool batch message: session=${sessionId}, reason=${reason}`);
+            logger.debug(`[ToolBatcher] Dropping stale tool text message: session=${sessionId}, reason=${reason}`);
             return;
         }
         try {
-            await this.sendMessage(sessionId, text);
+            await this.sendText(sessionId, text);
         }
         catch (err) {
-            logger.error(`[ToolBatcher] Failed to send tool batch message: session=${sessionId}, reason=${reason}`, err);
+            logger.error(`[ToolBatcher] Failed to send tool text message: session=${sessionId}, reason=${reason}`, err);
+        }
+    }
+    async sendFileSafe(sessionId, fileData, reason, expectedGeneration) {
+        if (this.generation !== expectedGeneration) {
+            logger.debug(`[ToolBatcher] Dropping stale tool file message: session=${sessionId}, reason=${reason}`);
+            return;
         }
+        try {
+            await this.sendFile(sessionId, fileData);
+        }
+        catch (err) {
+            logger.error(`[ToolBatcher] Failed to send tool file message: session=${sessionId}, reason=${reason}`, err);
+        }
+    }
+    buildFlushItems(entries) {
+        const result = [];
+        const textBuffer = [];
+        const flushTextBuffer = () => {
+            if (textBuffer.length === 0) {
+                return;
+            }
+            const packedTextMessages = this.packMessages(textBuffer);
+            for (const text of packedTextMessages) {
+                result.push({ kind: "text", text });
+            }
+            textBuffer.length = 0;
+        };
+        for (const entry of entries) {
+            if (entry.kind === "text") {
+                textBuffer.push(entry.text);
+            }
+            else {
+                flushTextBuffer();
+                result.push({ kind: "file", fileData: entry.fileData });
+            }
+        }
+        flushTextBuffer();
+        return result;
     }
     packMessages(messages) {
         const normalizedEntries = messages

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.6.0",
+  "version": "0.6.1-rc.1",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",