@grinev/opencode-telegram-bot 0.19.2 → 0.20.0

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/scheduled-task/executor.js

@@ -2,6 +2,7 @@ import { config } from "../config.js";
 import { t } from "../i18n/index.js";
 import { opencodeClient } from "../opencode/client.js";
 import { logger } from "../utils/logger.js";
+import { cleanupScheduledTaskSessionIgnores, registerScheduledTaskSessionIgnore, } from "./session-ignore.js";
 export const SCHEDULED_TASK_AGENT = "build";
 const SCHEDULED_TASK_SESSION_TITLE = "Scheduled task run";
 const EXECUTION_POLL_INTERVAL_MS = 2000;
@@ -298,6 +299,7 @@ export async function executeScheduledTask(task) {
     let sessionId = null;
     let deleteTemporarySession = true;
     try {
+        await cleanupScheduledTaskSessionIgnores();
         const { data: session, error: createError } = await opencodeClient.session.create({
             directory: task.projectWorktree,
             title: SCHEDULED_TASK_SESSION_TITLE,
@@ -306,6 +308,7 @@ export async function executeScheduledTask(task) {
             throw createError || new Error("Failed to create temporary scheduled task session");
         }
         sessionId = session.id;
+        await registerScheduledTaskSessionIgnore(session.id);
         const promptOptions = {
             sessionID: session.id,
             directory: session.directory,

package/dist/scheduled-task/runtime.js

@@ -7,6 +7,7 @@ import { sendBotText } from "../bot/utils/telegram-text.js";
 import { formatAssistantRunFooter } from "../bot/utils/assistant-run-footer.js";
 import { executeScheduledTask, SCHEDULED_TASK_AGENT } from "./executor.js";
 import { foregroundSessionState } from "./foreground-state.js";
+import { cleanupScheduledTaskSessionIgnores } from "./session-ignore.js";
 import { computeNextRunAt, isTaskDue } from "./next-run.js";
 import { getScheduledTask, listScheduledTasks, removeScheduledTask, replaceScheduledTasks, updateScheduledTask, } from "./store.js";
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
@@ -96,6 +97,7 @@ export class ScheduledTaskRuntime {
             return;
         }
         this.initialized = true;
+        await cleanupScheduledTaskSessionIgnores();
         await this.recoverTasksOnStartup();
         await this.flushDeferredDeliveries();
     }

package/dist/scheduled-task/schedule-parser.js

@@ -1,5 +1,6 @@
 import { opencodeClient } from "../opencode/client.js";
 import { logger } from "../utils/logger.js";
+import { cleanupScheduledTaskSessionIgnores, registerScheduledTaskSessionIgnore, } from "./session-ignore.js";
 const SCHEDULE_PARSE_SESSION_TITLE = "Scheduled task schedule parser";
 function getLocalTimezone() {
     return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
@@ -133,6 +134,8 @@ export async function parseTaskSchedule(scheduleText, directory) {
     const timezone = getLocalTimezone();
     let sessionId = null;
     try {
+        logger.debug(`[ScheduledTaskScheduleParser] Parsing schedule: directory=${trimmedDirectory}, textLength=${trimmedScheduleText.length}`);
+        await cleanupScheduledTaskSessionIgnores();
         const { data: session, error: createError } = await opencodeClient.session.create({
             directory: trimmedDirectory,
             title: SCHEDULE_PARSE_SESSION_TITLE,
@@ -141,6 +144,8 @@ export async function parseTaskSchedule(scheduleText, directory) {
             throw createError || new Error("Failed to create temporary schedule parser session");
         }
         sessionId = session.id;
+        await registerScheduledTaskSessionIgnore(session.id);
+        logger.debug(`[ScheduledTaskScheduleParser] Created temporary session: sessionId=${session.id}`);
         const { data: response, error: promptError } = await opencodeClient.session.prompt({
             sessionID: session.id,
             directory: session.directory,
@@ -151,6 +156,7 @@ export async function parseTaskSchedule(scheduleText, directory) {
             throw promptError || new Error("Failed to parse schedule");
         }
         const responseText = collectResponseText(response.parts);
+        logger.debug(`[ScheduledTaskScheduleParser] Received parser response: sessionId=${session.id}, textLength=${responseText.length}`);
         if (!responseText) {
             throw new Error("Schedule parser returned an empty response");
         }

package/dist/scheduled-task/session-ignore.js

@@ -0,0 +1,53 @@
+import { getScheduledTaskSessionIgnores, setScheduledTaskSessionIgnores, } from "../settings/manager.js";
+const SCHEDULED_TASK_SESSION_IGNORE_TTL_MS = 24 * 60 * 60 * 1000;
+let mutationQueue = Promise.resolve();
+function isFreshIgnore(ignore, nowMs) {
+    const createdAtMs = Date.parse(ignore.createdAt);
+    return !Number.isNaN(createdAtMs) && nowMs - createdAtMs < SCHEDULED_TASK_SESSION_IGNORE_TTL_MS;
+}
+function pruneExpiredIgnores(ignores, nowMs) {
+    return ignores.filter((ignore) => isFreshIgnore(ignore, nowMs));
+}
+async function mutateIgnores(mutator) {
+    const runMutation = async () => {
+        const currentIgnores = getScheduledTaskSessionIgnores();
+        const { ignores, result } = mutator(currentIgnores);
+        await setScheduledTaskSessionIgnores(ignores);
+        return result;
+    };
+    const mutationPromise = mutationQueue.then(runMutation, runMutation);
+    mutationQueue = mutationPromise.catch(() => undefined);
+    return mutationPromise;
+}
+export function isScheduledTaskSessionIgnored(sessionId, now = new Date()) {
+    const nowMs = now.getTime();
+    return getScheduledTaskSessionIgnores().some((ignore) => ignore.sessionId === sessionId && isFreshIgnore(ignore, nowMs));
+}
+export async function registerScheduledTaskSessionIgnore(sessionId, createdAt = new Date()) {
+    await mutateIgnores((ignores) => {
+        const nowMs = createdAt.getTime();
+        const nextIgnores = pruneExpiredIgnores(ignores, nowMs).filter((ignore) => ignore.sessionId !== sessionId);
+        return {
+            ignores: [...nextIgnores, { sessionId, createdAt: createdAt.toISOString() }],
+            result: undefined,
+        };
+    });
+}
+export async function removeScheduledTaskSessionIgnore(sessionId) {
+    await mutateIgnores((ignores) => ({
+        ignores: ignores.filter((ignore) => ignore.sessionId !== sessionId),
+        result: undefined,
+    }));
+}
+export async function cleanupScheduledTaskSessionIgnores(now = new Date()) {
+    return mutateIgnores((ignores) => {
+        const nextIgnores = pruneExpiredIgnores(ignores, now.getTime());
+        return {
+            ignores: nextIgnores,
+            result: ignores.length - nextIgnores.length,
+        };
+    });
+}
+export function __resetScheduledTaskSessionIgnoreForTests() {
+    mutationQueue = Promise.resolve();
+}

package/dist/settings/manager.js

@@ -5,6 +5,9 @@ import { logger } from "../utils/logger.js";
 function cloneScheduledTasks(tasks) {
     return tasks?.map((task) => cloneScheduledTask(task));
 }
+function cloneScheduledTaskSessionIgnores(ignores) {
+    return ignores?.map((ignore) => ({ ...ignore }));
+}
 function getSettingsFilePath() {
     return getRuntimePaths().settingsFilePath;
 }
@@ -121,6 +124,13 @@ export function setScheduledTasks(tasks) {
     currentSettings.scheduledTasks = cloneScheduledTasks(tasks);
     return writeSettingsFile(currentSettings);
 }
+export function getScheduledTaskSessionIgnores() {
+    return cloneScheduledTaskSessionIgnores(currentSettings.scheduledTaskSessionIgnores) ?? [];
+}
+export function setScheduledTaskSessionIgnores(ignores) {
+    currentSettings.scheduledTaskSessionIgnores = cloneScheduledTaskSessionIgnores(ignores);
+    return writeSettingsFile(currentSettings);
+}
 export function __resetSettingsForTests() {
     currentSettings = {};
     settingsWriteQueue = Promise.resolve();
@@ -138,6 +148,8 @@ export async function loadSettings() {
     }
     currentSettings = loadedSettings;
     currentSettings.scheduledTasks = cloneScheduledTasks(loadedSettings.scheduledTasks) ?? [];
+    currentSettings.scheduledTaskSessionIgnores =
+        cloneScheduledTaskSessionIgnores(loadedSettings.scheduledTaskSessionIgnores) ?? [];
     if (requiresRewrite) {
         void writeSettingsFile(currentSettings);
     }

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.20.0",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",