echoclaw-relay-agent 0.22.3 → 0.22.5

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

@@ -97,6 +97,9 @@ function parseArgs(argv) {
         else if (arg === 'status') {
             command = 'status';
         }
+        else if (arg === 'restart') {
+            command = 'restart';
+        }
         else if (arg === 'uninstall') {
             command = 'uninstall';
         }
@@ -171,6 +174,7 @@ ${BOLD}EchoClaw Relay Agent${RESET}
 ${BOLD}Usage:${RESET}
   ${CYAN}echoclaw-relay setup <CODE>${RESET}       Pair + install as system service (${BOLD}recommended${RESET})
   ${CYAN}echoclaw-relay status${RESET}             Show service status
+  ${CYAN}echoclaw-relay restart${RESET}            Restart system service
   ${CYAN}echoclaw-relay uninstall${RESET}          Remove system service
 
 ${BOLD}Setup Options:${RESET}
@@ -423,6 +427,31 @@ async function runStatus() {
     }
     console.log();
 }
+async function runRestart() {
+    printLogo();
+    const svc = await getServiceManager();
+    const st = await svc.status();
+    if (!st.installed) {
+        console.log(`  ${RED}Service not installed.${RESET}`);
+        console.log(`  Run ${CYAN}echoclaw-relay setup <CODE>${RESET} first.\n`);
+        process.exit(1);
+    }
+    console.log(`  Restarting service...`);
+    await svc.restart();
+    // Brief wait for process to come up
+    await new Promise(r => setTimeout(r, 1500));
+    const after = await svc.status();
+    if (after.running) {
+        console.log(`  ${GREEN}${BOLD}Service restarted successfully.${RESET}`);
+        if (after.pid)
+            console.log(`  PID: ${after.pid}`);
+    }
+    else {
+        console.log(`  ${YELLOW}Service restarted but may still be starting up.${RESET}`);
+        console.log(`  Run ${CYAN}echoclaw-relay status${RESET} to check.`);
+    }
+    console.log();
+}
 async function runUninstall() {
     printLogo();
     const svc = await getServiceManager();
@@ -745,6 +774,9 @@ async function main() {
         else if (opts.command === 'status') {
             await runStatus();
         }
+        else if (opts.command === 'restart') {
+            await runRestart();
+        }
         else if (opts.command === 'uninstall') {
             await runUninstall();
         }

package/dist/service/launchd.d.ts

@@ -10,6 +10,7 @@
 import type { ServiceManager, ServiceStatus, ServiceInstallOptions } from './platform.js';
 export declare class LaunchdService implements ServiceManager {
     install(relayServer: string, options?: ServiceInstallOptions): Promise<void>;
+    restart(): Promise<void>;
     uninstall(): Promise<void>;
     status(): Promise<ServiceStatus>;
 }

package/dist/service/launchd.js

@@ -105,6 +105,14 @@ ${args.map(a => `    <string>${escapeXml(a)}</string>`).join('\n')}
         await fs.writeFile(PLIST_PATH, plist, 'utf-8');
         await bootstrapService();
     }
+    async restart() {
+        const st = await this.status();
+        if (!st.installed) {
+            throw new Error('Service not installed. Run setup first.');
+        }
+        await bootoutService();
+        await bootstrapService();
+    }
     async uninstall() {
         await bootoutService();
         try {

package/dist/service/platform.d.ts

@@ -10,6 +10,7 @@ export interface ServiceInstallOptions {
 export interface ServiceManager {
     install(relayServer: string, options?: ServiceInstallOptions): Promise<void>;
     uninstall(): Promise<void>;
+    restart(): Promise<void>;
     status(): Promise<ServiceStatus>;
 }
 export interface ServiceStatus {

package/dist/service/systemd.d.ts

@@ -11,6 +11,7 @@
 import type { ServiceManager, ServiceStatus, ServiceInstallOptions } from './platform.js';
 export declare class SystemdService implements ServiceManager {
     install(relayServer: string, options?: ServiceInstallOptions): Promise<void>;
+    restart(): Promise<void>;
     uninstall(): Promise<void>;
     status(): Promise<ServiceStatus>;
 }

package/dist/service/systemd.js

@@ -171,6 +171,13 @@ WantedBy=default.target
             console.log(`  ⚠  loginctl enable-linger failed (may require sudo). Service will start on login.`);
         }
     }
+    async restart() {
+        const userSessionOk = await isUserSessionAvailable();
+        if (!userSessionOk) {
+            throw new Error('systemd user session not available. Try: sudo loginctl enable-linger $(whoami)');
+        }
+        await execFileAsync('systemctl', ['--user', 'restart', UNIT_NAME]);
+    }
     async uninstall() {
         try {
             await execFileAsync('systemctl', ['--user', 'disable', '--now', UNIT_NAME]);

package/dist/service/windows.d.ts

@@ -7,6 +7,7 @@
 import type { ServiceManager, ServiceStatus, ServiceInstallOptions } from './platform.js';
 export declare class WindowsService implements ServiceManager {
     install(relayServer: string, options?: ServiceInstallOptions): Promise<void>;
+    restart(): Promise<void>;
     uninstall(): Promise<void>;
     status(): Promise<ServiceStatus>;
 }

package/dist/service/windows.js

@@ -128,6 +128,13 @@ export class WindowsService {
         }
         catch { /* may fail if already running */ }
     }
+    async restart() {
+        try {
+            await execFileAsync('schtasks', ['/End', '/TN', TASK_NAME]);
+        }
+        catch { /* not running */ }
+        await execFileAsync('schtasks', ['/Run', '/TN', TASK_NAME]);
+    }
     async uninstall() {
         try {
             await execFileAsync('schtasks', ['/End', '/TN', TASK_NAME]);

package/package.json

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