@grinev/opencode-telegram-bot 0.20.4 → 0.20.5

package/dist/bot/commands/abort.js

@@ -5,10 +5,19 @@ import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
 import { assistantRunState } from "../assistant-run-state.js";
+import { markAttachedSessionIdle } from "../../attach/service.js";
+import { clearPromptResponseMode } from "../handlers/prompt.js";
+import { markUserAbortRequested } from "../utils/abort-error-suppression.js";
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function abortLocalStreaming() {
     clearAllInteractionState("abort_command");
 }
+async function releaseAbortBusyState(sessionId, reason) {
+    foregroundSessionState.markIdle(sessionId);
+    assistantRunState.clearRun(sessionId, reason);
+    await markAttachedSessionIdle(sessionId);
+    clearPromptResponseMode(sessionId);
+}
 async function pollSessionStatus(sessionId, directory, maxWaitMs = 5000) {
     const startedAt = Date.now();
     const pollIntervalMs = 500;
@@ -61,6 +70,7 @@ export async function abortCurrentOperation(ctx, options = {}) {
         }
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), 5000);
+        markUserAbortRequested(currentSession.id);
         try {
             const { data: abortResult, error: abortError } = await opencodeClient.session.abort({
                 sessionID: currentSession.id,
@@ -69,12 +79,14 @@ export async function abortCurrentOperation(ctx, options = {}) {
             clearTimeout(timeoutId);
             if (abortError) {
                 logger.warn("[Abort] Abort request failed:", abortError);
+                await releaseAbortBusyState(currentSession.id, "abort_unconfirmed");
                 if (notifyUser && chatId !== null && waitingMessageId !== null) {
                     await ctx.api.editMessageText(chatId, waitingMessageId, t("stop.warn_unconfirmed"));
                 }
                 return;
             }
             if (abortResult !== true) {
+                await releaseAbortBusyState(currentSession.id, "abort_maybe_finished");
                 if (notifyUser && chatId !== null && waitingMessageId !== null) {
                     await ctx.api.editMessageText(chatId, waitingMessageId, t("stop.warn_maybe_finished"));
                 }
@@ -82,8 +94,7 @@ export async function abortCurrentOperation(ctx, options = {}) {
             }
             const finalStatus = await pollSessionStatus(currentSession.id, currentSession.directory, 5000);
             if (finalStatus === "idle" || finalStatus === "not-found") {
-                foregroundSessionState.markIdle(currentSession.id);
-                assistantRunState.clearRun(currentSession.id, "abort_confirmed");
+                await releaseAbortBusyState(currentSession.id, "abort_confirmed");
                 if (notifyUser && chatId !== null && waitingMessageId !== null) {
                     await ctx.api.editMessageText(chatId, waitingMessageId, t("stop.success"));
                 }
@@ -96,6 +107,7 @@ export async function abortCurrentOperation(ctx, options = {}) {
         }
         catch (error) {
             clearTimeout(timeoutId);
+            await releaseAbortBusyState(currentSession.id, "abort_error");
             if (error instanceof Error && error.name === "AbortError") {
                 if (notifyUser && chatId !== null && waitingMessageId !== null) {
                     await ctx.api.editMessageText(chatId, waitingMessageId, t("stop.warn_timeout"));

package/dist/bot/commands/opencode-start.js

@@ -5,6 +5,43 @@ 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";
+const SERVER_READY_TIMEOUT_MS = 10_000;
+const SERVER_READY_POLL_INTERVAL_MS = 500;
+const HEALTH_CHECK_TIMEOUT_MS = 3_000;
+const HEALTH_CHECK_TIMED_OUT = Symbol("health-check-timed-out");
+async function healthWithTimeout(timeoutMs = HEALTH_CHECK_TIMEOUT_MS) {
+    const controller = new AbortController();
+    let timeout;
+    try {
+        return await Promise.race([
+            opencodeClient.global.health({ signal: controller.signal }),
+            new Promise((resolve) => {
+                timeout = setTimeout(() => {
+                    controller.abort();
+                    resolve(HEALTH_CHECK_TIMED_OUT);
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}
+async function getHealthIfAvailable() {
+    try {
+        const result = await healthWithTimeout();
+        if (result === HEALTH_CHECK_TIMED_OUT) {
+            logger.warn(`[Bot] OpenCode health check timed out after ${HEALTH_CHECK_TIMEOUT_MS}ms`);
+            return null;
+        }
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Wait for OpenCode server to become ready by polling health endpoint
  * @param maxWaitMs Maximum time to wait in milliseconds
@@ -12,18 +49,12 @@ import { editBotText } from "../utils/telegram-text.js";
  */
 async function waitForServerReady(maxWaitMs = 10000) {
     const startTime = Date.now();
-    const pollInterval = 500;
     while (Date.now() - startTime < maxWaitMs) {
-        try {
-            const { data, error } = await opencodeClient.global.health();
-            if (!error && data?.healthy) {
-                return true;
-            }
-        }
-        catch {
-            // Server not ready yet
+        const health = await getHealthIfAvailable();
+        if (health?.data?.healthy) {
+            return true;
         }
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        await new Promise((resolve) => setTimeout(resolve, SERVER_READY_POLL_INTERVAL_MS));
     }
     return false;
 }
@@ -40,8 +71,9 @@ export async function opencodeStartCommand(ctx) {
         }
         // Check if server is already accessible.
         try {
-            const { data, error } = await opencodeClient.global.health();
-            if (!error && data?.healthy) {
+            const health = await getHealthIfAvailable();
+            const data = health?.data;
+            if (data?.healthy) {
                 await ctx.reply(t("opencode_start.already_running", { version: data.version || t("common.unknown") }));
                 await opencodeReadyLifecycle.notifyReady("opencode_start_already_running");
                 return;
@@ -67,7 +99,7 @@ export async function opencodeStartCommand(ctx) {
         }
         childProcess.unref();
         logger.info("[Bot] Waiting for OpenCode server to become ready...");
-        const ready = await waitForServerReady(10000);
+        const ready = await waitForServerReady(SERVER_READY_TIMEOUT_MS);
         if (!ready) {
             await editBotText({
                 api: ctx.api,
@@ -79,7 +111,7 @@ export async function opencodeStartCommand(ctx) {
             });
             return;
         }
-        const { data: health } = await opencodeClient.global.health();
+        const health = (await getHealthIfAvailable())?.data;
         await editBotText({
             api: ctx.api,
             chatId: ctx.chat.id,

package/dist/bot/index.js

@@ -62,6 +62,7 @@ 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";
+import { shouldSuppressUserAbortSessionError } from "./utils/abort-error-suppression.js";
 import { editRenderedBotPart, getTelegramRenderedPartSignature, sendRenderedBotPart, } from "./utils/telegram-text.js";
 import { formatAssistantRunFooter } from "./utils/assistant-run-footer.js";
 import { getModelCapabilities, supportsInput } from "../model/capabilities.js";
@@ -745,6 +746,12 @@ async function ensureEventSubscription(directory) {
             toolCallStreamer.flushSession(sessionId, "session_error"),
         ]);
         const normalizedMessage = message.trim() || t("common.unknown_error");
+        if (shouldSuppressUserAbortSessionError(sessionId, normalizedMessage)) {
+            logger.debug(`[Bot] Suppressed user-initiated abort error: session=${sessionId}`);
+            foregroundSessionState.markIdle(sessionId);
+            await scheduledTaskRuntime.flushDeferredDeliveries();
+            return;
+        }
         const truncatedMessage = normalizedMessage.length > 3500
             ? `${normalizedMessage.slice(0, 3497)}...`
             : normalizedMessage;

package/dist/bot/middleware/interaction-guard.js

@@ -1,4 +1,5 @@
 import { resolveInteractionGuardDecision } from "../../interaction/guard.js";
+import { reconcileForegroundBusyState } from "../utils/busy-guard.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 function getInteractionBlockedMessage(reason, interactionKind) {
@@ -72,7 +73,11 @@ function getInteractionBlockedMessage(reason, interactionKind) {
     }
 }
 export async function interactionGuardMiddleware(ctx, next) {
-    const decision = resolveInteractionGuardDecision(ctx);
+    let decision = resolveInteractionGuardDecision(ctx);
+    if (!decision.allow && decision.busy) {
+        await reconcileForegroundBusyState();
+        decision = resolveInteractionGuardDecision(ctx);
+    }
     if (decision.allow) {
         await next();
         return;

package/dist/bot/utils/abort-error-suppression.js

@@ -0,0 +1,32 @@
+// Covers abort request timeout, post-abort status polling, and delayed SSE reconnect delivery.
+const USER_ABORT_SUPPRESSION_WINDOW_MS = 90_000;
+const userAbortRequestedAtBySession = new Map();
+function deleteExpiredAbortRequests(now = Date.now()) {
+    for (const [sessionId, requestedAt] of userAbortRequestedAtBySession) {
+        if (now - requestedAt > USER_ABORT_SUPPRESSION_WINDOW_MS) {
+            userAbortRequestedAtBySession.delete(sessionId);
+        }
+    }
+}
+export function markUserAbortRequested(sessionId) {
+    const now = Date.now();
+    deleteExpiredAbortRequests(now);
+    userAbortRequestedAtBySession.set(sessionId, now);
+}
+export function shouldSuppressUserAbortSessionError(sessionId, message) {
+    if (message.trim().toLowerCase() !== "aborted") {
+        return false;
+    }
+    const requestedAt = userAbortRequestedAtBySession.get(sessionId);
+    if (requestedAt === undefined) {
+        return false;
+    }
+    userAbortRequestedAtBySession.delete(sessionId);
+    return Date.now() - requestedAt <= USER_ABORT_SUPPRESSION_WINDOW_MS;
+}
+export function __resetUserAbortErrorSuppressionForTests() {
+    userAbortRequestedAtBySession.clear();
+}
+export function __getUserAbortErrorSuppressionSizeForTests() {
+    return userAbortRequestedAtBySession.size;
+}

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

@@ -1,9 +1,35 @@
 import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
 import { attachManager } from "../../attach/manager.js";
+import { reconcileBusyStateNow } from "./busy-reconciliation.js";
 import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
 export function isForegroundBusy() {
     return foregroundSessionState.isBusy() || attachManager.isBusy();
 }
+function getBusyDirectories() {
+    const directories = new Set();
+    for (const session of foregroundSessionState.getBusySessions()) {
+        directories.add(session.directory);
+    }
+    const attached = attachManager.getSnapshot();
+    if (attached?.busy) {
+        directories.add(attached.directory);
+    }
+    return [...directories];
+}
+export async function reconcileForegroundBusyState() {
+    if (!isForegroundBusy()) {
+        return;
+    }
+    for (const directory of getBusyDirectories()) {
+        try {
+            await reconcileBusyStateNow(directory);
+        }
+        catch (error) {
+            logger.warn("[BusyGuard] Failed to reconcile foreground busy state", error);
+        }
+    }
+}
 export async function replyBusyBlocked(ctx) {
     const message = t("bot.session_busy");
     if (ctx.callbackQuery) {

package/dist/opencode/events.js

@@ -3,7 +3,9 @@ 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;
+let sseIdleTimeoutMs = 30_000;
 const FATAL_NO_STREAM_ERROR = "No stream returned from event subscription";
+const SSE_IDLE_TIMEOUT_ERROR = "SSE stream idle timeout";
 let eventStream = null;
 let eventCallback = null;
 let isListening = false;
@@ -32,6 +34,44 @@ function waitWithAbort(ms, signal) {
         signal.addEventListener("abort", onAbort, { once: true });
     });
 }
+function createAttemptAbortController(parentSignal) {
+    const controller = new AbortController();
+    if (parentSignal.aborted) {
+        controller.abort();
+        return { controller, cleanup: () => { } };
+    }
+    const onAbort = () => controller.abort();
+    parentSignal.addEventListener("abort", onAbort, { once: true });
+    return {
+        controller,
+        cleanup: () => parentSignal.removeEventListener("abort", onAbort),
+    };
+}
+function readStreamWithIdleTimeout(stream, signal) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            signal.removeEventListener("abort", onAbort);
+            resolve(result);
+        };
+        const onAbort = () => finish({ type: "aborted" });
+        const timeout = setTimeout(() => finish({ type: "timeout" }), sseIdleTimeoutMs);
+        if (signal.aborted) {
+            finish({ type: "aborted" });
+            return;
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+        stream.next().then((result) => finish({ type: "next", result }), (error) => finish({ type: "error", error }));
+    });
+}
+function isEventStreamIdleTimeoutError(error) {
+    return error instanceof Error && error.message === SSE_IDLE_TIMEOUT_ERROR;
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
@@ -114,15 +154,17 @@ export async function subscribeToEvents(directory, callback) {
         let reconnectAttempt = 0;
         let useLegacyEventsOnce = false;
         while (isListening && activeDirectory === directory && !controller.signal.aborted) {
+            let attemptAbort = null;
             try {
                 let subscription;
+                attemptAbort = createAttemptAbortController(controller.signal);
                 if (useLegacyEventsOnce) {
                     useLegacyEventsOnce = false;
-                    subscription = await subscribeToLegacyEventStream(directory, controller.signal);
+                    subscription = await subscribeToLegacyEventStream(directory, attemptAbort.controller.signal);
                 }
                 else {
                     try {
-                        subscription = await subscribeToGlobalEventStream(controller.signal);
+                        subscription = await subscribeToGlobalEventStream(attemptAbort.controller.signal);
                         logger.debug(`Using global OpenCode event stream for ${directory}`);
                     }
                     catch (error) {
@@ -133,43 +175,67 @@ export async function subscribeToEvents(directory, callback) {
                             throw error;
                         }
                         logger.warn(`Global event stream unavailable for ${directory}, falling back to project event stream`, error);
-                        subscription = await subscribeToLegacyEventStream(directory, controller.signal);
+                        subscription = await subscribeToLegacyEventStream(directory, attemptAbort.controller.signal);
                     }
                 }
                 reconnectAttempt = 0;
                 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`);
-                        break;
-                    }
-                    // 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
-                        const callbackSnapshot = eventCallback;
-                        setImmediate(() => {
-                            if (streamAbortController !== controller ||
-                                controller.signal.aborted ||
-                                !isListening ||
-                                activeDirectory !== directory ||
-                                listenerGeneration !== generation) {
-                                return;
-                            }
-                            callbackSnapshot(normalizedEvent);
-                        });
+                try {
+                    while (isListening && activeDirectory === directory && !controller.signal.aborted) {
+                        const readResult = await readStreamWithIdleTimeout(eventStream, attemptAbort.controller.signal);
+                        if (readResult.type === "aborted") {
+                            logger.debug(`Event listener stopped or changed directory, breaking loop`);
+                            break;
+                        }
+                        if (readResult.type === "timeout") {
+                            attemptAbort.controller.abort();
+                            const closeStream = eventStream.return?.(undefined);
+                            void closeStream?.catch(() => undefined);
+                            throw new Error(SSE_IDLE_TIMEOUT_ERROR);
+                        }
+                        if (readResult.type === "error") {
+                            throw readResult.error;
+                        }
+                        if (readResult.result.done) {
+                            break;
+                        }
+                        const event = readResult.result.value;
+                        // 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
+                            const callbackSnapshot = eventCallback;
+                            setImmediate(() => {
+                                if (streamAbortController !== controller ||
+                                    controller.signal.aborted ||
+                                    !isListening ||
+                                    activeDirectory !== directory ||
+                                    listenerGeneration !== generation) {
+                                    return;
+                                }
+                                try {
+                                    callbackSnapshot(normalizedEvent);
+                                }
+                                catch (error) {
+                                    logger.error("[Events] Callback failed:", error);
+                                }
+                            });
+                        }
                     }
                 }
+                finally {
+                    attemptAbort.cleanup();
+                }
                 eventStream = null;
                 if (!isListening || activeDirectory !== directory || controller.signal.aborted) {
                     break;
@@ -188,6 +254,7 @@ export async function subscribeToEvents(directory, callback) {
                 }
             }
             catch (error) {
+                attemptAbort?.cleanup();
                 eventStream = null;
                 if (controller.signal.aborted || !isListening || activeDirectory !== directory) {
                     logger.info("Event listener aborted");
@@ -199,7 +266,10 @@ export async function subscribeToEvents(directory, callback) {
                 }
                 reconnectAttempt++;
                 const reconnectDelay = getReconnectDelayMs(reconnectAttempt);
-                if (isExpectedOpencodeUnavailableError(error)) {
+                if (isEventStreamIdleTimeoutError(error)) {
+                    logger.warn(`Event stream idle timeout for ${directory}, reconnecting in ${reconnectDelay}ms (attempt=${reconnectAttempt})`);
+                }
+                else if (isExpectedOpencodeUnavailableError(error)) {
                     logger.warn(`Event stream unavailable for ${directory}, reconnecting in ${reconnectDelay}ms (attempt=${reconnectAttempt})`);
                 }
                 else {
@@ -251,3 +321,6 @@ export function stopEventListening() {
     activeDirectory = null;
     logger.info("Event listener stopped");
 }
+export function __setSseIdleTimeoutForTests(timeoutMs) {
+    sseIdleTimeoutMs = timeoutMs;
+}

package/dist/scheduled-task/executor.js

@@ -94,9 +94,26 @@ function findLatestAssistantMessage(messages) {
     }
     return null;
 }
+function getAssistantFinishReason(message) {
+    for (let index = message.parts.length - 1; index >= 0; index -= 1) {
+        const part = message.parts[index];
+        if (part?.type === "step-finish" && typeof part.reason === "string" && part.reason.trim()) {
+            return part.reason.trim();
+        }
+    }
+    if (typeof message.info.finish === "string" && message.info.finish.trim()) {
+        return message.info.finish.trim();
+    }
+    return null;
+}
 function extractAssistantResult(message) {
     if (!message) {
-        return { resultText: null, errorMessage: null, completed: false, message: null };
+        return {
+            resultText: null,
+            errorMessage: null,
+            completed: false,
+            message: null,
+        };
     }
     const errorMessage = extractErrorMessage(message.info.error);
     if (errorMessage) {
@@ -108,10 +125,13 @@ function extractAssistantResult(message) {
         };
     }
     const resultText = collectResponseText(message.parts);
+    const completed = Boolean(message.info.time?.completed);
+    const finishReason = getAssistantFinishReason(message);
+    const awaitingToolCalls = completed && finishReason === "tool-calls";
     return {
-        resultText,
+        resultText: awaitingToolCalls ? null : resultText,
         errorMessage: null,
-        completed: Boolean(message.info.time?.completed),
+        completed: completed && !awaitingToolCalls,
         message,
     };
 }
@@ -120,6 +140,7 @@ function summarizeAssistantParts(parts) {
         id: part.id,
         type: part.type,
         ignored: part.ignored,
+        reason: part.reason,
         ...(typeof part.text === "string" ? { textLength: part.text.length } : {}),
         ...(part.tool ? { tool: part.tool } : {}),
         ...(part.state?.status ? { status: part.state.status } : {}),
@@ -136,6 +157,7 @@ function logEmptyAssistantResponseDiagnostics(taskId, sessionId, directory, mess
                 id: message.info.id,
                 completed: Boolean(message.info.time?.completed),
                 summary: Boolean(message.info.summary),
+                finish: getAssistantFinishReason(message),
                 errorMessage: extractErrorMessage(message.info.error),
                 parts: summarizeAssistantParts(message.parts),
             }

package/package.json

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