hedgequantx 2.9.121 → 2.9.123

package/package.json

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

package/src/pages/algo/algo-executor.js

@@ -34,9 +34,9 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   const accountName = showName 
     ? (account.accountName || account.rithmicAccountId || account.accountId) 
     : 'HQX *****';
-  const symbolName = contract.name;  // Display name: "Micro E-mini S&P 500"
-  const symbolCode = contract.symbol || contract.id;  // Rithmic symbol: "MESH6"
-  const contractId = contract.id;
+  const symbolName = contract.name || contract.baseSymbol || 'Unknown';
+  const symbolCode = contract.symbol || contract.baseSymbol || contract.id;  // Rithmic symbol for subscription
+  const contractId = contract.symbol || contract.baseSymbol || contract.id;  // For strategy tracking
   const tickSize = contract.tickSize || 0.25;
   
   const ui = new AlgoUI({ 
@@ -87,6 +87,10 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     risk: maxRisk
   });
   
+  // Log detailed contract info for debugging
+  sessionLogger.log('CONFIG', `symbolCode=${symbolCode} contractId=${contractId} exchange=${contract.exchange} tickSize=${tickSize}`);
+  sessionLogger.log('CONFIG', `account=${account.accountId} rithmicId=${account.rithmicAccountId || 'N/A'}`);
+  
   strategy.on('log', (log) => {
     const type = log.type === 'debug' ? 'debug' : log.type === 'info' ? 'analysis' : 'system';
     ui.addLog(type, log.message);
@@ -243,6 +247,12 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     const now = Date.now();
     const currentSecond = Math.floor(now / 1000);
     
+    // Debug first 5 ticks to verify data
+    if (tickCount <= 5) {
+      const p = Number(tick.price) || Number(tick.tradePrice) || 'NULL';
+      sessionLogger.log('TICK', `#${tickCount} price=${p} symbol=${tick.symbol || tick.contractId || 'N/A'}`);
+    }
+    
     // Count ticks per second
     if (currentSecond === lastTickSecond) {
       ticksPerSecond++;
@@ -347,13 +357,16 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     lastBid = bid;
     lastAsk = ask;
     
-    strategy.processTick({
-      contractId: tick.contractId || contractId,
-      price: price, bid: bid, ask: ask,
-      volume: volume, 
-      side: tick.side || tick.lastTradeSide || 'unknown',
-      timestamp: tick.timestamp || Date.now()
-    });
+    // Only process tick if we have a valid price
+    if (price && price > 0) {
+      strategy.processTick({
+        contractId: tick.contractId || contractId,
+        price: price, bid: bid, ask: ask,
+        volume: volume, 
+        side: tick.side || tick.lastTradeSide || 'unknown',
+        timestamp: tick.timestamp || Date.now()
+      });
+    }
     
     // Calculate latency from Rithmic ssboe/usecs or inter-tick timing
     if (tick.ssboe && tick.usecs !== undefined) {

package/src/services/rithmic/index.js

@@ -98,6 +98,18 @@ class RithmicService extends EventEmitter {
 
       await this.orderConn.connect(config);
       this.orderConn.on('message', createOrderHandler(this));
+      
+      // Auto-reconnect on disconnect
+      this.orderConn.on('disconnected', async ({ code, reason }) => {
+        log.warn('ORDER_PLANT disconnected', { code, reason });
+        this.emit('disconnected', { plant: 'ORDER', code, reason });
+        
+        // Auto-reconnect if we have credentials (not manual disconnect)
+        if (this.credentials && code !== 1000) {
+          log.info('Attempting auto-reconnect in 3s...');
+          setTimeout(() => this._autoReconnect(), 3000);
+        }
+      });
 
       return new Promise((resolve) => {
         const timeout = setTimeout(() => {
@@ -163,6 +175,13 @@ class RithmicService extends EventEmitter {
 
       await this.pnlConn.connect(config);
       this.pnlConn.on('message', createPnLHandler(this));
+      
+      // Auto-reconnect PnL on disconnect
+      this.pnlConn.on('disconnected', ({ code }) => {
+        if (this.credentials && code !== 1000) {
+          setTimeout(() => this.connectPnL(this.credentials.username, this.credentials.password), 3000);
+        }
+      });
 
       return new Promise((resolve) => {
         const timeout = setTimeout(() => resolve(false), TIMEOUTS.RITHMIC_PNL);
@@ -200,6 +219,13 @@ class RithmicService extends EventEmitter {
       };
 
       await this.tickerConn.connect(config);
+      
+      // Auto-reconnect Ticker on disconnect
+      this.tickerConn.on('disconnected', ({ code }) => {
+        if (this.credentials && code !== 1000) {
+          setTimeout(() => this.connectTicker(this.credentials.username, this.credentials.password), 3000);
+        }
+      });
 
       return new Promise((resolve) => {
         const timeout = setTimeout(() => {
@@ -383,9 +409,42 @@ class RithmicService extends EventEmitter {
     return { isOpen: true, message: 'Market is open' };
   }
 
+  // ==================== AUTO-RECONNECT ====================
+
+  async _autoReconnect() {
+    if (!this.credentials) {
+      log.warn('Cannot auto-reconnect: no credentials');
+      return;
+    }
+    
+    const { username, password } = this.credentials;
+    log.info('Auto-reconnecting...');
+    this.emit('reconnecting');
+    
+    try {
+      const result = await this.login(username, password);
+      if (result.success) {
+        log.info('Auto-reconnect successful');
+        this.emit('reconnected', { accounts: result.accounts });
+      } else {
+        log.warn('Auto-reconnect failed', { error: result.error });
+        this.emit('reconnectFailed', { error: result.error });
+        // Retry in 10s
+        setTimeout(() => this._autoReconnect(), 10000);
+      }
+    } catch (err) {
+      log.error('Auto-reconnect error', { error: err.message });
+      this.emit('reconnectFailed', { error: err.message });
+      // Retry in 10s
+      setTimeout(() => this._autoReconnect(), 10000);
+    }
+  }
+
   // ==================== CLEANUP ====================
 
   async disconnect() {
+    // Clear credentials to prevent auto-reconnect on manual disconnect
+    this.credentials = null;
     const connections = [this.orderConn, this.pnlConn, this.tickerConn];
     
     for (const conn of connections) {