opencode-gateway 0.2.2 → 0.2.3

package/dist/telegram/client.d.ts

@@ -6,7 +6,7 @@ export declare class TelegramApiError extends Error {
 export declare class TelegramBotClient {
     private readonly botToken;
     constructor(botToken: string);
-    getUpdates(offset: number | null, timeoutSeconds: number): Promise<TelegramUpdate[]>;
+    getUpdates(offset: number | null, timeoutSeconds: number, signal?: AbortSignal): Promise<TelegramUpdate[]>;
     getMe(): Promise<TelegramBotProfile>;
     getChat(chatId: string): Promise<TelegramChat>;
     getFile(fileId: string): Promise<TelegramFileRecord>;

package/dist/telegram/client.js

@@ -12,12 +12,12 @@ export class TelegramBotClient {
     constructor(botToken) {
         this.botToken = botToken;
     }
-    async getUpdates(offset, timeoutSeconds) {
+    async getUpdates(offset, timeoutSeconds, signal) {
         return this.call("getUpdates", {
             offset,
             timeout: timeoutSeconds,
             allowed_updates: ["message", "callback_query"],
-        });
+        }, signal);
     }
     async getMe() {
         return this.call("getMe", {});
@@ -100,7 +100,7 @@ export class TelegramBotClient {
             text,
         });
     }
-    async call(method, body) {
+    async call(method, body, signal) {
         let response;
         try {
             response = await fetch(`https://api.telegram.org/bot${this.botToken}/${method}`, {
@@ -109,6 +109,7 @@ export class TelegramBotClient {
                     "content-type": "application/json",
                 },
                 body: JSON.stringify(stripUndefined(body)),
+                signal,
             });
         }
         catch (error) {

package/dist/telegram/poller.d.ts

@@ -6,6 +6,11 @@ import type { GatewayMailboxRuntime } from "../runtime/mailbox";
 import type { SqliteStore } from "../store/sqlite";
 import { type TelegramPollingClientLike } from "./client";
 import type { TelegramInboundMediaStore } from "./media";
+type PollerTiming = {
+    timeoutFloorMs: number;
+    timeoutGraceMs: number;
+    stallGraceMs: number;
+};
 export declare class TelegramPollingService {
     private readonly client;
     private readonly mailbox;
@@ -16,14 +21,24 @@ export declare class TelegramPollingService {
     private readonly mediaStore;
     private readonly questions;
     private readonly allowlist;
+    private readonly timing;
     private running;
+    private inFlightStartedAtMs;
+    private consecutiveFailures;
+    private recoveredAtMs;
     constructor(client: TelegramPollingClientLike, mailbox: GatewayMailboxRuntimeLike, store: SqliteStore, logger: BindingLoggerHost, config: Extract<TelegramConfig, {
         enabled: true;
-    }>, mailboxRouter: GatewayMailboxRouter, mediaStore: TelegramInboundMediaStore, questions: GatewayQuestionRuntime);
+    }>, mailboxRouter: MailboxRouterLike, mediaStore: TelegramInboundMediaStoreLike, questions: GatewayQuestionRuntimeLike, timing?: Partial<PollerTiming>);
     start(): void;
     isRunning(): boolean;
+    currentPollStartedAtMs(): number | null;
+    requestTimeoutMs(): number;
+    recoveryRecordedAtMs(): number | null;
     private runLoop;
     private advanceOffset;
 }
 type GatewayMailboxRuntimeLike = Pick<GatewayMailboxRuntime, "enqueueInboundMessage">;
+type MailboxRouterLike = Pick<GatewayMailboxRouter, "resolve">;
+type TelegramInboundMediaStoreLike = Pick<TelegramInboundMediaStore, "materializeInboundMessage">;
+type GatewayQuestionRuntimeLike = Pick<GatewayQuestionRuntime, "handleTelegramCallbackQuery">;
 export {};

package/dist/telegram/poller.js

@@ -1,7 +1,10 @@
 import { formatError } from "../utils/error";
 import { TelegramApiError } from "./client";
 import { buildTelegramAllowlist, normalizeTelegramUpdate } from "./normalize";
-import { recordTelegramChatType, recordTelegramPollFailure, recordTelegramPollSuccess } from "./state";
+import { recordTelegramChatType, recordTelegramPollCompleted, recordTelegramPollFailure, recordTelegramPollStarted, recordTelegramPollSuccess, recordTelegramPollTimeout, } from "./state";
+const POLL_TIMEOUT_FLOOR_MS = 15_000;
+const POLL_TIMEOUT_GRACE_MS = 10_000;
+const POLL_STALL_GRACE_MS = 5_000;
 export class TelegramPollingService {
     client;
     mailbox;
@@ -12,8 +15,12 @@ export class TelegramPollingService {
     mediaStore;
     questions;
     allowlist;
+    timing;
     running = false;
-    constructor(client, mailbox, store, logger, config, mailboxRouter, mediaStore, questions) {
+    inFlightStartedAtMs = null;
+    consecutiveFailures = 0;
+    recoveredAtMs = null;
+    constructor(client, mailbox, store, logger, config, mailboxRouter, mediaStore, questions, timing) {
         this.client = client;
         this.mailbox = mailbox;
         this.store = store;
@@ -23,6 +30,11 @@ export class TelegramPollingService {
         this.mediaStore = mediaStore;
         this.questions = questions;
         this.allowlist = buildTelegramAllowlist(config);
+        this.timing = {
+            timeoutFloorMs: timing?.timeoutFloorMs ?? POLL_TIMEOUT_FLOOR_MS,
+            timeoutGraceMs: timing?.timeoutGraceMs ?? POLL_TIMEOUT_GRACE_MS,
+            stallGraceMs: timing?.stallGraceMs ?? POLL_STALL_GRACE_MS,
+        };
     }
     start() {
         if (this.running) {
@@ -36,18 +48,40 @@ export class TelegramPollingService {
     isRunning() {
         return this.running;
     }
+    currentPollStartedAtMs() {
+        return this.inFlightStartedAtMs;
+    }
+    requestTimeoutMs() {
+        return Math.max(this.config.pollTimeoutSeconds * 1_000 + this.timing.timeoutGraceMs, this.timing.timeoutFloorMs);
+    }
+    recoveryRecordedAtMs() {
+        return this.recoveredAtMs;
+    }
     async runLoop() {
         let offset = this.store.getTelegramUpdateOffset();
         let retryDelayMs = 1_000;
         for (;;) {
+            const pollStartedAtMs = Date.now();
+            recordTelegramPollStarted(this.store, pollStartedAtMs);
+            const controller = new AbortController();
+            const timeoutHandle = setTimeout(() => {
+                controller.abort();
+            }, this.requestTimeoutMs() + this.timing.stallGraceMs);
+            this.inFlightStartedAtMs = pollStartedAtMs;
             try {
-                const updates = await this.client.getUpdates(offset, this.config.pollTimeoutSeconds);
-                recordTelegramPollSuccess(this.store, Date.now());
+                const updates = await this.client.getUpdates(offset, this.config.pollTimeoutSeconds, controller.signal);
+                const recordedAtMs = Date.now();
+                recordTelegramPollCompleted(this.store, recordedAtMs);
+                recordTelegramPollSuccess(this.store, recordedAtMs);
+                if (this.consecutiveFailures > 0) {
+                    this.recoveredAtMs = recordedAtMs;
+                    this.logger.log("info", `telegram poller recovered after ${this.consecutiveFailures} consecutive failure(s)`);
+                }
                 for (const update of updates) {
                     const nextOffset = update.update_id + 1;
                     const normalized = normalizeTelegramUpdate(update, this.allowlist, this.mailboxRouter);
                     if (normalized.kind === "ignore") {
-                        this.logger.log("info", `ignoring telegram update ${update.update_id}: ${normalized.reason}`);
+                        this.logger.log("debug", `ignoring telegram update ${update.update_id}: ${normalized.reason}`);
                         offset = this.advanceOffset(nextOffset);
                         continue;
                     }
@@ -64,18 +98,32 @@ export class TelegramPollingService {
                     await this.mailbox.enqueueInboundMessage(await this.mediaStore.materializeInboundMessage(normalized.message, "telegram_update", String(update.update_id)), "telegram_update", String(update.update_id));
                     offset = this.advanceOffset(nextOffset);
                 }
+                this.consecutiveFailures = 0;
                 retryDelayMs = 1_000;
             }
             catch (error) {
-                recordTelegramPollFailure(this.store, formatTelegramPollerError(error), Date.now());
+                const recordedAtMs = Date.now();
+                recordTelegramPollCompleted(this.store, recordedAtMs);
+                const pollError = classifyTelegramPollError(error, this.requestTimeoutMs());
+                this.consecutiveFailures += 1;
+                if (pollError.kind === "timeout") {
+                    recordTelegramPollTimeout(this.store, pollError.message, recordedAtMs);
+                }
+                else {
+                    recordTelegramPollFailure(this.store, pollError.message, recordedAtMs);
+                }
                 if (isPermanentTelegramFailure(error)) {
-                    this.logger.log("error", formatTelegramPollerError(error));
+                    this.logger.log("error", pollError.message);
                     return;
                 }
-                this.logger.log("warn", formatTelegramPollerError(error));
+                this.logger.log("warn", pollError.message);
                 await sleep(retryDelayMs);
                 retryDelayMs = Math.min(retryDelayMs * 2, 15_000);
             }
+            finally {
+                clearTimeout(timeoutHandle);
+                this.inFlightStartedAtMs = null;
+            }
         }
     }
     advanceOffset(offset) {
@@ -90,6 +138,27 @@ function isPermanentTelegramFailure(error) {
 function formatTelegramPollerError(error) {
     return `telegram poller failure: ${formatError(error)}`;
 }
+function classifyTelegramPollError(error, requestTimeoutMs) {
+    if (isAbortError(error)) {
+        return {
+            kind: "timeout",
+            message: `telegram poller timeout after ${requestTimeoutMs}ms`,
+        };
+    }
+    return {
+        kind: "error",
+        message: formatTelegramPollerError(error),
+    };
+}
+function isAbortError(error) {
+    if (error instanceof DOMException) {
+        return error.name === "AbortError";
+    }
+    if (error instanceof Error) {
+        return error.name === "AbortError";
+    }
+    return false;
+}
 function sleep(durationMs) {
     return new Promise((resolve) => {
         setTimeout(resolve, durationMs);

package/dist/telegram/runtime.d.ts

@@ -13,6 +13,7 @@ type OpencodeEventStreamLike = {
 export type GatewayTelegramStatus = TelegramHealthSnapshot & {
     enabled: boolean;
     polling: boolean;
+    pollState: "disabled" | "idle" | "running" | "stalled" | "recovering";
     allowlistMode: "disabled" | "explicit";
     allowedChatsCount: number;
     allowedUsersCount: number;
@@ -32,6 +33,7 @@ export type TelegramSendTestResult = {
     mode: "oneshot" | "progressive";
 };
 type TelegramTextDeliveryLike = Pick<GatewayTextDelivery, "sendTest">;
+type TelegramPollingStateLike = Pick<TelegramPollingService, "currentPollStartedAtMs" | "isRunning" | "recoveryRecordedAtMs" | "requestTimeoutMs" | "start">;
 export declare class GatewayTelegramRuntime {
     private readonly client;
     private readonly delivery;
@@ -40,7 +42,7 @@ export declare class GatewayTelegramRuntime {
     private readonly config;
     private readonly polling;
     private readonly opencodeEvents;
-    constructor(client: TelegramRuntimeClientLike | null, delivery: TelegramTextDeliveryLike, store: SqliteStore, logger: BindingLoggerHost, config: TelegramConfig, polling: TelegramPollingService | null, opencodeEvents: OpencodeEventStreamLike);
+    constructor(client: TelegramRuntimeClientLike | null, delivery: TelegramTextDeliveryLike, store: SqliteStore, logger: BindingLoggerHost, config: TelegramConfig, polling: TelegramPollingStateLike | null, opencodeEvents: OpencodeEventStreamLike);
     isEnabled(): boolean;
     isPolling(): boolean;
     allowlistMode(): "disabled" | "explicit";

package/dist/telegram/runtime.js

@@ -1,6 +1,8 @@
 import { formatUnixMsAsUtc } from "../tools/time";
 import { formatError } from "../utils/error";
 import { readTelegramHealthSnapshot, recordTelegramProbeFailure, recordTelegramProbeSuccess, recordTelegramSendFailure, } from "./state";
+const RECENT_RECOVERY_WINDOW_MS = 60_000;
+const POLL_STALLED_GRACE_MS = 5_000;
 export class GatewayTelegramRuntime {
     client;
     delivery;
@@ -37,6 +39,7 @@ export class GatewayTelegramRuntime {
                 ...snapshot,
                 enabled: false,
                 polling: false,
+                pollState: "disabled",
                 allowlistMode: "disabled",
                 allowedChatsCount: 0,
                 allowedUsersCount: 0,
@@ -53,14 +56,14 @@ export class GatewayTelegramRuntime {
             const bot = await this.client.getMe();
             const recordedAtMs = Date.now();
             recordTelegramProbeSuccess(this.store, bot, recordedAtMs);
-            return buildEnabledStatus(this.config, readTelegramHealthSnapshot(this.store), this.isPolling(), "ok", null, bot, this.opencodeEvents);
+            return buildEnabledStatus(this.config, readTelegramHealthSnapshot(this.store), this.polling, "ok", null, bot, this.opencodeEvents);
         }
         catch (error) {
             const message = formatError(error);
             const recordedAtMs = Date.now();
             recordTelegramProbeFailure(this.store, message, recordedAtMs);
             this.logger.log("warn", `telegram live probe failed: ${message}`);
-            return buildEnabledStatus(this.config, readTelegramHealthSnapshot(this.store), this.isPolling(), "failed", message, null, this.opencodeEvents);
+            return buildEnabledStatus(this.config, readTelegramHealthSnapshot(this.store), this.polling, "failed", message, null, this.opencodeEvents);
         }
     }
     async sendTest(chatId, topic, text, mode) {
@@ -97,10 +100,12 @@ export class GatewayTelegramRuntime {
     }
 }
 function buildEnabledStatus(config, snapshot, polling, liveProbe, liveProbeError, bot, opencodeEvents) {
+    const pollingEnabled = polling?.isRunning() ?? false;
     return {
         ...snapshot,
         enabled: true,
-        polling,
+        polling: pollingEnabled,
+        pollState: resolvePollState(snapshot, polling),
         allowlistMode: "explicit",
         allowedChatsCount: config.allowedChats.length,
         allowedUsersCount: config.allowedUsers.length,
@@ -113,6 +118,25 @@ function buildEnabledStatus(config, snapshot, polling, liveProbe, liveProbeError
         lastEventStreamError: opencodeEvents.lastStreamError(),
     };
 }
+function resolvePollState(snapshot, polling) {
+    if (polling === null || !polling.isRunning()) {
+        return "idle";
+    }
+    const now = Date.now();
+    const inFlightStartedAtMs = polling.currentPollStartedAtMs();
+    if (inFlightStartedAtMs !== null &&
+        now - inFlightStartedAtMs > polling.requestTimeoutMs() + POLL_STALLED_GRACE_MS) {
+        return "stalled";
+    }
+    const recoveredAtMs = polling.recoveryRecordedAtMs();
+    if (recoveredAtMs !== null && now - recoveredAtMs <= RECENT_RECOVERY_WINDOW_MS) {
+        return "recovering";
+    }
+    if (snapshot.lastPollStartedMs !== null) {
+        return "running";
+    }
+    return "idle";
+}
 function normalizeRequiredField(value, field) {
     const trimmed = value.trim();
     if (trimmed.length === 0) {

package/dist/telegram/state.d.ts

@@ -4,8 +4,12 @@ export type TelegramStreamingFallbackReason = "non_private_chat" | "progressive_
 export type TelegramHealthSnapshot = {
     updateOffset: number | null;
     lastPollSuccessMs: number | null;
+    lastPollStartedMs: number | null;
+    lastPollCompletedMs: number | null;
     lastPollErrorAtMs: number | null;
     lastPollErrorMessage: string | null;
+    lastPollTimeoutAtMs: number | null;
+    lastPollTimeoutMessage: string | null;
     lastSendSuccessMs: number | null;
     lastSendErrorAtMs: number | null;
     lastSendErrorMessage: string | null;
@@ -22,8 +26,11 @@ export type TelegramHealthSnapshot = {
     lastStreamFallbackReason: TelegramStreamingFallbackReason | null;
 };
 export declare function readTelegramHealthSnapshot(store: SqliteStore): TelegramHealthSnapshot;
+export declare function recordTelegramPollStarted(store: SqliteStore, recordedAtMs: number): void;
+export declare function recordTelegramPollCompleted(store: SqliteStore, recordedAtMs: number): void;
 export declare function recordTelegramPollSuccess(store: SqliteStore, recordedAtMs: number): void;
 export declare function recordTelegramPollFailure(store: SqliteStore, message: string, recordedAtMs: number): void;
+export declare function recordTelegramPollTimeout(store: SqliteStore, message: string, recordedAtMs: number): void;
 export declare function recordTelegramSendSuccess(store: SqliteStore, recordedAtMs: number): void;
 export declare function recordTelegramSendFailure(store: SqliteStore, message: string, recordedAtMs: number): void;
 export declare function recordTelegramProbeSuccess(store: SqliteStore, bot: TelegramBotProfile, recordedAtMs: number): void;

package/dist/telegram/state.js

@@ -1,7 +1,11 @@
 const TELEGRAM_UPDATE_OFFSET_KEY = "telegram.update_offset";
 const TELEGRAM_LAST_POLL_SUCCESS_MS_KEY = "telegram.last_poll_success_ms";
+const TELEGRAM_LAST_POLL_STARTED_MS_KEY = "telegram.last_poll_started_ms";
+const TELEGRAM_LAST_POLL_COMPLETED_MS_KEY = "telegram.last_poll_completed_ms";
 const TELEGRAM_LAST_POLL_ERROR_AT_MS_KEY = "telegram.last_poll_error_at_ms";
 const TELEGRAM_LAST_POLL_ERROR_MESSAGE_KEY = "telegram.last_poll_error_message";
+const TELEGRAM_LAST_POLL_TIMEOUT_AT_MS_KEY = "telegram.last_poll_timeout_at_ms";
+const TELEGRAM_LAST_POLL_TIMEOUT_MESSAGE_KEY = "telegram.last_poll_timeout_message";
 const TELEGRAM_LAST_SEND_SUCCESS_MS_KEY = "telegram.last_send_success_ms";
 const TELEGRAM_LAST_SEND_ERROR_AT_MS_KEY = "telegram.last_send_error_at_ms";
 const TELEGRAM_LAST_SEND_ERROR_MESSAGE_KEY = "telegram.last_send_error_message";
@@ -20,8 +24,12 @@ export function readTelegramHealthSnapshot(store) {
     return {
         updateOffset: readStoredInteger(store, TELEGRAM_UPDATE_OFFSET_KEY),
         lastPollSuccessMs: readStoredInteger(store, TELEGRAM_LAST_POLL_SUCCESS_MS_KEY),
+        lastPollStartedMs: readStoredInteger(store, TELEGRAM_LAST_POLL_STARTED_MS_KEY),
+        lastPollCompletedMs: readStoredInteger(store, TELEGRAM_LAST_POLL_COMPLETED_MS_KEY),
         lastPollErrorAtMs: readStoredInteger(store, TELEGRAM_LAST_POLL_ERROR_AT_MS_KEY),
         lastPollErrorMessage: readStoredText(store, TELEGRAM_LAST_POLL_ERROR_MESSAGE_KEY),
+        lastPollTimeoutAtMs: readStoredInteger(store, TELEGRAM_LAST_POLL_TIMEOUT_AT_MS_KEY),
+        lastPollTimeoutMessage: readStoredText(store, TELEGRAM_LAST_POLL_TIMEOUT_MESSAGE_KEY),
         lastSendSuccessMs: readStoredInteger(store, TELEGRAM_LAST_SEND_SUCCESS_MS_KEY),
         lastSendErrorAtMs: readStoredInteger(store, TELEGRAM_LAST_SEND_ERROR_AT_MS_KEY),
         lastSendErrorMessage: readStoredText(store, TELEGRAM_LAST_SEND_ERROR_MESSAGE_KEY),
@@ -38,15 +46,28 @@ export function readTelegramHealthSnapshot(store) {
         lastStreamFallbackReason: readStoredFallbackReason(store),
     };
 }
+export function recordTelegramPollStarted(store, recordedAtMs) {
+    store.putStateValue(TELEGRAM_LAST_POLL_STARTED_MS_KEY, String(recordedAtMs), recordedAtMs);
+}
+export function recordTelegramPollCompleted(store, recordedAtMs) {
+    store.putStateValue(TELEGRAM_LAST_POLL_COMPLETED_MS_KEY, String(recordedAtMs), recordedAtMs);
+}
 export function recordTelegramPollSuccess(store, recordedAtMs) {
     store.putStateValue(TELEGRAM_LAST_POLL_SUCCESS_MS_KEY, String(recordedAtMs), recordedAtMs);
     store.putStateValue(TELEGRAM_LAST_POLL_ERROR_AT_MS_KEY, "", recordedAtMs);
     store.putStateValue(TELEGRAM_LAST_POLL_ERROR_MESSAGE_KEY, "", recordedAtMs);
+    store.putStateValue(TELEGRAM_LAST_POLL_TIMEOUT_AT_MS_KEY, "", recordedAtMs);
+    store.putStateValue(TELEGRAM_LAST_POLL_TIMEOUT_MESSAGE_KEY, "", recordedAtMs);
 }
 export function recordTelegramPollFailure(store, message, recordedAtMs) {
     store.putStateValue(TELEGRAM_LAST_POLL_ERROR_AT_MS_KEY, String(recordedAtMs), recordedAtMs);
     store.putStateValue(TELEGRAM_LAST_POLL_ERROR_MESSAGE_KEY, message, recordedAtMs);
 }
+export function recordTelegramPollTimeout(store, message, recordedAtMs) {
+    store.putStateValue(TELEGRAM_LAST_POLL_TIMEOUT_AT_MS_KEY, String(recordedAtMs), recordedAtMs);
+    store.putStateValue(TELEGRAM_LAST_POLL_TIMEOUT_MESSAGE_KEY, message, recordedAtMs);
+    recordTelegramPollFailure(store, message, recordedAtMs);
+}
 export function recordTelegramSendSuccess(store, recordedAtMs) {
     store.putStateValue(TELEGRAM_LAST_SEND_SUCCESS_MS_KEY, String(recordedAtMs), recordedAtMs);
     store.putStateValue(TELEGRAM_LAST_SEND_ERROR_AT_MS_KEY, "", recordedAtMs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-gateway",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Gateway plugin for OpenCode",
   "license": "MIT",
   "type": "module",