@grinev/opencode-telegram-bot 0.19.2 → 0.19.3

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

@@ -3,7 +3,7 @@ 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 { notifyOpencodeReadyIfHealthy, registerOpenCodeReadyRefreshHandler, } from "../opencode/ready-refresh.js";
 import { loadSettings } from "../settings/manager.js";
 import { scheduledTaskRuntime } from "../scheduled-task/runtime.js";
 import { reconcileStoredModelSelection } from "../model/manager.js";
@@ -40,12 +40,11 @@ export async function startBotApp() {
     logger.debug(`[Runtime] Application start mode: ${mode}`);
     await loadSettings();
     await reconcileStoredModelSelection();
-    const autoRestartHandledStartup = await opencodeAutoRestartService.start();
-    if (!autoRestartHandledStartup) {
-        await refreshSessionCacheIfOpencodeReady("startup");
-    }
+    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,7 +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 { 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";
@@ -43,7 +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");
+                await opencodeReadyLifecycle.notifyReady("opencode_start_already_running");
                 return;
             }
         }
@@ -90,7 +90,7 @@ export async function opencodeStartCommand(ctx) {
             }),
         });
         logger.info(`[Bot] OpenCode server started successfully, PID=${pid}, port=${localTarget.port}`);
-        await refreshSessionCacheAfterOpencodeReady("opencode_start_success");
+        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/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/opencode/auto-restart.js

@@ -1,8 +1,8 @@
 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";
-import { refreshSessionCacheAfterOpencodeReady } from "./ready-refresh.js";
 const SERVER_READY_TIMEOUT_MS = 10000;
 const SERVER_READY_POLL_INTERVAL_MS = 500;
 function sleep(ms) {
@@ -71,11 +71,12 @@ export class OpencodeAutoRestartService {
                 logger.debug(`[OpenCodeAutoRestart] Health-check succeeded: reason=${reason}`);
                 if (!this.serverWasHealthy) {
                     this.serverWasHealthy = true;
-                    await refreshSessionCacheAfterOpencodeReady(`auto_restart_${reason}`);
+                    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) => {
@@ -90,7 +91,7 @@ export class OpencodeAutoRestartService {
             }
             logger.info(`[OpenCodeAutoRestart] OpenCode server recovered: pid=${pid ?? "unknown"}, port=${this.localTarget.port}`);
             this.serverWasHealthy = true;
-            await refreshSessionCacheAfterOpencodeReady(`auto_restart_${reason}`);
+            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

@@ -2,7 +2,9 @@ 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() {
+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;
@@ -29,9 +31,25 @@ export async function refreshSessionCacheAfterOpencodeReady(reason) {
 }
 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/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.2",
+  "version": "0.19.3",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",