hedgequantx 2.9.240 → 2.9.242

package/package.json

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

package/src/services/daemon/client.js

@@ -43,6 +43,21 @@ class DaemonClient extends EventEmitter {
     
     /** @type {Object|null} Cached daemon info */
     this.daemonInfo = null;
+    
+    /** @type {boolean} Auto-reconnect enabled */
+    this.autoReconnect = true;
+    
+    /** @type {number} Reconnect attempts */
+    this.reconnectAttempts = 0;
+    
+    /** @type {number} Max reconnect attempts */
+    this.maxReconnectAttempts = 10;
+    
+    /** @type {NodeJS.Timeout|null} Reconnect timer */
+    this.reconnectTimer = null;
+    
+    /** @type {boolean} Intentionally disconnecting */
+    this._disconnecting = false;
   }
   
   /**
@@ -64,6 +79,9 @@ class DaemonClient extends EventEmitter {
           this.daemonInfo = await this._request(MSG_TYPE.HANDSHAKE, null, TIMEOUTS.HANDSHAKE);
           log.debug('Handshake complete', this.daemonInfo);
           
+          // Reset reconnect attempts on successful connection
+          this.reconnectAttempts = 0;
+          
           // Start ping interval
           this._startPing();
           
@@ -84,8 +102,14 @@ class DaemonClient extends EventEmitter {
       
       this.socket.on('close', () => {
         log.debug('Disconnected from daemon');
+        const wasConnected = this.connected;
         this._cleanup();
         this.emit('disconnected');
+        
+        // Auto-reconnect if enabled and not intentionally disconnecting
+        if (wasConnected && this.autoReconnect && !this._disconnecting) {
+          this._scheduleReconnect();
+        }
       });
       
       this.socket.on('error', (err) => {
@@ -113,16 +137,28 @@ class DaemonClient extends EventEmitter {
   
   /**
    * Disconnect from daemon
+   * @param {boolean} [permanent=false] - If true, disable auto-reconnect
    */
