@grinev/opencode-telegram-bot 0.14.0 → 0.15.0

package/dist/pinned/manager.js

@@ -1,3 +1,5 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
 import { logger } from "../utils/logger.js";
 import { opencodeClient } from "../opencode/client.js";
 import { getCurrentSession } from "../session/manager.js";
@@ -15,6 +17,7 @@ class PinnedMessageManager {
         sessionId: null,
         sessionTitle: t("pinned.default_session_title"),
         projectName: "",
+        projectBranch: null,
         tokensUsed: 0,
         tokensLimit: 0,
         lastUpdated: 0,
@@ -23,6 +26,11 @@ class PinnedMessageManager {
     };
     contextLimit = null;
     onKeyboardUpdateCallback;
+    updateDebounceTimer = null;
+    updateTask = null;
+    pendingUpdate = false;
+    pendingForceUpdate = false;
+    lastRenderedMessageText = null;
     /**
      * Initialize manager with bot API and chat ID
      */
@@ -47,9 +55,7 @@ class PinnedMessageManager {
         // Update state
         this.state.sessionId = sessionId;
         this.state.sessionTitle = sessionTitle || t("pinned.default_session_title");
-        const project = getCurrentProject();
-        this.state.projectName =
-            project?.name || this.extractProjectName(project?.worktree) || t("pinned.unknown");
+        await this.refreshProjectMetadata();
         // Fetch context limit for current model
         await this.fetchContextLimit();
         // Trigger keyboard update callback with reset context (0 tokens)
@@ -58,6 +64,9 @@ class PinnedMessageManager {
         }
         // Reset changed files for new session
         this.state.changedFiles = [];
+        this.lastRenderedMessageText = null;
+        this.pendingUpdate = false;
+        this.pendingForceUpdate = false;
         // Unpin old message and create new one
         await this.unpinOldMessage();
         await this.createPinnedMessage();
@@ -163,12 +172,17 @@ class PinnedMessageManager {
      * Used at thinking time to push accumulated silent updates to Telegram.
      */
     async refresh() {
-        await this.updatePinnedMessage();
+        await this.refreshProjectMetadata();
+        await this.updatePinnedMessage(true);
     }
     /**
      * Called when cost info is received from SSE events
      */
     async onCostUpdate(cost) {
+        if (!Number.isFinite(cost) || cost === 0) {
+            logger.debug("[PinnedManager] Ignoring non-impacting cost update");
+            return;
+        }
         const currentCost = this.state.cost || 0;
         this.state.cost = currentCost + cost;
         logger.debug(`[PinnedManager] Cost added: $${cost.toFixed(2)}, total session: $${(this.state.cost || 0).toFixed(2)}`);
@@ -223,6 +237,10 @@ class PinnedMessageManager {
             logger.debug("[PinnedManager] Ignoring empty session.diff, keeping tool-collected data");
             return;
         }
+        if (this.areFileDiffsEqual(this.state.changedFiles, diffs)) {
+            logger.debug("[PinnedManager] Ignoring unchanged session.diff");
+            return;
+        }
         this.state.changedFiles = diffs;
         logger.debug(`[PinnedManager] Session diff updated: ${diffs.length} files`);
         await this.updatePinnedMessage();
@@ -243,15 +261,14 @@ class PinnedMessageManager {
         // Schedule debounced update (avoid spamming Telegram API on rapid tool events)
         this.scheduleDebouncedUpdate();
     }
-    updateDebounceTimer = null;
     scheduleDebouncedUpdate() {
         if (this.updateDebounceTimer) {
             clearTimeout(this.updateDebounceTimer);
         }
         this.updateDebounceTimer = setTimeout(() => {
             this.updateDebounceTimer = null;
-            this.updatePinnedMessage();
-        }, 500);
+            void this.updatePinnedMessage();
+        }, 1000);
     }
     /**
      * Load file diffs from API for current session.
@@ -397,6 +414,61 @@ class PinnedMessageManager {
             logger.debug("[PinnedManager] Could not refresh session title:", err);
         }
     }
+    /**
+     * Refresh current project name and git branch.
+     */
+    async refreshProjectMetadata() {
+        const project = getCurrentProject();
+        this.state.projectName =
+            project?.name || this.extractProjectName(project?.worktree) || t("pinned.unknown");
+        this.state.projectBranch = await this.getGitBranchName(project?.worktree);
+    }
+    /**
+     * Resolve current git branch for a project worktree.
+     */
+    async getGitBranchName(worktree) {
+        if (!worktree) {
+            return null;
+        }
+        try {
+            const gitDir = await this.resolveGitDir(worktree);
+            if (!gitDir) {
+                return null;
+            }
+            const headPath = path.join(gitDir, "HEAD");
+            const headContent = (await readFile(headPath, "utf-8")).trim();
+            const match = headContent.match(/^ref:\s+refs\/heads\/(.+)$/);
+            return match?.[1] || null;
+        }
+        catch (err) {
+            logger.debug("[PinnedManager] Could not resolve git branch:", err);
+            return null;
+        }
+    }
+    /**
+     * Resolve git directory for a normal repository or linked worktree.
+     */
+    async resolveGitDir(worktree) {
+        const gitPath = path.join(worktree, ".git");
+        try {
+            const gitStat = await stat(gitPath);
+            if (gitStat.isDirectory()) {
+                return gitPath;
+            }
+            if (!gitStat.isFile()) {
+                return null;
+            }
+            const gitPointer = (await readFile(gitPath, "utf-8")).trim();
+            const match = gitPointer.match(/^gitdir:\s*(.+)$/i);
+            if (!match) {
+                return null;
+            }
+            return path.resolve(worktree, match[1].trim());
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * Extract project name from worktree path
      */
@@ -430,6 +502,21 @@ class PinnedMessageManager {
             return normalized;
         return ".../" + segments.slice(-3).join("/");
     }
+    areFileDiffsEqual(current, next) {
+        if (current.length !== next.length) {
+            return false;
+        }
+        for (let index = 0; index < current.length; index++) {
+            const left = current[index];
+            const right = next[index];
+            if (left.file !== right.file ||
+                left.additions !== right.additions ||
+                left.deletions !== right.deletions) {
+                return false;
+            }
+        }
+        return true;
+    }
     /**
      * Fetch context limit from current model configuration
      */
@@ -452,9 +539,12 @@ class PinnedMessageManager {
     formatMessage() {
         const currentModel = getStoredModel();
         const modelName = formatModelDisplayName(currentModel.providerID, currentModel.modelID);
+        const projectDisplayName = this.state.projectBranch
+            ? `${this.state.projectName}: ${this.state.projectBranch}`
+            : this.state.projectName;
         const lines = [
             `${this.state.sessionTitle}`,
-            t("pinned.line.project", { project: this.state.projectName }),
+            t("pinned.line.project", { project: projectDisplayName }),
             t("pinned.line.model", { model: modelName }),
             formatContextLine(this.state.tokensUsed, this.state.tokensLimit),
         ];
@@ -498,6 +588,7 @@ class PinnedMessageManager {
             this.state.messageId = sentMessage.message_id;
             this.state.chatId = this.chatId;
             this.state.lastUpdated = Date.now();
+            this.lastRenderedMessageText = text;
             // Save to settings for persistence
             setPinnedMessageId(sentMessage.message_id);
             // Pin the message (silently)
@@ -513,36 +604,67 @@ class PinnedMessageManager {
     /**
      * Update existing pinned message text
      */
-    async updatePinnedMessage() {
+    async updatePinnedMessage(forceUpdate = false) {
         if (!this.api || !this.chatId || !this.state.messageId) {
             return;
         }
-        try {
-            const text = this.formatMessage();
-            await this.api.editMessageText(this.chatId, this.state.messageId, text);
-            this.state.lastUpdated = Date.now();
-            logger.debug(`[PinnedManager] Updated pinned message: ${this.state.messageId}`);
-            // Trigger keyboard update callback
-            if (this.onKeyboardUpdateCallback && this.state.tokensLimit > 0) {
-                setImmediate(() => {
-                    this.onKeyboardUpdateCallback(this.state.tokensUsed, this.state.tokensLimit);
-                });
-            }
+        this.pendingUpdate = true;
+        if (forceUpdate) {
+            this.pendingForceUpdate = true;
         }
-        catch (err) {
-            // Handle "message is not modified" error silently
-            if (err instanceof Error && err.message.includes("message is not modified")) {
+        if (this.updateTask) {
+            await this.updateTask;
+            return;
+        }
+        this.updateTask = this.flushPendingPinnedUpdates().finally(() => {
+            this.updateTask = null;
+        });
+        await this.updateTask;
+    }
+    async flushPendingPinnedUpdates() {
+        while (this.pendingUpdate) {
+            this.pendingUpdate = false;
+            const shouldForceUpdate = this.pendingForceUpdate;
+            this.pendingForceUpdate = false;
+            if (!this.api || !this.chatId || !this.state.messageId) {
                 return;
             }
-            // Handle "message to edit not found" - recreate
-            if (err instanceof Error && err.message.includes("message to edit not found")) {
-                logger.warn("[PinnedManager] Pinned message was deleted, recreating...");
-                this.state.messageId = null;
-                clearPinnedMessageId();
-                await this.createPinnedMessage();
-                return;
+            const text = this.formatMessage();
+            if (!shouldForceUpdate && text === this.lastRenderedMessageText) {
+                logger.debug("[PinnedManager] Skipping pinned update: message content unchanged");
+                continue;
+            }
+            try {
+                await this.api.editMessageText(this.chatId, this.state.messageId, text);
+                this.state.lastUpdated = Date.now();
+                this.lastRenderedMessageText = text;
+                logger.debug(`[PinnedManager] Updated pinned message: ${this.state.messageId}`);
+                // Trigger keyboard update callback
+                if (this.onKeyboardUpdateCallback && this.state.tokensLimit > 0) {
+                    setImmediate(() => {
+                        this.onKeyboardUpdateCallback(this.state.tokensUsed, this.state.tokensLimit);
+                    });
+                }
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message.toLowerCase() : String(err).toLowerCase();
+                // Handle "message is not modified" error silently
+                if (errorMessage.includes("message is not modified")) {
+                    this.lastRenderedMessageText = text;
+                    continue;
+                }
+                // Handle "message to edit not found" - recreate
+                if (errorMessage.includes("message to edit not found")) {
+                    logger.warn("[PinnedManager] Pinned message was deleted, recreating...");
+                    this.state.messageId = null;
+                    this.lastRenderedMessageText = null;
+                    this.pendingForceUpdate = false;
+                    clearPinnedMessageId();
+                    await this.createPinnedMessage();
+                    continue;
+                }
+                logger.error("[PinnedManager] Error updating pinned message:", err);
             }
-            logger.error("[PinnedManager] Error updating pinned message:", err);
         }
     }
     /**
@@ -556,6 +678,9 @@ class PinnedMessageManager {
             // Unpin all messages (ensures clean state)
             await this.api.unpinAllChatMessages(this.chatId).catch(() => { });
             this.state.messageId = null;
+            this.lastRenderedMessageText = null;
+            this.pendingUpdate = false;
+            this.pendingForceUpdate = false;
             clearPinnedMessageId();
             logger.debug("[PinnedManager] Unpinned old messages");
         }
@@ -585,7 +710,11 @@ class PinnedMessageManager {
             this.state.sessionId = null;
             this.state.tokensUsed = 0;
             this.state.tokensLimit = 0;
+            this.state.projectBranch = null;
             this.state.changedFiles = [];
+            this.lastRenderedMessageText = null;
+            this.pendingUpdate = false;
+            this.pendingForceUpdate = false;
             clearPinnedMessageId();
             return;
         }
@@ -597,9 +726,13 @@ class PinnedMessageManager {
             this.state.sessionId = null;
             this.state.sessionTitle = t("pinned.default_session_title");
             this.state.projectName = "";
+            this.state.projectBranch = null;
             this.state.tokensUsed = 0;
             this.state.tokensLimit = 0;
             this.state.changedFiles = [];
+            this.lastRenderedMessageText = null;
+            this.pendingUpdate = false;
+            this.pendingForceUpdate = false;
             clearPinnedMessageId();
             logger.info("[PinnedManager] Cleared pinned message state");
         }

package/dist/settings/manager.js

@@ -63,6 +63,13 @@ export function clearSession() {
     currentSettings.currentSession = undefined;
     void writeSettingsFile(currentSettings);
 }
+export function isTtsEnabled() {
+    return currentSettings.ttsEnabled === true;
+}
+export function setTtsEnabled(enabled) {
+    currentSettings.ttsEnabled = enabled;
+    void writeSettingsFile(currentSettings);
+}
 export function getCurrentAgent() {
     return currentSettings.currentAgent;
 }

package/dist/summary/formatter.js

@@ -6,6 +6,15 @@ import { t } from "../i18n/index.js";
 import { getCurrentProject } from "../settings/manager.js";
 const TELEGRAM_MESSAGE_LIMIT = 4096;
 const MARKDOWN_V2_RESERVED_CHARS = /([_\*\[\]\(\)~`>#+\-=|{}.!\\])/g;
+function truncateWithEllipsis(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    if (maxLength <= 3) {
+        return ".".repeat(Math.max(0, maxLength));
+    }
+    return `${text.slice(0, maxLength - 3).trimEnd()}...`;
+}
 function endsWithOddTrailingBackslashes(text, start, end) {
     let backslashCount = 0;
     for (let index = end - 1; index >= start; index--) {
@@ -380,7 +389,7 @@ export function formatToolInfo(toolInfo) {
         description = `${input.description}\n`;
     }
     if (tool === "bash" && input && typeof input.command === "string") {
-        details = input.command;
+        details = truncateWithEllipsis(input.command, config.bot.bashToolDisplayMaxLength);
     }
     if (tool === "apply_patch") {
         const filediff = toolInfo.metadata && "filediff" in toolInfo.metadata

package/dist/tts/client.js

@@ -0,0 +1,59 @@
+import { config } from "../config.js";
+import { logger } from "../utils/logger.js";
+const TTS_REQUEST_TIMEOUT_MS = 60_000;
+export function isTtsConfigured() {
+    return Boolean(config.tts.apiUrl && config.tts.apiKey);
+}
+export async function synthesizeSpeech(text) {
+    if (!isTtsConfigured()) {
+        throw new Error("TTS is not configured: set TTS API credentials");
+    }
+    const input = text.trim();
+    if (!input) {
+        throw new Error("TTS input text is empty");
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), TTS_REQUEST_TIMEOUT_MS);
+    try {
+        const url = `${config.tts.apiUrl}/audio/speech`;
+        logger.debug(`[TTS] Sending speech synthesis request: url=${url}, model=${config.tts.model}, voice=${config.tts.voice}, chars=${input.length}`);
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${config.tts.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                model: config.tts.model,
+                voice: config.tts.voice,
+                input,
+                response_format: "mp3",
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const errorBody = await response.text().catch(() => "");
+            throw new Error(`TTS API returned HTTP ${response.status}: ${errorBody || response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        if (buffer.length === 0) {
+            throw new Error("TTS API returned an empty audio response");
+        }
+        logger.debug(`[TTS] Generated speech audio: ${buffer.length} bytes`);
+        return {
+            buffer,
+            filename: "assistant-reply.mp3",
+            mimeType: "audio/mpeg",
+        };
+    }
+    catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") {
+            throw new Error(`TTS request timed out after ${TTS_REQUEST_TIMEOUT_MS}ms`);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/utils/telegram-rate-limit-retry.js

@@ -0,0 +1,93 @@
+function getErrorMessage(error) {
+    const parts = [];
+    if (error instanceof Error) {
+        parts.push(error.message);
+    }
+    if (typeof error === "object" && error !== null) {
+        const description = Reflect.get(error, "description");
+        if (typeof description === "string") {
+            parts.push(description);
+        }
+        const message = Reflect.get(error, "message");
+        if (typeof message === "string") {
+            parts.push(message);
+        }
+    }
+    if (typeof error === "string") {
+        parts.push(error);
+    }
+    return parts.join("\n");
+}
+function getRetryAfterSecondsFromError(error) {
+    if (typeof error === "object" && error !== null) {
+        const parameters = Reflect.get(error, "parameters");
+        if (typeof parameters === "object" && parameters !== null) {
+            const retryAfter = Reflect.get(parameters, "retry_after");
+            if (typeof retryAfter === "number" && Number.isFinite(retryAfter) && retryAfter > 0) {
+                return retryAfter;
+            }
+        }
+    }
+    const message = getErrorMessage(error);
+    const retryMatch = message.match(/retry after\s+(\d+)/i);
+    if (!retryMatch) {
+        return null;
+    }
+    const parsedSeconds = Number.parseInt(retryMatch[1], 10);
+    if (!Number.isFinite(parsedSeconds) || parsedSeconds <= 0) {
+        return null;
+    }
+    return parsedSeconds;
+}
+function isTelegramRateLimitError(error) {
+    if (typeof error === "object" && error !== null) {
+        const status = Reflect.get(error, "status");
+        if (typeof status === "number" && status === 429) {
+            return true;
+        }
+        const errorCode = Reflect.get(error, "error_code");
+        if (typeof errorCode === "number" && errorCode === 429) {
+            return true;
+        }
+    }
+    const message = getErrorMessage(error).toLowerCase();
+    return /\b429\b/.test(message) || message.includes("too many requests");
+}
+function wait(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+export function getTelegramRetryAfterMs(error, fallbackDelayMs = 1000) {
+    if (!isTelegramRateLimitError(error)) {
+        return null;
+    }
+    const retryAfterSeconds = getRetryAfterSecondsFromError(error);
+    if (retryAfterSeconds !== null) {
+        return retryAfterSeconds * 1000;
+    }
+    return Math.max(1, Math.floor(fallbackDelayMs));
+}
+export async function withTelegramRateLimitRetry(operation, options) {
+    const maxRetries = Math.max(0, Math.floor(options?.maxRetries ?? 3));
+    const fallbackDelayMs = options?.fallbackDelayMs ?? 1000;
+    let attempt = 0;
+    while (true) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            const retryAfterMs = getTelegramRetryAfterMs(error, fallbackDelayMs);
+            if (retryAfterMs === null || attempt >= maxRetries) {
+                throw error;
+            }
+            attempt += 1;
+            options?.onRetry?.({
+                attempt,
+                retryAfterMs,
+                error,
+            });
+            await wait(retryAfterMs);
+        }
+    }
+}

package/package.json

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