hedgequantx 2.9.164 → 2.9.166

package/package.json

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

package/src/services/rithmic/contracts.js

@@ -83,12 +83,18 @@ const fetchAllFrontMonths = (service) => {
     throw new Error('TICKER_PLANT not connected');
   }
 
+  const tickerState = service.tickerConn.connectionState;
+  const tickerConnected = service.tickerConn.isConnected;
+  log.debug('fetchAllFrontMonths starting', { tickerState, tickerConnected });
+
   return new Promise((resolve) => {
     const contracts = new Map();
     const productsToCheck = new Map();
+    let msgCount = 0;
 
     // Handler for ProductCodes responses
     const productHandler = (msg) => {
+      msgCount++;
       if (msg.templateId !== 112) return;
       
       const decoded = decodeProductCodes(msg.data);
@@ -112,6 +118,7 @@ const fetchAllFrontMonths = (service) => {
 
     // Handler for FrontMonth responses
     const frontMonthHandler = (msg) => {
+      msgCount++;
       if (msg.templateId !== 114) return;
       
       const decoded = decodeFrontMonthContract(msg.data);
@@ -128,23 +135,36 @@ const fetchAllFrontMonths = (service) => {
     service.tickerConn.on('message', frontMonthHandler);
 
     // Request all product codes
-    service.tickerConn.send('RequestProductCodes', {
-      templateId: 111,
-      userMsg: ['get-products'],
-    });
+    log.debug('Sending RequestProductCodes');
+    try {
+      service.tickerConn.send('RequestProductCodes', {
+        templateId: 111,
+        userMsg: ['get-products'],
+      });
+    } catch (err) {
+      log.warn('Failed to send RequestProductCodes', { error: err.message });
+    }
 
     // After timeout, request front months
     setTimeout(() => {
       service.tickerConn.removeListener('message', productHandler);
-      log.debug('Collected products', { count: productsToCheck.size });
+      log.debug('Collected products', { count: productsToCheck.size, totalMsgs: msgCount });
+
+      if (productsToCheck.size === 0) {
+        log.warn('No products collected - TICKER may not be working');
+      }
 
       for (const product of productsToCheck.values()) {
-        service.tickerConn.send('RequestFrontMonthContract', {
-          templateId: 113,
-          userMsg: [product.productCode],
-          symbol: product.productCode,
-          exchange: product.exchange,
-        });
+        try {
+          service.tickerConn.send('RequestFrontMonthContract', {
+            templateId: 113,
+            userMsg: [product.productCode],
+            symbol: product.productCode,
+            exchange: product.exchange,
+          });
+        } catch (err) {
+          log.warn('Failed to send RequestFrontMonthContract', { product: product.productCode, error: err.message });
+        }
       }
 
       // Collect results after timeout
@@ -171,7 +191,7 @@ const fetchAllFrontMonths = (service) => {
         // Sort alphabetically by base symbol
         results.sort((a, b) => a.baseSymbol.localeCompare(b.baseSymbol));
 
-        log.debug('Got contracts from API', { count: results.length });
+        log.debug('Got contracts from API', { count: results.length, totalMsgs: msgCount });
         resolve(results);
       }, TIMEOUTS.RITHMIC_PRODUCTS);
     }, TIMEOUTS.RITHMIC_CONTRACTS);

package/src/services/rithmic-broker/daemon.js

@@ -342,22 +342,70 @@ class RithmicBrokerDaemon {
     // Log service state for debugging
     const hasCredentials = !!conn.service.credentials;
     const hasTickerConn = !!conn.service.tickerConn;
-    log('DEBUG', 'getContracts request', { propfirm: payload.propfirmKey, hasCredentials, hasTickerConn });
+    const tickerState = conn.service.tickerConn?.connectionState;
+    log('DEBUG', 'getContracts request', { propfirm: payload.propfirmKey, hasCredentials, hasTickerConn, tickerState });
     
     try {
       const result = await conn.service.getContracts();
+      
+      // Log detailed result
+      const tickerStateAfter = conn.service.tickerConn?.connectionState;
       log('DEBUG', 'getContracts result', { 
         propfirm: payload.propfirmKey, 
         success: result.success, 
         count: result.contracts?.length || 0,
+        source: result.source,
+        tickerStateAfter,
         error: result.error 
       });
+      
+      // If no contracts found, return fallback list for common futures
+      if (!result.success || result.contracts?.length === 0) {
+        log('WARN', 'Using fallback contracts list');
+        const fallbackContracts = this._getFallbackContracts();
+        return { type: 'contracts', payload: { success: true, contracts: fallbackContracts, source: 'fallback' }, requestId };
+      }
+      
       return { type: 'contracts', payload: result, requestId };
     } catch (err) {
       log('ERROR', 'getContracts exception', { propfirm: payload.propfirmKey, error: err.message, stack: err.stack?.split('\n')[1] });
-      return { type: 'contracts', payload: { success: false, error: err.message, contracts: [] }, requestId };
+      // Return fallback on error
+      log('WARN', 'Using fallback contracts due to error');
+      const fallbackContracts = this._getFallbackContracts();
+      return { type: 'contracts', payload: { success: true, contracts: fallbackContracts, source: 'fallback' }, requestId };
     }
   }
+  
+  /**
+   * Get fallback contracts list when TICKER_PLANT fails
+   * These are common futures that most prop firms support
+   */
+  _getFallbackContracts() {
+    const now = new Date();
+    const month = now.getMonth();
+    const year = now.getFullYear();
+    
+    // Determine front month code (H=Mar, M=Jun, U=Sep, Z=Dec for indices)
+    const monthCodes = ['H', 'H', 'H', 'M', 'M', 'M', 'U', 'U', 'U', 'Z', 'Z', 'Z'];
+    const frontMonth = monthCodes[month];
+    const yearCode = String(year).slice(-1);
+    const suffix = frontMonth + yearCode;
+    
+    return [
+      { symbol: `MNQ${suffix}`, baseSymbol: 'MNQ', name: 'Micro E-mini Nasdaq-100', exchange: 'CME', tickSize: 0.25 },
+      { symbol: `MES${suffix}`, baseSymbol: 'MES', name: 'Micro E-mini S&P 500', exchange: 'CME', tickSize: 0.25 },
+      { symbol: `NQ${suffix}`, baseSymbol: 'NQ', name: 'E-mini Nasdaq-100', exchange: 'CME', tickSize: 0.25 },
+      { symbol: `ES${suffix}`, baseSymbol: 'ES', name: 'E-mini S&P 500', exchange: 'CME', tickSize: 0.25 },
+      { symbol: `MCL${suffix}`, baseSymbol: 'MCL', name: 'Micro WTI Crude Oil', exchange: 'NYMEX', tickSize: 0.01 },
+      { symbol: `MGC${suffix}`, baseSymbol: 'MGC', name: 'Micro Gold', exchange: 'COMEX', tickSize: 0.10 },
+      { symbol: `M2K${suffix}`, baseSymbol: 'M2K', name: 'Micro E-mini Russell 2000', exchange: 'CME', tickSize: 0.10 },
+      { symbol: `MYM${suffix}`, baseSymbol: 'MYM', name: 'Micro E-mini Dow', exchange: 'CBOT', tickSize: 0.50 },
+      { symbol: `RTY${suffix}`, baseSymbol: 'RTY', name: 'E-mini Russell 2000', exchange: 'CME', tickSize: 0.10 },
+      { symbol: `YM${suffix}`, baseSymbol: 'YM', name: 'E-mini Dow', exchange: 'CBOT', tickSize: 1.00 },
+      { symbol: `CL${suffix}`, baseSymbol: 'CL', name: 'Crude Oil', exchange: 'NYMEX', tickSize: 0.01 },
+      { symbol: `GC${suffix}`, baseSymbol: 'GC', name: 'Gold', exchange: 'COMEX', tickSize: 0.10 },
+    ];
+  }
 
   async _handleSearchContracts(payload, requestId) {
     const conn = this.connections.get(payload.propfirmKey);

package/src/services/session.js

@@ -111,19 +111,38 @@ const connections = {
     log.info('Connection added', { type, propfirm: propfirm || type });
   },
 
+  /**
+   * Sanitize account data to prevent corrupted data from being saved
+   */
+  _sanitizeAccount(acc) {
+    if (!acc || typeof acc !== 'object' || !acc.accountId) return null;
+    return {
+      accountId: String(acc.accountId),
+      fcmId: acc.fcmId ? String(acc.fcmId) : undefined,
+      ibId: acc.ibId ? String(acc.ibId) : undefined,
+      accountName: acc.accountName ? String(acc.accountName) : undefined,
+    };
+  },
+
   saveToStorage() {
     // Load existing sessions to preserve AI agents
     const existingSessions = storage.load();
     const aiSessions = existingSessions.filter(s => s.type === 'ai');
     
     // Build Rithmic sessions - INCLUDE accounts to avoid Rithmic API limit on restore
-    const rithmicSessions = this.services.map(conn => ({
-      type: conn.type,
-      propfirm: conn.propfirm,
-      propfirmKey: conn.service.propfirmKey || conn.propfirmKey,
-      credentials: conn.service.credentials,
-      accounts: conn.service.accounts || [],  // CRITICAL: Cache accounts to avoid 2000 GetAccounts limit
-    }));
+    const rithmicSessions = this.services.map(conn => {
+      // Sanitize accounts to prevent corrupted data
+      const rawAccounts = conn.service.accounts || [];
+      const accounts = rawAccounts.map(a => this._sanitizeAccount(a)).filter(Boolean);
+      
+      return {
+        type: conn.type,
+        propfirm: conn.propfirm,
+        propfirmKey: conn.service.propfirmKey || conn.propfirmKey,
+        credentials: conn.service.credentials,
+        accounts,  // CRITICAL: Cache sanitized accounts to avoid 2000 GetAccounts limit
+      };
+    });
     
     // Merge: AI sessions + Rithmic sessions
     storage.save([...aiSessions, ...rithmicSessions]);
@@ -200,8 +219,17 @@ const connections = {
     if (type === 'rithmic' && session.credentials) {
       const client = new RithmicBrokerClient(propfirmKey || 'apex_rithmic');
       
-      // CRITICAL: Pass cached accounts to avoid Rithmic's 2000 GetAccounts limit
-      const loginOptions = session.accounts ? { cachedAccounts: session.accounts } : {};
+      // Validate cached accounts before using
+      let validAccounts = null;
+      if (session.accounts && Array.isArray(session.accounts)) {
+        validAccounts = session.accounts
+          .map(a => this._sanitizeAccount(a))
+          .filter(Boolean);
+        if (validAccounts.length === 0) validAccounts = null;
+      }
+      
+      // CRITICAL: Pass validated cached accounts to avoid Rithmic's 2000 GetAccounts limit
+      const loginOptions = validAccounts ? { cachedAccounts: validAccounts } : {};
       const result = await client.login(session.credentials.username, session.credentials.password, loginOptions);
       
       if (result.success) {
@@ -212,7 +240,7 @@ const connections = {
           propfirmKey,
           connectedAt: new Date(),
         });
-        log.debug('Rithmic session restored via broker', { hasCachedAccounts: !!session.accounts });
+        log.debug('Rithmic session restored via broker', { hasCachedAccounts: !!validAccounts, accountCount: validAccounts?.length || 0 });
       }
     }
   },