echoclaw-relay-agent 0.22.2 → 0.22.4

package/dist/RelayAgent.js

@@ -157,6 +157,8 @@ export class RelayAgent extends EventEmitter {
             this.transport = null;
         }
         this.frameCrypto = null;
+        this._dataHandler = null;
+        this._dataHandlerInner = null;
         try {
             if (pairingCode) {
                 // New pairing — overwrite any existing session
@@ -173,6 +175,21 @@ export class RelayAgent extends EventEmitter {
                 }
             }
         }
+        catch (err) {
+            // Clean up zombie transport on failure (prevents auto-reconnect loop)
+            const t = this.transport;
+            if (t) {
+                t.removeAllListeners();
+                t.disconnect();
+                this.transport = null;
+            }
+            this.frameCrypto = null;
+            this.sessionKey = null;
+            this._dataHandler = null;
+            this._dataHandlerInner = null;
+            this.setStatus('disconnected');
+            throw err;
+        }
         finally {
             this._starting = false;
         }
@@ -236,7 +253,7 @@ export class RelayAgent extends EventEmitter {
     async freshPairing(code) {
         this.setStatus('connecting');
         // Connect to relay server as agent
-        const agentUrl = `${this.config.relayServer}/agent/connect?code=${code}`;
+        const agentUrl = `${this.config.relayServer}/agent/connect?code=${code}&protocol=2`;
         this.transport = new RelayTransport({
             url: agentUrl,
             reconnect: this.config.reconnect,
@@ -281,7 +298,7 @@ export class RelayAgent extends EventEmitter {
         this.frameCrypto = new FrameCrypto(this.sessionKey);
         // _paired stays false until HELLO confirmed — prevents on('open') from
         // emitting 'connected' before server confirms the session exists.
-        const resumeUrl = `${this.config.relayServer}/agent/connect?resume=${session.relaySessionId}`;
+        const resumeUrl = `${this.config.relayServer}/agent/connect?resume=${session.relaySessionId}&protocol=2`;
         this.transport = new RelayTransport({
             url: resumeUrl,
             reconnect: this.config.reconnect,
@@ -318,7 +335,7 @@ export class RelayAgent extends EventEmitter {
                 }
                 else if (msg.type === 'CLOSE' && msg.sender_role === 'server') {
                     const payload = msg.payload || 'unknown';
-                    if (['SESSION_NOT_FOUND', 'SESSION_EXPIRED', 'INVALID_SESSION', 'DEVICE_TOKEN_MISMATCH'].includes(payload)) {
+                    if (['SESSION_NOT_FOUND', 'SESSION_EXPIRED', 'INVALID_SESSION', 'DEVICE_TOKEN_MISMATCH', 'SESSION_PROTOCOL_MISMATCH'].includes(payload)) {
                         this.sessionStore.clear().catch(() => { });
                     }
                     settle(() => reject(new Error(`Relay server closed: ${payload}`)));
@@ -356,7 +373,7 @@ export class RelayAgent extends EventEmitter {
         this._paired = true;
         // Update transport URL so auto-reconnect uses ?resume=sessionId
         if (this.transport) {
-            this.transport.setUrl(`${this.config.relayServer}/agent/connect?resume=${result.sessionId}`);
+            this.transport.setUrl(`${this.config.relayServer}/agent/connect?resume=${result.sessionId}&protocol=2`);
         }
         // Build session data with sessionKey for persistence
         const sessionData = {
@@ -452,6 +469,28 @@ export class RelayAgent extends EventEmitter {
         this.transport.on('connect_timeout', (timeoutMs) => {
             this.emit('error', Object.assign(new Error(`Connection timed out after ${timeoutMs / 1000}s`), { code: 'CONNECT_TIMEOUT' }));
         });
+        // Handle server fatal CLOSE messages (SESSION_NOT_FOUND, SESSION_PROTOCOL_MISMATCH, etc.)
+        const SESSION_FATAL = new Set(['SESSION_NOT_FOUND', 'INVALID_SESSION', 'SESSION_PROTOCOL_MISMATCH']);
+        this.transport.on('message', (msg) => {
+            if ((msg.type === 'CLOSE' || msg.type === 'STATUS') && msg.sender_role === 'server') {
+                const payload = typeof msg.payload === 'string' ? msg.payload : '';
+                if (payload === 'UNPAIRED' || SESSION_FATAL.has(payload)) {
+                    this.sessionStore.clear().catch(() => { });
+                    this._paired = false;
+                    this._stopped = true;
+                    this.gatewayManager?.stop();
+                    this.transport?.disconnect();
+                    this.transport = null;
+                    this.sessionKey = null;
+                    this.frameCrypto = null;
+                    this._dataHandler = null;
+                    this._dataHandlerInner = null;
+                    this.setStatus('disconnected');
+                    this.emit(payload === 'UNPAIRED' ? 'unpaired' : 'session_fatal', { reason: payload });
+                    return;
+                }
+            }
+        });
         this.transport.on('open', () => {
             if (!this.transport || !this._paired || !this.sessionKey)
                 return;

package/dist/RelayClient.js

@@ -126,6 +126,7 @@ export class RelayClient extends EventEmitter {
         this._stopped = false;
         // Teardown previous transport before starting new
         if (this.transport) {
+            this.transport.removeAllListeners();
             this.transport.disconnect();
             this.transport = null;
         }
@@ -139,6 +140,19 @@ export class RelayClient extends EventEmitter {
                 await this.freshPairing();
             }
         }
+        catch (err) {
+            // Clean up zombie transport on failure (prevents auto-reconnect loop)
+            const t = this.transport;
+            if (t) {
+                t.removeAllListeners();
+                t.disconnect();
+                this.transport = null;
+            }
+            this.frameCrypto = null;
+            this.sessionKey = null;
+            this.setStatus('disconnected');
+            throw err;
+        }
         finally {
             this._connecting = false;
         }
@@ -200,7 +214,7 @@ export class RelayClient extends EventEmitter {
     }
     async freshPairing() {
         this.setStatus('connecting');
-        const clientUrl = `${this.config.relayServer}/client/connect`;
+        const clientUrl = `${this.config.relayServer}/client/connect?protocol=2`;
         this.transport = new RelayTransport({
             url: clientUrl,
             reconnect: this.config.reconnect,
@@ -244,7 +258,7 @@ export class RelayClient extends EventEmitter {
         this.frameCrypto = new FrameCrypto(this.sessionKey);
         // _paired stays false until HELLO confirmed — prevents on('open') from
         // emitting 'connected' before server confirms the session exists.
-        const resumeUrl = `${this.config.relayServer}/client/connect?resume=${session.relaySessionId}`;
+        const resumeUrl = `${this.config.relayServer}/client/connect?resume=${session.relaySessionId}&protocol=2`;
         this.transport = new RelayTransport({
             url: resumeUrl,
             reconnect: this.config.reconnect,
@@ -281,7 +295,7 @@ export class RelayClient extends EventEmitter {
                 }
                 else if (msg.type === 'CLOSE' && msg.sender_role === 'server') {
                     const payload = msg.payload || 'unknown';
-                    if (['SESSION_NOT_FOUND', 'SESSION_EXPIRED', 'INVALID_SESSION', 'DEVICE_TOKEN_MISMATCH'].includes(payload)) {
+                    if (['SESSION_NOT_FOUND', 'SESSION_EXPIRED', 'INVALID_SESSION', 'DEVICE_TOKEN_MISMATCH', 'SESSION_PROTOCOL_MISMATCH'].includes(payload)) {
                         this.sessionStore.clear().catch(() => { });
                     }
                     settle(() => reject(new Error(`Relay server closed: ${payload}`)));
@@ -308,7 +322,7 @@ export class RelayClient extends EventEmitter {
         this._paired = true;
         // Update transport URL so auto-reconnect uses ?resume=sessionId
         if (this.transport) {
-            this.transport.setUrl(`${this.config.relayServer}/client/connect?resume=${result.sessionId}`);
+            this.transport.setUrl(`${this.config.relayServer}/client/connect?resume=${result.sessionId}&protocol=2`);
         }
         // Persist session with sessionKey for future resume
         const sessionData = {
@@ -381,7 +395,7 @@ export class RelayClient extends EventEmitter {
         });
         // Handle server messages (CLOSE/STATUS)
         const PEER_STATUS = new Set(['AGENT_WARNING', 'AGENT_ONLINE', 'DESKTOP_DISCONNECTED']);
-        const SESSION_FATAL = new Set(['SESSION_NOT_FOUND', 'INVALID_SESSION']);
+        const SESSION_FATAL = new Set(['SESSION_NOT_FOUND', 'INVALID_SESSION', 'SESSION_PROTOCOL_MISMATCH']);
         this.transport.on('message', (msg) => {
             if ((msg.type === 'CLOSE' || msg.type === 'STATUS') && msg.sender_role === 'server') {
                 const payload = typeof msg.payload === 'string' ? msg.payload : '';
@@ -394,12 +408,26 @@ export class RelayClient extends EventEmitter {
                 }
                 if (payload === 'UNPAIRED') {
                     this.sessionStore.clear().catch(() => { });
-                    this.emit('unpaired');
+                    this._paired = false;
+                    this._stopped = true;
                     this.transport?.disconnect();
+                    this.transport = null;
+                    this.sessionKey = null;
+                    this.frameCrypto = null;
+                    this.setStatus('disconnected');
+                    this.emit('unpaired');
                     return;
                 }
                 if (SESSION_FATAL.has(payload)) {
                     this.sessionStore.clear().catch(() => { });
+                    this._paired = false;
+                    this._stopped = true;
+                    this.transport?.disconnect();
+                    this.transport = null;
+                    this.sessionKey = null;
+                    this.frameCrypto = null;
+                    this.setStatus('disconnected');
+                    this.emit('session_fatal', { reason: payload });
                     return;
                 }
             }

package/dist/cli.js

@@ -175,7 +175,7 @@ ${BOLD}Usage:${RESET}
 
 ${BOLD}Setup Options:${RESET}
   --relay=URL        Relay server URL (default: ${DEFAULT_RELAY})
-  --bridge-port=PORT Local OpenClaw bridge port (default: 8013)
+  --bridge-port=PORT Local OpenClaw bridge port (default: 18789)
   -h, --help         Show this help
 
 ${BOLD}How it works:${RESET}

package/dist/gateway/GatewayWatchdog.d.ts

@@ -5,9 +5,15 @@
  * Requires N consecutive failures before declaring bridge down (failureThreshold).
  * Uses jittered intervals to prevent synchronized spikes.
  *
- * V2: When bridge goes down, attempts to restart the OpenClaw process
+ * When bridge goes down, attempts to restart the OpenClaw process
  * via platform service manager (launchctl on macOS, systemctl on Linux).
  * Rate limited: max 3 restart attempts per 10 minute window.
+ *
+ * Fixes applied (external AI review):
+ * - Restart retries on every tick while down (not just on state transition)
+ * - 5s cooldown after restart before next health check
+ * - Immediate re-check after successful restart
+ * - Exceptions in _check() count as failures (not silently swallowed)
  */
 import { EventEmitter } from 'node:events';
 import { TokenDiscovery } from './TokenDiscovery.js';
@@ -37,13 +43,16 @@ export declare class GatewayWatchdog extends EventEmitter {
     start(): void;
     /** Stop health checks. Idempotent / re-entrant safe. */
     stop(): void;
-    /** Run one check, then schedule next with fresh jitter. Prevents overlap. */
+    /** Schedule the next tick with jitter. */
+    private _scheduleNext;
+    /** Run one check, then schedule next. Prevents overlap. */
     private _tick;
     private _check;
     private _transition;
     /**
-     * Attempt to restart the OpenClaw process when bridge goes down.
+     * Attempt to restart the OpenClaw process when bridge is down.
      * Rate limited: max 3 attempts per 10 minute window.
+     * Called on every tick while down — internal guards prevent over-restarting.
      */
     private _attemptRestart;
 }

package/dist/gateway/GatewayWatchdog.js

@@ -5,9 +5,15 @@
  * Requires N consecutive failures before declaring bridge down (failureThreshold).
  * Uses jittered intervals to prevent synchronized spikes.
  *
- * V2: When bridge goes down, attempts to restart the OpenClaw process
+ * When bridge goes down, attempts to restart the OpenClaw process
  * via platform service manager (launchctl on macOS, systemctl on Linux).
  * Rate limited: max 3 restart attempts per 10 minute window.
+ *
+ * Fixes applied (external AI review):
+ * - Restart retries on every tick while down (not just on state transition)
+ * - 5s cooldown after restart before next health check
+ * - Immediate re-check after successful restart
+ * - Exceptions in _check() count as failures (not silently swallowed)
  */
 import { EventEmitter } from 'node:events';
 import { restartOpenClaw } from './ProcessRestart.js';
@@ -15,6 +21,7 @@ import { DEFAULT_GATEWAY_CONFIG } from './types.js';
 // ── Restart rate limiting ────────────────────────────────────
 const RESTART_WINDOW_MS = 10 * 60 * 1000; // 10 minutes
 const MAX_RESTARTS_PER_WINDOW = 3;
+const RESTART_COOLDOWN_MS = 5000; // wait for process to start before next check
 export class GatewayWatchdog extends EventEmitter {
     constructor(config) {
         super();
@@ -72,7 +79,7 @@ export class GatewayWatchdog extends EventEmitter {
             writable: true,
             value: false
         });
-        // V2: Restart tracking
+        // Restart tracking
         Object.defineProperty(this, "_restartTimestamps", {
             enumerable: true,
             configurable: true,
@@ -121,17 +128,28 @@ export class GatewayWatchdog extends EventEmitter {
         }
     }
     // ── Private ────────────────────────────────────────────────
-    /** Run one check, then schedule next with fresh jitter. Prevents overlap. */
+    /** Schedule the next tick with jitter. */
+    _scheduleNext(delayMs) {
+        if (this._stopped)
+            return;
+        const jitter = 1 + (Math.random() * 0.4 - 0.2);
+        const delay = delayMs ?? Math.round(this.checkIntervalMs * jitter);
+        this.timer = setTimeout(() => this._tick(), delay);
+    }
+    /** Run one check, then schedule next. Prevents overlap. */
     _tick() {
         this._check()
-            .catch(() => { })
+            .catch((err) => {
+            // Unexpected error in check logic itself — count as failure
+            this.consecutiveFailures++;
+            if (this.consecutiveFailures >= this.failureThreshold) {
+                this._transition('down');
+                this._attemptRestart();
+            }
+            this.emit('error', err instanceof Error ? err : new Error(String(err)));
+        })
             .finally(() => {
-            if (this._stopped)
-                return;
-            // Per-tick jitter (±20%) — recalculated each cycle
-            const jitter = 1 + (Math.random() * 0.4 - 0.2);
-            const delayMs = Math.round(this.checkIntervalMs * jitter);
-            this.timer = setTimeout(() => this._tick(), delayMs);
+            this._scheduleNext();
         });
     }
     async _check() {
@@ -151,7 +169,7 @@ export class GatewayWatchdog extends EventEmitter {
         }
         if (alive) {
             this.consecutiveFailures = 0;
-            // V2: Reset restart exhaustion on recovery
+            // Reset restart exhaustion on recovery
             if (this._status === 'down') {
                 this._restartExhausted = false;
             }
@@ -161,6 +179,9 @@ export class GatewayWatchdog extends EventEmitter {
             this.consecutiveFailures++;
             if (this.consecutiveFailures >= this.failureThreshold) {
                 this._transition('down');
+                // Attempt restart on every tick while down (not just on state transition).
+                // _attemptRestart has its own rate limiting.
+                this._attemptRestart();
             }
             // Below threshold: stay in current state (don't flap on transient failures)
         }
@@ -185,14 +206,13 @@ export class GatewayWatchdog extends EventEmitter {
                 baseUrl: this._endpoint?.baseUrl,
                 consecutiveFailures: this.consecutiveFailures,
             });
-            // V2: Attempt restart
-            this._attemptRestart();
         }
     }
-    // ── V2: Process restart ────────────────────────────────────
+    // ── Process restart ────────────────────────────────────
     /**
-     * Attempt to restart the OpenClaw process when bridge goes down.
+     * Attempt to restart the OpenClaw process when bridge is down.
      * Rate limited: max 3 attempts per 10 minute window.
+     * Called on every tick while down — internal guards prevent over-restarting.
      */
     _attemptRestart() {
         if (this._restartInProgress || this._restartExhausted || this._stopped)
@@ -222,6 +242,18 @@ export class GatewayWatchdog extends EventEmitter {
                     method: result.method,
                     output: result.output,
                 });
+                // After successful restart, wait for process to start then re-check
+                if (!this._stopped) {
+                    // Cancel the already-scheduled next tick, replace with cooldown + immediate check
+                    if (this.timer) {
+                        clearTimeout(this.timer);
+                        this.timer = null;
+                    }
+                    this.timer = setTimeout(() => {
+                        if (!this._stopped)
+                            this._tick();
+                    }, RESTART_COOLDOWN_MS);
+                }
             }
             else {
                 this.emit('restart_failed', {

package/dist/gateway/types.d.ts

@@ -10,11 +10,11 @@ import type { TunnelPayload } from 'echoclaw-crypto';
 export interface GatewayConfig {
     /** Enable the gateway layer. When false, RelayAgent behaves as V1. */
     enabled: boolean;
-    /** Local bridge port. Default: 8013 */
+    /** Local bridge port. Default: 18789 */
     bridgePort?: number;
     /** Local bridge host. Default: 'localhost'. Forced to loopback only. */
     bridgeHost?: string;
-    /** Ports to probe during discovery. Default: [8013, 8080] */
+    /** Ports to probe during discovery. Default: [18789] */
     discoveryPorts?: number[];
     /** Health check interval in ms. Default: 30_000 */
     healthCheckIntervalMs?: number;
@@ -36,9 +36,9 @@ export interface GatewayConfig {
     deviceName?: string;
 }
 export declare const DEFAULT_GATEWAY_CONFIG: {
-    readonly bridgePort: 8013;
+    readonly bridgePort: 18789;
     readonly bridgeHost: "localhost";
-    readonly discoveryPorts: readonly [8013, 8080];
+    readonly discoveryPorts: readonly [18789];
     readonly healthCheckIntervalMs: 30000;
     readonly healthCheckPath: "/health";
     readonly heartbeatIntervalMs: 10000;

package/dist/gateway/types.js

@@ -7,9 +7,9 @@
  * Key design: Ack + Heartbeat + Push async model for long-running AI tasks.
  */
 export const DEFAULT_GATEWAY_CONFIG = {
-    bridgePort: 8013,
+    bridgePort: 18789,
     bridgeHost: 'localhost',
-    discoveryPorts: [8013, 8080],
+    discoveryPorts: [18789],
     healthCheckIntervalMs: 30000,
     healthCheckPath: '/health',
     heartbeatIntervalMs: 10000,

package/package.json

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