hedgequantx 2.6.124 → 2.6.126

package/package.json

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

package/src/pages/algo/one-account.js

@@ -78,21 +78,32 @@ const oneAccountMenu = async (service) => {
   // Use the service attached to the account (from getAllAccounts), fallback to getServiceForAccount
   const accountService = selectedAccount.service || connections.getServiceForAccount(selectedAccount.accountId) || service;
   
-  // Select symbol
-  const contract = await selectSymbol(accountService, selectedAccount);
-  if (!contract) return;
+  // Select symbols (up to MAX_SYMBOLS)
+  const contracts = await selectSymbols(accountService, selectedAccount);
+  if (!contracts || contracts.length === 0) return;
   
-  // Configure algo
-  const config = await configureAlgo(selectedAccount, contract);
+  // Configure algo (shared config for all symbols)
+  const config = await configureAlgo(selectedAccount, contracts);
   if (!config) return;
   
-  await launchAlgo(accountService, selectedAccount, contract, config);
+  // Launch algo for all selected symbols
+  if (contracts.length === 1) {
+    // Single symbol - use original launchAlgo
+    await launchAlgo(accountService, selectedAccount, contracts[0], config);
+  } else {
+    // Multiple symbols - launch parallel trading
+    await launchMultiAlgo(accountService, selectedAccount, contracts, config);
+  }
 };
 
+// Maximum number of symbols to trade simultaneously
+const MAX_SYMBOLS = 5;
+
 /**
  * Symbol selection - sorted with popular indices first
+ * Allows selecting multiple symbols (up to MAX_SYMBOLS)
  */
