hedgequantx 2.9.247 → 2.9.249

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.9.247",
+  "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

@@ -215,32 +215,56 @@ const handleShowOrdersResponse = (service, data) => {
 
 /**
  * Handle new order response (template 313)
+ * rpCode[0] = '0' means accepted, anything else = rejected by gateway
  */
 const handleNewOrderResponse = (service, data) => {
   try {
     const res = proto.decode('ResponseNewOrder', data);
-    debug('New order response:', JSON.stringify(res));
     
-    // Emit as orderNotification for the placeOrder listener
-    // Even if no basketId, emit for rejection handling
-    const isRejected = res.rpCode?.[0] !== '0';
+    const isAccepted = res.rpCode?.[0] === '0';
+    
+    // Build rejection reason from rpCode array
+    // rpCode is typically ['code', 'message'] or just ['code']
+    let rejectReason = null;
+    if (!isAccepted) {
+      // 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 = {
-      basketId: res.basketId || res.orderId || res.userMsg?.[0] || 'unknown',
-      accountId: res.accountId,
+      basketId: res.basketId || null,
       symbol: res.symbol,
       exchange: res.exchange || 'CME',
-      status: isRejected ? 5 : 2, // 2=Working, 5=Rejected
-      notifyType: isRejected ? 0 : 1, // 1=Accepted
+      notifyType: isAccepted ? 1 : 6, // 1=STATUS (accepted), 6=REJECT
+      status: isAccepted ? 2 : 6,
+      text: rejectReason,
       rpCode: res.rpCode,
-      rqHandlerRpCode: res.rqHandlerRpCode, // Also include request handler response code
       userMsg: res.userMsg,
     };
     service.emit('orderNotification', order);
-    
-    // Also emit specific event
     service.emit('newOrderResponse', res);
   } catch (e) {
-    debug('Error decoding ResponseNewOrder:', e.message);
+    console.error('Error decoding ResponseNewOrder:', e.message);
   }
 };
 
@@ -369,12 +393,50 @@ const handleAccountRmsInfo = (service, data) => {
 
 /**
  * Handle exchange order notification (fills/trades)
- * NotifyType: 5 = FILL
+ * NotifyType: 1=STATUS, 2=MODIFY, 3=CANCEL, 4=TRIGGER, 5=FILL, 6=REJECT
  */
 const handleExchangeNotification = (service, data) => {
   try {
     const res = proto.decode('ExchangeOrderNotification', data);
-    debug('Exchange notification:', res.notifyType, res.symbol);
+    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 = {
+      basketId: res.basketId,
+      accountId: res.accountId,
+      symbol: res.symbol,
+      exchange: res.exchange || 'CME',
+      notifyType: res.notifyType, // 1=STATUS, 5=FILL, 6=REJECT
+      status: res.notifyType === 5 ? 3 : res.notifyType === 6 ? 6 : 2,
+      fillPrice: res.fillPrice ? parseFloat(res.fillPrice) : null,
+      fillSize: res.fillSize ? parseInt(res.fillSize) : null,
+      avgFillPrice: res.avgFillPrice ? parseFloat(res.avgFillPrice) : null,
+      totalFillSize: res.totalFillSize ? parseInt(res.totalFillSize) : null,
+      confirmedSize: res.confirmedSize ? parseInt(res.confirmedSize) : null,
+      text: rejectText,
+      userMsg: res.userTag ? [res.userTag] : null,
+    };
+    service.emit('orderNotification', orderNotif);
     
     // notifyType 5 = FILL (trade executed)
     if (res.notifyType === 5 && res.fillPrice && res.fillSize) {

package/src/services/rithmic/orders.js

@@ -125,72 +125,83 @@ const placeOrder = async (service, orderData) => {
     }, ORDER_TIMEOUTS.PLACE);
 
     const onNotification = (order) => {
-      // HFT: Fast match by orderTag first (most specific)
-      const orderMatches = (order.userMsg && order.userMsg.includes(orderTag)) || 
-                          order.symbol === orderData.symbol;
+      // Match by symbol
+      if (order.symbol !== orderData.symbol) return;
       
-      if (orderMatches) {
+      const notifyType = order.notifyType;
+      
+      // FILL (notifyType 5) - Order executed
+      if (notifyType === 5) {
         clearTimeout(timeout);
         service.removeListener('orderNotification', onNotification);
-        
-        // HFT: Combined status check (2=Working, 3=Filled, 15=Complete)
-        const status = order.status;
-        if (status === 2 || status === 3 || order.notifyType === 15) {
-          resolve({
-            success: true,
-            orderId: order.basketId,
-            status,
-            fillPrice: order.avgFillPrice || orderData.price,
-            filledQty: order.totalFillSize || orderData.size,
-            orderTag,
-          });
-        } else if (status === 5 || status === 6) {
-          // Extract rejection reason from rpCode[1] or rqHandlerRpCode[1]
-          const rpCode = order.rpCode;
-          const rqCode = order.rqHandlerRpCode;
-          let errorMsg = `Order rejected: status ${status}`;
-          
-          // Try rpCode first, then rqHandlerRpCode
-          if (rpCode && Array.isArray(rpCode) && rpCode.length > 1 && rpCode[1]) {
-            errorMsg = `Rejected: ${rpCode[1]}`;
-          } else if (rqCode && Array.isArray(rqCode) && rqCode.length > 1 && rqCode[1]) {
-            errorMsg = `Rejected: ${rqCode[1]}`;
-          } else if (rpCode && Array.isArray(rpCode) && rpCode[0] && rpCode[0] !== '0') {
-            errorMsg = `Rejected: code ${rpCode[0]}`;
-          }
-          
-          resolve({
-            success: false,
-            error: errorMsg,
-            orderId: order.basketId,
-            orderTag,
-            rpCode,
-            rqHandlerRpCode: rqCode,
-          });
+        resolve({
+          success: true,
+          orderId: order.basketId,
+          status: 3,
+          fillPrice: order.avgFillPrice || order.fillPrice || orderData.price,
+          filledQty: order.totalFillSize || order.fillSize || orderData.size,
+          orderTag,
+        });
+        return;
+      }
+      
+      // REJECT (notifyType 6) - Order rejected
+      if (notifyType === 6) {
+        clearTimeout(timeout);
+        service.removeListener('orderNotification', onNotification);
+        resolve({
+          success: false,
+          error: order.text || 'Order rejected',
+          orderId: order.basketId,
+          orderTag,
+        });
+        return;
+      }
+      
+      // STATUS (notifyType 1) with basketId - Order accepted by gateway
+      if (notifyType === 1 && order.basketId) {
+        // For market orders, wait a bit more for fill notification
+        // For limit orders, this is success (working)
+        if (orderData.type === 2) {
+          // Market order - don't resolve yet, wait for fill
+          return;
         }
+        clearTimeout(timeout);
+        service.removeListener('orderNotification', onNotification);
+        resolve({
+          success: true,
+          orderId: order.basketId,
+          status: 2,
+          fillPrice: orderData.price,
+          filledQty: 0,
+          orderTag,
+        });
+        return;
       }
     };
 
     service.on('orderNotification', onNotification);
 
-    // HFT: Inline order request construction (no try-catch in hot path)
     const exchange = orderData.exchange || 'CME';
     
-    // Get trade route from cache
+    // CRITICAL: Get trade route - orders WILL BE REJECTED without it
     let tradeRoute = null;
     const routes = service.tradeRoutes;
     if (routes && routes.size > 0) {
       const routeInfo = routes.get(exchange);
-      tradeRoute = routeInfo ? routeInfo.tradeRoute : 
-                   routes.values().next().value?.tradeRoute || null;
+      tradeRoute = routeInfo?.tradeRoute || routes.values().next().value?.tradeRoute;
     }
     
-    // Warn if no trade route - Rithmic will reject the order
+    // FAIL FAST if no trade route
     if (!tradeRoute) {
-      DEBUG && console.log('[Orders] WARNING: No trade route for', exchange, '- order may be rejected');
+      clearTimeout(timeout);
+      service.removeListener('orderNotification', onNotification);
+      console.log('[Orders] ERROR: No trade route for', exchange);
+      resolve({ success: false, error: `No trade route for ${exchange}. Login may be incomplete.`, orderTag });
+      return;
     }
     
-    // HFT: Reuse template and mutate (faster than object spread)
+    // Build order request
     ORDER_REQUEST_TEMPLATE.userMsg[0] = orderTag;
     ORDER_REQUEST_TEMPLATE.fcmId = service.loginInfo.fcmId;
     ORDER_REQUEST_TEMPLATE.ibId = service.loginInfo.ibId;