hedgequantx 2.9.125 → 2.9.127

package/package.json

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

package/src/lib/data.js

@@ -36,8 +36,9 @@ class MarketDataFeed extends EventEmitter {
   /**
    * Connect to Rithmic TICKER_PLANT
    * @param {Object} rithmicCredentials - Credentials from RithmicService.getRithmicCredentials()
+   * @param {number} retries - Number of connection retries (default: 2)
    */
-  async connect(rithmicCredentials) {
+  async connect(rithmicCredentials, retries = 2) {
     if (this.connected) return;
 
     if (!rithmicCredentials || !rithmicCredentials.userId || !rithmicCredentials.password) {
@@ -45,7 +46,6 @@ class MarketDataFeed extends EventEmitter {
     }
 
     this.credentials = rithmicCredentials;
-    this.connection = new RithmicConnection();
 
     this.config = {
       uri: rithmicCredentials.gateway || RITHMIC_ENDPOINTS.CHICAGO,
@@ -56,39 +56,74 @@ class MarketDataFeed extends EventEmitter {
       appVersion: '2.0.0',
     };
 
-    try {
-      // Ensure protobuf definitions are loaded
-      await proto.load();
-      
-      await this.connection.connect(this.config);
+    // Ensure protobuf definitions are loaded
+    await proto.load();
 
-      // Setup message handler for market data
-      this.connection.on('message', (msg) => this._handleMessage(msg));
-
-      // Login to TICKER_PLANT
-      return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          reject(new Error('TICKER_PLANT login timeout'));
-        }, 15000);
-
-        this.connection.once('loggedIn', () => {
-          clearTimeout(timeout);
-          this.connected = true;
-          this.emit('connected');
-          resolve(true);
+    let lastError = null;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        if (attempt > 0) {
+          this.emit('debug', `TICKER_PLANT retry ${attempt}/${retries}...`);
+          await new Promise(r => setTimeout(r, 2000)); // Wait 2s before retry
+        }
+        
+        this.connection = new RithmicConnection();
+        
+        // Connection timeout handler
+        this.connection.on('error', (err) => {
+          this.emit('debug', `TICKER_PLANT connection error: ${err.message}`);
         });
+        
+        await this.connection.connect(this.config);
+        this.emit('debug', `TICKER_PLANT WebSocket connected to ${this.config.uri}`);
 
-        this.connection.once('loginFailed', (data) => {
-          clearTimeout(timeout);
-          reject(new Error(data.message || 'TICKER_PLANT login failed'));
+        // Setup message handler for market data
+        this.connection.on('message', (msg) => this._handleMessage(msg));
+        
+        // Handle disconnection for auto-reconnect
+        this.connection.on('disconnected', ({ code, reason }) => {
+          this.connected = false;
+          this.emit('disconnected', { code, reason });
+          // Auto-reconnect if not manual close
+          if (code !== 1000 && this.credentials) {
+            this.emit('debug', 'TICKER_PLANT disconnected, will reconnect in 3s...');
+            setTimeout(() => this.connect(this.credentials, 1), 3000);
+          }
         });
 
-        this.connection.login('TICKER_PLANT');
-      });
-    } catch (e) {
-      this.emit('error', e);
-      throw e;
+        // Login to TICKER_PLANT
+        return await new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            reject(new Error('TICKER_PLANT login timeout'));
+          }, 15000);
+
+          this.connection.once('loggedIn', () => {
+            clearTimeout(timeout);
+            this.connected = true;
+            this.emit('connected');
+            resolve(true);
+          });
+
+          this.connection.once('loginFailed', (data) => {
+            clearTimeout(timeout);
+            reject(new Error(data.message || 'TICKER_PLANT login failed'));
+          });
+
+          this.connection.login('TICKER_PLANT');
+        });
+      } catch (e) {
+        lastError = e;
+        this.emit('debug', `TICKER_PLANT attempt ${attempt + 1} failed: ${e.message}`);
+        if (this.connection) {
+          try { await this.connection.disconnect(); } catch (_) {}
+          this.connection = null;
+        }
+      }
     }
+
+    // All retries failed
+    this.emit('error', lastError);
+    throw lastError;
   }
 
   /**

package/src/services/rithmic/connection.js

@@ -172,11 +172,13 @@ class RithmicConnection extends EventEmitter {
 
       if (res.rpCode?.[0] === '0') {
         this.state = 'LOGGED_IN';
-        this.startHeartbeat(res.heartbeatInterval || 60);
+        // Use heartbeat interval from server, minimum 10s, default 30s
+        const hbInterval = Math.max(10, res.heartbeatInterval || 30);
+        this.startHeartbeat(hbInterval);
         this.emit('loggedIn', {
           fcmId: res.fcmId,
           ibId: res.ibId,
-          heartbeatInterval: res.heartbeatInterval,
+          heartbeatInterval: hbInterval,
         });
       } else {
         const errorCode = res.rpCode?.[0] || 'UNKNOWN';
@@ -202,13 +204,23 @@ class RithmicConnection extends EventEmitter {
 
   startHeartbeat(intervalSec) {
     this.stopHeartbeat();
+    // Send heartbeat at half the interval to be safe (minimum every 5 seconds)
+    const hbMs = Math.max(5000, Math.floor(intervalSec * 1000 / 2));
     this.heartbeatTimer = setInterval(() => {
       try {
-        this.send('RequestHeartbeat', { templateId: REQ.HEARTBEAT });
+        if (this.ws?.readyState === WebSocket.OPEN) {
+          this.send('RequestHeartbeat', { templateId: REQ.HEARTBEAT });
+        }
       } catch (e) {
-        // Ignore
+        // Ignore heartbeat errors
+      }
+    }, hbMs);
+    // Send first heartbeat immediately
+    try {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.send('RequestHeartbeat', { templateId: REQ.HEARTBEAT });
       }
-    }, (intervalSec - 5) * 1000);
+    } catch (e) {}
   }
 
   stopHeartbeat() {