hedgequantx 2.9.246 → 2.9.248

package/package.json

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

package/src/pages/algo/ui.js

@@ -77,47 +77,37 @@ const center = (text, width) => {
 
 /**
  * Fit text to exact width (truncate or pad)
- * Ensures output is EXACTLY width characters (visible)
+ * Ensures output is EXACTLY width visible characters
  */
 const fitToWidth = (text, width) => {
   const plain = stripAnsi(text);
   
-  if (plain.length > width) {
-    // Need to truncate - find cut point accounting for ANSI codes
-    let visibleCount = 0;
-    let cutIndex = 0;
-    let inAnsi = false;
-    
-    for (let i = 0; i < text.length; i++) {
-      if (text[i] === '\x1B') {
-        inAnsi = true;
-      } else if (inAnsi && text[i] === 'm') {
-        inAnsi = false;
-      } else if (!inAnsi) {
-        visibleCount++;
-        if (visibleCount >= width - 2) {
-          cutIndex = i + 1;
-          break;
-        }
+  if (plain.length <= width) {
+    // Pad to exact width
+    return text + ' '.repeat(width - plain.length);
+  }
+  
+  // Need to truncate to (width - 2) visible chars, then add ".."
+  const targetLen = width - 2;
+  let visibleCount = 0;
+  let cutIndex = 0;
+  let i = 0;
+  
+  while (i < text.length && visibleCount < targetLen) {
+    if (text[i] === '\x1B') {
+      // Skip entire ANSI sequence
+      while (i < text.length && text[i] !== 'm') {
+        i++;
       }
-      cutIndex = i + 1;
-    }
-    
-    // Truncate and add ".." (2 chars to stay within width)
-    const truncated = text.substring(0, cutIndex);
-    const truncatedPlain = stripAnsi(truncated);
-    const remaining = width - truncatedPlain.length;
-    
-    if (remaining >= 2) {
-      return truncated + '..' + ' '.repeat(remaining - 2);
-    } else if (remaining > 0) {
-      return truncated + ' '.repeat(remaining);
+      i++; // skip 'm'
+    } else {
+      visibleCount++;
+      i++;
     }
-    return truncated;
+    cutIndex = i;
   }
   
-  // Pad to exact width
-  return text + ' '.repeat(width - plain.length);
+  return text.substring(0, cutIndex) + '..';
 };
 
 /**

package/src/services/rithmic/handlers.js

@@ -215,32 +215,34 @@ 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';
+    const rejectReason = res.rpCode?.[1] || res.rqHandlerRpCode?.[1] || 'Unknown';
+    
+    // Log rejection details for debugging
+    if (!isAccepted) {
+      console.log('[Rithmic] Order rejected:', 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: isAccepted ? null : 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 +371,31 @@ 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);
+    
+    // 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: res.text || res.reportText,
+      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;