@grinev/opencode-telegram-bot 0.20.0 → 0.20.2

package/dist/bot/commands/commands.js

@@ -292,7 +292,7 @@ async function executeCommand(ctx, deps, params) {
     const model = storedModel.providerID && storedModel.modelID
         ? `${storedModel.providerID}/${storedModel.modelID}`
         : undefined;
-    foregroundSessionState.markBusy(session.id);
+    foregroundSessionState.markBusy(session.id, session.directory);
     await markAttachedSessionBusy(session.id);
     assistantRunState.startRun(session.id, {
         startedAt: Date.now(),

package/dist/bot/handlers/prompt.js

@@ -198,7 +198,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
             fileCount: fileParts.length,
         };
         logger.info(`[Bot] Calling session.promptAsync (start-only) with agent=${currentAgent}, fileCount=${fileParts.length}...`);
-        foregroundSessionState.markBusy(currentSession.id);
+        foregroundSessionState.markBusy(currentSession.id, currentSession.directory);
         await markAttachedSessionBusy(currentSession.id);
         assistantRunState.startRun(currentSession.id, {
             startedAt: Date.now(),

package/dist/bot/index.js

@@ -59,6 +59,7 @@ import { clearPromptResponseMode, processUserPrompt } from "./handlers/prompt.js
 import { handleVoiceMessage } from "./handlers/voice.js";
 import { handleDocumentMessage } from "./handlers/document.js";
 import { downloadTelegramFile, toDataUri } from "./utils/file-download.js";
+import { reconcileBusyState } from "./utils/busy-reconciliation.js";
 import { finalizeAssistantResponse } from "./utils/finalize-assistant-response.js";
 import { sendTtsResponseForSession } from "./utils/send-tts-response.js";
 import { deliverThinkingMessage } from "./utils/thinking-message.js";
@@ -800,6 +801,9 @@ async function ensureEventSubscription(directory) {
     });
     logger.info(`[Bot] Subscribing to OpenCode events for project: ${directory}`);
     subscribeToEvents(directory, (event) => {
+        if (event.type === "server.heartbeat") {
+            void reconcileBusyState(directory);
+        }
         const attached = attachManager.getSnapshot();
         const eventSessionId = getEventSessionId(event);
         if (attached &&

package/dist/bot/utils/busy-reconciliation.js

@@ -0,0 +1,113 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { foregroundSessionState, } from "../../scheduled-task/foreground-state.js";
+import { scheduledTaskRuntime } from "../../scheduled-task/runtime.js";
+import { attachManager } from "../../attach/manager.js";
+import { markAttachedSessionBusy, markAttachedSessionIdle } from "../../attach/service.js";
+import { assistantRunState } from "../assistant-run-state.js";
+import { clearPromptResponseMode } from "../handlers/prompt.js";
+import { logger } from "../../utils/logger.js";
+const RECONCILE_MIN_INTERVAL_MS = 10_000;
+const FOREGROUND_BUSY_RECONCILE_GRACE_MS = 2_000;
+const inFlightDirectories = new Set();
+const lastReconcileAtByDirectory = new Map();
+function getReconciliationTargets(directory) {
+    const foregroundBusySessions = foregroundSessionState
+        .getBusySessions()
+        .filter((session) => session.directory === directory);
+    const attachedSession = attachManager.getSnapshot();
+    const attachedSessionForDirectory = attachedSession?.directory === directory ? attachedSession : null;
+    return { foregroundBusySessions, attachedSessionForDirectory };
+}
+function getSessionStatus(statuses, sessionId) {
+    if (!statuses || typeof statuses !== "object") {
+        return null;
+    }
+    const status = statuses[sessionId];
+    return status ?? null;
+}
+function isTerminalStatus(status) {
+    return !status || status.type === "idle" || status.type === "error";
+}
+function isWithinForegroundBusyGracePeriod(session, now) {
+    return now - session.markedAt < FOREGROUND_BUSY_RECONCILE_GRACE_MS;
+}
+async function clearForegroundBusySession(sessionId, reason) {
+    foregroundSessionState.markIdle(sessionId);
+    assistantRunState.clearRun(sessionId, reason);
+    clearPromptResponseMode(sessionId);
+}
+export async function reconcileBusyStateNow(directory, now = Date.now()) {
+    if (!directory) {
+        return;
+    }
+    const { foregroundBusySessions, attachedSessionForDirectory } = getReconciliationTargets(directory);
+    if (foregroundBusySessions.length === 0 && !attachedSessionForDirectory) {
+        return;
+    }
+    const { data: statuses, error } = await opencodeClient.session.status({ directory });
+    if (error || !statuses) {
+        logger.warn("[BusyReconciliation] Failed to load session status", error);
+        return;
+    }
+    const freshForegroundSessionIds = new Set(foregroundBusySessions
+        .filter((session) => isWithinForegroundBusyGracePeriod(session, now))
+        .map((session) => session.sessionId));
+    if (attachedSessionForDirectory) {
+        const attachedStatus = getSessionStatus(statuses, attachedSessionForDirectory.sessionId);
+        if (attachedStatus?.type === "busy") {
+            await markAttachedSessionBusy(attachedSessionForDirectory.sessionId);
+        }
+        else if (isTerminalStatus(attachedStatus) &&
+            !freshForegroundSessionIds.has(attachedSessionForDirectory.sessionId)) {
+            await markAttachedSessionIdle(attachedSessionForDirectory.sessionId);
+        }
+    }
+    let clearedForegroundSession = false;
+    for (const session of foregroundBusySessions) {
+        const status = getSessionStatus(statuses, session.sessionId);
+        if (!isTerminalStatus(status)) {
+            continue;
+        }
+        if (freshForegroundSessionIds.has(session.sessionId)) {
+            logger.debug(`[BusyReconciliation] Skipping fresh foreground busy state: session=${session.sessionId}, directory=${session.directory}, status=${status?.type ?? "not-found"}`);
+            continue;
+        }
+        logger.info(`[BusyReconciliation] Clearing stale foreground busy state: session=${session.sessionId}, directory=${session.directory}, status=${status?.type ?? "not-found"}`);
+        if (attachedSessionForDirectory?.sessionId !== session.sessionId) {
+            await markAttachedSessionIdle(session.sessionId);
+        }
+        await clearForegroundBusySession(session.sessionId, "status_reconcile_idle");
+        clearedForegroundSession = true;
+    }
+    if (clearedForegroundSession) {
+        await scheduledTaskRuntime.flushDeferredDeliveries();
+    }
+}
+export async function reconcileBusyState(directory, now = Date.now()) {
+    if (!directory || inFlightDirectories.has(directory)) {
+        return;
+    }
+    const { foregroundBusySessions, attachedSessionForDirectory } = getReconciliationTargets(directory);
+    if (foregroundBusySessions.length === 0 && !attachedSessionForDirectory) {
+        return;
+    }
+    const lastReconcileAt = lastReconcileAtByDirectory.get(directory);
+    if (lastReconcileAt !== undefined && now - lastReconcileAt < RECONCILE_MIN_INTERVAL_MS) {
+        return;
+    }
+    lastReconcileAtByDirectory.set(directory, now);
+    inFlightDirectories.add(directory);
+    try {
+        await reconcileBusyStateNow(directory, now);
+    }
+    catch (error) {
+        logger.warn("[BusyReconciliation] Failed to reconcile busy state", error);
+    }
+    finally {
+        inFlightDirectories.delete(directory);
+    }
+}
+export function __resetBusyReconciliationForTests() {
+    inFlightDirectories.clear();
+    lastReconcileAtByDirectory.clear();
+}

package/dist/opencode/events.js

@@ -32,6 +32,65 @@ function waitWithAbort(ms, signal) {
         signal.addEventListener("abort", onAbort, { once: true });
     });
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isEventLike(value) {
+    return isRecord(value) && typeof value.type === "string" && isRecord(value.properties);
+}
+function normalizeDirectoryForComparison(directory) {
+    const normalized = directory.replace(/\\/g, "/").replace(/\/+$/, "");
+    return /^[a-z]:/i.test(normalized) ? normalized.toLowerCase() : normalized;
+}
+function isSameDirectory(left, right) {
+    return normalizeDirectoryForComparison(left) === normalizeDirectoryForComparison(right);
+}
+function normalizeGlobalEvent(rawEvent, directory) {
+    if (isEventLike(rawEvent)) {
+        return rawEvent;
+    }
+    if (!isRecord(rawEvent) || !("payload" in rawEvent)) {
+        logger.debug("[Events] Ignoring global event with unknown shape");
+        return null;
+    }
+    const eventDirectory = typeof rawEvent.directory === "string" ? rawEvent.directory : null;
+    if (eventDirectory && !isSameDirectory(eventDirectory, directory)) {
+        return null;
+    }
+    if (!isEventLike(rawEvent.payload)) {
+        logger.debug("[Events] Ignoring global event with unknown payload shape");
+        return null;
+    }
+    return rawEvent.payload;
+}
+function normalizeEvent(rawEvent, source, directory) {
+    if (source === "global") {
+        return normalizeGlobalEvent(rawEvent, directory);
+    }
+    if (!isEventLike(rawEvent)) {
+        logger.debug("[Events] Ignoring legacy event with unknown shape");
+        return null;
+    }
+    return rawEvent;
+}
+async function subscribeToGlobalEventStream(signal) {
+    const globalEvents = opencodeClient.global;
+    if (!globalEvents?.event) {
+        throw new Error("Global event subscription is not available");
+    }
+    const result = await globalEvents.event({ signal });
+    if (!result.stream) {
+        throw new Error(FATAL_NO_STREAM_ERROR);
+    }
+    return { source: "global", stream: result.stream };
+}
+async function subscribeToLegacyEventStream(directory, signal) {
+    const result = await opencodeClient.event.subscribe({ directory }, { signal });
+    if (!result.stream) {
+        throw new Error(FATAL_NO_STREAM_ERROR);
+    }
+    return { source: "legacy", stream: result.stream };
+}
 export async function subscribeToEvents(directory, callback) {
     if (isListening && activeDirectory === directory) {
         eventCallback = callback;
@@ -53,14 +112,33 @@ export async function subscribeToEvents(directory, callback) {
     streamAbortController = controller;
     try {
         let reconnectAttempt = 0;
+        let useLegacyEventsOnce = false;
         while (isListening && activeDirectory === directory && !controller.signal.aborted) {
             try {
-                const result = await opencodeClient.event.subscribe({ directory }, { signal: controller.signal });
-                if (!result.stream) {
-                    throw new Error(FATAL_NO_STREAM_ERROR);
+                let subscription;
+                if (useLegacyEventsOnce) {
+                    useLegacyEventsOnce = false;
+                    subscription = await subscribeToLegacyEventStream(directory, controller.signal);
+                }
+                else {
+                    try {
+                        subscription = await subscribeToGlobalEventStream(controller.signal);
+                        logger.debug(`Using global OpenCode event stream for ${directory}`);
+                    }
+                    catch (error) {
+                        if (controller.signal.aborted || !isListening || activeDirectory !== directory) {
+                            throw error;
+                        }
+                        if (isExpectedOpencodeUnavailableError(error)) {
+                            throw error;
+                        }
+                        logger.warn(`Global event stream unavailable for ${directory}, falling back to project event stream`, error);
+                        subscription = await subscribeToLegacyEventStream(directory, controller.signal);
+                    }
                 }
                 reconnectAttempt = 0;
-                eventStream = result.stream;
+                eventStream = subscription.stream;
+                let usefulEventCount = 0;
                 for await (const event of eventStream) {
                     if (!isListening || activeDirectory !== directory || controller.signal.aborted) {
                         logger.debug(`Event listener stopped or changed directory, breaking loop`);
@@ -69,6 +147,13 @@ export async function subscribeToEvents(directory, callback) {
                     // CRITICAL: Explicitly yield to the event loop BEFORE processing the event
                     // This allows grammY to handle getUpdates between SSE events
                     await new Promise((resolve) => setImmediate(resolve));
+                    const normalizedEvent = normalizeEvent(event, subscription.source, directory);
+                    if (!normalizedEvent) {
+                        continue;
+                    }
+                    if (normalizedEvent.type !== "server.connected") {
+                        usefulEventCount++;
+                    }
                     if (eventCallback) {
                         // Use setImmediate to avoid blocking the event loop
                         // and let grammY process incoming Telegram updates
@@ -81,7 +166,7 @@ export async function subscribeToEvents(directory, callback) {
                                 listenerGeneration !== generation) {
                                 return;
                             }
-                            callbackSnapshot(event);
+                            callbackSnapshot(normalizedEvent);
                         });
                     }
                 }
@@ -89,6 +174,11 @@ export async function subscribeToEvents(directory, callback) {
                 if (!isListening || activeDirectory !== directory || controller.signal.aborted) {
                     break;
                 }
+                if (subscription.source === "global" && usefulEventCount === 0) {
+                    useLegacyEventsOnce = true;
+                    logger.warn(`Global event stream ended without project events for ${directory}, falling back to project event stream`);
+                    continue;
+                }
                 reconnectAttempt++;
                 const reconnectDelay = getReconnectDelayMs(reconnectAttempt);
                 logger.warn(`Event stream ended for ${directory}, reconnecting in ${reconnectDelay}ms (attempt=${reconnectAttempt})`);

package/dist/scheduled-task/foreground-state.js

@@ -1,32 +1,42 @@
 import { logger } from "../utils/logger.js";
 class ForegroundSessionState {
-    activeSessionIds = new Set();
-    markBusy(sessionId) {
-        if (!sessionId) {
+    activeSessions = new Map();
+    markBusy(sessionId, directory) {
+        if (!sessionId || !directory) {
             return;
         }
-        this.activeSessionIds.add(sessionId);
-        logger.debug(`[ScheduledTaskForeground] Marked session busy: session=${sessionId}, count=${this.activeSessionIds.size}`);
+        this.activeSessions.set(sessionId, { sessionId, directory, markedAt: Date.now() });
+        logger.debug(`[ScheduledTaskForeground] Marked session busy: session=${sessionId}, directory=${directory}, count=${this.activeSessions.size}`);
     }
     markIdle(sessionId) {
         if (!sessionId) {
             return;
         }
-        this.activeSessionIds.delete(sessionId);
-        logger.debug(`[ScheduledTaskForeground] Marked session idle: session=${sessionId}, count=${this.activeSessionIds.size}`);
+        this.activeSessions.delete(sessionId);
+        logger.debug(`[ScheduledTaskForeground] Marked session idle: session=${sessionId}, count=${this.activeSessions.size}`);
+    }
+    getBusySessions() {
+        return Array.from(this.activeSessions.values(), (session) => ({ ...session }));
     }
     isBusy() {
-        return this.activeSessionIds.size > 0;
+        return this.activeSessions.size > 0;
     }
     clearAll(reason) {
-        if (this.activeSessionIds.size === 0) {
+        if (this.activeSessions.size === 0) {
             return;
         }
-        logger.info(`[ScheduledTaskForeground] Cleared foreground busy state: reason=${reason}, count=${this.activeSessionIds.size}`);
-        this.activeSessionIds.clear();
+        logger.info(`[ScheduledTaskForeground] Cleared foreground busy state: reason=${reason}, count=${this.activeSessions.size}`);
+        this.activeSessions.clear();
     }
     __resetForTests() {
-        this.activeSessionIds.clear();
+        this.activeSessions.clear();
+    }
+    __setMarkedAtForTests(sessionId, markedAt) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        this.activeSessions.set(sessionId, { ...session, markedAt });
     }
 }
 export const foregroundSessionState = new ForegroundSessionState();

package/dist/summary/aggregator.js

@@ -173,6 +173,10 @@ class SummaryAggregator {
             this.handleMessagePartDelta(event);
             return;
         }
+        if (eventType === "server.heartbeat") {
+            logger.debug("[Aggregator] Heartbeat received");
+            return;
+        }
         // Log all question-related events for debugging
         if (event.type.startsWith("question.")) {
             logger.info(`[Aggregator] Question event: ${event.type}`, JSON.stringify(event.properties, null, 2));

package/package.json

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