@grinev/opencode-telegram-bot 0.20.1 → 0.20.2

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/package.json

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