hedgequantx 2.9.180 → 2.9.182

package/package.json

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

package/src/services/rithmic/contracts.js

@@ -251,9 +251,23 @@ const fetchAllFrontMonths = (service) => {
 
       let sentCount = 0;
       let sendErrors = [];
-      // Only send for first 5 products to test
+      
+      // Prioritize CME products (ES, NQ, MNQ, MES, etc.) - most used by traders
       const productsArray = Array.from(productsToCheck.values());
-      const testProducts = productsArray.slice(0, 60); // Limit to 60 for testing
+      const prioritySymbols = ['ES', 'NQ', 'MNQ', 'MES', 'RTY', 'M2K', 'YM', 'MYM', 'CL', 'MCL', 'GC', 'MGC', 'SI', 'HG', 'NG', 'ZB', 'ZN', 'ZF', 'ZT', '6E', '6J', '6B', '6A', '6C', '6S', 'ZC', 'ZS', 'ZW', 'ZM', 'ZL', 'HE', 'LE', 'GF'];
+      
+      // Sort: priority symbols first (CME), then others
+      productsArray.sort((a, b) => {
+        const aPriority = prioritySymbols.includes(a.productCode) ? 0 : 1;
+        const bPriority = prioritySymbols.includes(b.productCode) ? 0 : 1;
+        if (aPriority !== bPriority) return aPriority - bPriority;
+        // Within same priority, prefer CME/CBOT
+        const aExchange = (a.exchange === 'CME' || a.exchange === 'CBOT') ? 0 : 1;
+        const bExchange = (b.exchange === 'CME' || b.exchange === 'CBOT') ? 0 : 1;
+        return aExchange - bExchange;
+      });
+      
+      const testProducts = productsArray.slice(0, 60); // Limit to 60
       
       for (const product of testProducts) {
         try {

package/src/services/session.js

@@ -85,13 +85,19 @@ const storage = {
 };
 
 // Lazy load services to avoid circular dependencies
-let RithmicBrokerClient, brokerManager;
+let RithmicBrokerClient, brokerManager, RithmicService;
 const loadServices = () => {
   if (!RithmicBrokerClient) {
     ({ RithmicBrokerClient, manager: brokerManager } = require('./rithmic-broker'));
   }
+  if (!RithmicService) {
+    ({ RithmicService } = require('./rithmic'));
+  }
 };
 
+// Direct mode flag - bypass daemon completely
+const DIRECT_MODE = process.env.HQX_DIRECT === '1' || true; // Default to direct for now
+
 /**
  * Multi-connection manager (Rithmic only)
  */
@@ -152,6 +158,28 @@ const connections = {
   async restoreFromStorage() {
     loadServices();
     
+    // DIRECT MODE: Bypass daemon, connect directly to Rithmic
+    if (DIRECT_MODE) {
+      log.info('Direct mode enabled - bypassing daemon');
+      
+      const sessions = storage.load();
+      const rithmicSessions = sessions.filter(s => s.type === 'rithmic');
+      
+      if (!rithmicSessions.length) {
+        return false;
+      }
+      
+      for (const session of rithmicSessions) {
+        try {
+          await this._restoreSessionDirect(session);
+        } catch (err) {
+          log.warn('Failed to restore session direct', { error: err.message });
+        }
+      }
+      
+      return this.services.length > 0;
+    }
+    
     // Check if daemon is already running with active connections
     const daemonStatus = await brokerManager.getStatus();
     
@@ -211,6 +239,41 @@ const connections = {
     
     return this.services.length > 0;
   },
+  
+  /**
+   * Restore session using direct RithmicService (no daemon)
+   */
+  async _restoreSessionDirect(session) {
+    const { type, propfirm, propfirmKey } = session;
+    
+    if (type === 'rithmic' && session.credentials) {
+      const service = new RithmicService(propfirmKey || 'apex_rithmic');
+      
+      // Validate cached accounts
+      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;
+      }
+      
+      // Login with cached accounts to avoid API limit
+      const loginOptions = validAccounts ? { skipFetchAccounts: true, cachedAccounts: validAccounts } : {};
+      const result = await service.login(session.credentials.username, session.credentials.password, loginOptions);
+      
+      if (result.success) {
+        this.services.push({
+          type,
+          service,
+          propfirm,
+          propfirmKey,
+          connectedAt: new Date(),
+        });
+        log.info('Direct session restored', { propfirm, accounts: service.accounts?.length || 0 });
+      }
+    }
+  },
 
   async _restoreSession(session) {
     const { type, propfirm, propfirmKey } = session;