echoclaw-relay-agent 0.19.3 → 0.20.0

package/dist/RelayAgent.d.ts

@@ -27,6 +27,7 @@ export declare class RelayAgent extends EventEmitter {
     private pairingCode;
     private _status;
     private _dataHandler;
+    private _dataHandlerInner;
     private _stopped;
     private _starting;
     private _paired;

package/dist/RelayAgent.js

@@ -81,6 +81,12 @@ export class RelayAgent extends EventEmitter {
             writable: true,
             value: null
         });
+        Object.defineProperty(this, "_dataHandlerInner", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
         Object.defineProperty(this, "_stopped", {
             enumerable: true,
             configurable: true,
@@ -286,9 +292,11 @@ export class RelayAgent extends EventEmitter {
         this.sessionKey = null;
         this.frameCrypto = null;
         this._dataHandler = null;
+        this._dataHandlerInner = null;
         this._rekeyListener = null;
         this._proactiveKeyPair = null;
         this._rekeyInFlight = false;
+        this._identityExchanged = false;
         this.setStatus('disconnected');
     }
     // ── Private ────────────────────────────────────────────────
@@ -552,7 +560,16 @@ export class RelayAgent extends EventEmitter {
                 this.emit('error', ixErr);
             }
         }
-        // Persist session (with identity fields if exchange succeeded)
+        // Persist session — merge with existing to preserve identity data on re-key.
+        // Fresh pairing writes clean; re-key only updates sessionKey/sessionId.
+        if (!freshPairing) {
+            const existing = await this.sessionStore.load();
+            if (existing) {
+                sessionData.identityDeviceId = sessionData.identityDeviceId || existing.identityDeviceId;
+                sessionData.peerPublicKeyRaw = sessionData.peerPublicKeyRaw || existing.peerPublicKeyRaw;
+                sessionData.bindingSecret = sessionData.bindingSecret || existing.bindingSecret;
+            }
+        }
         await this.sessionStore.save(sessionData);
         // Re-install re-key listener so future desktop HELLOs are handled.
         // Without this, after a re-key, the listener references the old transport
@@ -602,18 +619,19 @@ export class RelayAgent extends EventEmitter {
                 this._identityExchanged = true;
                 return;
             }
-            // Remove early handler before entering wait — prevents both handlers from
-            // processing the same message simultaneously (Reviewer #2, #3 finding).
-            this.removeListener('message', earlyHandler);
-            // Use early-captured message if available, otherwise wait with timeout
-            const peerIdentity = earlyIdentity ?? await this._waitForIdentityExchange(10000);
-            // Respond with our own identity
+            // SYMMETRIC EXCHANGE: Send our identity FIRST, then wait for peer's.
+            // Both sides send immediately upon pairing — eliminates "who sends first" race.
             const myPubKeyBase64 = toBase64(ed.publicKeyRaw);
             await this.send({
                 type: 'identity_exchange',
                 ed25519_pubkey: myPubKeyBase64,
                 device_id: identity.deviceId,
             });
+            // Remove early handler before entering wait — prevents both handlers from
+            // processing the same message simultaneously.
+            this.removeListener('message', earlyHandler);
+            // Use early-captured message if available, otherwise wait with timeout
+            const peerIdentity = earlyIdentity ?? await this._waitForIdentityExchange(15000);
             // Persist peer's public key
             await this.identityStore.updatePeer(peerIdentity.ed25519_pubkey);
             sessionData.peerPublicKeyRaw = peerIdentity.ed25519_pubkey;
@@ -650,11 +668,16 @@ export class RelayAgent extends EventEmitter {
     setupDataHandler() {
         if (!this.transport)
             return;
-        // Remove previous data handler to prevent listener accumulation on reconnect
-        if (this._dataHandler) {
-            this.transport.removeListener('message', this._dataHandler);
+        // Single permanent listener pattern: install once, swap inner handler on re-key.
+        // Prevents listener accumulation from multiple onPaired() calls.
+        if (!this._dataHandler) {
+            this._dataHandler = (msg) => {
+                if (this._dataHandlerInner)
+                    this._dataHandlerInner(msg);
+            };
+            this.transport.on('message', this._dataHandler);
         }
-        this._dataHandler = async (msg) => {
+        this._dataHandlerInner = async (msg) => {
             if (msg.type !== 'DATA' || !msg.iv || !msg.payload || !this.frameCrypto)
                 return;
             try {
@@ -693,7 +716,6 @@ export class RelayAgent extends EventEmitter {
                 this.emit('error', err);
             }
         };
-        this.transport.on('message', this._dataHandler);
     }
     setupTransportEvents() {
         if (!this.transport)
@@ -702,6 +724,11 @@ export class RelayAgent extends EventEmitter {
             if (!this._stopped) {
                 this.setStatus('reconnecting');
                 this.emit('disconnected', { code: 0, reason: 'transport closed' });
+                // Reset re-key state on transport close — new connection = fresh re-key.
+                // Prevents deadlock where old _rekeyInFlight blocks new connection's re-key.
+                this._rekeyInFlight = false;
+                this._activePairing?.abort();
+                this._activePairing = null;
                 // V2: Notify gateway of disconnect (starts grace period)
                 this.gatewayManager?.onDisconnected();
             }

package/dist/RelayClient.js

@@ -286,11 +286,20 @@ export class RelayClient extends EventEmitter {
             await this.onPaired(result, 'paired');
         }
         catch (err) {
-            // Identity exchange failed on fresh pairing — tear down transport to
-            // prevent leaking an authenticated-but-unusable WebSocket, then re-throw.
-            // Do NOT emit('error') here — the throw propagates to connect() caller.
-            this.transport?.disconnect();
-            throw err;
+            // Identity exchange failed — non-fatal for fresh pairing.
+            // ECDH succeeded, encrypted channel works. Identity exchange only enables
+            // V2 identity-based reconnect. Keep connection alive, emit warning.
+            const isIdentityErr = err?.message?.includes('Identity exchange');
+            if (isIdentityErr) {
+                console.warn('[RelayClient] Identity exchange failed (non-fatal):', err?.message);
+                this.emit('error', Object.assign(new Error(`Identity exchange failed: ${err?.message}`), { name: 'IdentityExchangeError' }));
+                // Connection is usable — don't tear down
+            }
+            else {
+                // Non-identity errors are still fatal
+                this.transport?.disconnect();
+                throw err;
+            }
         }
     }
     async resumeSession(session) {
@@ -577,7 +586,8 @@ export class RelayClient extends EventEmitter {
                 this._identityExchanged = true;
                 return; // finally will clean up earlyHandler
             }
-            // Send our Ed25519 public key to the agent (through E2E encrypted DATA channel)
+            // SYMMETRIC EXCHANGE: Send our identity FIRST, then wait for peer's.
+            // Both sides send immediately upon pairing — eliminates "who sends first" race.
             const myPubKeyBase64 = toBase64(ed.publicKeyRaw);
             await this.send({
                 type: 'identity_exchange',
@@ -586,8 +596,8 @@ export class RelayClient extends EventEmitter {
             });
             // Remove early handler before entering wait — prevents dual listeners
             this.removeListener('message', earlyHandler);
-            // Use early-captured message if available, otherwise wait with timeout
-            const peerIdentity = earlyIdentity ?? await this._waitForIdentityExchange(10000);
+            // Use early-captured message if available, otherwise wait with timeout (15s for setup)
+            const peerIdentity = earlyIdentity ?? await this._waitForIdentityExchange(15000);
             // Persist peer's public key
             await this.identityStore.updatePeer(peerIdentity.ed25519_pubkey);
             sessionData.peerPublicKeyRaw = peerIdentity.ed25519_pubkey;
@@ -675,21 +685,39 @@ export class RelayClient 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' }));
         });
-        // Listen for server CLOSE messages to handle re-ECDH and peer status notifications.
+        // Listen for server CLOSE/STATUS messages — whitelist dispatch.
+        // Only specific payloads trigger re-key. Others dispatch to handlers.
+        const REKEY_TRIGGERS = new Set(['AGENT_RESTARTED', 'FORCE_REKEY']);
+        const PEER_STATUS = new Set(['AGENT_WARNING', 'AGENT_ONLINE', 'DESKTOP_DISCONNECTED']);
+        const SESSION_FATAL = new Set(['SESSION_NOT_FOUND', 'INVALID_SESSION']);
         this.transport.on('message', (msg) => {
-            if (msg.type === 'CLOSE' && msg.sender_role === 'server') {
-                const payload = msg.payload;
-                if (payload === 'AGENT_WARNING' || payload === 'AGENT_ONLINE') {
-                    // Peer status notification — emit event, don't trigger re-key
+            if ((msg.type === 'CLOSE' || msg.type === 'STATUS') && msg.sender_role === 'server') {
+                const payload = typeof msg.payload === 'string' ? msg.payload : '';
+                if (REKEY_TRIGGERS.has(payload)) {
+                    this._needsRekey = true;
+                    return;
+                }
+                if (PEER_STATUS.has(payload)) {
                     this.emit('peer_status', {
-                        status: payload === 'AGENT_WARNING' ? 'warning' : 'online',
+                        status: payload === 'AGENT_ONLINE' ? 'online' : 'warning',
                         timestamp: msg.timestamp,
                     });
+                    return;
                 }
-                else {
-                    // AGENT_RESTARTED etc. — trigger re-ECDH on next open
-                    this._needsRekey = true;
+                if (payload === 'UNPAIRED') {
+                    // Permanent disconnection — clear session, stop reconnecting
+                    this.sessionStore.clear().catch(() => { });
+                    this.emit('unpaired');
+                    this.transport?.disconnect();
+                    return;
+                }
+                if (SESSION_FATAL.has(payload)) {
+                    // Session gone — clear and let reconnect do fresh pairing
+                    this.sessionStore.clear().catch(() => { });
+                    return;
                 }
+                // Unknown payload — log but don't trigger re-key
+                // (prevents infinite re-key loops from future server messages)
             }
         });
         this.transport.on('open', () => {

package/dist/chat/ChatHandler.js

@@ -706,6 +706,8 @@ export class ChatHandler {
                             }
                         }
                     }, 2000);
+                    if (timer.unref)
+                        timer.unref(); // Don't block process exit
                     this._lifecycleTimers.set(runId, timer);
                 }
             }

package/dist/relay/PairingProtocol.js

@@ -101,10 +101,15 @@ export class PairingProtocol extends EventEmitter {
                         reject(err);
                     }
                 }
-                // Error from server
-                if (msg.type === 'CLOSE') {
-                    cleanup();
-                    reject(new Error(`Relay server closed: ${msg.payload || 'unknown'}`));
+                // Server messages — only fatal errors reject pairing
+                if (msg.type === 'CLOSE' || msg.type === 'STATUS') {
+                    const payload = typeof msg.payload === 'string' ? msg.payload : '';
+                    const FATAL = ['SESSION_NOT_FOUND', 'INVALID_CODE', 'MISSING_CODE', 'NO_PAIRING', 'UNPAIRED'];
+                    if (FATAL.includes(payload)) {
+                        cleanup();
+                        reject(new Error(`Relay server closed: ${payload}`));
+                    }
+                    // Non-fatal (AGENT_WARNING, AGENT_ONLINE, DESKTOP_DISCONNECTED, STATUS) — ignore
                 }
             };
             this.transport.on('message', onMessage);
@@ -202,13 +207,18 @@ export class PairingProtocol extends EventEmitter {
                 }
                 // PAIRED notification from server — agent has joined (initiator mode)
                 // No action needed, just wait for agent's HELLO with pubkey
-                // Error from server
-                if (msg.type === 'CLOSE') {
-                    cleanup();
-                    const reason = msg.payload === 'INVALID_CODE'
-                        ? `Invalid pairing code: ****`
-                        : `Relay server closed: ${msg.payload || 'unknown'}`;
-                    reject(new Error(reason));
+                // Server messages — only fatal errors reject pairing
+                if (msg.type === 'CLOSE' || msg.type === 'STATUS') {
+                    const payload = typeof msg.payload === 'string' ? msg.payload : '';
+                    const FATAL = ['SESSION_NOT_FOUND', 'INVALID_CODE', 'MISSING_CODE', 'NO_PAIRING', 'UNPAIRED'];
+                    if (FATAL.includes(payload)) {
+                        cleanup();
+                        const reason = payload === 'INVALID_CODE'
+                            ? `Invalid pairing code: ****`
+                            : `Relay server closed: ${payload}`;
+                        reject(new Error(reason));
+                    }
+                    // Non-fatal — ignore
                 }
             };
             this.transport.on('message', onMessage);

package/dist/types.d.ts

@@ -12,7 +12,7 @@ export interface RelayMessage {
     version: typeof RELAY_PROTOCOL_VERSION;
     session_id: string;
     msg_id: string;
-    type: 'HELLO' | 'DATA' | 'PING' | 'CLOSE';
+    type: 'HELLO' | 'DATA' | 'PING' | 'CLOSE' | 'STATUS' | 'PAIRED';
     pubkey?: string;
     iv?: string;
     payload?: string;

package/package.json

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