@grinev/opencode-telegram-bot 0.19.1 → 0.19.2

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

@@ -3,9 +3,9 @@ import { readFile } from "node:fs/promises";
 import { cleanupBotRuntime, createBot } from "../bot/index.js";
 import { config } from "../config.js";
 import { opencodeAutoRestartService } from "../opencode/auto-restart.js";
+import { refreshSessionCacheIfOpencodeReady } from "../opencode/ready-refresh.js";
 import { loadSettings } from "../settings/manager.js";
 import { scheduledTaskRuntime } from "../scheduled-task/runtime.js";
-import { warmupSessionDirectoryCache } from "../session/cache-manager.js";
 import { reconcileStoredModelSelection } from "../model/manager.js";
 import { getRuntimeMode } from "../runtime/mode.js";
 import { getRuntimePaths } from "../runtime/paths.js";
@@ -40,8 +40,10 @@ export async function startBotApp() {
     logger.debug(`[Runtime] Application start mode: ${mode}`);
     await loadSettings();
     await reconcileStoredModelSelection();
-    await opencodeAutoRestartService.start();
-    await warmupSessionDirectoryCache();
+    const autoRestartHandledStartup = await opencodeAutoRestartService.start();
+    if (!autoRestartHandledStartup) {
+        await refreshSessionCacheIfOpencodeReady("startup");
+    }
     const bot = createBot();
     await scheduledTaskRuntime.initialize(bot);
     let shutdownStarted = false;

package/dist/bot/commands/opencode-start.js

@@ -1,6 +1,7 @@
 import { config } from "../../config.js";
 import { opencodeClient } from "../../opencode/client.js";
 import { resolveLocalOpencodeTarget, startLocalOpencodeServer } from "../../opencode/process.js";
+import { refreshSessionCacheAfterOpencodeReady } from "../../opencode/ready-refresh.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 import { editBotText } from "../utils/telegram-text.js";
@@ -42,6 +43,7 @@ export async function opencodeStartCommand(ctx) {
             const { data, error } = await opencodeClient.global.health();
             if (!error && data?.healthy) {
                 await ctx.reply(t("opencode_start.already_running", { version: data.version || t("common.unknown") }));
+                await refreshSessionCacheAfterOpencodeReady("opencode_start_already_running");
                 return;
             }
         }
@@ -88,6 +90,7 @@ export async function opencodeStartCommand(ctx) {
             }),
         });
         logger.info(`[Bot] OpenCode server started successfully, PID=${pid}, port=${localTarget.port}`);
