@wu529778790/open-im 1.9.4-beta.4 → 1.9.4-beta.5

package/dist/workbuddy/centrifuge-client.d.ts

@@ -32,6 +32,8 @@ export interface CentrifugeCallbacks {
     onDisconnected?: (reason?: string) => void;
     onError?: (error: Error) => void;
     onMessage?: (chatId: string, msgId: string, content: string) => void;
+    /** Called when reconnection has failed too many times — caller should do a full re-registration */
+    onPersistentFailure?: () => void;
 }
 export declare class WorkBuddyCentrifugeClient {
     private config;
@@ -41,6 +43,9 @@ export declare class WorkBuddyCentrifugeClient {
     private extraSubs;
     private state;
     private processedMsgIds;
+    private consecutiveErrors;
+    private pendingReplies;
+    private flushing;
     private static readonly MAX_MSG_ID_CACHE;
     constructor(config: CentrifugeClientConfig, callbacks?: CentrifugeCallbacks);
     get logPrefix(): string;
@@ -83,4 +88,12 @@ export declare class WorkBuddyCentrifugeClient {
      * Clean up old message IDs from cache
      */
     private cleanMsgIdCache;
+    /**
+     * Enqueue a failed reply for later delivery
+     */
+    private enqueuePendingReply;
+    /**
+     * Retry all pending replies after a successful reconnection
+     */
+    private flushPendingReplies;
 }

package/dist/workbuddy/centrifuge-client.js

@@ -6,6 +6,12 @@ import { WebSocket } from 'ws';
 import { randomUUID } from 'node:crypto';
 import { createLogger } from '../logger.js';
 const log = createLogger('WorkBuddyCentrifuge');
+/** Max consecutive errors before triggering full re-registration */
+const PERSISTENT_FAILURE_THRESHOLD = 5;
+/** Max queued replies awaiting delivery */
+const MAX_PENDING_REPLIES = 20;
+/** Max age (ms) of a queued reply before it's discarded */
+const PENDING_REPLY_TTL_MS = 5 * 60_000;
 export class WorkBuddyCentrifugeClient {
     config;
     callbacks;
@@ -14,6 +20,9 @@ export class WorkBuddyCentrifugeClient {
     extraSubs = [];
     state = 'disconnected';
     processedMsgIds = new Set();
+    consecutiveErrors = 0;
+    pendingReplies = [];
+    flushing = false;
     static MAX_MSG_ID_CACHE = 1000;
     constructor(config, callbacks = {}) {
         this.config = config;
@@ -39,7 +48,9 @@ export class WorkBuddyCentrifugeClient {
         this.client.on('connected', (ctx) => {
             log.info(`${this.logPrefix} Connected (transport=${ctx.transport})`);
             this.state = 'connected';
+            this.consecutiveErrors = 0;
             this.callbacks.onConnected?.();
+            this.flushPendingReplies();
         });
         this.client.on('disconnected', (ctx) => {
             log.info(`${this.logPrefix} Disconnected: code=${ctx.code}, reason=${ctx.reason}`);
@@ -56,7 +67,15 @@ export class WorkBuddyCentrifugeClient {
         });
         this.client.on('error', (ctx) => {
             log.error(`${this.logPrefix} Error: ${ctx.error.message}`);
+            this.consecutiveErrors++;
             this.callbacks.onError?.(new Error(ctx.error.message));
+            if (this.consecutiveErrors >= PERSISTENT_FAILURE_THRESHOLD) {
+                log.warn(`${this.logPrefix} ${this.consecutiveErrors} consecutive errors — triggering full re-registration`);
+                this.consecutiveErrors = 0;
+                // Stop the current Centrifuge instance so client.ts can create a fresh one
+                this.stop();
+                this.callbacks.onPersistentFailure?.();
+            }
         });
         // Create channel subscription
         this.sub = this.client.newSubscription(this.config.channel, {
@@ -216,7 +235,7 @@ export class WorkBuddyCentrifugeClient {
                 }
             }
             if (!sent) {
-                log.error(`${this.logPrefix} Failed to send COPILOT_RESPONSE after retries`);
+                this.enqueuePendingReply(url, httpPayload, this.config.httpAccessToken);
             }
             // Release the heartbeat lock so the periodic registration can resume
             this.config.releaseChannelLockFn?.();
@@ -325,4 +344,57 @@ export class WorkBuddyCentrifugeClient {
             });
         }
     }
+    /**
+     * Enqueue a failed reply for later delivery
+     */
+    enqueuePendingReply(url, payload, accessToken) {
+        // Evict expired entries
+        const now = Date.now();
+        this.pendingReplies = this.pendingReplies.filter((r) => now - r.addedAt < PENDING_REPLY_TTL_MS);
+        if (this.pendingReplies.length >= MAX_PENDING_REPLIES) {
+            const evicted = this.pendingReplies.shift();
+            log.warn(`${this.logPrefix} Pending replies full, evicting oldest (msgId=${evicted?.payload.msgId})`);
+        }
+        this.pendingReplies.push({ url, payload, accessToken, addedAt: now });
+        log.warn(`${this.logPrefix} Queued pending reply (queue=${this.pendingReplies.length}, msgId=${payload.msgId})`);
+    }
+    /**
+     * Retry all pending replies after a successful reconnection
+     */
+    async flushPendingReplies() {
+        if (this.flushing || this.pendingReplies.length === 0)
+            return;
+        this.flushing = true;
+        const now = Date.now();
+        // Take only non-expired replies
+        const toSend = this.pendingReplies.filter((r) => now - r.addedAt < PENDING_REPLY_TTL_MS);
+        this.pendingReplies = [];
+        if (toSend.length > 0) {
+            log.info(`${this.logPrefix} Flushing ${toSend.length} pending reply(ies)`);
+        }
+        for (const reply of toSend) {
+            try {
+                const res = await fetch(reply.url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${reply.accessToken}`,
+                    },
+                    body: JSON.stringify(reply.payload),
+                    signal: AbortSignal.timeout(30_000),
+                });
+                const body = await res.text().catch(() => '');
+                if (res.ok) {
+                    log.info(`${this.logPrefix} Flushed pending reply ok: msgId=${reply.payload.msgId}`);
+                }
+                else {
+                    log.error(`${this.logPrefix} Flushed pending reply failed: ${res.status} ${body.substring(0, 200)}`);
+                }
+            }
+            catch (err) {
+                log.error(`${this.logPrefix} Flushed pending reply error: msgId=${reply.payload.msgId}`, err);
+            }
+        }
+        this.flushing = false;
+    }
 }

package/dist/workbuddy/client.js

@@ -198,6 +198,15 @@ async function connect() {
             log.error(`WorkBuddy Centrifuge error: ${error instanceof Error ? error.message : JSON.stringify(error)}`);
             updateState('error');
         },
+        onPersistentFailure: () => {
+            log.warn('WorkBuddy Centrifuge persistent failure detected — doing full re-registration');
+            if (heartbeatTimer) {
+                clearInterval(heartbeatTimer);
+                heartbeatTimer = null;
+            }
+            updateState('disconnected');
+            scheduleReconnect();
+        },
         onMessage: async (chatId, msgId, content) => {
             if (messageHandler) {
                 try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.9.4-beta.4",
+  "version": "1.9.4-beta.5",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, CodeBuddy)",
   "type": "module",
   "main": "dist/index.js",