hedgequantx 2.9.224 → 2.9.226

package/package.json

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

package/src/app.js

@@ -78,10 +78,17 @@ function createDaemonProxyService(client, propfirm, credentials = null) {
       // Return credentials for algo trading market data connection
       if (!storedCredentials) return null;
       const { RITHMIC_ENDPOINTS } = require('./services/rithmic');
+      const { getPropFirm } = require('./config/propfirms');
+      
+      // Get the proper rithmicSystem from propfirm config
+      const propfirmKey = propfirm?.key || 'apex_rithmic';
+      const propfirmConfig = getPropFirm(propfirmKey);
+      const systemName = propfirmConfig?.rithmicSystem || propfirm?.rithmicSystem || propfirm?.name || 'Apex';
+      
       return {
         userId: storedCredentials.username,
         password: storedCredentials.password,
-        systemName: propfirm?.systemName || propfirm?.name || 'Apex',
+        systemName,
         gateway: RITHMIC_ENDPOINTS?.CHICAGO || 'wss://rprotocol.rithmic.com:443',
       };
     },

package/src/services/daemon/handlers.js

@@ -54,17 +54,30 @@ function createHandlers(daemon) {
     const result = await daemon.rithmic.login(username, password);
     
     if (result.success) {
+      // Get rithmicSystem from config
+      const { getPropFirm } = require('../../config/propfirms');
+      const propfirmConfig = getPropFirm(propfirmKey);
+      
       daemon.propfirm = {
         key: propfirmKey,
         name: daemon.rithmic.propfirm.name,
+        rithmicSystem: propfirmConfig?.rithmicSystem || daemon.rithmic.propfirm.systemName || 'Apex',
       };
       
+      // 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([{
         type: 'rithmic',
         propfirm: daemon.propfirm.name,
         propfirmKey,
+        rithmicSystem: daemon.propfirm.rithmicSystem,
         credentials: { username, password },
         accounts: daemon.rithmic.accounts,
       }]);
@@ -109,10 +122,23 @@ function createHandlers(daemon) {
     );
     
     if (result.success) {
+      // Get rithmicSystem from config or session
+      const { getPropFirm } = require('../../config/propfirms');
+      const propfirmConfig = getPropFirm(propfirmKey);
+      
       daemon.propfirm = {
         key: propfirmKey,
         name: daemon.rithmic.propfirm.name,
+        rithmicSystem: propfirmConfig?.rithmicSystem || rithmicSession.rithmicSystem || daemon.rithmic.propfirm.systemName || 'Apex',
       };
+      
+      // 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 +155,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;
@@ -280,6 +310,13 @@ function createHandlers(daemon) {
     
     // Return credentials for algo trading market data
     const { RITHMIC_ENDPOINTS } = require('../rithmic');
+    const { getPropFirm } = require('../../config/propfirms');
+    
+    // Get proper rithmicSystem from config
+    const propfirmKey = rithmicSession.propfirmKey || daemon.propfirm?.key || 'apex_rithmic';
+    const propfirmConfig = getPropFirm(propfirmKey);
+    const systemName = propfirmConfig?.rithmicSystem || daemon.propfirm?.name || rithmicSession.propfirm || 'Apex';
+    
     daemon._send(socket, createMessage(MSG_TYPE.CREDENTIALS, {
       success: true,
       credentials: {
@@ -289,9 +326,10 @@ function createHandlers(daemon) {
       rithmicCredentials: {
         userId: rithmicSession.credentials.username,
         password: rithmicSession.credentials.password,
-        systemName: daemon.propfirm?.name || rithmicSession.propfirm || 'Apex',
+        systemName,
         gateway: RITHMIC_ENDPOINTS?.CHICAGO || 'wss://rprotocol.rithmic.com:443',
       },
+      propfirmKey,
     }, id));
   }
   

package/src/services/daemon/proxy.js

@@ -335,10 +335,16 @@ class DaemonProxyService extends EventEmitter {
     // For daemon mode, return stored credentials
     if (this.credentials && this.propfirmKey) {
       const { RITHMIC_ENDPOINTS } = require('../rithmic');
+      const { getPropFirm } = require('../../config/propfirms');
+      
+      // Get proper rithmicSystem from config
+      const propfirmConfig = getPropFirm(this.propfirmKey);
+      const systemName = propfirmConfig?.rithmicSystem || this.propfirm?.rithmicSystem || 'Apex';
+      
       return {
         userId: this.credentials.username,
         password: this.credentials.password,
-        systemName: this.propfirm?.systemName || 'Apex',
+        systemName,
         gateway: RITHMIC_ENDPOINTS?.CHICAGO || 'wss://rprotocol.rithmic.com:443',
       };
     }

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 {