hedgequantx 2.6.88 → 2.6.90

package/package.json

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

package/src/pages/algo/one-account.js

@@ -399,84 +399,68 @@ const launchAlgo = async (service, account, contract, config) => {
   }
   
   // ═══════════════════════════════════════════════════════════════════════════
-  // REAL-TIME P&L VIA WEBSOCKET (like R Trader)
-  // Listen to pnlUpdate events from Rithmic PNL_PLANT WebSocket
+  // REAL-TIME P&L VIA WEBSOCKET
+  // - Rithmic: Uses EventEmitter (service.on) for real-time updates
+  // - ProjectX: Uses HTTP polling (handled in pollPnL function below)
   // ═══════════════════════════════════════════════════════════════════════════
   const rithmicAccountId = account.rithmicAccountId || account.accountId;
+  const serviceHasEvents = typeof service.on === 'function';
   
-  service.on('pnlUpdate', (pnlData) => {
-    // Only update for our account
-    if (pnlData.accountId !== rithmicAccountId) return;
-    
-    // ═══════════════════════════════════════════════════════════════════════════
-    // ACCOUNT_PNL_UPDATE (451) - All R Trader account-level metrics
-    // ═══════════════════════════════════════════════════════════════════════════
-    
-    // Closed P&L (realized) - from closed trades today
-    if (pnlData.closedPositionPnl !== undefined) {
-      stats.closedPnl = parseFloat(pnlData.closedPositionPnl);
-    }
-    
-    // Account Balance
-    if (pnlData.accountBalance !== undefined) {
-      stats.balance = parseFloat(pnlData.accountBalance);
-    }
-    
-    // Buying Power (Available)
-    if (pnlData.availableBuyingPower !== undefined) {
-      stats.buyingPower = parseFloat(pnlData.availableBuyingPower);
-    }
-    
-    // Margin Balance
-    if (pnlData.marginBalance !== undefined) {
-      stats.margin = parseFloat(pnlData.marginBalance);
-    }
-    
-    // Net Liquidation Value (balance + openPnl) - same as R Trader
-    if (pnlData.netLiquidation !== undefined) {
-      stats.netLiquidation = parseFloat(pnlData.netLiquidation);
-    } else if (stats.balance !== null) {
-      // Calculate if not provided directly
-      stats.netLiquidation = stats.balance + (stats.openPnl || 0);
-    }
-    
-    // Total P&L = openPnl (from positionUpdate) + closedPnl (from pnlUpdate)
-    // This matches R Trader's "Today's P&L" calculation
-    stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
-  });
-  
-  // Listen to position updates for real-time position tracking (like R Trader)
-  // INSTRUMENT_PNL_UPDATE (450) provides per-instrument P&L in real-time
-  service.on('positionUpdate', (pos) => {
-    if (!pos || pos.accountId !== rithmicAccountId) return;
-    if (pos.symbol !== symbolName && !pos.symbol?.includes(symbolName.replace(/[A-Z]\d+$/, ''))) return;
-    
-    // Update position info (like R Trader Positions panel)
-    const wasFlat = stats.position === 0;
-    stats.position = pos.quantity || 0;
-    stats.entryPrice = pos.averagePrice || 0;
-    currentPosition = pos.quantity || 0;
-    
-    // Track entry time when opening a new position
-    if (wasFlat && stats.position !== 0) {
-      stats.entryTime = Date.now();
-    } else if (stats.position === 0) {
-      stats.entryTime = null;
-    }
-    
-    // CRITICAL: Update Open P&L from instrument-level data (real-time, same as R Trader)
-    // pos.openPnl comes from INSTRUMENT_PNL_UPDATE (450) - this is the unrealized P&L
-    if (pos.openPnl !== undefined && pos.openPnl !== null) {
-      stats.openPnl = pos.openPnl;
-      // Recalculate total P&L whenever Open P&L changes
-      // Total P&L = openPnl + closedPnl (same formula as R Trader)
+  if (serviceHasEvents) {
+    // RITHMIC ONLY: Real-time P&L via WebSocket
+    service.on('pnlUpdate', (pnlData) => {
+      // Only update for our account
+      if (pnlData.accountId !== rithmicAccountId) return;
+      
+      // ACCOUNT_PNL_UPDATE (451) - All R Trader account-level metrics
+      if (pnlData.closedPositionPnl !== undefined) {
+        stats.closedPnl = parseFloat(pnlData.closedPositionPnl);
+      }
+      if (pnlData.accountBalance !== undefined) {
+        stats.balance = parseFloat(pnlData.accountBalance);
+      }
+      if (pnlData.availableBuyingPower !== undefined) {
+        stats.buyingPower = parseFloat(pnlData.availableBuyingPower);
+      }
+      if (pnlData.marginBalance !== undefined) {
+        stats.margin = parseFloat(pnlData.marginBalance);
+      }
+      if (pnlData.netLiquidation !== undefined) {
+        stats.netLiquidation = parseFloat(pnlData.netLiquidation);
+      } else if (stats.balance !== null) {
+        stats.netLiquidation = stats.balance + (stats.openPnl || 0);
+      }
+      
+      // Total P&L = openPnl + closedPnl (same as R Trader)
       stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
-      // Also update Net Liquidation (balance + openPnl)
-      if (stats.balance !== null) {
-        stats.netLiquidation = stats.balance + stats.openPnl;
+    });
+    
+    // RITHMIC ONLY: Real-time position updates
+    service.on('positionUpdate', (pos) => {
+      if (!pos || pos.accountId !== rithmicAccountId) return;
+      if (pos.symbol !== symbolName && !pos.symbol?.includes(symbolName.replace(/[A-Z]\d+$/, ''))) return;
+      
+      const wasFlat = stats.position === 0;
+      stats.position = pos.quantity || 0;
+      stats.entryPrice = pos.averagePrice || 0;
+      currentPosition = pos.quantity || 0;
+      
+      if (wasFlat && stats.position !== 0) {
+        stats.entryTime = Date.now();
+      } else if (stats.position === 0) {
+        stats.entryTime = null;
       }
-    }
-  });
+      
+      // Update Open P&L from INSTRUMENT_PNL_UPDATE (450)
+      if (pos.openPnl !== undefined && pos.openPnl !== null) {
+        stats.openPnl = pos.openPnl;
+        stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
+        if (stats.balance !== null) {
+          stats.netLiquidation = stats.balance + stats.openPnl;
+        }
+      }
+    });
+  }
   
   // Initialize AI Strategy Supervisor - agents observe, learn & optimize
   // Only if user enabled AI in config
@@ -869,20 +853,32 @@ const launchAlgo = async (service, account, contract, config) => {
     algoLogger.error(ui, 'CONNECTION ERROR', e.message.substring(0, 50));
   }
   
-  // Poll account P&L and sync with real trades from API (fallback, WebSocket is primary)
+  // Poll account P&L and sync with real trades from API
+  // For ProjectX: This is the PRIMARY source of P&L data (no WebSocket events)
+  // For Rithmic: This is a fallback (WebSocket events are primary)
   const pollPnL = async () => {
     try {
-      // Get account P&L (fallback if WebSocket not updating)
+      // Get account P&L
       const accountResult = await service.getTradingAccounts();
       if (accountResult.success && accountResult.accounts) {
         const acc = accountResult.accounts.find(a => a.accountId === account.accountId);
-        if (acc && acc.profitAndLoss !== undefined && acc.profitAndLoss !== null) {
-          // Use day P&L directly (same as R Trader)
-          stats.pnl = acc.profitAndLoss;
+        if (acc) {
+          // Total day P&L
+          if (acc.profitAndLoss !== undefined && acc.profitAndLoss !== null) {
+            stats.pnl = acc.profitAndLoss;
+          }
+          // Closed P&L (realized)
+          if (acc.realizedPnl !== undefined) {
+            stats.closedPnl = acc.realizedPnl;
+          }
+          // Balance
+          if (acc.balance !== undefined) {
+            stats.balance = acc.balance;
+          }
         }
       }
       
-      // Check positions - detect when position closes
+      // Check positions - get Open P&L and detect when position closes
       const posResult = await service.getPositions(account.accountId);
       if (posResult.success && posResult.positions) {
         const pos = posResult.positions.find(p => {
@@ -892,6 +888,20 @@ const launchAlgo = async (service, account, contract, config) => {
         
         const newPositionQty = pos?.quantity || 0;
         
+        // Update Open P&L from position (unrealized P&L)
+        if (pos && pos.unrealizedPnl !== undefined) {
+          stats.openPnl = pos.unrealizedPnl;
+        } else if (pos && pos.profitAndLoss !== undefined) {
+          stats.openPnl = pos.profitAndLoss;
+        } else if (newPositionQty === 0) {
+          stats.openPnl = 0; // Flat = no open P&L
+        }
+        
+        // Recalculate total P&L if we have components
+        if (stats.openPnl !== null && stats.closedPnl !== null) {
+          stats.pnl = stats.openPnl + stats.closedPnl;
+        }
+        
         // Position just closed - cancel remaining orders and log result
         if (lastPositionQty !== 0 && newPositionQty === 0) {
           // Cancel all open orders to prevent new positions

package/src/pages/algo/smart-logs.js

@@ -244,7 +244,11 @@ function getMarketBiasLog(direction, delta, ofi) {
  * Get a momentum log
  */
 function getMomentumLog(momentum, zscore) {
-  const isUp = momentum > 0;
+  // Handle undefined/NaN values
+  const mom = typeof momentum === 'number' && !isNaN(momentum) ? momentum : 0;
+  const z = typeof zscore === 'number' && !isNaN(zscore) ? zscore : 0;
+  
+  const isUp = mom > 0;
   const pool = isUp ? MOMENTUM_UP_MESSAGES : MOMENTUM_DOWN_MESSAGES;
   const category = isUp ? 'mom_up' : 'mom_down';
   const message = getVariedMessage(category, pool, isUp ? 'Momentum up' : 'Momentum down');
@@ -252,7 +256,7 @@ function getMomentumLog(momentum, zscore) {
 
   return {
     message: `${arrow} ${message}`,
-    details: `Mom=${momentum.toFixed(1)} | Z=${zscore.toFixed(2)}`,
+    details: `Mom=${mom.toFixed(1)} | Z=${z.toFixed(2)}`,
   };
 }
 
@@ -260,7 +264,10 @@ function getMomentumLog(momentum, zscore) {
  * Get a mean reversion log
  */
 function getMeanReversionLog(zscore) {
-  const isOverbought = zscore > 0;
+  // Handle undefined/NaN values
+  const z = typeof zscore === 'number' && !isNaN(zscore) ? zscore : 0;
+  
+  const isOverbought = z > 0;
   const pool = isOverbought ? OVERBOUGHT_MESSAGES : OVERSOLD_MESSAGES;
   const category = isOverbought ? 'mr_overbought' : 'mr_oversold';
   const message = getVariedMessage(category, pool, isOverbought ? 'Overbought' : 'Oversold');
@@ -268,7 +275,7 @@ function getMeanReversionLog(zscore) {
 
   return {
     message: `${arrow} ${message}`,
-    details: `Z-Score: ${zscore.toFixed(2)} | Looking for ${isOverbought ? 'SHORT' : 'LONG'}`,
+    details: `Z-Score: ${z.toFixed(2)} | Looking for ${isOverbought ? 'SHORT' : 'LONG'}`,
   };
 }