@grinev/opencode-telegram-bot 0.17.0 → 0.19.0

package/dist/summary/aggregator.js

@@ -24,6 +24,17 @@ function countDiffChangesFromText(text) {
     }
     return { additions, deletions };
 }
+function normalizeSnapshotValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeSnapshotValue(item));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entryValue]) => [key, normalizeSnapshotValue(entryValue)]));
+    }
+    return value;
+}
 class SummaryAggregator {
     currentSessionId = null;
     textMessageStates = new Map();
@@ -32,6 +43,7 @@ class SummaryAggregator {
     lastUpdated = 0;
     onCompleteCallback = null;
     onPartialCallback = null;
+    onExternalUserInputCallback = null;
     onToolCallback = null;
     onToolFileCallback = null;
     onQuestionCallback = null;
@@ -50,6 +62,7 @@ class SummaryAggregator {
     onClearedCallback = null;
     processedToolStates = new Set();
     thinkingFiredForMessages = new Set();
+    deliveredExternalUserMessageIds = new Set();
     knownTextPartIds = new Map();
     bot = null;
     chatId = null;
@@ -63,6 +76,7 @@ class SummaryAggregator {
     pendingSubagentCardIdsByParent = new Map();
     pendingChildSessionIdsByParent = new Map();
     fallbackSubagentCardIdsByParent = new Map();
+    lastSubagentSnapshot = "";
     setBotAndChatId(bot, chatId) {
         this.bot = bot;
         this.chatId = chatId;
@@ -73,6 +87,9 @@ class SummaryAggregator {
     setOnPartial(callback) {
         this.onPartialCallback = callback;
     }
+    setOnExternalUserInput(callback) {
+        this.onExternalUserInputCallback = callback;
+    }
     setOnTool(callback) {
         this.onToolCallback = callback;
     }
@@ -226,6 +243,7 @@ class SummaryAggregator {
         this.knownTextPartIds.clear();
         this.processedToolStates.clear();
         this.thinkingFiredForMessages.clear();
+        this.deliveredExternalUserMessageIds.clear();
         this.trackedSessionParents.clear();
         this.subagentStates.clear();
         this.subagentOrder = [];
@@ -233,6 +251,7 @@ class SummaryAggregator {
         this.pendingSubagentCardIdsByParent.clear();
         this.pendingChildSessionIdsByParent.clear();
         this.fallbackSubagentCardIdsByParent.clear();
+        this.lastSubagentSnapshot = "";
         this.messageCount = 0;
         this.lastUpdated = 0;
         if (this.onClearedCallback) {
@@ -306,6 +325,28 @@ class SummaryAggregator {
             terminalMessage: state.terminalMessage,
             updatedAt: state.updatedAt,
         }));
+        const snapshot = JSON.stringify(subagents.map((subagent) => ({
+            cardId: subagent.cardId,
+            sessionId: subagent.sessionId,
+            parentSessionId: subagent.parentSessionId,
+            agent: subagent.agent,
+            description: subagent.description,
+            prompt: subagent.prompt,
+            command: subagent.command,
+            status: subagent.status,
+            providerID: subagent.providerID,
+            modelID: subagent.modelID,
+            tokens: subagent.tokens,
+            cost: subagent.cost,
+            currentTool: subagent.currentTool,
+            currentToolInput: normalizeSnapshotValue(subagent.currentToolInput),
+            currentToolTitle: subagent.currentToolTitle,
+            terminalMessage: subagent.terminalMessage,
+        })));
+        if (snapshot === this.lastSubagentSnapshot) {
+            return;
+        }
+        this.lastSubagentSnapshot = snapshot;
         this.onSubagentCallback(this.currentSessionId, subagents);
     }
     createSubagentState(parentSessionId, sessionId, cardId = `subagent-${parentSessionId}-${Date.now()}-${this.subagentOrder.length}`) {
@@ -605,6 +646,10 @@ class SummaryAggregator {
         }
         const messageID = info.id;
         this.messages.set(messageID, { role: info.role });
+        if (info.role === "user") {
+            this.emitExternalUserInputIfReady(info.sessionID, messageID);
+            return;
+        }
         if (info.role === "assistant") {
             if (!this.textMessageStates.has(messageID)) {
                 this.textMessageStates.set(messageID, {
@@ -655,15 +700,8 @@ class SummaryAggregator {
                         completedAt: time?.completed,
                     });
                 }
-                this.textMessageStates.delete(messageID);
-                this.messages.delete(messageID);
-                this.partHashes.delete(messageID);
-                this.knownTextPartIds.delete(messageID);
+                this.cleanupCompletedMessage(messageID);
                 logger.debug(`[Aggregator] Message completed cleanup: remaining messages=${this.textMessageStates.size}`);
-                if (this.textMessageStates.size === 0) {
-                    logger.debug("[Aggregator] No more active messages, stopping typing indicator");
-                    this.stopTypingIndicator();
-                }
             }
             this.lastUpdated = Date.now();
         }
@@ -741,6 +779,9 @@ class SummaryAggregator {
                 this.startTypingIndicator();
                 this.emitPartialText(part.sessionID, messageID, fullText);
             }
+            else if (messageInfo && messageInfo.role === "user") {
+                this.emitExternalUserInputIfReady(part.sessionID, messageID);
+            }
             else {
                 const state = this.getOrCreateTextMessageState(messageID);
                 state.optimisticUpdateCount++;
@@ -857,9 +898,48 @@ class SummaryAggregator {
         if (!combined.trim()) {
             return;
         }
+        const messageInfo = this.messages.get(messageID);
+        if (messageInfo?.role === "user") {
+            this.emitExternalUserInputIfReady(sessionID, messageID);
+            return;
+        }
         this.startTypingIndicator();
         this.emitPartialText(sessionID, messageID, combined);
     }
+    emitExternalUserInputIfReady(sessionId, messageId) {
+        if (sessionId !== this.currentSessionId || this.deliveredExternalUserMessageIds.has(messageId)) {
+            return;
+        }
+        const messageInfo = this.messages.get(messageId);
+        if (!messageInfo || messageInfo.role !== "user") {
+            return;
+        }
+        const messageText = this.getCombinedMessageText(messageId).trim();
+        if (!messageText) {
+            return;
+        }
+        this.deliveredExternalUserMessageIds.add(messageId);
+        this.cleanupCompletedMessage(messageId);
+        if (!this.onExternalUserInputCallback) {
+            return;
+        }
+        const callback = this.onExternalUserInputCallback;
+        setImmediate(() => {
+            Promise.resolve(callback(sessionId, messageId, messageText)).catch((err) => {
+                logger.error("[Aggregator] Error in external user input callback:", err);
+            });
+        });
+    }
+    cleanupCompletedMessage(messageId) {
+        this.textMessageStates.delete(messageId);
+        this.messages.delete(messageId);
+        this.partHashes.delete(messageId);
+        this.knownTextPartIds.delete(messageId);
+        if (this.textMessageStates.size === 0) {
+            logger.debug("[Aggregator] No more active messages, stopping typing indicator");
+            this.stopTypingIndicator();
+        }
+    }
     emitPartialText(sessionId, messageId, messageText) {
         if (!this.onPartialCallback || !messageText.trim()) {
             return;
@@ -1103,7 +1183,7 @@ class SummaryAggregator {
             const callback = this.onQuestionCallback;
             setImmediate(async () => {
                 try {
-                    await callback(questions, id);
+                    await callback(questions, id, sessionID);
                 }
                 catch (err) {
                     logger.error("[Aggregator] Error in question callback:", err);

package/dist/summary/formatter.js

@@ -1,9 +1,9 @@
 import * as path from "path";
-import { convert } from "telegram-markdown-v2";
 import { config } from "../config.js";
 import { logger } from "../utils/logger.js";
 import { t } from "../i18n/index.js";
 import { getCurrentProject } from "../settings/manager.js";
+import { convertToTelegramMarkdownV2 } from "./markdown-to-telegram-v2.js";
 import { normalizeMarkdownForTelegramRendering } from "../telegram/render/markdown-normalizer.js";
 const TELEGRAM_MESSAGE_LIMIT = 4096;
 const MARKDOWN_V2_RESERVED_CHARS = /([_\*\[\]\(\)~`>#+\-=|{}.!\\])/g;
@@ -90,7 +90,7 @@ export function escapePlainTextForTelegramMarkdownV2(text) {
 function formatMarkdownForTelegram(text) {
     try {
         const preprocessed = normalizeMarkdownForTelegramRendering(text);
-        return escapeMarkdownV2PipesOutsideCode(convert(preprocessed, "keep"));
+        return escapeMarkdownV2PipesOutsideCode(convertToTelegramMarkdownV2(preprocessed));
     }
     catch (error) {
         logger.warn("[Formatter] Failed to convert markdown summary, falling back to raw text", error);

package/dist/summary/markdown-to-telegram-v2.js

@@ -0,0 +1,99 @@
+import { parseTelegramBlocks } from "../telegram/render/block-parser.js";
+import { normalizeMarkdownForTelegramRendering } from "../telegram/render/markdown-normalizer.js";
+/**
+ * Escapes characters reserved in Telegram MarkdownV2.
+ * These must be escaped everywhere except when used as syntactic delimiters
+ * we intentionally emit (e.g. the surrounding * of bold).
+ */
+function escapeMarkdownV2(text) {
+    return text.replace(/([_*[\]()~`>#+\-=|{}.!\\])/g, "\\$1");
+}
+function escapeMarkdownV2Code(text) {
+    return text.replace(/([`\\])/g, "\\$1");
+}
+function escapeMarkdownV2LinkUrl(text) {
+    return text.replace(/([)\\])/g, "\\$1");
+}
+function renderInlineNodes(nodes) {
+    return nodes
+        .map((node) => {
+        switch (node.type) {
+            case "text":
+                return escapeMarkdownV2(node.text);
+            case "bold":
+                return `*${renderInlineNodes(node.children)}*`;
+            case "italic":
+                return `_${renderInlineNodes(node.children)}_`;
+            case "strike":
+                return `~${renderInlineNodes(node.children)}~`;
+            case "code":
+                return `\`${escapeMarkdownV2Code(node.text)}\``;
+            case "link":
+                return `[${renderInlineNodes(node.text)}](${escapeMarkdownV2LinkUrl(node.url)})`;
+            case "underline":
+                return `__${renderInlineNodes(node.children)}__`;
+            case "spoiler":
+                return `||${renderInlineNodes(node.children)}||`;
+            default:
+                return escapeMarkdownV2(String(node));
+        }
+    })
+        .join("");
+}
+function renderBlock(block) {
+    switch (block.type) {
+        case "paragraph":
+            return renderInlineNodes(block.inlines);
+        case "heading": {
+            const content = renderInlineNodes(block.inlines);
+            return `*${content}*`;
+        }
+        case "blockquote":
+            return block.lines
+                .map((line) => renderInlineNodes(line)
+                .split("\n")
+                .map((part) => `> ${part}`)
+                .join("\n"))
+                .join("\n");
+        case "list":
+            return block.items
+                .map((item, index) => {
+                const prefix = block.ordered ? `${index + 1}\\. ` : "\\- ";
+                const body = renderInlineNodes(item);
+                return `${prefix}${body}`;
+            })
+                .join("\n");
+        case "code":
+            return `\`\`\`${escapeMarkdownV2Code(block.language ?? "")}\n${escapeMarkdownV2Code(block.text)}\n\`\`\``;
+        case "table": {
+            if (block.rows.length === 0) {
+                return "";
+            }
+            const header = `\\| ${block.rows[0].map(escapeMarkdownV2).join(" \\| ")} \\|`;
+            const separator = `\\| ${block.rows[0].map(() => "\\-\\-\\-").join(" \\| ")} \\|`;
+            const body = block.rows
+                .slice(1)
+                .map((row) => `\\| ${row.map(escapeMarkdownV2).join(" \\| ")} \\|`);
+            return [header, separator, ...body].join("\n");
+        }
+        case "rule":
+            return "---";
+        case "plain":
+            return escapeMarkdownV2(block.text);
+    }
+}
+/**
+ * Converts standard Markdown into Telegram MarkdownV2.
+ *
+ * Uses the project's existing block parser (unified/remark) so that
+ * headings, lists, tables, code blocks, etc. are handled consistently
+ * with the entity-based Telegram renderer.
+ */
+export function convertToTelegramMarkdownV2(markdown) {
+    const normalized = normalizeMarkdownForTelegramRendering(markdown);
+    const blocks = parseTelegramBlocks(normalized);
+    if (blocks.length === 0) {
+        return "";
+    }
+    return blocks.map(renderBlock).join("\n\n");
+}

package/dist/summary/subagent-formatter.js

@@ -1,10 +1,31 @@
 import { formatModelDisplayName } from "../pinned/format.js";
 import { t } from "../i18n/index.js";
 import { formatCompactToolInfo } from "./formatter.js";
+function shouldPreferInputDetails(tool, input) {
+    if (!input) {
+        return false;
+    }
+    switch (tool) {
+        case "read":
+        case "edit":
+        case "write":
+        case "apply_patch":
+            return typeof input.path === "string" || typeof input.filePath === "string";
+        case "bash":
+            return typeof input.command === "string";
+        case "grep":
+        case "glob":
+            return typeof input.pattern === "string";
+    }
+    return ["query", "url", "name", "prompt", "text"].some((field) => typeof input[field] === "string");
+}
 function formatToolStep(subagent) {
     if (!subagent.currentTool) {
         return "";
     }
+    const toolTitle = shouldPreferInputDetails(subagent.currentTool, subagent.currentToolInput)
+        ? undefined
+        : subagent.currentToolTitle;
     const toolInfo = {
         sessionId: subagent.sessionId ?? subagent.parentSessionId,
         messageId: subagent.cardId,
@@ -13,12 +34,12 @@ function formatToolStep(subagent) {
         state: {
             status: "running",
             input: subagent.currentToolInput ?? {},
-            title: subagent.currentToolTitle,
+            title: toolTitle,
             metadata: {},
             time: { start: subagent.updatedAt },
         },
         input: subagent.currentToolInput,
-        title: subagent.currentToolTitle,
+        title: toolTitle,
         metadata: {},
         hasFileAttachment: false,
     };

package/dist/telegram/render/inline-renderer.js

@@ -32,6 +32,18 @@ function pushEntity(state, entity) {
     }
     state.entities.push(entity);
 }
+function isTelegramTextLinkUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return ["http:", "https:", "tg:", "mailto:"].includes(parsed.protocol);
+    }
+    catch {
+        return false;
+    }
+}
+function isLocalReferenceUrl(url) {
+    return url.startsWith("#") || url.startsWith("/") || url.startsWith("./") || url.startsWith("../");
+}
 function renderIntoState(state, nodes) {
     for (const node of nodes) {
         switch (node.type) {
@@ -81,6 +93,12 @@ function renderIntoState(state, nodes) {
             case "link": {
                 const offset = state.text.length;
                 renderIntoState(state, node.text);
+                if (!isTelegramTextLinkUrl(node.url)) {
+                    if (isLocalReferenceUrl(node.url)) {
+                        appendText(state, ` (${node.url})`);
+                        break;
+                    }
+                }
                 pushEntity(state, {
                     type: "text_link",
                     offset,

package/dist/tts/client.js

@@ -1,22 +1,80 @@
 import { config } from "../config.js";
 import { logger } from "../utils/logger.js";
+import textToSpeech from "@google-cloud/text-to-speech";
 const TTS_REQUEST_TIMEOUT_MS = 60_000;
 export function isTtsConfigured() {
+    if (config.tts.provider === "google") {
+        return Boolean(process.env.GOOGLE_APPLICATION_CREDENTIALS);
+    }
     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");
+/**
+ * Removes markdown syntax that TTS engines would read aloud
+ * (asterisks, backticks, heading markers, etc.).
+ */
+export function stripMarkdownForSpeech(text) {
+    let clean = text;
+    // fenced code blocks → inline content
+    clean = clean.replace(/```[\s\S]*?```/g, (match) => {
+        const inner = match.replace(/^```\w*\n?/, "").replace(/\n?```$/, "");
+        return inner.replace(/\n/g, " ");
+    });
+    clean = clean.replace(/`([^`]+)`/g, "$1");
+    clean = clean.replace(/\*\*\*(.+?)\*\*\*/g, "$1");
+    clean = clean.replace(/\*\*(.+?)\*\*/g, "$1");
+    clean = clean.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "$1");
+    clean = clean.replace(/~~(.+?)~~/g, "$1");
+    clean = clean.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+    clean = clean.replace(/^#{1,6}\s+/gm, "");
+    clean = clean.replace(/^>\s?/gm, "");
+    clean = clean.replace(/^[-*]\s+/gm, "");
+    clean = clean.replace(/^\d+\.\s+/gm, "");
+    clean = clean.replace(/^[-*_]{3,}\s*$/gm, "");
+    clean = clean.replace(/<\/?[A-Za-z][^>]*>/g, "");
+    clean = clean.replace(/[ \t]+/g, " ");
+    clean = clean.replace(/\n{3,}/g, "\n\n");
+    return clean.trim();
+}
+/** Extracts "ll-CC" from Google voice names like "de-DE-Neural2-B". */
+export function extractLanguageCode(voiceName) {
+    const match = voiceName.match(/^([a-z]{2,3}-[A-Z]{2})/);
+    return match ? match[1] : "en-US";
+}
+// --- Provider implementations ---
+let googleClient = null;
+function getGoogleClient() {
+    if (!googleClient) {
+        googleClient = new textToSpeech.TextToSpeechClient();
     }
-    const input = text.trim();
-    if (!input) {
-        throw new Error("TTS input text is empty");
+    return googleClient;
+}
+/** @internal Reset Google client singleton (for tests only). */
+export function _resetGoogleClient() {
+    googleClient = null;
+}
+async function synthesizeWithGoogle(text) {
+    const client = getGoogleClient();
+    const voiceName = config.tts.voice || "en-US-Studio-O";
+    const languageCode = extractLanguageCode(voiceName);
+    logger.debug(`[TTS] Google Cloud TTS: voice=${voiceName}, languageCode=${languageCode}, chars=${text.length}`);
+    const [response] = await client.synthesizeSpeech({
+        input: { text },
+        voice: { languageCode, name: voiceName },
+        audioConfig: { audioEncoding: "MP3" },
+    }, { timeout: TTS_REQUEST_TIMEOUT_MS });
+    const raw = response.audioContent;
+    const buffer = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+    if (buffer.length === 0) {
+        throw new Error("Google TTS API returned an empty audio response");
     }
+    return { buffer, filename: "assistant-reply.mp3", mimeType: "audio/mpeg" };
+}
+async function synthesizeWithOpenAi(text) {
+    const url = `${config.tts.apiUrl}/audio/speech`;
+    logger.debug(`[TTS] OpenAI-compatible: url=${url}, model=${config.tts.model}, voice=${config.tts.voice}, chars=${text.length}`);
     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: {
@@ -26,7 +84,7 @@ export async function synthesizeSpeech(text) {
             body: JSON.stringify({
                 model: config.tts.model,
                 voice: config.tts.voice,
-                input,
+                input: text,
                 response_format: "mp3",
             }),
             signal: controller.signal,
@@ -35,17 +93,37 @@ export async function synthesizeSpeech(text) {
             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);
+        const buffer = Buffer.from(await response.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",
-        };
+        return { buffer, filename: "assistant-reply.mp3", mimeType: "audio/mpeg" };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+// --- Public API ---
+function getNotConfiguredMessage() {
+    return config.tts.provider === "google"
+        ? "TTS is not configured: set GOOGLE_APPLICATION_CREDENTIALS for Google Cloud TTS"
+        : "TTS is not configured: set TTS_API_URL and TTS_API_KEY";
+}
+export async function synthesizeSpeech(text) {
+    if (!isTtsConfigured()) {
+        throw new Error(getNotConfiguredMessage());
+    }
+    const raw = text.trim();
+    if (!raw) {
+        throw new Error("TTS input text is empty");
+    }
+    const input = stripMarkdownForSpeech(raw);
+    try {
+        if (config.tts.provider === "google") {
+            return await synthesizeWithGoogle(input);
+        }
+        return await synthesizeWithOpenAi(input);
     }
     catch (err) {
         if (err instanceof DOMException && err.name === "AbortError") {
@@ -53,7 +131,4 @@ export async function synthesizeSpeech(text) {
         }
         throw err;
     }
-    finally {
-        clearTimeout(timeout);
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",
@@ -51,6 +51,7 @@
   },
   "homepage": "https://github.com/grinev/opencode-telegram-bot#readme",
   "dependencies": {
+    "@google-cloud/text-to-speech": "^6.4.0",
     "@grammyjs/menu": "^1.3.1",
     "@opencode-ai/sdk": "^1.1.21",
     "better-sqlite3": "^12.6.2",
@@ -61,7 +62,6 @@
     "remark-gfm": "^4.0.1",
     "remark-parse": "^11.0.0",
     "socks-proxy-agent": "^8.0.5",
-    "telegram-markdown-v2": "^0.0.4",
     "unified": "^11.0.5"
   },
   "devDependencies": {