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

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

@@ -0,0 +1,259 @@
+import { logger } from "../utils/logger.js";
+const DEFAULT_INTERVAL_SECONDS = 5;
+const TELEGRAM_MESSAGE_MAX_LENGTH = 4096;
+function normalizeIntervalSeconds(value) {
+    if (!Number.isFinite(value)) {
+        return DEFAULT_INTERVAL_SECONDS;
+    }
+    const normalized = Math.floor(value);
+    if (normalized < 0) {
+        return DEFAULT_INTERVAL_SECONDS;
+    }
+    return normalized;
+}
+export class ToolMessageBatcher {
+    intervalSeconds;
+    sendText;
+    sendFile;
+    queues = new Map();
+    timers = new Map();
+    sessionTasks = new Map();
+    generation = 0;
+    constructor(options) {
+        this.intervalSeconds = normalizeIntervalSeconds(options.intervalSeconds);
+        this.sendText = options.sendText;
+        this.sendFile = options.sendFile;
+    }
+    setIntervalSeconds(nextIntervalSeconds) {
+        const normalized = normalizeIntervalSeconds(nextIntervalSeconds);
+        if (this.intervalSeconds === normalized) {
+            return;
+        }
+        this.intervalSeconds = normalized;
+        logger.info(`[ToolBatcher] Interval updated: ${normalized}s`);
+        if (normalized === 0) {
+            void this.flushAll("interval_updated");
+            return;
+        }
+        const sessionIds = Array.from(this.queues.keys());
+        for (const sessionId of sessionIds) {
+            this.restartTimer(sessionId);
+        }
+    }
+    getIntervalSeconds() {
+        return this.intervalSeconds;
+    }
+    enqueue(sessionId, message) {
+        const normalizedMessage = message.trim();
+        if (!sessionId || normalizedMessage.length === 0) {
+            return;
+        }
+        if (this.intervalSeconds === 0) {
+            const expectedGeneration = this.generation;
+            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({ kind: "text", text: normalizedMessage });
+        this.queues.set(sessionId, queue);
+        logger.debug(`[ToolBatcher] Queued text message: session=${sessionId}, queueSize=${queue.length}, interval=${this.intervalSeconds}s`);
+        this.ensureTimer(sessionId);
+    }
+    enqueueFile(sessionId, fileData) {
+        if (!sessionId) {
+            return;
+        }
+        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())) {
+            this.clearTimer(sessionId);
+        }
+        const sessionIds = Array.from(this.queues.keys());
+        for (const sessionId of sessionIds) {
+            await this.flushSession(sessionId, reason);
+        }
+    }
+    clearSession(sessionId, reason) {
+        this.generation++;
+        this.clearTimer(sessionId);
+        if (this.queues.delete(sessionId)) {
+            logger.debug(`[ToolBatcher] Cleared session queue: session=${sessionId}, reason=${reason}`);
+        }
+    }
+    clearAll(reason) {
+        this.generation++;
+        for (const timer of this.timers.values()) {
+            clearTimeout(timer);
+        }
+        const queuedSessions = this.queues.size;
+        this.timers.clear();
+        this.queues.clear();
+        if (queuedSessions > 0) {
+            logger.debug(`[ToolBatcher] Cleared all queued tool messages: sessions=${queuedSessions}, reason=${reason}`);
+        }
+    }
+    clearTimer(sessionId) {
+        const timer = this.timers.get(sessionId);
+        if (!timer) {
+            return;
+        }
+        clearTimeout(timer);
+        this.timers.delete(sessionId);
+    }
+    ensureTimer(sessionId) {
+        if (this.timers.has(sessionId)) {
+            return;
+        }
+        this.restartTimer(sessionId);
+    }
+    restartTimer(sessionId) {
+        this.clearTimer(sessionId);
+        const timer = setTimeout(() => {
+            this.timers.delete(sessionId);
+            void this.flushSession(sessionId, "interval_elapsed");
+        }, this.intervalSeconds * 1000);
+        this.timers.set(sessionId, timer);
+    }
+    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 text message: session=${sessionId}, reason=${reason}`);
+            return;
+        }
+        try {
+            await this.sendText(sessionId, text);
+        }
+        catch (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
+            .flatMap((message) => this.splitLongText(message, TELEGRAM_MESSAGE_MAX_LENGTH))
+            .filter((entry) => entry.length > 0);
+        if (normalizedEntries.length === 0) {
+            return [];
+        }
+        const result = [];
+        let current = "";
+        for (const entry of normalizedEntries) {
+            if (!current) {
+                current = entry;
+                continue;
+            }
+            const candidate = `${current}\n\n${entry}`;
+            if (candidate.length <= TELEGRAM_MESSAGE_MAX_LENGTH) {
+                current = candidate;
+                continue;
+            }
+            result.push(current);
+            current = entry;
+        }
+        if (current) {
+            result.push(current);
+        }
+        return result;
+    }
+    splitLongText(text, limit) {
+        if (text.length <= limit) {
+            return [text];
+        }
+        const chunks = [];
+        let remaining = text;
+        while (remaining.length > limit) {
+            let splitIndex = remaining.lastIndexOf("\n", limit);
+            if (splitIndex <= 0 || splitIndex < Math.floor(limit * 0.5)) {
+                splitIndex = limit;
+            }
+            chunks.push(remaining.slice(0, splitIndex));
+            remaining = remaining.slice(splitIndex).replace(/^\n+/, "");
+        }
+        if (remaining.length > 0) {
+            chunks.push(remaining);
+        }
+        return chunks;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.5.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",