-const selectSymbol = async (service, account) => {
+const selectSymbols = async (service, account) => {
   const spinner = ora({ text: 'LOADING SYMBOLS...', color: 'yellow' }).start();
   
   const contractsResult = await service.getContracts();
@@ -126,28 +137,102 @@ const selectSymbol = async (service, account) => {
   
   spinner.succeed(`FOUND ${contracts.length} CONTRACTS`);
   
-  // Display sorted contracts from API (uniform format: NAME - DESCRIPTION)
-  const options = contracts.map(c => {
-    const name = c.name || c.symbol || c.baseSymbol;
-    const desc = c.description || '';
-    const label = desc ? `${name} - ${desc}` : name;
-    return { label, value: c };
-  });
+  // Multi-symbol selection loop
+  const selectedContracts = [];
   
-  options.push({ label: chalk.gray('< BACK'), value: 'back' });
+  while (selectedContracts.length < MAX_SYMBOLS) {
+    console.log();
+    if (selectedContracts.length > 0) {
+      console.log(chalk.cyan(`  SELECTED (${selectedContracts.length}/${MAX_SYMBOLS}):`));
+      selectedContracts.forEach((c, i) => {
+        const name = c.name || c.symbol || c.baseSymbol;
+        console.log(chalk.green(`    ${i + 1}. ${name}`));
+      });
+      console.log();
+    }
+    
+    // Filter out already selected contracts
+    const availableContracts = contracts.filter(c => {
+      const cId = c.id || c.symbol || c.name;
+      return !selectedContracts.some(sc => (sc.id || sc.symbol || sc.name) === cId);
+    });
+    
+    // Build options
+    const options = availableContracts.map(c => {
+      const name = c.name || c.symbol || c.baseSymbol;
+      const desc = c.description || '';
+      const label = desc ? `${name} - ${desc}` : name;
+      return { label, value: c };
+    });
+    
+    // Add done/back options
+    if (selectedContracts.length > 0) {
+      options.unshift({ label: chalk.green(`✓ DONE (trade ${selectedContracts.length} symbol${selectedContracts.length > 1 ? 's' : ''})`), value: 'done' });
+    }
+    options.push({ label: chalk.gray('< BACK'), value: 'back' });
+    
+    const promptText = selectedContracts.length === 0 
+      ? chalk.yellow(`SELECT SYMBOL (1-${MAX_SYMBOLS}):`)
+      : chalk.yellow(`ADD SYMBOL (${selectedContracts.length + 1}/${MAX_SYMBOLS}) OR DONE:`);
+    
+    const choice = await prompts.selectOption(promptText, options);
+    
+    if (choice === 'back' || choice === null) {
+      if (selectedContracts.length === 0) {
+        return null; // Go back
+      }
+      // Remove last selected
+      selectedContracts.pop();
+      continue;
+    }
+    
+    if (choice === 'done') {
+      break; // Done selecting
+    }
+    
+    // Add selected contract
+    selectedContracts.push(choice);
+    
+    if (selectedContracts.length >= MAX_SYMBOLS) {
+      console.log(chalk.yellow(`  MAX ${MAX_SYMBOLS} SYMBOLS REACHED`));
+      break;
+    }
+  }
   
-  const contract = await prompts.selectOption(chalk.yellow('SELECT SYMBOL:'), options);
-  return contract === 'back' || contract === null ? null : contract;
+  return selectedContracts.length > 0 ? selectedContracts : null;
+};
+
+/**
+ * Legacy single symbol selection (kept for compatibility)
+ */
+const selectSymbol = async (service, account) => {
+  const contracts = await selectSymbols(service, account);
+  return contracts && contracts.length > 0 ? contracts[0] : null;
 };
 
 /**
  * Configure algo
+ * @param {Object} account - Trading account
+ * @param {Array|Object} contractsOrContract - Single contract or array of contracts
  */
-const configureAlgo = async (account, contract) => {
+const configureAlgo = async (account, contractsOrContract) => {
+  // Normalize to array
+  const contractList = Array.isArray(contractsOrContract) ? contractsOrContract : [contractsOrContract];
+  
   console.log();
   console.log(chalk.cyan('  CONFIGURE ALGO PARAMETERS'));
   console.log();
   
+  // Show selected symbols
+  if (contractList.length > 1) {
+    console.log(chalk.white(`  TRADING ${contractList.length} SYMBOLS:`));
+    contractList.forEach((c, i) => {
+      const name = c.name || c.symbol || c.baseSymbol;
+      console.log(chalk.yellow(`    ${i + 1}. ${name}`));
+    });
+    console.log();
+  }
+  
   const contracts = await prompts.numberInput('NUMBER OF CONTRACTS:', 1, 1, 10);
   if (contracts === null) return null;
   
@@ -1283,4 +1368,291 @@ const launchAlgo = async (service, account, contract, config) => {
   await prompts.waitForEnter();
 };
 
+/**
+ * Launch multi-symbol algo trading
+ * Runs multiple symbols in parallel on the same account
+ * 
+ * @param {Object} service - Trading service
+ * @param {Object} account - Trading account
+ * @param {Array} contracts - Array of contracts to trade
+ * @param {Object} config - Algo configuration
+ */
+const launchMultiAlgo = async (service, account, contracts, config) => {
+  const { contracts: qty, dailyTarget, maxRisk, showName } = config;
+  
+  const accountName = showName 
+    ? (account.accountName || account.rithmicAccountId || account.accountId) 
+    : 'HQX *****';
+  const connectionType = account.platform || 'ProjectX';
+  const useFastPath = isRithmicFastPath(service);
+  
+  // Build symbol list string
+  const symbolNames = contracts.map(c => c.name || c.symbol || c.baseSymbol);
+  const symbolsStr = symbolNames.join(', ');
+  
+  const ui = new AlgoUI({ 
+    subtitle: `MULTI-SYMBOL (${contracts.length})`, 
+    mode: 'one-account' 
+  });
+  
+  // Shared stats across all symbols
+  const stats = {
+    accountName,
+    symbol: symbolsStr,
+    qty,
+    target: dailyTarget,
+    risk: maxRisk,
+    propfirm: account.propfirm || 'Unknown',
+    platform: connectionType,
+    pnl: null,
+    openPnl: null,
+    closedPnl: null,
+    balance: null,
+    buyingPower: null,
+    margin: null,
+    netLiquidation: null,
+    position: 0,
+    entryPrice: 0,
+    lastPrice: 0,
+    trades: 0,
+    wins: 0,
+    losses: 0,
+    sessionPnl: 0,
+    latency: 0,
+    connected: false,
+    startTime: Date.now(),
+    aiSupervision: config.enableAI || false,
+    aiMode: null,
+    agentCount: 0,
+    fastPath: useFastPath,
+    avgEntryLatency: 0,
+    avgFillLatency: 0,
+    entryLatencies: [],
+    // Multi-symbol specific
+    activeSymbols: contracts.length,
+    symbolStats: {}, // Per-symbol stats
+  };
+  
+  // Initialize per-symbol stats
+  contracts.forEach(c => {
+    const name = c.name || c.symbol;
+    stats.symbolStats[name] = {
+      position: 0,
+      trades: 0,
+      wins: 0,
+      losses: 0,
+      pnl: 0,
+    };
+  });
+  
+  let running = true;
+  let stopReason = null;
+  
+  // Track market feeds and position managers for cleanup
+  const marketFeeds = [];
+  const positionManagers = [];
+  
+  ui.render(stats);
+  ui.addLog('info', `MULTI-SYMBOL MODE: ${contracts.length} symbols`);
+  symbolNames.forEach(name => ui.addLog('info', `  → ${name}`));
+  
+  // Launch trading for each symbol
+  const symbolPromises = contracts.map(async (contract, index) => {
+    const symbolName = contract.name || contract.symbol;
+    const contractId = contract.id || contract.symbol || contract.name;
+    const tickSize = contract.tickSize ?? null;
+    const tickValue = contract.tickValue ?? null;
+    
+    // Initialize strategy for this symbol
+    const strategy = (USE_HFT_STRATEGY && useFastPath) ? hftStrategy : M1;
+    if (tickSize !== null && tickValue !== null) {
+      strategy.initialize(contractId, tickSize, tickValue);
+    }
+    
+    // Initialize Position Manager for fast path
+    let positionManager = null;
+    if (useFastPath) {
+      positionManager = new PositionManager(service, strategy);
+      if (tickSize !== null && tickValue !== null) {
+        positionManager.setContractInfo(symbolName, { tickSize, tickValue, contractId });
+      }
+      positionManager.start();
+      positionManagers.push(positionManager);
+      
+      // Position manager events
+      positionManager.on('entryFilled', ({ position, fillLatencyMs }) => {
+        stats.entryLatencies.push(fillLatencyMs);
+        stats.avgFillLatency = stats.entryLatencies.reduce((a, b) => a + b, 0) / stats.entryLatencies.length;
+        const side = position.side === 0 ? 'LONG' : 'SHORT';
+        ui.addLog('filled', `[${symbolName}] ${side} ${position.size}x @ ${position.entryPrice} | ${fillLatencyMs}ms`);
+      });
+      
+      positionManager.on('exitFilled', ({ exitPrice, pnlTicks, holdDurationMs }) => {
+        const holdSec = (holdDurationMs / 1000).toFixed(1);
+        if (pnlTicks !== null && tickValue !== null) {
+          const pnlDollars = pnlTicks * tickValue;
+          stats.sessionPnl += pnlDollars;
+          stats.symbolStats[symbolName].pnl += pnlDollars;
+          
+          if (pnlDollars >= 0) {
+            stats.wins++;
+            stats.symbolStats[symbolName].wins++;
+            ui.addLog('win', `[${symbolName}] +$${pnlDollars.toFixed(2)} @ ${exitPrice} | ${holdSec}s`);
+          } else {
+            stats.losses++;
+            stats.symbolStats[symbolName].losses++;
+            ui.addLog('loss', `[${symbolName}] -$${Math.abs(pnlDollars).toFixed(2)} @ ${exitPrice} | ${holdSec}s`);
+          }
+          stats.trades++;
+          stats.symbolStats[symbolName].trades++;
+        }
+        ui.render(stats);
+      });
+    }
+    
+    // Connect market feed for this symbol
+    const MarketFeedClass = useFastPath ? RithmicMarketDataFeed : MarketDataFeed;
+    const marketFeed = new MarketFeedClass(service);
+    marketFeeds.push(marketFeed);
+    
+    try {
+      await marketFeed.connect(contractId, account.accountId);
+      ui.addLog('success', `[${symbolName}] Market feed connected`);
+      stats.connected = true;
+      
+      // Handle market data ticks
+      marketFeed.on('tick', (tick) => {
+        if (!running) return;
+        
+        stats.latency = tick.latency || 0;
+        stats.lastPrice = tick.price || tick.last || 0;
+        
+        // Get strategy signal
+        const signal = strategy.onTick ? strategy.onTick(tick) : strategy.analyze?.(tick);
+        
+        if (signal && signal.action && signal.action !== 'hold') {
+          if (useFastPath && positionManager) {
+            // Fast path execution
+            if (signal.action === 'buy' || signal.action === 'long') {
+              positionManager.openPosition(symbolName, contract.exchange || 'CME', 0, qty, account.accountId);
+            } else if (signal.action === 'sell' || signal.action === 'short') {
+              positionManager.openPosition(symbolName, contract.exchange || 'CME', 1, qty, account.accountId);
+            } else if (signal.action === 'close' || signal.action === 'exit') {
+              positionManager.closePosition(symbolName);
+            }
+          }
+        }
+        
+        ui.render(stats);
+      });
+      
+    } catch (err) {
+      ui.addLog('error', `[${symbolName}] Failed to connect: ${err.message}`);
+    }
+  });
+  
+  // Wait for all symbols to initialize
+  await Promise.all(symbolPromises);
+  
+  // Keyboard handler for emergency stop
+  let emergencyStopInProgress = false;
+  
+  const setupKeyHandler = () => {
+    if (!process.stdin.isTTY) return;
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    
+    const onKey = async (str, key) => {
+      if (key && (key.name === 'x' || key.name === 'X' || (key.ctrl && key.name === 'c'))) {
+        if (emergencyStopInProgress) return;
+        emergencyStopInProgress = true;
+        running = false;
+        stopReason = 'manual';
+        
+        ui.addLog('warning', '████ EMERGENCY STOP - CLOSING ALL POSITIONS ████');
+        
+        // Close all positions on all symbols
+        for (const pm of positionManagers) {
+          try {
+            pm.closeAllPositions();
+          } catch (e) {}
+        }
+        
+        ui.addLog('info', 'All positions closed');
+        ui.render(stats);
+      }
+    };
+    process.stdin.on('keypress', onKey);
+    return () => {
+      process.stdin.removeListener('keypress', onKey);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    };
+  };
+  
+  const cleanupKeys = setupKeyHandler();
+  
+  // Wait for stop
+  await new Promise(resolve => {
+    const check = setInterval(() => {
+      if (!running) {
+        clearInterval(check);
+        resolve();
+      }
+    }, 100);
+  });
+  
+  // Cleanup
+  for (const pm of positionManagers) {
+    try { pm.stop(); } catch {}
+  }
+  
+  for (const feed of marketFeeds) {
+    try { await feed.disconnect(); } catch {}
+  }
+  
+  try { if (cleanupKeys) cleanupKeys(); } catch {}
+  try { ui.cleanup(); } catch {}
+  
+  try {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    process.stdin.resume();
+  } catch {}
+  
+  // Duration
+  const durationMs = Date.now() - stats.startTime;
+  const hours = Math.floor(durationMs / 3600000);
+  const minutes = Math.floor((durationMs % 3600000) / 60000);
+  const seconds = Math.floor((durationMs % 60000) / 1000);
+  stats.duration = hours > 0 
+    ? `${hours}h ${minutes}m ${seconds}s`
+    : minutes > 0 
+      ? `${minutes}m ${seconds}s`
+      : `${seconds}s`;
+  
+  // Summary with per-symbol breakdown
+  console.log();
+  console.log(chalk.cyan('═══════════════════════════════════════════════════════════════'));
+  console.log(chalk.cyan('                    MULTI-SYMBOL SESSION SUMMARY'));
+  console.log(chalk.cyan('═══════════════════════════════════════════════════════════════'));
+  console.log();
+  
+  for (const [symbol, symStats] of Object.entries(stats.symbolStats)) {
+    const winRate = symStats.trades > 0 ? ((symStats.wins / symStats.trades) * 100).toFixed(0) : 0;
+    const pnlColor = symStats.pnl >= 0 ? chalk.green : chalk.red;
+    console.log(chalk.white(`  ${symbol}:`));
+    console.log(`    Trades: ${symStats.trades} | WR: ${winRate}% | P&L: ${pnlColor('$' + symStats.pnl.toFixed(2))}`);
+  }
+  
+  console.log();
+  console.log(chalk.white(`  TOTAL: ${stats.trades} trades | ${stats.wins}W/${stats.losses}L | Session P&L: ${stats.sessionPnl >= 0 ? chalk.green('$' + stats.sessionPnl.toFixed(2)) : chalk.red('$' + stats.sessionPnl.toFixed(2))}`));
+  console.log(chalk.white(`  Duration: ${stats.duration}`));
+  console.log();
+  console.log(chalk.cyan('═══════════════════════════════════════════════════════════════'));
+  
+  await prompts.waitForEnter();
+};
+
 module.exports = { oneAccountMenu };

package/src/services/ai/proxy-manager.js

@@ -529,8 +529,10 @@ const submitCallback = async (callbackUrl, provider = 'anthropic') => {
   const config = providerConfig[provider] || providerConfig.anthropic;
   
   // Submit to the provider's OAuth callback port directly
+  // Pass ALL query parameters from the callback URL, not just code and state
+  // Some providers (like Gemini) require additional params like scope, authuser, etc.
   return new Promise((resolve, reject) => {
-    const callbackPath = `${config.path}?code=${encodeURIComponent(code)}&state=${encodeURIComponent(state)}`;
+    const callbackPath = `${config.path}?${url.searchParams.toString()}`;
     
     const req = http.request({
       hostname: '127.0.0.1',