hedgequantx 2.9.248 → 2.9.249

package/package.json

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

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

@@ -118,6 +118,32 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   }
   ui.addLog('system', 'Connecting to market data...');
   
+  // Listen for position updates from Rithmic (external closes, manual trades)
+  const accId = account.rithmicAccountId || account.accountId;
+  service.on('positionUpdate', (pos) => {
+    // Match by account and symbol
+    const posSymbol = pos.contractId || pos.symbol || '';
+    const matchesSymbol = posSymbol.includes(contract.name) || posSymbol.includes(contractId) || 
+                          posSymbol === symbolCode || contractId.includes(posSymbol);
+    const matchesAccount = pos.accountId === accId || pos.accountId === account.accountId;
+    
+    if (matchesSymbol && matchesAccount) {
+      const qty = parseInt(pos.quantity) || 0;
+      if (!isNaN(qty) && Math.abs(qty) < 1000 && qty !== currentPosition) {
+        const oldPos = currentPosition;
+        currentPosition = qty;
+        if (qty === 0 && oldPos !== 0) {
+          ui.addLog('trade', `Position closed externally (was ${oldPos})`);
+          sessionLogger.log('POSITION', `External close: ${oldPos} -> 0`);
+          pendingOrder = false;  // Reset pending order flag
+        } else if (qty !== 0 && oldPos === 0) {
+          ui.addLog('trade', `Position opened externally: ${qty}`);
+          sessionLogger.log('POSITION', `External open: 0 -> ${qty}`);
+        }
+      }
+    }
+  });
+  
   strategy.on('signal', async (signal) => {
     const dir = signal.direction?.toUpperCase() || 'UNKNOWN';
     const signalLog = smartLogs.getSignalLog(dir, symbolCode, (signal.confidence || 0) * 100, strategyName);

package/src/services/daemon/proxy.js

@@ -45,6 +45,9 @@ class DaemonProxyService extends EventEmitter {
     
     /** @type {Object|null} Credentials for direct mode */
     this.credentials = null;
+    
+    /** @type {Map<string, Object>} Cached P&L data for daemon mode */
+    this._pnlCache = new Map();
   }
   
   /**
@@ -192,7 +195,20 @@ class DaemonProxyService extends EventEmitter {
     
     client.on('orderUpdate', (data) => this.emit('orderUpdate', data));
     client.on('positionUpdate', (data) => this.emit('positionUpdate', data));
-    client.on('pnlUpdate', (data) => this.emit('pnlUpdate', data));
+    
+    // Cache P&L data for sync getAccountPnL calls
+    client.on('pnlUpdate', (data) => {
+      if (data && data.accountId) {
+        this._pnlCache.set(data.accountId, {
+          pnl: data.dayPnl ?? data.pnl ?? null,
+          openPnl: data.openPositionPnl ?? data.openPnl ?? null,
+          closedPnl: data.closedPositionPnl ?? data.closedPnl ?? null,
+          balance: data.accountBalance ?? data.balance ?? null,
+        });
+      }
+      this.emit('pnlUpdate', data);
+    });
+    
     client.on('fill', (data) => this.emit('fill', data));
     client.on('marketData', (data) => this.emit('marketData', data));
     client.on('rithmicDisconnected', (data) => this.emit('disconnected', data));
@@ -248,8 +264,15 @@ class DaemonProxyService extends EventEmitter {
     if (!this._backend) return { pnl: null, openPnl: null, closedPnl: null, balance: null };
     
     if (this._mode === 'daemon') {
-      // For daemon, we need to make async call but this is sync interface
-      // Return cached value or null
+      // Return cached P&L from pnlUpdate events
+      const cached = this._pnlCache.get(accountId);
+      if (cached) return cached;
+      
+      // Try without account ID (some events don't include it)
+      if (this._pnlCache.size === 1) {
+        return this._pnlCache.values().next().value;
+      }
+      
       return { pnl: null, openPnl: null, closedPnl: null, balance: null };
     }
     return this._backend.getAccountPnL(accountId);

package/src/services/rithmic/handlers.js

@@ -222,11 +222,33 @@ const handleNewOrderResponse = (service, data) => {
     const res = proto.decode('ResponseNewOrder', data);
     
     const isAccepted = res.rpCode?.[0] === '0';
-    const rejectReason = res.rpCode?.[1] || res.rqHandlerRpCode?.[1] || 'Unknown';
     
-    // Log rejection details for debugging
+    // Build rejection reason from rpCode array
+    // rpCode is typically ['code', 'message'] or just ['code']
+    let rejectReason = null;
     if (!isAccepted) {
-      console.log('[Rithmic] Order rejected:', rejectReason, '| rpCode:', res.rpCode, '| rqHandlerRpCode:', res.rqHandlerRpCode);
+      // Try to get the error message from rpCode[1] or rqHandlerRpCode[1]
+      const rpMsg = res.rpCode?.slice(1).join(' ') || '';
+      const rqMsg = res.rqHandlerRpCode?.slice(1).join(' ') || '';
+      rejectReason = rpMsg || rqMsg || null;
+      
+      // If no message, interpret the code
+      if (!rejectReason && res.rpCode?.[0]) {
+        const codeMap = {
+          '1': 'Invalid request',
+          '2': 'Invalid account',
+          '3': 'Invalid symbol',
+          '4': 'Invalid quantity',
+          '5': 'Insufficient buying power',
+          '6': 'Market closed',
+          '7': 'Order rejected by risk system',
+          '8': 'Position limit exceeded',
+          '9': 'Rate limit exceeded',
+        };
+        rejectReason = codeMap[res.rpCode[0]] || `Gateway rejected (code: ${res.rpCode[0]})`;
+      }
+      
+      console.log('[Rithmic] Gateway rejection:', rejectReason, '| rpCode:', res.rpCode, '| rqHandlerRpCode:', res.rqHandlerRpCode);
     }
     
     const order = {
@@ -235,7 +257,7 @@ const handleNewOrderResponse = (service, data) => {
       exchange: res.exchange || 'CME',
       notifyType: isAccepted ? 1 : 6, // 1=STATUS (accepted), 6=REJECT
       status: isAccepted ? 2 : 6,
-      text: isAccepted ? null : rejectReason,
+      text: rejectReason,
       rpCode: res.rpCode,
       userMsg: res.userMsg,
     };
@@ -378,6 +400,25 @@ const handleExchangeNotification = (service, data) => {
     const res = proto.decode('ExchangeOrderNotification', data);
     debug('Exchange notification:', res.notifyType, res.symbol, res.status);
     
+    // Build rejection text from available fields
+    // Priority: text > reportText > remarks > status code interpretation
+    let rejectText = res.text || res.reportText || res.remarks || null;
+    if (!rejectText && res.notifyType === 6) {
+      // Map common Rithmic status codes to human-readable messages
+      const statusMap = {
+        '1': 'Order pending',
+        '2': 'Order working',
+        '3': 'Order filled',
+        '4': 'Order partially filled',
+        '5': 'Order rejected by exchange',
+        '6': 'Order cancelled',
+        '7': 'Order expired',
+        '8': 'Order suspended',
+      };
+      rejectText = statusMap[res.status] || `Exchange rejected (code: ${res.status || 'unknown'})`;
+      console.log('[Rithmic] Exchange rejection:', rejectText, '| status:', res.status, '| symbol:', res.symbol);
+    }
+    
     // Emit orderNotification for placeOrder listener
     // This is critical for order tracking
     const orderNotif = {
@@ -392,7 +433,7 @@ const handleExchangeNotification = (service, data) => {
       avgFillPrice: res.avgFillPrice ? parseFloat(res.avgFillPrice) : null,
       totalFillSize: res.totalFillSize ? parseInt(res.totalFillSize) : null,
       confirmedSize: res.confirmedSize ? parseInt(res.confirmedSize) : null,
-      text: res.text || res.reportText,
+      text: rejectText,
       userMsg: res.userTag ? [res.userTag] : null,
     };
     service.emit('orderNotification', orderNotif);