hedgequantx 2.9.224 → 2.9.225

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.9.224",
+  "version": "2.9.225",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {

package/src/services/daemon/handlers.js

@@ -59,6 +59,13 @@ function createHandlers(daemon) {
         name: daemon.rithmic.propfirm.name,
       };
       
+      // Save credentials for auto-reconnect
+      daemon._saveCredentials(username, password);
+      daemon._lastRithmicResponse = Date.now();
+      
+      // Start health monitoring
+      daemon._startHealthCheck();
+      
       // Save session for restore
       const { storage } = require('../session');
       storage.save([{
@@ -113,6 +120,14 @@ function createHandlers(daemon) {
         key: propfirmKey,
         name: daemon.rithmic.propfirm.name,
       };
+      
+      // Save credentials for auto-reconnect
+      daemon._saveCredentials(credentials.username, credentials.password);
+      daemon._lastRithmicResponse = Date.now();
+      
+      // Start health monitoring
+      daemon._startHealthCheck();
+      
       log.info('Session restored', { propfirm: daemon.propfirm.name });
     } else {
       daemon.rithmic = null;
@@ -129,6 +144,10 @@ function createHandlers(daemon) {
   }
   
   async function handleLogout(socket, id) {
+    // Stop health monitoring
+    daemon._stopHealthCheck();
+    daemon._savedCredentials = null;
+    
     if (daemon.rithmic) {
       await daemon.rithmic.disconnect();
       daemon.rithmic = null;

package/src/services/daemon/server.js

@@ -56,6 +56,18 @@ class DaemonServer extends EventEmitter {
     
     /** @type {Object} Message handlers */
     this.handlers = createHandlers(this);
+    
+    /** @type {NodeJS.Timer|null} Health check interval */
+    this._healthCheckInterval = null;
+    
+    /** @type {number} Last successful Rithmic response timestamp */
+    this._lastRithmicResponse = 0;
+    
+    /** @type {boolean} Is currently reconnecting */
+    this._isReconnecting = false;
+    
+    /** @type {Object} Saved credentials for reconnection */
+    this._savedCredentials = null;
   }
   
   /**
@@ -264,6 +276,138 @@ class DaemonServer extends EventEmitter {
    */
   _setupRithmicEvents() {
     setupRithmicEvents(this);
+    
+    // Monitor disconnection
+    if (this.rithmic) {
+      this.rithmic.on('disconnected', (info) => {
+        log.warn('Rithmic disconnected', info);
+        this._handleRithmicDisconnect();
+      });
+      
+      this.rithmic.on('reconnected', () => {
+        log.info('Rithmic reconnected');
+        this._lastRithmicResponse = Date.now();
+        this._isReconnecting = false;
+      });
+    }
+  }
+  
+  /**
+   * Start health monitoring
+   */
+  _startHealthCheck() {
+    if (this._healthCheckInterval) return;
+    
+    // Check every 30 seconds
+    this._healthCheckInterval = setInterval(() => {
+      this._performHealthCheck();
+    }, 30000);
+    
+    log.debug('Health check started');
+  }
+  
+  /**
+   * Stop health monitoring
+   */
+  _stopHealthCheck() {
+    if (this._healthCheckInterval) {
+      clearInterval(this._healthCheckInterval);
+      this._healthCheckInterval = null;
+    }
+  }
+  
+  /**
+   * Perform health check on Rithmic connection
+   */
+  async _performHealthCheck() {
+    if (!this.rithmic || this._isReconnecting) return;
+    
+    try {
+      // Try to get accounts as a health check (uses cache, no API call)
+      const result = await this.rithmic.getTradingAccounts();
+      
+      if (result.success) {
+        this._lastRithmicResponse = Date.now();
+      } else {
+        log.warn('Health check failed', { error: result.error });
+        
+        // If no response for 2 minutes, try reconnect
+        const timeSinceLastResponse = Date.now() - this._lastRithmicResponse;
+        if (timeSinceLastResponse > 120000) {
+          log.warn('Rithmic unresponsive for 2 minutes, attempting reconnect');
+          this._handleRithmicDisconnect();
+        }
+      }
+    } catch (err) {
+      log.error('Health check error', { error: err.message });
+    }
+  }
+  
+  /**
+   * Handle Rithmic disconnection - attempt reconnect
+   */
+  async _handleRithmicDisconnect() {
+    if (this._isReconnecting) {
+      log.debug('Already reconnecting, skipping');
+      return;
+    }
+    
+    if (!this._savedCredentials) {
+      log.warn('Cannot reconnect: no saved credentials');
+      return;
+    }
+    
+    this._isReconnecting = true;
+    
+    // Notify clients
+    this._broadcast(createMessage(MSG_TYPE.EVENT_DISCONNECTED, {
+      reason: 'Connection lost, reconnecting...',
+      reconnecting: true,
+    }));
+    
+    // Use reconnect module
+    const { handleAutoReconnect } = require('../rithmic/reconnect');
+    
+    // Prepare service with credentials
+    if (this.rithmic) {
+      this.rithmic.credentials = this._savedCredentials;
+    }
+    
+    try {
+      await handleAutoReconnect(this.rithmic);
+      
+      if (this.rithmic && this.rithmic.accounts?.length > 0) {
+        this._lastRithmicResponse = Date.now();
+        this._isReconnecting = false;
+        
+        // Notify clients of reconnection
+        this._broadcast(createMessage(MSG_TYPE.EVENT_RECONNECTED, {
+          propfirm: this.propfirm,
+          accounts: this.rithmic.accounts.length,
+        }));
+        
+        log.info('Reconnection successful');
+      }
+    } catch (err) {
+      log.error('Reconnection failed', { error: err.message });
+      this._isReconnecting = false;
+      
+      // Schedule retry in 5 minutes
+      setTimeout(() => {
+        if (this.isRunning && !this._isReconnecting) {
+          this._handleRithmicDisconnect();
+        }
+      }, 300000);
+    }
+  }
+  
+  /**
+   * Save credentials for reconnection
+   * @param {string} username
+   * @param {string} password
+   */
+  _saveCredentials(username, password) {
+    this._savedCredentials = { username, password };
   }
   
   /**
@@ -296,6 +440,9 @@ class DaemonServer extends EventEmitter {
   async stop() {
     log.info('Stopping daemon...');
     
+    // Stop health monitoring
+    this._stopHealthCheck();
+    
     // Stop all algo sessions
     for (const [id, session] of this.algoSessions) {
       try {