hedgequantx 2.9.221 → 2.9.223

package/dist/lib/m/ultra-scalping.js

@@ -561,7 +561,8 @@ class HQXUltraScalpingStrategy extends EventEmitter {
     // Set last bar time to now
     this.lastBarTime.set(contractId, Date.now());
     
-    this.emit('log', { type: 'info', message: `Preloaded ${histBars.length} bars for ${contractId}` });
+    // Tick-based strategy uses bars only for warmup reference data (volatility, ranges)
+    this.emit('log', { type: 'info', message: `Reference data loaded (${histBars.length} periods) - tick engine ready` });
   }
 
   /**

package/package.json

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

package/src/app.js

@@ -39,9 +39,10 @@ let daemonClient = null;
  * Create a proxy service that uses daemon for all operations
  * @param {Object} client - DaemonClient instance
  * @param {Object} propfirm - Propfirm info
+ * @param {Object} credentials - Optional credentials {username, password}
  * @returns {Object} Service-like object
  */
-function createDaemonProxyService(client, propfirm) {
+function createDaemonProxyService(client, propfirm, credentials = null) {
   const checkMarketHours = () => {
     const now = new Date(), utcDay = now.getUTCDay(), utcHour = now.getUTCHours();
     const isDST = now.getTimezoneOffset() < Math.max(
@@ -56,8 +57,11 @@ function createDaemonProxyService(client, propfirm) {
     return { isOpen: true, message: 'Market is open' };
   };
   
+  // Store credentials for algo trading (market data feed)
+  let storedCredentials = credentials;
+  
   return {
-    propfirm, propfirmKey: propfirm?.key, accounts: [], credentials: null,
+    propfirm, propfirmKey: propfirm?.key, accounts: [], credentials: storedCredentials,
     async getTradingAccounts() { return client.getTradingAccounts(); },
     async getPositions() { return client.getPositions(); },
     async getOrders() { return client.getOrders(); },
@@ -70,9 +74,22 @@ function createDaemonProxyService(client, propfirm) {
     getAccountPnL() { return { pnl: null, openPnl: null, closedPnl: null, balance: null }; },
     getToken() { return 'daemon-connected'; },
     getPropfirm() { return propfirm?.key || 'apex'; },
-    getRithmicCredentials() { return null; },
+    getRithmicCredentials() {
+      // Return credentials for algo trading market data connection
+      if (!storedCredentials) return null;
+      const { RITHMIC_ENDPOINTS } = require('./services/rithmic');
+      return {
+        userId: storedCredentials.username,
+        password: storedCredentials.password,
+        systemName: propfirm?.systemName || propfirm?.name || 'Apex',
+        gateway: RITHMIC_ENDPOINTS?.CHICAGO || 'wss://rprotocol.rithmic.com:443',
+      };
+    },
+    setCredentials(creds) { storedCredentials = creds; },
     checkMarketHours,
     async disconnect() { return { success: true }; },
+    // For algo - disconnect ticker before starting new market data connection
+    async disconnectTicker() { return { success: true }; },
   };
 }
 
@@ -266,8 +283,19 @@ const run = async () => {
           // Daemon already has a connection, use it
           const accountsResult = await daemonClient.getTradingAccounts();
           if (accountsResult.success && accountsResult.accounts?.length > 0) {
+            // Get credentials for algo trading
+            let credentials = null;
+            try {
+              const credResult = await daemonClient.getCredentials();
+              if (credResult.success) {
+                credentials = credResult.credentials;
+              }
+            } catch (credErr) {
+              log.warn('Failed to get credentials', { error: credErr.message });
+            }
+            
             // Create a proxy service that uses daemon
-            currentService = createDaemonProxyService(daemonClient, status.propfirm);
+            currentService = createDaemonProxyService(daemonClient, status.propfirm, credentials);
             connections.services.push({
               type: 'rithmic',
               service: currentService,
@@ -282,7 +310,18 @@ const run = async () => {
           // Daemon not connected, try to restore session via daemon
           const restoreResult = await daemonClient.restoreSession();
           if (restoreResult.success) {
-            currentService = createDaemonProxyService(daemonClient, restoreResult.propfirm);
+            // Get credentials for algo trading
+            let credentials = null;
+            try {
+              const credResult = await daemonClient.getCredentials();
+              if (credResult.success) {
+                credentials = credResult.credentials;
+              }
+            } catch (credErr) {
+              log.warn('Failed to get credentials', { error: credErr.message });
+            }
+            
+            currentService = createDaemonProxyService(daemonClient, restoreResult.propfirm, credentials);
             connections.services.push({
               type: 'rithmic',
               service: currentService,
@@ -348,7 +387,8 @@ const run = async () => {
               if (daemonClient?.connected) {
                 result = await daemonClient.login(selectedPropfirm.key, credentials.username, credentials.password);
                 if (result.success) {
-                  currentService = createDaemonProxyService(daemonClient, result.propfirm);
+                  // Pass credentials for algo trading market data
+                  currentService = createDaemonProxyService(daemonClient, result.propfirm, credentials);
                   connections.services.push({
                     type: 'rithmic', service: currentService,
                     propfirm: selectedPropfirm.name, propfirmKey: selectedPropfirm.key, connectedAt: new Date(),

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

@@ -78,7 +78,12 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   sessionLogger.log('CONFIG', `account=${account.accountId} rithmicId=${account.rithmicAccountId || 'N/A'}`);
   
   strategy.on('log', (log) => {
-    const type = log.type === 'debug' ? 'debug' : log.type === 'info' ? 'analysis' : 'system';
+    // Debug logs only go to session file, not UI (too verbose)
+    if (log.type === 'debug') {
+      sessionLogger.log('DEBUG', log.message);
+      return;
+    }
+    const type = log.type === 'info' ? 'analysis' : 'system';
     ui.addLog(type, log.message);
     sessionLogger.log(type.toUpperCase(), log.message);
   });
@@ -352,12 +357,12 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
         if (histBars && histBars.length > 0) {
           strategy.preloadBars(contractId, histBars);
           // Different message for tick-based vs bar-based strategies
-          const isTickBased = strategyId === 'ultra-scalping';
+          const isTickBased = strategyId === 'ultra-scalping' || strategyId === 'hqx-scalping';
           const msg = isTickBased 
-            ? `Warmup data loaded - QUANT models initializing...`
+            ? `Reference data loaded - QUANT tick engine initializing...`
             : `Loaded ${histBars.length} historical bars - ready to trade!`;
           ui.addLog('system', msg);
-          sessionLogger.log('HISTORY', `Preloaded ${histBars.length} bars for warmup`);
+          sessionLogger.log('WARMUP', isTickBased ? `Tick engine warmup with ${histBars.length} ref periods` : `Preloaded ${histBars.length} bars`);
         } else {
           ui.addLog('system', 'No history - warming up with live ticks...');
         }

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

@@ -74,13 +74,15 @@ const executeMultiSymbol = async ({ service, account, contracts, config, strateg
     // Filter logs - only show important events (swings, zones, signals)
     strategy.on('log', (log) => {
       const msg = log.message || '';
+      // Skip debug logs in UI (too verbose)
+      if (log.type === 'debug') return;
       // Skip bar close logs (too noisy with 5 symbols)
       if (msg.includes('[BAR]')) return;
       // Skip routine pivot checks
       if (msg.includes('Checking pivot')) return;
       // Show swing and zone events
       const prefix = `[${symbolCode}] `;
-      ui.addLog(log.type === 'debug' ? 'debug' : 'analysis', prefix + msg);
+      ui.addLog('analysis', prefix + msg);
     });
   }
   

package/src/services/daemon/client.js

@@ -351,6 +351,14 @@ class DaemonClient extends EventEmitter {
     return this._request(MSG_TYPE.SEARCH_CONTRACTS, { search });
   }
   
+  /**
+   * Get credentials for algo trading
+   * @returns {Promise<Object>}
+   */
+  async getCredentials() {
+    return this._request(MSG_TYPE.GET_CREDENTIALS);
+  }
+  
   /**
    * Subscribe to market data
    * @param {string} symbol

package/src/services/daemon/constants.js

@@ -42,6 +42,7 @@ const MSG_TYPE = {
   GET_STATUS: 'get_status',
   GET_CONTRACTS: 'get_contracts',
   SEARCH_CONTRACTS: 'search_contracts',
+  GET_CREDENTIALS: 'get_credentials',
   
   // Data responses
   ACCOUNTS: 'accounts',
@@ -50,6 +51,7 @@ const MSG_TYPE = {
   PNL: 'pnl',
   STATUS: 'status',
   CONTRACTS: 'contracts',
+  CREDENTIALS: 'credentials',
   
   // Trading
   PLACE_ORDER: 'place_order',

package/src/services/daemon/handlers.js

@@ -262,6 +262,39 @@ function createHandlers(daemon) {
     daemon._send(socket, createMessage(MSG_TYPE.ORDER_RESULT, result, id));
   }
   
+  // ==================== CREDENTIALS HANDLER ====================
+  
+  async function handleGetCredentials(socket, id) {
+    // Load credentials from saved session
+    const { storage } = require('../session');
+    const sessions = storage.load();
+    const rithmicSession = sessions.find(s => s.type === 'rithmic' && s.credentials);
+    
+    if (!rithmicSession || !rithmicSession.credentials) {
+      daemon._send(socket, createMessage(MSG_TYPE.CREDENTIALS, {
+        success: false,
+        error: 'No credentials available',
+      }, id));
+      return;
+    }
+    
+    // Return credentials for algo trading market data
+    const { RITHMIC_ENDPOINTS } = require('../rithmic');
+    daemon._send(socket, createMessage(MSG_TYPE.CREDENTIALS, {
+      success: true,
+      credentials: {
+        username: rithmicSession.credentials.username,
+        password: rithmicSession.credentials.password,
+      },
+      rithmicCredentials: {
+        userId: rithmicSession.credentials.username,
+        password: rithmicSession.credentials.password,
+        systemName: daemon.propfirm?.name || rithmicSession.propfirm || 'Apex',
+        gateway: RITHMIC_ENDPOINTS?.CHICAGO || 'wss://rprotocol.rithmic.com:443',
+      },
+    }, id));
+  }
+  
   // ==================== CONTRACT HANDLERS ====================
   
   async function handleGetContracts(socket, id) {
@@ -332,6 +365,7 @@ function createHandlers(daemon) {
     handleGetPositions,
     handleGetOrders,
     handleGetPnL,
+    handleGetCredentials,
     handlePlaceOrder,
     handleCancelOrder,
     handleCancelAll,

package/src/services/daemon/server.js

@@ -196,6 +196,10 @@ class DaemonServer extends EventEmitter {
           await h.handleGetPnL(socket, id, data);
           break;
           
+        case MSG_TYPE.GET_CREDENTIALS:
+          await h.handleGetCredentials(socket, id);
+          break;
+          
         case MSG_TYPE.PLACE_ORDER:
           await h.handlePlaceOrder(socket, id, data);
           break;