@grinev/opencode-telegram-bot 0.19.1 → 0.19.3

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 { notifyOpencodeReadyIfHealthy, registerOpenCodeReadyRefreshHandler, } 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,10 +40,11 @@ export async function startBotApp() {
     logger.debug(`[Runtime] Application start mode: ${mode}`);
     await loadSettings();
     await reconcileStoredModelSelection();
-    await opencodeAutoRestartService.start();
-    await warmupSessionDirectoryCache();
+    registerOpenCodeReadyRefreshHandler();
     const bot = createBot();
     await scheduledTaskRuntime.initialize(bot);
+    await opencodeAutoRestartService.start();
+    await notifyOpencodeReadyIfHealthy("startup");
     let shutdownStarted = false;
     let serviceStateCleared = false;
     let shutdownTimeout = null;

package/dist/attach/service.js

@@ -1,5 +1,6 @@
 import { opencodeClient } from "../opencode/client.js";
 import { stopEventListening } from "../opencode/events.js";
+import { isOpencodeServerHealthy } from "../opencode/ready-refresh.js";
 import { summaryAggregator } from "../summary/aggregator.js";
 import { pinnedMessageManager } from "../pinned/manager.js";
 import { keyboardManager } from "../keyboard/manager.js";
@@ -11,6 +12,7 @@ import { getCurrentSession } from "../session/manager.js";
 import { getCurrentProject } from "../settings/manager.js";
 import { attachManager } from "./manager.js";
 import { logger } from "../utils/logger.js";
+import { isExpectedOpencodeUnavailableError } from "../utils/opencode-error.js";
 function getAttachBusyStatus(sessionId, statuses) {
     if (!statuses || typeof statuses !== "object") {
         return false;
@@ -18,13 +20,16 @@ function getAttachBusyStatus(sessionId, statuses) {
     const sessionStatus = statuses[sessionId];
     return sessionStatus?.type === "busy";
 }
-async function ensureAttachPinnedSession({ api, chatId, session, }) {
+async function ensureAttachPinnedSession({ api, chatId, session, forceFullRestore = false, }) {
     if (!pinnedMessageManager.isInitialized()) {
         pinnedMessageManager.initialize(api, chatId);
     }
     keyboardManager.initialize(api, chatId);
     const pinnedState = pinnedMessageManager.getState();
     if (pinnedState.sessionId === session.id && pinnedState.messageId) {
+        if (forceFullRestore) {
+            await pinnedMessageManager.loadContextFromHistory(session.id, session.directory);
+        }
         return;
     }
     if (pinnedState.messageId && pinnedState.sessionId === null) {
@@ -51,7 +56,12 @@ async function restorePendingQuestion(bot, chatId, sessionId, directory) {
         directory,
     });
     if (error || !data) {
-        logger.warn("[Attach] Failed to load pending questions during attach:", error);
+        if (isExpectedOpencodeUnavailableError(error)) {
+            logger.warn("[Attach] OpenCode server unavailable; skipping pending question restore");
+        }
+        else {
+            logger.warn("[Attach] Failed to load pending questions during attach:", error);
+        }
         return false;
     }
     const pendingQuestion = data.find((request) => request.sessionID === sessionId);
@@ -67,7 +77,12 @@ async function restorePendingPermissions(bot, chatId, sessionId, directory) {
         directory,
     });
     if (error || !data) {
-        logger.warn("[Attach] Failed to load pending permissions during attach:", error);
+        if (isExpectedOpencodeUnavailableError(error)) {
+            logger.warn("[Attach] OpenCode server unavailable; skipping pending permission restore");
+        }
+        else {
+            logger.warn("[Attach] Failed to load pending permissions during attach:", error);
+        }
         return 0;
     }
     const pendingPermissions = data.filter((request) => request.sessionID === sessionId);
@@ -77,12 +92,13 @@ async function restorePendingPermissions(bot, chatId, sessionId, directory) {
     return pendingPermissions.length;
 }
 export async function attachToSession(deps) {
-    const { bot, chatId, session, ensureEventSubscription } = deps;
+    const { bot, chatId, session, ensureEventSubscription, forceFullRestore = false } = deps;
     const alreadyAttached = attachManager.isAttachedSession(session.id, session.directory);
     await ensureAttachPinnedSession({
         api: bot.api,
         chatId,
         session,
+        forceFullRestore,
     });
     if (!alreadyAttached) {
         await ensureEventSubscription(session.directory);
@@ -98,7 +114,12 @@ export async function attachToSession(deps) {
         directory: session.directory,
     });
     if (statusesError) {
-        logger.warn("[Attach] Failed to load session status during attach:", statusesError);
+        if (isExpectedOpencodeUnavailableError(statusesError)) {
+            logger.warn("[Attach] OpenCode server unavailable; skipping session status restore");
+        }
+        else {
+            logger.warn("[Attach] Failed to load session status during attach:", statusesError);
+        }
     }
     const busy = getAttachBusyStatus(session.id, statuses);
     if (busy) {
@@ -110,7 +131,9 @@ export async function attachToSession(deps) {
     await syncPinnedAttachState();
     let restoredQuestion = false;
     let restoredPermissions = 0;
-    if (!alreadyAttached && !questionManager.isActive() && !permissionManager.isActive()) {
+    if ((!alreadyAttached || forceFullRestore) &&
+        !questionManager.isActive() &&
+        !permissionManager.isActive()) {
         restoredQuestion = await restorePendingQuestion(bot, chatId, session.id, session.directory);
         if (!restoredQuestion) {
             restoredPermissions = await restorePendingPermissions(bot, chatId, session.id, session.directory);
@@ -134,11 +157,16 @@ export async function restoreAttachedCurrentSession(deps) {
         return false;
     }
     try {
+        if (!(await isOpencodeServerHealthy())) {
+            logger.warn(`[Attach] OpenCode server is unavailable; skipping followed session restore: session=${currentSession.id}, directory=${currentSession.directory}`);
+            return false;
+        }
         await attachToSession({
             bot: deps.bot,
             chatId: deps.chatId,
             session: currentSession,
             ensureEventSubscription: deps.ensureEventSubscription,
+            forceFullRestore: deps.forceFullRestore,
         });
         logger.info(`[Attach] Restored followed session on startup: session=${currentSession.id}, directory=${currentSession.directory}`);
         return true;

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 { opencodeReadyLifecycle } from "../../opencode/ready-lifecycle.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 opencodeReadyLifecycle.notifyReady("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 opencodeReadyLifecycle.notifyReady("opencode_start_success");
     }
     catch (err) {
         logger.error("[Bot] Error in /opencode-start command:", err);

package/dist/bot/index.js

@@ -40,6 +40,7 @@ import { interactionManager } from "../interaction/manager.js";
 import { clearAllInteractionState } from "../interaction/cleanup.js";
 import { keyboardManager } from "../keyboard/manager.js";
 import { stopEventListening, subscribeToEvents } from "../opencode/events.js";
+import { opencodeReadyLifecycle } from "../opencode/ready-lifecycle.js";
 import { summaryAggregator } from "../summary/aggregator.js";
 import { formatToolInfo } from "../summary/formatter.js";
 import { renderSubagentCards } from "../summary/subagent-formatter.js";
@@ -76,6 +77,7 @@ let botInstance = null;
 let chatIdInstance = null;
 let commandsInitialized = false;
 let heartbeatTimer = null;
+let unsubscribeReadyRestore = null;
 const TELEGRAM_DOCUMENT_CAPTION_MAX_LENGTH = 1024;
 const RESPONSE_STREAM_THROTTLE_MS = config.bot.responseStreamThrottleMs;
 const RESPONSE_STREAM_TEXT_LIMIT = 3800;
@@ -809,6 +811,18 @@ export function createBot() {
     const bot = new Bot(config.telegram.token, botOptions);
     botInstance = bot;
     chatIdInstance = config.telegram.allowedUserId;
+    unsubscribeReadyRestore?.();
+    unsubscribeReadyRestore = opencodeReadyLifecycle.onReady(async (reason) => {
+        const restored = await restoreAttachedCurrentSession({
+            bot,
+            chatId: config.telegram.allowedUserId,
+            ensureEventSubscription,
+            forceFullRestore: true,
+        });
+        if (restored) {
+            logger.info(`[Bot] Restored followed session after OpenCode ready: reason=${reason}`);
+        }
+    });
     // Heartbeat for diagnostics: verify the event loop is not blocked
     let heartbeatCounter = 0;
     heartbeatTimer = setInterval(() => {
@@ -1024,14 +1038,6 @@ export function createBot() {
     });
     // Voice and audio message handlers (STT transcription -> prompt)
     const voicePromptDeps = { bot, ensureEventSubscription };
-    safeBackgroundTask({
-        taskName: "bot.restoreFollowedSession",
-        task: () => restoreAttachedCurrentSession({
-            bot,
-            chatId: config.telegram.allowedUserId,
-            ensureEventSubscription,
-        }),
-    });
     bot.on("message:voice", async (ctx) => {
         logger.debug(`[Bot] Received voice message, chatId=${ctx.chat.id}`);
         botInstance = bot;
@@ -1146,6 +1152,8 @@ export function createBot() {
     return bot;
 }
 export function cleanupBotRuntime(reason) {
+    unsubscribeReadyRestore?.();
+    unsubscribeReadyRestore = null;
     stopEventListening();
     summaryAggregator.clear();
     responseStreamer.clearAll(reason);

package/dist/bot/utils/external-user-input.js

@@ -1,9 +1,16 @@
 import { t } from "../../i18n/index.js";
 import { escapePlainTextForTelegramMarkdownV2 } from "../../summary/formatter.js";
 import { sendBotText } from "./telegram-text.js";
+const EXTERNAL_USER_INPUT_MAX_DISPLAY_LENGTH = 2000;
 function normalizeExternalUserInputText(text) {
     return text.replace(/\r\n/g, "\n").trim();
 }
+function truncateExternalUserInputText(text) {
+    if (text.length <= EXTERNAL_USER_INPUT_MAX_DISPLAY_LENGTH) {
+        return text;
+    }
+    return `${text.slice(0, EXTERNAL_USER_INPUT_MAX_DISPLAY_LENGTH - 3)}...`;
+}
 function buildQuotedPlainText(text) {
     return text
         .split("\n")
@@ -21,10 +28,11 @@ export function buildExternalUserInputNotification(text) {
     if (!normalizedText) {
         return null;
     }
+    const displayText = truncateExternalUserInputText(normalizedText);
     const title = `👤 ${t("bot.external_user_input")}`;
     return {
-        text: `${escapePlainTextForTelegramMarkdownV2(title)}\n\n${buildQuotedMarkdownText(normalizedText)}`,
-        rawFallbackText: `${title}\n\n${buildQuotedPlainText(normalizedText)}`,
+        text: `${escapePlainTextForTelegramMarkdownV2(title)}\n\n${buildQuotedMarkdownText(displayText)}`,
+        rawFallbackText: `${title}\n\n${buildQuotedPlainText(displayText)}`,
     };
 }
 export async function deliverExternalUserInputNotification({ api, chatId, currentSessionId, sessionId, text, consumeSuppressedInput, }) {

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/context-limit.js

@@ -1,6 +1,7 @@
 import { opencodeClient } from "../opencode/client.js";
 import { logger } from "../utils/logger.js";
 import { DEFAULT_CONTEXT_LIMIT } from "../pinned/format.js";
+import { isExpectedOpencodeUnavailableError } from "../utils/opencode-error.js";
 const PROVIDER_CACHE_TTL_MS = 10 * 60 * 1000;
 const contextLimitCache = new Map();
 let providersCacheExpiresAt = 0;
@@ -20,7 +21,12 @@ async function refreshContextLimitCache() {
         try {
             const { data, error } = await opencodeClient.config.providers();
             if (error || !data) {
-                logger.warn("[ModelContextLimit] Failed to fetch providers:", error);
+                if (isExpectedOpencodeUnavailableError(error)) {
+                    logger.warn("[ModelContextLimit] OpenCode server unavailable; using default context limit");
+                }
+                else {
+                    logger.warn("[ModelContextLimit] Failed to fetch providers:", error);
+                }
                 return;
             }
             contextLimitCache.clear();
@@ -35,7 +41,12 @@ async function refreshContextLimitCache() {
             logger.debug(`[ModelContextLimit] Cached limits for ${contextLimitCache.size} provider/model pairs`);
         }
         catch (error) {
-            logger.warn("[ModelContextLimit] Error refreshing providers cache:", error);
+            if (isExpectedOpencodeUnavailableError(error)) {
+                logger.warn("[ModelContextLimit] OpenCode server unavailable; using default context limit");
+            }
+            else {
+                logger.warn("[ModelContextLimit] Error refreshing providers cache:", error);
+            }
         }
         finally {
             providersFetchInFlight = null;

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

@@ -1,6 +1,7 @@
 import { config } from "../config.js";
 import { logger } from "../utils/logger.js";
 import { opencodeClient } from "./client.js";
+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;
@@ -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,14 @@ export class OpencodeAutoRestartService {
         try {
             if (await isOpencodeServerHealthy()) {
                 logger.debug(`[OpenCodeAutoRestart] Health-check succeeded: reason=${reason}`);
+                if (!this.serverWasHealthy) {
+                    this.serverWasHealthy = true;
+                    await opencodeReadyLifecycle.notifyReady(`auto_restart_${reason}`);
+                }
                 return;
             }
+            this.serverWasHealthy = false;
+            opencodeReadyLifecycle.notifyUnavailable(`auto_restart_${reason}`);
             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 +90,8 @@ export class OpencodeAutoRestartService {
                 return;
             }
             logger.info(`[OpenCodeAutoRestart] OpenCode server recovered: pid=${pid ?? "unknown"}, port=${this.localTarget.port}`);
+            this.serverWasHealthy = true;
+            await opencodeReadyLifecycle.notifyReady(`auto_restart_${reason}`);
         }
         catch (error) {
             logger.error("[OpenCodeAutoRestart] Failed to check or restart OpenCode server", error);

package/dist/opencode/events.js

@@ -1,5 +1,6 @@
 import { opencodeClient } from "./client.js";
 import { logger } from "../utils/logger.js";
+import { isExpectedOpencodeUnavailableError } from "../utils/opencode-error.js";
 const RECONNECT_BASE_DELAY_MS = 1000;
 const RECONNECT_MAX_DELAY_MS = 15000;
 const FATAL_NO_STREAM_ERROR = "No stream returned from event subscription";
@@ -108,7 +109,12 @@ export async function subscribeToEvents(directory, callback) {
                 }
                 reconnectAttempt++;
                 const reconnectDelay = getReconnectDelayMs(reconnectAttempt);
-                logger.error(`Event stream error for ${directory}, reconnecting in ${reconnectDelay}ms (attempt=${reconnectAttempt})`, error);
+                if (isExpectedOpencodeUnavailableError(error)) {
+                    logger.warn(`Event stream unavailable for ${directory}, reconnecting in ${reconnectDelay}ms (attempt=${reconnectAttempt})`);
+                }
+                else {
+                    logger.error(`Event stream error for ${directory}, reconnecting in ${reconnectDelay}ms (attempt=${reconnectAttempt})`, error);
+                }
                 const shouldContinue = await waitWithAbort(reconnectDelay, controller.signal);
                 if (!shouldContinue) {
                     break;
@@ -121,7 +127,12 @@ export async function subscribeToEvents(directory, callback) {
             logger.info("Event listener aborted");
             return;
         }
-        logger.error("Event stream error:", error);
+        if (isExpectedOpencodeUnavailableError(error)) {
+            logger.warn("Event stream unavailable; listener stopped");
+        }
+        else {
+            logger.error("Event stream error:", error);
+        }
         isListening = false;
         activeDirectory = null;
         streamAbortController = null;

package/dist/opencode/ready-lifecycle.js

@@ -0,0 +1,45 @@
+import { logger } from "../utils/logger.js";
+class OpencodeReadyLifecycle {
+    ready = false;
+    handlers = new Set();
+    onReady(handler) {
+        this.handlers.add(handler);
+        return () => {
+            this.handlers.delete(handler);
+        };
+    }
+    isReady() {
+        return this.ready;
+    }
+    async notifyReady(reason) {
+        if (this.ready) {
+            logger.debug(`[OpenCodeReady] Ready notification ignored: reason=${reason}`);
+            return false;
+        }
+        this.ready = true;
+        logger.info(`[OpenCodeReady] OpenCode server is ready: reason=${reason}`);
+        for (const handler of this.handlers) {
+            try {
+                await handler(reason);
+            }
+            catch (error) {
+                logger.warn(`[OpenCodeReady] Ready handler failed: reason=${reason}`, error);
+            }
+        }
+        return true;
+    }
+    notifyUnavailable(reason) {
+        if (!this.ready) {
+            logger.debug(`[OpenCodeReady] Unavailable notification ignored: reason=${reason}`);
+            return false;
+        }
+        this.ready = false;
+        logger.warn(`[OpenCodeReady] OpenCode server became unavailable: reason=${reason}`);
+        return true;
+    }
+    __resetForTests() {
+        this.ready = false;
+        this.handlers.clear();
+    }
+}
+export const opencodeReadyLifecycle = new OpencodeReadyLifecycle();

package/dist/opencode/ready-refresh.js

@@ -0,0 +1,55 @@
+import { reconcileStoredModelSelection } from "../model/manager.js";
+import { warmupSessionDirectoryCache } from "../session/cache-manager.js";
+import { logger } from "../utils/logger.js";
+import { opencodeClient } from "./client.js";
+import { opencodeReadyLifecycle } from "./ready-lifecycle.js";
+let readyRefreshRegistered = false;
+export 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())) {
+        opencodeReadyLifecycle.notifyUnavailable(reason);
+        logger.warn(`[OpenCodeReady] OpenCode server is not running; skipping session cache refresh: reason=${reason}`);
+        return false;
+    }
+    await refreshSessionCacheAfterOpencodeReady(reason);
+    return true;
+}
+export function registerOpenCodeReadyRefreshHandler() {
+    if (readyRefreshRegistered) {
+        return;
+    }
+    readyRefreshRegistered = true;
+    opencodeReadyLifecycle.onReady((reason) => refreshSessionCacheAfterOpencodeReady(reason));
+}
+export async function notifyOpencodeReadyIfHealthy(reason) {
+    if (!(await isOpencodeServerHealthy())) {
+        opencodeReadyLifecycle.notifyUnavailable(reason);
+        logger.warn(`[OpenCodeReady] OpenCode server is not running: reason=${reason}`);
+        return false;
+    }
+    return opencodeReadyLifecycle.notifyReady(reason);
+}

package/dist/pinned/manager.js

@@ -5,6 +5,7 @@ import { getCurrentSession } from "../session/manager.js";
 import { getCurrentProject, getPinnedMessageId, setPinnedMessageId, clearPinnedMessageId, } from "../settings/manager.js";
 import { getStoredModel } from "../model/manager.js";
 import { getModelContextLimit } from "../model/context-limit.js";
+import { isExpectedOpencodeUnavailableError } from "../utils/opencode-error.js";
 import { t } from "../i18n/index.js";
 import { DEFAULT_CONTEXT_LIMIT, formatContextLine, formatCostLine, formatModelDisplayName, } from "./format.js";
 class PinnedMessageManager {
@@ -128,7 +129,12 @@ class PinnedMessageManager {
                 directory,
             });
             if (error || !messagesData) {
-                logger.warn("[PinnedManager] Failed to load session history:", error);
+                if (isExpectedOpencodeUnavailableError(error)) {
+                    logger.warn("[PinnedManager] OpenCode server unavailable; skipping session history load");
+                }
+                else {
+                    logger.warn("[PinnedManager] Failed to load session history:", error);
+                }
                 return;
             }
             // Get the maximum context size and total cost from session history
@@ -164,7 +170,12 @@ class PinnedMessageManager {
             await this.updatePinnedMessage();
         }
         catch (err) {
-            logger.error("[PinnedManager] Error loading context from history:", err);
+            if (isExpectedOpencodeUnavailableError(err)) {
+                logger.warn("[PinnedManager] OpenCode server unavailable; skipping session history load");
+            }
+            else {
+                logger.error("[PinnedManager] Error loading context from history:", err);
+            }
         }
     }
     /**
@@ -337,7 +348,12 @@ class PinnedMessageManager {
             await this.loadDiffsFromMessages(sessionId, project.worktree);
         }
         catch (err) {
-            logger.debug("[PinnedManager] Could not load diffs from API:", err);
+            if (isExpectedOpencodeUnavailableError(err)) {
+                logger.debug("[PinnedManager] OpenCode server unavailable; skipping diff restore");
+            }
+            else {
+                logger.debug("[PinnedManager] Could not load diffs from API:", err);
+            }
         }
     }
     /**
@@ -351,7 +367,12 @@ class PinnedMessageManager {
                 directory,
             });
             if (error || !messagesData) {
-                logger.debug(`[PinnedManager] loadDiffsFromMessages: error or no data`);
+                if (isExpectedOpencodeUnavailableError(error)) {
+                    logger.debug("[PinnedManager] OpenCode server unavailable; skipping diff message restore");
+                }
+                else {
+                    logger.debug(`[PinnedManager] loadDiffsFromMessages: error or no data`);
+                }
                 return;
             }
             logger.debug(`[PinnedManager] loadDiffsFromMessages: ${messagesData.length} messages`);
@@ -422,7 +443,12 @@ class PinnedMessageManager {
             }
         }
         catch (err) {
-            logger.debug("[PinnedManager] Could not load diffs from messages:", err);
+            if (isExpectedOpencodeUnavailableError(err)) {
+                logger.debug("[PinnedManager] OpenCode server unavailable; skipping diff message restore");
+            }
+            else {
+                logger.debug("[PinnedManager] Could not load diffs from messages:", err);
+            }
         }
     }
     /**
@@ -445,7 +471,12 @@ class PinnedMessageManager {
             }
         }
         catch (err) {
-            logger.debug("[PinnedManager] Could not refresh session title:", err);
+            if (isExpectedOpencodeUnavailableError(err)) {
+                logger.debug("[PinnedManager] OpenCode server unavailable; skipping session title refresh");
+            }
+            else {
+                logger.debug("[PinnedManager] Could not refresh session title:", err);
+            }
         }
     }
     /**
@@ -523,7 +554,12 @@ class PinnedMessageManager {
             logger.debug(`[PinnedManager] Context limit: ${this.contextLimit}`);
         }
         catch (err) {
-            logger.error("[PinnedManager] Error fetching context limit:", err);
+            if (isExpectedOpencodeUnavailableError(err)) {
+                logger.warn("[PinnedManager] OpenCode server unavailable; using default context limit");
+            }
+            else {
+                logger.error("[PinnedManager] Error fetching context limit:", err);
+            }
             this.contextLimit = DEFAULT_CONTEXT_LIMIT;
             this.state.tokensLimit = this.contextLimit;
         }

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/dist/utils/opencode-error.js

@@ -0,0 +1,13 @@
+export function isExpectedOpencodeUnavailableError(error) {
+    if (!error) {
+        return false;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.toLowerCase();
+    return (normalized.includes("fetch failed") ||
+        normalized.includes("failed to fetch") ||
+        normalized.includes("econnrefused") ||
+        normalized.includes("econnreset") ||
+        normalized.includes("enotfound") ||
+        normalized.includes("connectex"));
+}

package/package.json

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