+        await refreshSessionCacheAfterOpencodeReady("opencode_start_success");
     }
     catch (err) {
         logger.error("[Bot] Error in /opencode-start command:", err);

package/dist/bot/utils/send-with-markdown-fallback.js

@@ -6,6 +6,7 @@ const MARKDOWN_PARSE_ERROR_MARKERS = [
     "entity beginning",
     "bad request: can't parse",
 ];
+const TELEGRAM_ENTITY_URL_ERROR_MARKERS = ["entity url", "wrong http url", "url host is empty"];
 const MARKDOWN_V2_RESERVED_CHARS = new Set([
     "_",
     "*",
@@ -91,6 +92,13 @@ export function isTelegramMarkdownParseError(error) {
     }
     return MARKDOWN_PARSE_ERROR_MARKERS.some((marker) => errorText.includes(marker));
 }
+export function isTelegramEntityUrlError(error) {
+    const errorText = getErrorText(error);
+    if (!errorText) {
+        return false;
+    }
+    return TELEGRAM_ENTITY_URL_ERROR_MARKERS.some((marker) => errorText.includes(marker));
+}
 export async function sendMessageWithMarkdownFallback({ api, chatId, text, rawFallbackText, options, parseMode, }) {
     if (!parseMode) {
         return api.sendMessage(chatId, text, options);
@@ -104,10 +112,7 @@ export async function sendMessageWithMarkdownFallback({ api, chatId, text, rawFa
         return await api.sendMessage(chatId, text, markdownOptions);
     }
     catch (error) {
-        if (!isTelegramMarkdownParseError(error)) {
-            throw error;
-        }
-        if (parseMode === "MarkdownV2") {
+        if (parseMode === "MarkdownV2" && isTelegramMarkdownParseError(error)) {
             const escapedText = escapeTelegramMarkdownV2(text);
             if (escapedText !== text) {
                 logger.warn("[Bot] Markdown parse failed, retrying message with escaped MarkdownV2", error);
@@ -115,15 +120,12 @@ export async function sendMessageWithMarkdownFallback({ api, chatId, text, rawFa
                     return await api.sendMessage(chatId, escapedText, markdownOptions);
                 }
                 catch (escapedError) {
-                    if (!isTelegramMarkdownParseError(escapedError)) {
-                        throw escapedError;
-                    }
-                    logger.warn("[Bot] Escaped Markdown parse failed, retrying message in raw mode", escapedError);
+                    logger.warn("[Bot] Escaped Markdown send failed, retrying message in raw mode", escapedError);
                     return api.sendMessage(chatId, fallbackText, stripMarkdownFormattingOptions(options));
                 }
             }
         }
-        logger.warn("[Bot] Markdown parse failed, retrying message in raw mode", error);
+        logger.warn("[Bot] Formatted message send failed, retrying message in raw mode", error);
         return api.sendMessage(chatId, fallbackText, stripMarkdownFormattingOptions(options));
     }
 }
@@ -140,10 +142,7 @@ export async function editMessageWithMarkdownFallback({ api, chatId, messageId,
         return await api.editMessageText(chatId, messageId, text, markdownOptions);
     }
     catch (error) {
-        if (!isTelegramMarkdownParseError(error)) {
-            throw error;
-        }
-        if (parseMode === "MarkdownV2") {
+        if (parseMode === "MarkdownV2" && isTelegramMarkdownParseError(error)) {
             const escapedText = escapeTelegramMarkdownV2(text);
             if (escapedText !== text) {
                 logger.warn("[Bot] Markdown parse failed, retrying edited message with escaped MarkdownV2", error);
@@ -151,15 +150,12 @@ export async function editMessageWithMarkdownFallback({ api, chatId, messageId,
                     return await api.editMessageText(chatId, messageId, escapedText, markdownOptions);
                 }
                 catch (escapedError) {
-                    if (!isTelegramMarkdownParseError(escapedError)) {
-                        throw escapedError;
-                    }
-                    logger.warn("[Bot] Escaped Markdown parse failed, retrying edited message in raw mode", escapedError);
+                    logger.warn("[Bot] Escaped Markdown edit failed, retrying edited message in raw mode", escapedError);
                     return api.editMessageText(chatId, messageId, fallbackText, stripMarkdownFormattingOptions(options));
                 }
             }
         }
-        logger.warn("[Bot] Markdown parse failed, retrying edited message in raw mode", error);
+        logger.warn("[Bot] Formatted message edit failed, retrying edited message in raw mode", error);
         return api.editMessageText(chatId, messageId, fallbackText, stripMarkdownFormattingOptions(options));
     }
 }

package/dist/bot/utils/telegram-text.js

@@ -1,5 +1,5 @@
 import { logger } from "../../utils/logger.js";
-import { editMessageWithMarkdownFallback, isTelegramMarkdownParseError, sendMessageWithMarkdownFallback, } from "./send-with-markdown-fallback.js";
+import { editMessageWithMarkdownFallback, sendMessageWithMarkdownFallback, } from "./send-with-markdown-fallback.js";
 function resolveParseMode(format) {
     if (format === "markdown_v2") {
         return "MarkdownV2";
@@ -56,10 +56,7 @@ export async function sendRenderedBotPart({ api, chatId, part, options, }) {
         };
     }
     catch (error) {
-        if (!isTelegramMarkdownParseError(error)) {
-            throw error;
-        }
-        logger.warn("[Bot] Entity payload rejected, retrying assistant message part in raw mode", error);
+        logger.warn("[Bot] Entity payload send failed, retrying assistant message part in raw mode", error);
         const sentMessage = await api.sendMessage(chatId, part.fallbackText, rawOptions);
         logger.debug("[Bot] Assistant message part sent in raw fallback mode", {
             fallbackTextLength: part.fallbackText.length,
@@ -95,10 +92,7 @@ export async function editRenderedBotPart({ api, chatId, messageId, part, option
         };
     }
     catch (error) {
-        if (!isTelegramMarkdownParseError(error)) {
-            throw error;
-        }
-        logger.warn("[Bot] Entity payload rejected, retrying assistant edit part in raw mode", error);
+        logger.warn("[Bot] Entity payload edit failed, retrying assistant edit part in raw mode", error);
         await api.editMessageText(chatId, messageId, part.fallbackText, rawOptions);
         logger.debug("[Bot] Assistant edit part applied in raw fallback mode", {
             messageId,

package/dist/model/manager.js

@@ -4,6 +4,12 @@ import { opencodeClient } from "../opencode/client.js";
 import { logger } from "../utils/logger.js";
 import path from "node:path";
 const MODEL_CATALOG_CACHE_TTL_MS = 10 * 60 * 1000;
+const SERVER_UNAVAILABLE_ERROR_MARKERS = [
+    "fetch failed",
+    "econnrefused",
+    "connection refused",
+    "connect refused",
+];
 let cachedValidModelKeys = null;
 let modelCatalogCacheExpiresAt = 0;
 let modelCatalogFetchInFlight = null;
@@ -34,8 +40,63 @@ function filterModelsByCatalog(models, validModelKeys) {
     }
     return models.filter((model) => validModelKeys.has(getModelKey(model.providerID, model.modelID)));
 }
-async function getValidModelKeys() {
-    if (cachedValidModelKeys && Date.now() < modelCatalogCacheExpiresAt) {
+function hasServerUnavailableMarker(value) {
+    const lower = value.toLowerCase();
+    return SERVER_UNAVAILABLE_ERROR_MARKERS.some((marker) => lower.includes(marker));
+}
+function isServerUnavailableError(error) {
+    const queue = [error];
+    const seen = new Set();
+    while (queue.length > 0) {
+        const current = queue.pop();
+        if (!current || seen.has(current)) {
+            continue;
+        }
+        seen.add(current);
+        if (typeof current === "string") {
+            if (hasServerUnavailableMarker(current)) {
+                return true;
+            }
+            continue;
+        }
+        if (current instanceof Error) {
+            if (hasServerUnavailableMarker(`${current.name}: ${current.message}`)) {
+                return true;
+            }
+            const errorWithCause = current;
+            if (errorWithCause.cause) {
+                queue.push(errorWithCause.cause);
+            }
+            continue;
+        }
+        if (typeof current === "object") {
+            const value = current;
+            if (typeof value.code === "string" && hasServerUnavailableMarker(value.code)) {
+                return true;
+            }
+            if (typeof value.message === "string" && hasServerUnavailableMarker(value.message)) {
+                return true;
+            }
+            if (value.cause) {
+                queue.push(value.cause);
+            }
+        }
+    }
+    return false;
+}
+function logModelCatalogRefreshFailure(error, type) {
+    if (isServerUnavailableError(error)) {
+        logger.warn("[ModelManager] OpenCode server is not running; skipping model catalog refresh");
+        return;
+    }
+    if (type === "error") {
+        logger.warn("[ModelManager] Failed to refresh model catalog:", error);
+        return;
+    }
+    logger.warn("[ModelManager] Error refreshing model catalog:", error);
+}
+async function getValidModelKeys(options) {
+    if (!options?.force && cachedValidModelKeys && Date.now() < modelCatalogCacheExpiresAt) {
         logger.debug(`[ModelManager] Model catalog cache hit: models=${cachedValidModelKeys.size}, ttlMs=${modelCatalogCacheExpiresAt - Date.now()}`);
         return cachedValidModelKeys;
     }
@@ -48,7 +109,7 @@ async function getValidModelKeys() {
             logger.debug("[ModelManager] Refreshing model catalog from OpenCode API");
             const response = await opencodeClient.config.providers();
             if (response.error || !response.data) {
-                logger.warn("[ModelManager] Failed to refresh model catalog:", response.error);
+                logModelCatalogRefreshFailure(response.error, "error");
                 if (cachedValidModelKeys) {
                     logger.warn("[ModelManager] Using stale model catalog cache after refresh failure");
                     return cachedValidModelKeys;
@@ -67,7 +128,7 @@ async function getValidModelKeys() {
             return cachedValidModelKeys;
         }
         catch (err) {
-            logger.warn("[ModelManager] Error refreshing model catalog:", err);
+            logModelCatalogRefreshFailure(err, "exception");
             if (cachedValidModelKeys) {
                 logger.warn("[ModelManager] Using stale model catalog cache after refresh exception");
                 return cachedValidModelKeys;
@@ -171,12 +232,12 @@ export async function getModelSelectionLists() {
  * Validate stored selected model against OpenCode providers catalog.
  * If selected model is unavailable, fallback to env default model.
  */
-export async function reconcileStoredModelSelection() {
+export async function reconcileStoredModelSelection(options) {
     const currentModel = getCurrentModel();
     if (!currentModel?.providerID || !currentModel.modelID) {
         return;
     }
-    const validModelKeys = await getValidModelKeys();
+    const validModelKeys = await getValidModelKeys({ force: options?.forceCatalogRefresh });
     if (!validModelKeys) {
         logger.warn("[ModelManager] Skipping stored model validation: model catalog unavailable");
         return;

package/dist/opencode/auto-restart.js

@@ -2,6 +2,7 @@ import { config } from "../config.js";
 import { logger } from "../utils/logger.js";
 import { opencodeClient } from "./client.js";
 import { resolveLocalOpencodeTarget, startLocalOpencodeServer, } from "./process.js";
+import { refreshSessionCacheAfterOpencodeReady } from "./ready-refresh.js";
 const SERVER_READY_TIMEOUT_MS = 10000;
 const SERVER_READY_POLL_INTERVAL_MS = 500;
 function sleep(ms) {
@@ -31,14 +32,15 @@ export class OpencodeAutoRestartService {
     localTarget = null;
     started = false;
     checkInProgress = false;
+    serverWasHealthy = false;
     async start() {
         if (this.started || !config.opencode.autoRestartEnabled) {
-            return;
+            return false;
         }
         const localTarget = resolveLocalOpencodeTarget(config.opencode.apiUrl);
         if (!localTarget) {
             logger.warn(`[OpenCodeAutoRestart] Disabled because OPENCODE_API_URL is not local: ${config.opencode.apiUrl}`);
-            return;
+            return false;
         }
         this.started = true;
         this.localTarget = localTarget;
@@ -48,6 +50,7 @@ export class OpencodeAutoRestartService {
             void this.checkAndRestart("interval");
         }, config.opencode.monitorIntervalSec * 1000);
         this.timer.unref?.();
+        return true;
     }
     stop() {
         if (this.timer) {
@@ -56,6 +59,7 @@ export class OpencodeAutoRestartService {
         }
         this.started = false;
         this.localTarget = null;
+        this.serverWasHealthy = false;
     }
     async checkAndRestart(reason) {
         if (this.checkInProgress || !this.localTarget) {
@@ -65,8 +69,13 @@ export class OpencodeAutoRestartService {
         try {
             if (await isOpencodeServerHealthy()) {
                 logger.debug(`[OpenCodeAutoRestart] Health-check succeeded: reason=${reason}`);
+                if (!this.serverWasHealthy) {
+                    this.serverWasHealthy = true;
+                    await refreshSessionCacheAfterOpencodeReady(`auto_restart_${reason}`);
+                }
                 return;
             }
+            this.serverWasHealthy = false;
             logger.warn(`[OpenCodeAutoRestart] OpenCode server is unavailable, starting local server: reason=${reason}, port=${this.localTarget.port}`);
             const childProcess = startLocalOpencodeServer(this.localTarget);
             childProcess.once("error", (error) => {
@@ -80,6 +89,8 @@ export class OpencodeAutoRestartService {
                 return;
             }
             logger.info(`[OpenCodeAutoRestart] OpenCode server recovered: pid=${pid ?? "unknown"}, port=${this.localTarget.port}`);
+            this.serverWasHealthy = true;
+            await refreshSessionCacheAfterOpencodeReady(`auto_restart_${reason}`);
         }
         catch (error) {
             logger.error("[OpenCodeAutoRestart] Failed to check or restart OpenCode server", error);

package/dist/opencode/ready-refresh.js

@@ -0,0 +1,37 @@
+import { reconcileStoredModelSelection } from "../model/manager.js";
+import { warmupSessionDirectoryCache } from "../session/cache-manager.js";
+import { logger } from "../utils/logger.js";
+import { opencodeClient } from "./client.js";
+async function isOpencodeServerHealthy() {
+    try {
+        const { data, error } = await opencodeClient.global.health();
+        return !error && data?.healthy === true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function refreshSessionCacheAfterOpencodeReady(reason) {
+    try {
+        await warmupSessionDirectoryCache();
+        logger.debug(`[OpenCodeReady] Session cache refreshed: reason=${reason}`);
+    }
+    catch (error) {
+        logger.warn(`[OpenCodeReady] Failed to refresh session cache: reason=${reason}`, error);
+    }
+    try {
+        await reconcileStoredModelSelection({ forceCatalogRefresh: true });
+        logger.debug(`[OpenCodeReady] Model catalog refreshed: reason=${reason}`);
+    }
+    catch (error) {
+        logger.warn(`[OpenCodeReady] Failed to refresh model catalog: reason=${reason}`, error);
+    }
+}
+export async function refreshSessionCacheIfOpencodeReady(reason) {
+    if (!(await isOpencodeServerHealthy())) {
+        logger.warn(`[OpenCodeReady] OpenCode server is not running; skipping session cache refresh: reason=${reason}`);
+        return false;
+    }
+    await refreshSessionCacheAfterOpencodeReady(reason);
+    return true;
+}

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

@@ -1,4 +1,4 @@
-import { validateTelegramEntities } from "./validator.js";
+import { isLoopbackTelegramHttpUrl, isValidTelegramTextLinkUrl, validateTelegramEntities, } from "./validator.js";
 const ENTITY_TYPE_PRIORITY = {
     bold: 1,
     italic: 2,
@@ -32,18 +32,15 @@ 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 appendPlainLinkTarget(state, offset, url) {
+    if (!url || state.text.slice(offset) === url) {
+        return;
+    }
+    appendText(state, ` (${url})`);
+}
 function renderIntoState(state, nodes) {
     for (const node of nodes) {
         switch (node.type) {
@@ -93,9 +90,9 @@ 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})`);
+                if (!isValidTelegramTextLinkUrl(node.url)) {
+                    if (isLocalReferenceUrl(node.url) || isLoopbackTelegramHttpUrl(node.url)) {
+                        appendPlainLinkTarget(state, offset, node.url);
                         break;
                     }
                 }

package/dist/telegram/render/validator.js

@@ -43,10 +43,36 @@ function isPartialOverlap(left, right) {
 function isStyleEntity(entity) {
     return STYLE_ENTITY_TYPES.has(entity.type);
 }
-function isValidLinkUrl(url) {
+function isLoopbackHttpHostname(hostname) {
+    const normalized = hostname.toLowerCase().replace(/^\[(.*)]$/, "$1").replace(/\.$/, "");
+    return (normalized === "localhost" ||
+        normalized.endsWith(".localhost") ||
+        normalized === "0.0.0.0" ||
+        normalized.startsWith("127.") ||
+        normalized === "::1");
+}
+export function isLoopbackTelegramHttpUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return ["http:", "https:"].includes(parsed.protocol) && isLoopbackHttpHostname(parsed.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+export function isValidTelegramTextLinkUrl(url) {
+    if (/\s/.test(url)) {
+        return false;
+    }
     try {
         const parsed = new URL(url);
-        return ["http:", "https:", "tg:", "mailto:"].includes(parsed.protocol);
+        if (!["http:", "https:", "tg:", "mailto:"].includes(parsed.protocol)) {
+            return false;
+        }
+        if (["http:", "https:"].includes(parsed.protocol)) {
+            return Boolean(parsed.hostname) && !isLoopbackTelegramHttpUrl(url);
+        }
+        return true;
     }
     catch {
         return false;
@@ -82,7 +108,7 @@ function validateEntityShape(textLength, entity, entityIndex) {
             entityIndex,
         });
     }
-    if (entity.type === "text_link" && !isValidLinkUrl(entity.url)) {
+    if (entity.type === "text_link" && !isValidTelegramTextLinkUrl(entity.url)) {
         issues.push({
             code: "invalid_link_url",
             message: `Invalid Telegram text_link URL: ${entity.url}`,

package/package.json

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