-  disconnect() {
+  disconnect(permanent = false) {
+    this._disconnecting = true;
+    if (permanent) {
+      this.autoReconnect = false;
+    }
+    
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    
     if (this.socket) {
       this.socket.destroy();
     }
     this._cleanup();
+    this._disconnecting = false;
   }
   
   /**
-   * Cleanup state
+   * Cleanup state (does NOT clear reconnect state)
    */
   _cleanup() {
     this.connected = false;
@@ -137,6 +173,18 @@ class DaemonClient extends EventEmitter {
     this.socket = null;
   }
   
+  /**
+   * Enable/disable auto-reconnect
+   * @param {boolean} enable
+   */
+  setAutoReconnect(enable) {
+    this.autoReconnect = enable;
+    if (!enable && this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  
   /**
    * Start ping interval
    */
@@ -145,12 +193,49 @@ class DaemonClient extends EventEmitter {
       try {
         await this._request(MSG_TYPE.PING, null, TIMEOUTS.PING_TIMEOUT);
       } catch (err) {
-        log.warn('Ping failed, disconnecting');
-        this.disconnect();
+        log.warn('Ping failed, will auto-reconnect');
+        // Don't call disconnect() - let socket close trigger reconnect
+        if (this.socket) {
+          this.socket.destroy();
+        }
       }
     }, TIMEOUTS.PING_INTERVAL);
   }
   
+  /**
+   * Schedule auto-reconnect with exponential backoff
+   */
+  _scheduleReconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+    }
+    
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      log.error('Max reconnect attempts reached, giving up');
+      this.emit('reconnectFailed');
+      return;
+    }
+    
+    // Exponential backoff: 1s, 2s, 4s, 8s... max 30s
+    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+    this.reconnectAttempts++;
+    
+    log.debug(`Scheduling reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      log.debug('Attempting reconnect...');
+      
+      const success = await this.connect();
+      if (success) {
+        log.debug('Reconnected successfully');
+        this.reconnectAttempts = 0;
+        this.emit('reconnected');
+      }
+      // If failed, the connect() will trigger another close -> scheduleReconnect
+    }, delay);
+  }
+  
   /**
    * Handle incoming message
    * @param {Object} msg

package/src/services/rithmic/orders.js

@@ -145,11 +145,18 @@ const placeOrder = async (service, orderData) => {
             orderTag,
           });
         } else if (status === 5 || status === 6) {
+          // Extract rejection reason from rpCode[1] if available
+          const rpCode = order.rpCode;
+          let errorMsg = `Order rejected: status ${status}`;
+          if (rpCode && Array.isArray(rpCode) && rpCode.length > 1 && rpCode[1]) {
+            errorMsg = `Order rejected: ${rpCode[1]}`;
+          }
           resolve({
             success: false,
-            error: `Order rejected: status ${status}`,
+            error: errorMsg,
             orderId: order.basketId,
             orderTag,
+            rpCode,
           });
         }
       }
@@ -169,6 +176,11 @@ const placeOrder = async (service, orderData) => {
                    routes.values().next().value?.tradeRoute || null;
     }
     
+    // Warn if no trade route - Rithmic will reject the order
+    if (!tradeRoute) {
+      DEBUG && console.log('[Orders] WARNING: No trade route for', exchange, '- order may be rejected');
+    }
+    
     // HFT: Reuse template and mutate (faster than object spread)
     ORDER_REQUEST_TEMPLATE.userMsg[0] = orderTag;
     ORDER_REQUEST_TEMPLATE.fcmId = service.loginInfo.fcmId;

package/src/services/rithmic/protobuf-utils.js

@@ -99,15 +99,24 @@ function skipField(buffer, offset, wireType) {
     case 0: // Varint
       const [, newOffset] = readVarint(buffer, offset);
       return newOffset;
-    case 1: // 64-bit
+    case 1: // 64-bit (fixed64, sfixed64, double)
       return offset + 8;
-    case 2: // Length-delimited
+    case 2: // Length-delimited (string, bytes, embedded messages, packed repeated)
       const [length, lenOffset] = readVarint(buffer, offset);
       return lenOffset + length;
-    case 5: // 32-bit
+    case 3: // Start group (deprecated)
+    case 4: // End group (deprecated)
+      // Groups are deprecated, skip to end of buffer
+      return buffer.length;
+    case 5: // 32-bit (fixed32, sfixed32, float)
       return offset + 4;
+    case 6: // Reserved (unused)
+    case 7: // Reserved (unused) - indicates corrupted data
+      // Skip to end to prevent infinite loops on corrupted data
+      return buffer.length;
     default:
-      throw new Error(`Unknown wire type: ${wireType}`);
+      // Unknown wire type - skip to end
+      return buffer.length;
   }
 }
 

package/src/services/rithmic/protobuf.js

@@ -93,8 +93,15 @@ class ProtobufHandler {
     // Skip 4-byte length prefix
     const data = buffer.length > 4 ? buffer.slice(4) : buffer;
     
+    // Sanity check: buffer must be at least a few bytes
+    if (data.length < 2) return -1;
+    
     let offset = 0;
-    while (offset < data.length) {
+    let iterations = 0;
+    const maxIterations = 100; // Prevent infinite loops on corrupted data
+    
+    while (offset < data.length && iterations < maxIterations) {
+      iterations++;
       try {
         const [tag, newOffset] = readVarint(data, offset);
         const fieldNumber = tag >>> 3;
@@ -106,7 +113,11 @@ class ProtobufHandler {
           return templateId;
         }
 
+        const prevOffset = offset;
         offset = skipField(data, offset, wireType);
+        
+        // Ensure we're making progress (prevent infinite loop)
+        if (offset <= prevOffset) break;
       } catch (e) {
         break;
       }