echoclaw-relay-agent 0.9.3 → 0.9.5

package/dist/RelayAgent.d.ts

@@ -30,6 +30,7 @@ export declare class RelayAgent extends EventEmitter {
     private _stopped;
     private _starting;
     private _paired;
+    private _rekeyRetryCount;
     private _activePairing;
     private readonly config;
     private readonly subscribers;

package/dist/RelayAgent.js

@@ -97,6 +97,12 @@ export class RelayAgent extends EventEmitter {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "_rekeyRetryCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
         Object.defineProperty(this, "_activePairing", {
             enumerable: true,
             configurable: true,
@@ -398,6 +404,7 @@ export class RelayAgent extends EventEmitter {
                 // If desktop is online, ECDH completes in <1s; 30s gives ample margin.
                 pairing.pairAsAgent(undefined, 30000)
                     .then(result => {
+                    this._rekeyRetryCount = 0; // Reset on success
                     this.onPaired(result);
                     // V2: Reattach gateway callbacks after reconnect
                     if (this.gatewayManager) {
@@ -411,11 +418,28 @@ export class RelayAgent extends EventEmitter {
                 })
                     .catch(err => {
                     this._activePairing = null;
+                    this._rekeyRetryCount++;
+                    // Circuit breaker: after 5 consecutive failures, force full reconnect cycle
+                    // (disconnect + restart resets the relay server connection from scratch)
+                    if (this._rekeyRetryCount >= 5) {
+                        this._rekeyRetryCount = 0; // Reset for next cycle
+                        this.emit('error', new Error(`Re-key failed 5 times, forcing fresh reconnect`));
+                        if (this.transport) {
+                            this.transport.disconnect();
+                            this.transport.restart();
+                        }
+                        return;
+                    }
                     // Re-key failed — keep old crypto intact, mark as connected
                     // (data handler still works with old keys if desktop didn't re-key either)
                     if (this._paired && this.sessionKey) {
                         this.setStatus('connected');
                     }
+                    // If WS is still OPEN, force reconnect to trigger fresh on('open')
+                    if (this.transport?.isConnected) {
+                        this.transport.disconnect();
+                        this.transport.restart();
+                    }
                     this.emit('error', err);
                 });
             }

package/dist/RelayClient.d.ts

@@ -36,6 +36,7 @@ export declare class RelayClient extends EventEmitter {
     private _stopped;
     private _paired;
     private _needsRekey;
+    private _rekeyRetryCount;
     private _activePairing;
     private readonly config;
     private readonly sessionStore;

package/dist/RelayClient.js

@@ -91,6 +91,12 @@ export class RelayClient extends EventEmitter {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "_rekeyRetryCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
         Object.defineProperty(this, "_activePairing", {
             enumerable: true,
             configurable: true,
@@ -371,12 +377,30 @@ export class RelayClient extends EventEmitter {
                 const pairing = new PairingProtocol(this.transport);
                 this._activePairing = pairing;
                 pairing.pairAsClient(this.pairingCode)
-                    .then(result => this.onPaired(result, 'resumed'))
+                    .then(result => {
+                    this._rekeyRetryCount = 0; // Reset on success
+                    this.onPaired(result, 'resumed');
+                })
                     .catch(err => {
                     this._activePairing = null;
-                    // Re-key failed — set _needsRekey back to true so next reconnect retries.
-                    // Without this, the client gets stuck with no crypto and no recovery path.
+                    this._rekeyRetryCount++;
+                    // Circuit breaker: stop after 5 consecutive re-key failures
+                    if (this._rekeyRetryCount >= 5) {
+                        this._needsRekey = false;
+                        this.emit('error', new Error(`Re-key failed after ${this._rekeyRetryCount} retries, giving up`));
+                        // Force transport to close and reconnect from scratch
+                        this.transport?.disconnect();
+                        return;
+                    }
+                    // Re-key failed — set _needsRekey back to true for retry.
                     this._needsRekey = true;
+                    // If WS is still OPEN (pairing failed at protocol level, not transport level),
+                    // _needsRekey won't be consumed until next on('open').
+                    // Force a reconnect to trigger a fresh on('open').
+                    if (this.transport?.isConnected) {
+                        this.transport.disconnect();
+                        this.transport.restart();
+                    }
                     this.emit('error', err);
                 });
             }

package/dist/chat/ChatHandler.d.ts

@@ -149,7 +149,10 @@ export declare class ChatHandler {
     private _extractText;
     /** Send a message back to desktop via the persistent callback. Buffers if disconnected. */
     private _send;
-    /** Flush buffered messages to desktop after relay reconnects. */
+    /** Sequential send queue to prevent message reordering between flush and real-time messages. */
+    private _sendQueue;
+    private _enqueueSend;
+    /** Flush buffered messages to desktop after relay reconnects (sequential, preserves order). */
     private _flushMessageBuffer;
     /**
      * Send a message via a captured sendBack reference.

package/dist/chat/ChatHandler.js

@@ -37,6 +37,8 @@ const RUN_TTL_MS = 10 * 60 * 1000;
 const RUN_CLEANUP_INTERVAL_MS = 60 * 1000;
 /** Max buffered messages when sendBack is null (relay disconnected). */
 const MAX_BUFFERED_MESSAGES = 50;
+/** Timeout for a single _sendBack call to prevent queue freeze (5 seconds). */
+const SEND_TIMEOUT_MS = 5000;
 // ── ChatHandler ──────────────────────────────────────────────────
 export class ChatHandler {
     constructor(config) {
@@ -112,6 +114,13 @@ export class ChatHandler {
             writable: true,
             value: []
         });
+        /** Sequential send queue to prevent message reordering between flush and real-time messages. */
+        Object.defineProperty(this, "_sendQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: Promise.resolve()
+        });
         this.sessionKey = config?.sessionKey ?? 'main';
         this.requestTimeoutMs = config?.requestTimeoutMs ?? 30000;
         this.wsClient = new OpenClawWsClient({
@@ -569,7 +578,8 @@ export class ChatHandler {
     /** Send a message back to desktop via the persistent callback. Buffers if disconnected. */
     async _send(msg) {
         if (this._sendBack) {
-            await this._sendBack(msg);
+            // Use send queue to guarantee ordering (flush + real-time share same queue)
+            await this._enqueueSend(msg);
         }
         else {
             // Buffer important messages while relay is disconnected (OpenClaw may still be responding)
@@ -580,13 +590,34 @@ export class ChatHandler {
             }
         }
     }
-    /** Flush buffered messages to desktop after relay reconnects. */
+    _enqueueSend(msg) {
+        const p = this._sendQueue.then(async () => {
+            if (!this._sendBack) {
+                // sendBack was cleared (relay disconnected) while message was queued.
+                // Re-buffer important messages to avoid permanent loss.
+                if (msg.type === 'chat_reply' || msg.type === 'chat_delta' || msg.type === 'chat_error') {
+                    if (this._messageBuffer.length < MAX_BUFFERED_MESSAGES) {
+                        this._messageBuffer.push(msg);
+                    }
+                }
+                return;
+            }
+            // Timeout protection: prevent a single hung _sendBack from freezing the entire queue.
+            await Promise.race([
+                this._sendBack(msg),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('send timeout')), SEND_TIMEOUT_MS)),
+            ]);
+        }).catch(() => { });
+        this._sendQueue = p;
+        return p;
+    }
+    /** Flush buffered messages to desktop after relay reconnects (sequential, preserves order). */
     _flushMessageBuffer() {
         if (!this._sendBack || this._messageBuffer.length === 0)
             return;
         const buf = this._messageBuffer.splice(0);
         for (const msg of buf) {
-            this._sendBack(msg).catch(() => { });
+            this._enqueueSend(msg);
         }
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "echoclaw-relay-agent",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "description": "EchoClaw Relay Connection — E2E encrypted relay transport, pairing, and session management",
   "type": "module",
   "main": "./dist/index.js",