hedgequantx 2.9.194 → 2.9.196

package/package.json

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

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

@@ -395,7 +395,11 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
             return sym.includes(contract.name) || sym.includes(contractId);
           });
           if (pos && pos.quantity !== 0) {
-            currentPosition = pos.quantity;
+            // Validate quantity is reasonable (prevent overflow values)
+            const qty = parseInt(pos.quantity);
+            if (!isNaN(qty) && Math.abs(qty) < 1000) {
+              currentPosition = qty;
+            }
           } else {
             currentPosition = 0;
           }
@@ -488,22 +492,92 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   clearInterval(pnlInterval);
   clearInterval(liveLogInterval);
   
-  // Flatten any open position before stopping
-  if (currentPosition !== 0) {
-    ui.addLog('system', `Flattening position: ${currentPosition > 0 ? 'LONG' : 'SHORT'} ${Math.abs(currentPosition)}`);
-    sessionLogger.log('EXIT', `Flattening position: ${currentPosition}`);
+  // ============================================================
+  // EMERGENCY FLATTEN - ULTRA SOLID
+  // 1. Cancel ALL pending orders
+  // 2. Exit position via Rithmic API
+  // 3. Fallback: Market order to flatten
+  // 4. Verify position is flat
+  // ============================================================
+  
+  const accountId = account.rithmicAccountId || account.accountId;
+  const exchange = contract.exchange || 'CME';
+  
+  ui.addLog('system', 'Stopping algo - cancelling orders...');
+  sessionLogger.log('EXIT', 'Emergency flatten initiated');
+  
+  // STEP 1: Cancel ALL pending orders
+  try {
+    if (service.cancelAllOrders) {
+      await service.cancelAllOrders(accountId);
+      ui.addLog('system', 'All pending orders cancelled');
+      sessionLogger.log('EXIT', 'All orders cancelled');
+    }
+  } catch (e) {
+    sessionLogger.log('EXIT', `Cancel orders error: ${e.message}`);
+  }
+  
+  // Wait for cancellations to process
+  await new Promise(r => setTimeout(r, 1000));
+  
+  // STEP 2: Try Rithmic's native ExitPosition first
+  try {
+    if (service.exitPosition) {
+      ui.addLog('system', 'Exiting position via Rithmic...');
+      const exitResult = await service.exitPosition(accountId, symbolCode, exchange);
+      if (exitResult.success) {
+        ui.addLog('system', 'Exit position command sent');
+        sessionLogger.log('EXIT', 'ExitPosition sent to Rithmic');
+      }
+    }
+  } catch (e) {
+    sessionLogger.log('EXIT', `ExitPosition error: ${e.message}`);
+  }
+  
+  // Wait for exit to process
+  await new Promise(r => setTimeout(r, 2000));
+  
+  // STEP 3: Verify position and flatten with market order if needed
+  let positionToFlatten = 0;
+  try {
+    const posResult = await service.getPositions(accountId);
+    if (posResult.success && posResult.positions) {
+      const pos = posResult.positions.find(p => {
+        const sym = p.contractId || p.symbol || '';
+        return sym.includes(symbolCode) || sym.includes(contract.name) || sym.includes(contract.baseSymbol);
+      });
+      if (pos && pos.quantity) {
+        const qty = parseInt(pos.quantity);
+        // Validate quantity is reasonable (not overflow - max 100 contracts)
+        if (!isNaN(qty) && qty !== 0 && Math.abs(qty) <= 100) {
+          positionToFlatten = qty;
+        }
+      }
+    }
+  } catch (e) {
+    sessionLogger.log('EXIT', `Get positions error: ${e.message}`);
+  }
+  
+  // STEP 4: Market order flatten if position still open
+  if (positionToFlatten !== 0) {
+    const side = positionToFlatten > 0 ? 'LONG' : 'SHORT';
+    const size = Math.abs(positionToFlatten);
+    ui.addLog('system', `Flattening ${side} ${size} @ market...`);
+    sessionLogger.log('EXIT', `Market flatten: ${side} ${size}`);
+    
     try {
       const flattenResult = await service.placeOrder({
-        accountId: account.rithmicAccountId || account.accountId,
+        accountId: accountId,
         symbol: symbolCode,
-        exchange: contract.exchange || 'CME',
-        type: 2, // Market
-        side: currentPosition > 0 ? 1 : 0, // Sell if long, Buy if short
-        size: Math.abs(currentPosition)
+        exchange: exchange,
+        type: 2, // Market order
+        side: positionToFlatten > 0 ? 1 : 0, // Sell if long, Buy if short
+        size: size
       });
+      
       if (flattenResult.success) {
-        ui.addLog('fill_' + (currentPosition > 0 ? 'sell' : 'buy'), `Position flattened @ market`);
-        sessionLogger.log('EXIT', `Position flattened successfully`);
+        ui.addLog('fill_' + (positionToFlatten > 0 ? 'sell' : 'buy'), `Position flattened @ market`);
+        sessionLogger.log('EXIT', 'Position flattened successfully');
       } else {
         ui.addLog('error', `Flatten failed: ${flattenResult.error}`);
         sessionLogger.log('EXIT', `Flatten failed: ${flattenResult.error}`);
@@ -512,8 +586,32 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
       ui.addLog('error', `Flatten error: ${e.message}`);
       sessionLogger.log('EXIT', `Flatten error: ${e.message}`);
     }
+    
     // Wait for fill
     await new Promise(r => setTimeout(r, 2000));
+    
+    // STEP 5: Final verification
+    try {
+      const verifyResult = await service.getPositions(accountId);
+      if (verifyResult.success && verifyResult.positions) {
+        const pos = verifyResult.positions.find(p => {
+          const sym = p.contractId || p.symbol || '';
+          return sym.includes(symbolCode);
+        });
+        if (pos && pos.quantity && Math.abs(parseInt(pos.quantity)) > 0 && Math.abs(parseInt(pos.quantity)) <= 100) {
+          ui.addLog('error', `WARNING: Position still open! Qty: ${pos.quantity}`);
+          sessionLogger.log('EXIT', `WARNING: Position NOT flat! Qty: ${pos.quantity}`);
+        } else {
+          ui.addLog('system', 'Position verified flat');
+          sessionLogger.log('EXIT', 'Position verified flat');
+        }
+      }
+    } catch (e) {
+      // Ignore verification errors
+    }
+  } else {
+    ui.addLog('system', 'No position to flatten');
+    sessionLogger.log('EXIT', 'No position to flatten');
   }
   
   await marketFeed.disconnect();

package/src/services/rithmic/index.js

@@ -17,7 +17,7 @@ const {
   getPositions,
   fetchTradeRoutes,
 } = require('./accounts');
-const { placeOrder, cancelOrder, getOrders, getOrderHistory, getOrderHistoryDates, getTradeHistoryFull, closePosition } = require('./orders');
+const { placeOrder, cancelOrder, cancelAllOrders, exitPosition, getOrders, getOrderHistory, getOrderHistoryDates, getTradeHistoryFull, closePosition } = require('./orders');
 const { fillsToRoundTrips, calculateTradeStats } = require('./trades');
 const { getContracts, searchContracts } = require('./contracts');
 const { handleAutoReconnect } = require('./reconnect');
@@ -320,6 +320,8 @@ class RithmicService extends EventEmitter {
   async getTradeHistoryFull(days) { return getTradeHistoryFull(this, days); }
   async placeOrder(orderData) { return placeOrder(this, orderData); }
   async cancelOrder(orderId) { return cancelOrder(this, orderId); }
+  async cancelAllOrders(accountId) { return cancelAllOrders(this, accountId); }
+  async exitPosition(accountId, symbol, exchange) { return exitPosition(this, accountId, symbol, exchange); }
   async closePosition(accountId, symbol) { return closePosition(this, accountId, symbol); }
   async getContracts() { return getContracts(this); }
   async searchContracts(searchText) { return searchContracts(this, searchText); }

package/src/services/rithmic/orders.js

@@ -473,9 +473,112 @@ const closePosition = async (service, accountId, symbol) => {
   });
 };
 
+/**
+ * Cancel all orders for an account
+ * Uses RequestCancelAllOrders (template 346)
+ * @param {RithmicService} service - The Rithmic service instance
+ * @param {string} accountId - Account ID
+ */
+const cancelAllOrders = async (service, accountId) => {
+  if (!service.orderConn || !service.loginInfo) {
+    return { success: false, error: 'Not connected' };
+  }
+
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      resolve({ success: true, message: 'Cancel all orders sent' });
+    }, 3000);
+
+    try {
+      service.orderConn.send('RequestCancelAllOrders', {
+        templateId: REQ.CANCEL_ALL_ORDERS,
+        userMsg: ['HQX-FLATTEN'],
+        fcmId: service.loginInfo.fcmId,
+        ibId: service.loginInfo.ibId,
+        accountId: accountId,
+      });
+      
+      // Listen for response
+      const handler = (msg) => {
+        if (msg.templateId === 347) { // ResponseCancelAllOrders
+          clearTimeout(timeout);
+          service.orderConn.removeListener('message', handler);
+          resolve({ success: true, message: 'All orders cancelled' });
+        }
+      };
+      service.orderConn.on('message', handler);
+      
+    } catch (error) {
+      clearTimeout(timeout);
+      resolve({ success: false, error: error.message });
+    }
+  });
+};
+
+/**
+ * Exit position using Rithmic's ExitPosition request
+ * Uses RequestExitPosition (template 3504)
+ * @param {RithmicService} service - The Rithmic service instance
+ * @param {string} accountId - Account ID  
+ * @param {string} symbol - Symbol to exit
+ * @param {string} exchange - Exchange (default CME)
+ */
+const exitPosition = async (service, accountId, symbol, exchange = 'CME') => {
+  if (!service.orderConn || !service.loginInfo) {
+    return { success: false, error: 'Not connected' };
+  }
+
+  // Get trade route
+  let tradeRoute = null;
+  if (service.tradeRoutes && service.tradeRoutes.size > 0) {
+    const routeInfo = service.tradeRoutes.get(exchange);
+    if (routeInfo) {
+      tradeRoute = routeInfo.tradeRoute;
+    } else {
+      const firstRoute = service.tradeRoutes.values().next().value;
+      if (firstRoute) tradeRoute = firstRoute.tradeRoute;
+    }
+  }
+
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      resolve({ success: true, message: 'Exit position sent' });
+    }, 5000);
+
+    try {
+      service.orderConn.send('RequestExitPosition', {
+        templateId: REQ.EXIT_POSITION,
+        userMsg: ['HQX-EXIT'],
+        fcmId: service.loginInfo.fcmId,
+        ibId: service.loginInfo.ibId,
+        accountId: accountId,
+        symbol: symbol,
+        exchange: exchange,
+        tradeRoute: tradeRoute,
+      });
+      
+      // Listen for response
+      const handler = (msg) => {
+        if (msg.templateId === 3505) { // ResponseExitPosition
+          clearTimeout(timeout);
+          service.orderConn.removeListener('message', handler);
+          resolve({ success: true, message: 'Position exit sent' });
+        }
+      };
+      service.orderConn.on('message', handler);
+      
+    } catch (error) {
+      clearTimeout(timeout);
+      resolve({ success: false, error: error.message });
+    }
+  });
+};
+
 module.exports = {
   placeOrder,
   cancelOrder,
+  cancelAllOrders,
+  exitPosition,
   getOrders,
   getOrderHistory,
   getOrderHistoryDates,