@grinev/opencode-telegram-bot 0.20.3 → 0.20.4

package/dist/app/start-bot-app.js

@@ -12,6 +12,7 @@ import { getRuntimePaths } from "../runtime/paths.js";
 import { clearServiceStateFile } from "../service/manager.js";
 import { getServiceStateFilePathFromEnv, isServiceChildProcess } from "../service/runtime.js";
 import { getLogFilePath, initializeLogger, logger } from "../utils/logger.js";
+import { safeBackgroundTask } from "../utils/safe-background-task.js";
 const SHUTDOWN_TIMEOUT_MS = 5000;
 async function getBotVersion() {
     try {
@@ -43,8 +44,13 @@ export async function startBotApp() {
     registerOpenCodeReadyRefreshHandler();
     const bot = createBot();
     await scheduledTaskRuntime.initialize(bot);
-    await opencodeAutoRestartService.start();
-    await notifyOpencodeReadyIfHealthy("startup");
+    safeBackgroundTask({
+        taskName: "app.opencodeStartup",
+        task: async () => {
+            await opencodeAutoRestartService.start();
+            await notifyOpencodeReadyIfHealthy("startup");
+        },
+    });
     let shutdownStarted = false;
     let serviceStateCleared = false;
     let shutdownTimeout = null;

package/dist/bot/handlers/question.js

@@ -8,7 +8,11 @@ import { interactionManager } from "../../interaction/manager.js";
 import { logger } from "../../utils/logger.js";
 import { safeBackgroundTask } from "../../utils/safe-background-task.js";
 import { t } from "../../i18n/index.js";
+import { editRenderedBotPart, sendRenderedBotPart } from "../utils/telegram-text.js";
 const MAX_BUTTON_LENGTH = 60;
+const TELEGRAM_MESSAGE_LIMIT = 4096;
+const TRUNCATION_SUFFIX = "…";
+const QUESTION_EMOJI = "❓";
 function getCallbackMessageId(ctx) {
     const message = ctx.callbackQuery?.message;
     if (!message || !("message_id" in message)) {
@@ -186,12 +190,26 @@ async function updateQuestionMessage(ctx) {
         logger.debug("[QuestionHandler] updateQuestionMessage: no current question");
         return;
     }
-    const text = formatQuestionText(question);
+    const part = formatQuestionDetailsPart(question);
     const keyboard = buildQuestionKeyboard(question, questionManager.getSelectedOptions(questionManager.getCurrentIndex()));
     logger.debug("[QuestionHandler] Updating question message");
     try {
-        await ctx.editMessageText(text, {
-            reply_markup: keyboard,
+        const chatId = ctx.chat?.id;
+        const messageId = getCallbackMessageId(ctx);
+        if (!chatId || messageId === null) {
+            await ctx.editMessageText(part.fallbackText, {
+                reply_markup: keyboard,
+            });
+            return;
+        }
+        await editRenderedBotPart({
+            api: ctx.api,
+            chatId,
+            messageId,
+            part,
+            options: {
+                reply_markup: keyboard,
+            },
         });
     }
     catch (err) {
@@ -205,16 +223,21 @@ export async function showCurrentQuestion(bot, chatId) {
         return;
     }
     logger.debug(`[QuestionHandler] Showing question: ${question.header} - ${question.question}`);
-    const text = formatQuestionText(question);
+    const part = formatQuestionDetailsPart(question);
     const keyboard = buildQuestionKeyboard(question, questionManager.getSelectedOptions(questionManager.getCurrentIndex()));
     logger.debug(`[QuestionHandler] Sending message with keyboard, chatId=${chatId}`);
     try {
-        const message = await bot.sendMessage(chatId, text, {
-            reply_markup: keyboard,
+        const { messageId } = await sendRenderedBotPart({
+            api: bot,
+            chatId,
+            part,
+            options: {
+                reply_markup: keyboard,
+            },
         });
-        logger.debug(`[QuestionHandler] Message sent, messageId=${message.message_id}`);
-        questionManager.addMessageId(message.message_id);
-        questionManager.setActiveMessageId(message.message_id);
+        questionManager.addMessageId(messageId);
+        logger.debug(`[QuestionHandler] Message sent, messageId=${messageId}`);
+        questionManager.setActiveMessageId(messageId);
         syncQuestionInteractionState("callback", questionManager.getCurrentIndex(), questionManager.getActiveMessageId());
         summaryAggregator.stopTypingIndicator();
     }
@@ -335,14 +358,67 @@ async function sendAllAnswersToAgent(bot, chatId) {
         },
     });
 }
-function formatQuestionText(question) {
+function formatQuestionDetailsPart(question) {
     const currentIndex = questionManager.getCurrentIndex();
     const totalQuestions = questionManager.getTotalQuestions();
     const progressText = totalQuestions > 0 ? `${currentIndex + 1}/${totalQuestions}` : "";
-    const headerTitle = [progressText, question.header].filter(Boolean).join(" ");
-    const header = headerTitle ? `${headerTitle}\n\n` : "";
+    const headerTitle = [QUESTION_EMOJI, progressText, question.header].filter(Boolean).join(" ");
+    const textParts = [];
+    const entities = [];
+    if (headerTitle) {
+        textParts.push(headerTitle);
+        entities.push({ type: "bold", offset: 0, length: headerTitle.length });
+    }
     const multiple = question.multiple ? t("question.multi_hint") : "";
-    return `${header}${question.question}${multiple}`;
+    const questionText = `${question.question}${multiple}`;
+    if (questionText) {
+        textParts.push(questionText);
+    }
+    for (const option of question.options) {
+        const optionText = formatOptionDetails(option);
+        const offset = textParts.join("\n\n").length + (textParts.length > 0 ? 2 : 0);
+        if (option.label) {
+            entities.push({ type: "bold", offset, length: option.label.length });
+        }
+        textParts.push(optionText);
+    }
+    const text = textParts.filter(Boolean).join("\n\n");
+    const truncated = truncateQuestionPart(text, entities);
+    return {
+        text: truncated.text,
+        entities: truncated.entities.length > 0 ? truncated.entities : undefined,
+        fallbackText: truncated.text,
+        source: truncated.entities.length > 0 ? "entities" : "plain",
+    };
+}
+function truncateQuestionPart(text, entities) {
+    if (text.length <= TELEGRAM_MESSAGE_LIMIT) {
+        return { text, entities };
+    }
+    const maxBaseLength = TELEGRAM_MESSAGE_LIMIT - TRUNCATION_SUFFIX.length;
+    let endIndex = maxBaseLength;
+    if (endIndex > 0 && isHighSurrogate(text.charCodeAt(endIndex - 1))) {
+        endIndex -= 1;
+    }
+    const truncatedText = `${text.slice(0, endIndex)}${TRUNCATION_SUFFIX}`;
+    const truncatedEntities = entities
+        .filter((entity) => entity.offset < endIndex)
+        .map((entity) => ({
+        ...entity,
+        length: Math.min(entity.length, endIndex - entity.offset),
+    }))
+        .filter((entity) => entity.length > 0);
+    return { text: truncatedText, entities: truncatedEntities };
+}
+function isHighSurrogate(codeUnit) {
+    return codeUnit >= 0xd800 && codeUnit <= 0xdbff;
+}
+function formatOptionDetails(option) {
+    const optionTitle = option.label;
+    if (!option.description) {
+        return optionTitle;
+    }
+    return `${optionTitle} — ${option.description}`;
 }
 function buildQuestionKeyboard(question, selectedOptions) {
     const keyboard = new InlineKeyboard();
@@ -351,7 +427,7 @@ function buildQuestionKeyboard(question, selectedOptions) {
     question.options.forEach((option, index) => {
         const isSelected = selectedOptions.has(index);
         const icon = isSelected ? "✅ " : "";
-        const buttonText = formatButtonText(option.label, option.description, icon);
+        const buttonText = formatButtonText(option.label, icon);
         const callbackData = `question:select:${questionIndex}:${index}`;
         logger.debug(`[QuestionHandler] Button ${index}: "${buttonText}" -> "${callbackData}"`);
         keyboard.text(buttonText, callbackData).row();
@@ -367,11 +443,8 @@ function buildQuestionKeyboard(question, selectedOptions) {
     logger.debug(`[QuestionHandler] Final keyboard: ${JSON.stringify(keyboard.inline_keyboard)}`);
     return keyboard;
 }
-function formatButtonText(label, description, icon) {
+function formatButtonText(label, icon) {
     let text = `${icon}${label}`;
-    if (description && icon === "") {
-        text += ` - ${description}`;
-    }
     if (text.length > MAX_BUTTON_LENGTH) {
         text = text.substring(0, MAX_BUTTON_LENGTH - 3) + "...";
     }

package/dist/bot/handlers/voice.js

@@ -8,6 +8,7 @@ import { isSttConfigured, transcribeAudio } from "../../stt/client.js";
 import { processUserPrompt } from "./prompt.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
+import { buildTelegramFileUrl } from "../utils/telegram-file-url.js";
 const TELEGRAM_DOWNLOAD_TIMEOUT_MS = 30_000;
 const TELEGRAM_DOWNLOAD_MAX_REDIRECTS = 3;
 let telegramDownloadAgent;
@@ -80,8 +81,7 @@ async function downloadTelegramFile(ctx, fileId) {
             logger.error("[Voice] Telegram getFile returned no file_path");
             return null;
         }
-        const apiRoot = (config.telegram.apiRoot ?? "https://api.telegram.org").replace(/\/$/, "");
-        const fileUrl = `${apiRoot}/file/bot${ctx.api.token}/${file.file_path}`;
+        const fileUrl = buildTelegramFileUrl(file.file_path);
         logger.debug(`[Voice] Downloading file: ${file.file_path} (${file.file_size ?? "?"} bytes)`);
         const buffer = await downloadTelegramFileByUrl(fileUrl);
         // Extract filename from file_path (e.g., "voice/file_123.oga" -> "file_123.oga")

package/dist/bot/utils/file-download.js

@@ -1,14 +1,9 @@
 // @ts-expect-error — node-fetch v2 ships no TS types and we avoid adding @types/node-fetch
 import nodeFetch from "node-fetch";
 import { Agent as HttpsAgent } from "https";
-import { config } from "../../config.js";
 import { logger } from "../../utils/logger.js";
-const DEFAULT_TELEGRAM_FILE_URL_BASE = "https://api.telegram.org/file/bot";
-function fileUrlBase() {
-    return config.telegram.apiRoot
-        ? `${config.telegram.apiRoot.replace(/\/$/, "")}/file/bot`
-        : DEFAULT_TELEGRAM_FILE_URL_BASE;
-}
+import { config } from "../../config.js";
+import { buildTelegramFileUrl } from "./telegram-file-url.js";
 const MAX_FILE_SIZE_BYTES = 20 * 1024 * 1024; // 20MB Telegram limit
 /**
  * Download a photo from Telegram servers
@@ -26,7 +21,7 @@ export async function downloadTelegramFile(api, fileId) {
         const sizeMb = (file.file_size / (1024 * 1024)).toFixed(2);
         throw new Error(`File too large: ${sizeMb}MB (max 20MB)`);
     }
-    const fileUrl = `${fileUrlBase()}${config.telegram.token}/${file.file_path}`;
+    const fileUrl = buildTelegramFileUrl(file.file_path);
     logger.debug(`[FileDownload] Downloading from ${fileUrl.replace(config.telegram.token, "***")}`);
     const fetchOptions = {};
     // Use proxy if configured

package/dist/bot/utils/telegram-file-url.js

@@ -0,0 +1,11 @@
+import { config } from "../../config.js";
+const DEFAULT_TELEGRAM_API_ROOT = "https://api.telegram.org";
+export function telegramFileUrlBase() {
+    const apiRoot = config.telegram.apiRoot
+        ? config.telegram.apiRoot.replace(/\/+$/, "")
+        : DEFAULT_TELEGRAM_API_ROOT;
+    return `${apiRoot}/file/bot`;
+}
+export function buildTelegramFileUrl(filePath) {
+    return `${telegramFileUrlBase()}${config.telegram.token}/${filePath}`;
+}

package/dist/opencode/auto-restart.js

@@ -5,12 +5,35 @@ import { opencodeReadyLifecycle } from "./ready-lifecycle.js";
 import { resolveLocalOpencodeTarget, startLocalOpencodeServer, } from "./process.js";
 const SERVER_READY_TIMEOUT_MS = 10000;
 const SERVER_READY_POLL_INTERVAL_MS = 500;
+const HEALTH_CHECK_TIMEOUT_MS = 3000;
+const HEALTH_CHECK_TIMED_OUT = Symbol("health-check-timed-out");
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+async function withTimeout(promise, timeoutMs) {
+    let timeout;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(HEALTH_CHECK_TIMED_OUT), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}
 async function isOpencodeServerHealthy() {
     try {
-        const { data, error } = await opencodeClient.global.health();
+        const result = await withTimeout(opencodeClient.global.health(), HEALTH_CHECK_TIMEOUT_MS);
+        if (result === HEALTH_CHECK_TIMED_OUT) {
+            logger.warn(`[OpenCodeAutoRestart] Health-check timed out after ${HEALTH_CHECK_TIMEOUT_MS}ms`);
+            return false;
+        }
+        const { data, error } = result;
         return !error && data?.healthy === true;
     }
     catch {

package/package.json

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