hedgequantx 2.6.41 → 2.6.43

package/package.json

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

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

@@ -362,6 +362,33 @@ 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
+  // ═══════════════════════════════════════════════════════════════════════════
+  const rithmicAccountId = account.rithmicAccountId || account.accountId;
+  
+  service.on('pnlUpdate', (pnlData) => {
+    // Only update for our account
+    if (pnlData.accountId !== rithmicAccountId) return;
+    
+    // Calculate P&L exactly like R Trader: openPositionPnl + closedPositionPnl
+    const openPnl = parseFloat(pnlData.openPositionPnl || 0);
+    const closedPnl = parseFloat(pnlData.closedPositionPnl || 0);
+    
+    // R Trader "Today's P&L" = unrealized + realized
+    stats.pnl = openPnl + closedPnl;
+  });
+  
+  // Also listen to position updates for real-time position tracking
+  service.on('positionUpdate', (pos) => {
+    if (!pos || pos.accountId !== rithmicAccountId) return;
+    if (pos.symbol !== symbolName && !pos.symbol?.includes(symbolName.replace(/[A-Z]\d+$/, ''))) return;
+    
+    // Update current position from WebSocket
+    currentPosition = pos.quantity || 0;
+  });
+  
   // Initialize AI Strategy Supervisor - agents observe, learn & optimize
   // Only if user enabled AI in config
   let aiAgentCount = 0;
@@ -716,16 +743,16 @@ 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
+  // Poll account P&L and sync with real trades from API (fallback, WebSocket is primary)
   const pollPnL = async () => {
     try {
-      // Get account P&L
+      // Get account P&L (fallback if WebSocket not updating)
       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) {
-          if (startingPnL === null) startingPnL = acc.profitAndLoss;
-          stats.pnl = acc.profitAndLoss - startingPnL;
+        if (acc && acc.profitAndLoss !== undefined && acc.profitAndLoss !== null) {
+          // Use day P&L directly (same as R Trader)
+          stats.pnl = acc.profitAndLoss;
         }
       }
       
@@ -828,8 +855,9 @@ const launchAlgo = async (service, account, contract, config) => {
   };
   
   // Start polling and UI refresh
+  // UI refreshes every 250ms, P&L polling every 10s (WebSocket is primary for P&L)
   const refreshInterval = setInterval(() => { if (running) ui.render(stats); }, 250);
-  const pnlInterval = setInterval(() => { if (running) pollPnL(); }, 2000);
+  const pnlInterval = setInterval(() => { if (running) pollPnL(); }, 10000);
   pollPnL(); // Initial poll
   
   // Keyboard handler

package/src/services/rithmic/accounts.js

@@ -115,15 +115,22 @@ const getTradingAccounts = async (service) => {
     const closedPnL = pnlData.closedPositionPnl ? parseFloat(pnlData.closedPositionPnl) : null;
     const dayPnL = pnlData.dayPnl ? parseFloat(pnlData.dayPnl) : null;
 
+    // Calculate P&L like R Trader: openPositionPnl + closedPositionPnl
+    // This matches what R Trader shows as "Today's P&L"
+    const totalPnL = (openPnL !== null || closedPnL !== null) 
+      ? (openPnL || 0) + (closedPnL || 0) 
+      : null;
+
     return {
       accountId: hashAccountId(acc.accountId),
       rithmicAccountId: acc.accountId,
       accountName: acc.accountId,  // Never expose real name - only account ID
       name: acc.accountId,         // Never expose real name - only account ID
       balance: accountBalance,
-      profitAndLoss: dayPnL !== null ? dayPnL : (openPnL !== null || closedPnL !== null ? (openPnL || 0) + (closedPnL || 0) : null),
+      profitAndLoss: totalPnL,  // Same as R Trader: open + closed
       openPnL: openPnL,
-      todayPnL: closedPnL,
+      closedPnL: closedPnL,
+      dayPnL: dayPnL,  // Keep for reference
       status: 0,
       platform: 'Rithmic',
       propfirm: service.propfirm.name,

package/src/services/rithmic/handlers.js

@@ -529,20 +529,14 @@ const handleOrderNotification = (service, data) => {
       const actualFillQty = fillInfo.totalFillQuantity || fillInfo.fillQuantity || notif.quantity || 0;
       const fillPrice = fillInfo.avgFillPrice || fillInfo.lastFillPrice || 0;
       
-      console.log(`[FILL] Received: ${orderTag} | ${fillInfo.transactionType === 1 ? 'BUY' : 'SELL'} ${actualFillQty}x @ ${fillPrice} | latency=${roundTripLatency}ms`);
-      
-      debug('ORDER FILLED:', {
-        orderTag,
-        side: fillInfo.transactionType === 1 ? 'BUY' : 'SELL',
-        qty: actualFillQty,
-        avgPrice: fillPrice,
-        latencyMs: roundTripLatency,
-      });
+      // Debug only - UI handles display via orderFilled event
+      debug('FILL Received:', orderTag, fillInfo.transactionType === 1 ? 'BUY' : 'SELL', actualFillQty, '@', fillPrice, 'latency:', roundTripLatency, 'ms');
       
       // Clone for fill event (async handlers may need to keep the data)
       service.emit('orderFilled', FillInfoPool.clone(fillInfo));
     } else {
-      console.log(`[ORDER STATUS] ${orderTag} | status=${fillInfo.status} text=${fillInfo.text || 'N/A'}`);
+      // Debug only - UI handles display via orderNotification event
+      debug('ORDER STATUS:', orderTag, 'status:', fillInfo.status, 'text:', fillInfo.text || 'N/A');
     }
   } catch (e) {
     debug('Error decoding order notification:', e.message);

package/src/services/rithmic/orders.js

@@ -135,8 +135,8 @@ const fastEntry = (service, orderData) => {
     const orderWithRoute = { ...orderData, tradeRoute };
     const order = OrderPool.fill(orderTag, effectiveLoginInfo, orderWithRoute);
     
-    // DEBUG: Log order details
-    console.log(`[ORDER] Sending: ${orderTag} | ${orderData.side === 0 ? 'BUY' : 'SELL'} ${orderData.size}x ${orderData.symbol} | acct=${orderData.accountId} | route=${tradeRoute}`);
+    // Debug only - UI handles display via events
+    debug('ORDER Sending:', orderTag, orderData.side === 0 ? 'BUY' : 'SELL', orderData.size, 'x', orderData.symbol, 'acct:', orderData.accountId, 'route:', tradeRoute);
     
     // OPTIMIZED: Use fastEncode with cached type
     const buffer = proto.fastEncode('RequestNewOrder', order);
@@ -150,7 +150,7 @@ const fastEntry = (service, orderData) => {
       service.orderConn.fastSend(buffer);
     }
     
-    console.log(`[ORDER] Sent to Rithmic: ${orderTag} | buffer=${buffer.length} bytes`);
+    debug('ORDER Sent to Rithmic:', orderTag, 'buffer:', buffer.length, 'bytes');
     
     // Track for round-trip latency measurement
     LatencyTracker.recordEntry(orderTag, entryTime);