@grinev/opencode-telegram-bot 0.20.0 → 0.20.1

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