hedgequantx 2.3.12 → 2.3.14

package/package.json

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

package/src/pages/algo/copy-trading.js

@@ -8,7 +8,6 @@ const ora = require('ora');
 const readline = require('readline');
 
 const { connections } = require('../../services');
-const { HQXServerService } = require('../../services/hqx-server');
 const { AlgoUI, renderSessionSummary } = require('./ui');
 const { logger, prompts } = require('../../utils');
 const { checkMarketHours } = require('../../services/projectx/market');
@@ -283,48 +282,100 @@ const launchCopyTrading = async (config) => {
     losses: 0,
     latency: 0,
     connected: false,
+    platform: lead.account.platform || 'ProjectX',
   };
 
   let running = true;
   let stopReason = null;
+  
+  // Measure API latency (CLI <-> API)
+  const measureLatency = async () => {
+    try {
+      const start = Date.now();
+      await lead.service.getPositions(lead.account.accountId);
+      stats.latency = Date.now() - start;
+    } catch (e) {
+      stats.latency = 0;
+    }
+  };
 
-  // Connect to HQX Server
-  const hqx = new HQXServerService();
-  const spinner = ora({ text: 'Connecting to HQX Server...', color: 'yellow' }).start();
-
-  try {
-    const auth = await hqx.authenticate(
-      lead.account.accountId.toString(),
-      lead.propfirm || 'topstep'
-    );
-    if (!auth.success) throw new Error(auth.error);
-
-    const conn = await hqx.connect();
-    if (!conn.success) throw new Error('WebSocket failed');
-
-    spinner.succeed('Connected');
-    stats.connected = true;
-  } catch (err) {
-    spinner.warn('HQX Server unavailable');
-    log.warn('HQX connection failed', { error: err.message });
-  }
-
-  // Event handlers
-  setupEventHandlers(hqx, ui, stats, lead, follower, showNames, () => {
-    running = false;
-  }, (reason) => {
-    stopReason = reason;
-  }, dailyTarget, maxRisk);
-
-  // Start algo on server
-  if (stats.connected) {
-    startCopyTradingOnServer(hqx, lead, follower, dailyTarget, maxRisk, ui);
-  }
+  // Local copy trading - no external server needed
+  ui.addLog('info', `Starting copy trading on ${stats.platform}...`);
+  ui.addLog('info', `Lead: ${stats.leadName} -> Follower: ${stats.followerName}`);
+  ui.addLog('info', `Symbol: ${stats.symbol} | Target: $${dailyTarget} | Risk: $${maxRisk}`);
+  stats.connected = true;
+  
+  // Track lead positions and copy to follower
+  let lastLeadPositions = [];
+  
+  const pollAndCopy = async () => {
+    try {
+      // Get lead positions
+      const leadResult = await lead.service.getPositions(lead.account.accountId);
+      if (!leadResult.success) return;
+      
+      const currentPositions = leadResult.positions || [];
+      
+      // Detect new positions on lead
+      for (const pos of currentPositions) {
+        const existing = lastLeadPositions.find(p => p.contractId === pos.contractId);
+        if (!existing && pos.quantity !== 0) {
+          // New position opened - copy to follower
+          ui.addLog('trade', `Lead opened: ${pos.quantity > 0 ? 'LONG' : 'SHORT'} ${Math.abs(pos.quantity)}x ${pos.symbol || pos.contractId}`);
+          // TODO: Place order on follower account
+        }
+      }
+      
+      // Detect closed positions
+      for (const oldPos of lastLeadPositions) {
+        const stillOpen = currentPositions.find(p => p.contractId === oldPos.contractId);
+        if (!stillOpen || stillOpen.quantity === 0) {
+          ui.addLog('info', `Lead closed: ${oldPos.symbol || oldPos.contractId}`);
+          // TODO: Close position on follower account
+        }
+      }
+      
+      lastLeadPositions = currentPositions;
+      
+      // Update P&L from lead
+      const leadPnL = currentPositions.reduce((sum, p) => sum + (p.profitAndLoss || 0), 0);
+      if (leadPnL !== stats.pnl) {
+        const diff = leadPnL - stats.pnl;
+        if (Math.abs(diff) > 0.01 && stats.pnl !== 0) {
+          stats.trades++;
+          if (diff >= 0) stats.wins++;
+          else stats.losses++;
+        }
+        stats.pnl = leadPnL;
+      }
+      
+      // Check target/risk limits
+      if (stats.pnl >= dailyTarget) {
+        stopReason = 'target';
+        running = false;
+        ui.addLog('success', `TARGET REACHED! +$${stats.pnl.toFixed(2)}`);
+      } else if (stats.pnl <= -maxRisk) {
+        stopReason = 'risk';
+        running = false;
+        ui.addLog('error', `MAX RISK HIT! -$${Math.abs(stats.pnl).toFixed(2)}`);
+      }
+    } catch (e) {
+      // Silent fail - will retry
+    }
+  };
 
   // UI refresh loop
   const refreshInterval = setInterval(() => {
     if (running) ui.render(stats);
   }, 250);
+  
+  // Measure API latency every 5 seconds
+  measureLatency(); // Initial measurement
+  const latencyInterval = setInterval(() => { if (running) measureLatency(); }, 5000);
+  
+  // Poll and copy every 2 seconds
+  pollAndCopy(); // Initial poll
+  const copyInterval = setInterval(() => { if (running) pollAndCopy(); }, 2000);
 
   // Keyboard handling
   const cleanupKeys = setupKeyboardHandler(() => {
@@ -344,11 +395,9 @@ const launchCopyTrading = async (config) => {
 
   // Cleanup
   clearInterval(refreshInterval);
+  clearInterval(latencyInterval);
+  clearInterval(copyInterval);
   if (cleanupKeys) cleanupKeys();
-  if (stats.connected) {
-    hqx.stopAlgo();
-    hqx.disconnect();
-  }
   ui.cleanup();
 
   // Show summary
@@ -356,88 +405,6 @@ const launchCopyTrading = async (config) => {
   await prompts.waitForEnter();
 };
 
-/**
- * Setup HQX event handlers
- */
-const setupEventHandlers = (hqx, ui, stats, lead, follower, showNames, stop, setReason, dailyTarget, maxRisk) => {
-  hqx.on('latency', (d) => {
-    stats.latency = d.latency || 0;
-  });
-
-  hqx.on('log', (d) => {
-    let msg = d.message;
-    if (!showNames) {
-      if (lead.account.accountName) {
-        msg = msg.replace(new RegExp(lead.account.accountName, 'gi'), 'Lead *****');
-      }
-      if (follower.account.accountName) {
-        msg = msg.replace(new RegExp(follower.account.accountName, 'gi'), 'Follower *****');
-      }
-    }
-    ui.addLog(d.type || 'info', msg);
-  });
-
-  hqx.on('trade', (d) => {
-    stats.trades++;
-    stats.pnl += d.pnl || 0;
-    d.pnl >= 0 ? stats.wins++ : stats.losses++;
-    ui.addLog(d.pnl >= 0 ? 'trade' : 'loss', `${d.pnl >= 0 ? '+' : ''}$${d.pnl.toFixed(2)}`);
-
-    if (stats.pnl >= dailyTarget) {
-      setReason('target');
-      stop();
-      ui.addLog('success', `TARGET! +$${stats.pnl.toFixed(2)}`);
-      hqx.stopAlgo();
-    } else if (stats.pnl <= -maxRisk) {
-      setReason('risk');
-      stop();
-      ui.addLog('error', `MAX RISK! -$${Math.abs(stats.pnl).toFixed(2)}`);
-      hqx.stopAlgo();
-    }
-  });
-
-  hqx.on('copy', (d) => {
-    ui.addLog('trade', `COPIED: ${d.side} ${d.quantity}x`);
-  });
-
-  hqx.on('error', (d) => {
-    ui.addLog('error', d.message);
-  });
-
-  hqx.on('disconnected', () => {
-    stats.connected = false;
-  });
-};
-
-/**
- * Start copy trading on HQX server
- */
-const startCopyTradingOnServer = (hqx, lead, follower, dailyTarget, maxRisk, ui) => {
-  ui.addLog('info', 'Starting Copy Trading...');
-
-  const leadCreds = lead.service.getRithmicCredentials?.() || null;
-  const followerCreds = follower.service.getRithmicCredentials?.() || null;
-
-  hqx.startCopyTrading({
-    leadAccountId: lead.account.accountId,
-    leadContractId: lead.symbol.id || lead.symbol.contractId,
-    leadSymbol: lead.symbol.symbol || lead.symbol.name,
-    leadContracts: lead.contracts,
-    leadPropfirm: lead.propfirm,
-    leadToken: lead.service.getToken?.() || null,
-    leadRithmicCredentials: leadCreds,
-    followerAccountId: follower.account.accountId,
-    followerContractId: follower.symbol.id || follower.symbol.contractId,
-    followerSymbol: follower.symbol.symbol || follower.symbol.name,
-    followerContracts: follower.contracts,
-    followerPropfirm: follower.propfirm,
-    followerToken: follower.service.getToken?.() || null,
-    followerRithmicCredentials: followerCreds,
-    dailyTarget,
-    maxRisk,
-  });
-};
-
 /**
  * Setup keyboard handler
  * @param {Function} onStop - Stop callback

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

@@ -7,7 +7,6 @@ const ora = require('ora');
 const readline = require('readline');
 
 const { connections } = require('../../services');
-const { HQXServerService } = require('../../services/hqx-server');
 const { AlgoUI, renderSessionSummary } = require('./ui');
 const { prompts } = require('../../utils');
 const { checkMarketHours } = require('../../services/projectx/market');
@@ -79,7 +78,7 @@ const oneAccountMenu = async (service) => {
 };
 
 /**
- * Symbol selection - RAW API data only
+ * Symbol selection - sorted with popular indices first
  */
 const selectSymbol = async (service, account) => {
   const spinner = ora({ text: 'Loading symbols...', color: 'yellow' }).start();
@@ -90,10 +89,32 @@ const selectSymbol = async (service, account) => {
     return null;
   }
   
-  const contracts = contractsResult.contracts;
+  let contracts = contractsResult.contracts;
+  
+  // Sort: Popular indices first (ES, NQ, MES, MNQ, RTY, YM, etc.)
+  const popularPrefixes = ['ES', 'NQ', 'MES', 'MNQ', 'M2K', 'RTY', 'YM', 'MYM', 'NKD', 'GC', 'SI', 'CL'];
+  
+  contracts.sort((a, b) => {
+    const nameA = a.name || '';
+    const nameB = b.name || '';
+    
+    // Check if names start with popular prefixes
+    const idxA = popularPrefixes.findIndex(p => nameA.startsWith(p));
+    const idxB = popularPrefixes.findIndex(p => nameB.startsWith(p));
+    
+    // Both are popular - sort by popularity order
+    if (idxA !== -1 && idxB !== -1) return idxA - idxB;
+    // Only A is popular - A first
+    if (idxA !== -1) return -1;
+    // Only B is popular - B first
+    if (idxB !== -1) return 1;
+    // Neither - alphabetical
+    return nameA.localeCompare(nameB);
+  });
+  
   spinner.succeed(`Found ${contracts.length} contracts`);
   
-  // Display EXACTLY what API returns - no modifications
+  // Display sorted contracts from API
   const options = contracts.map(c => ({
     label: `${c.name} - ${c.description}`,
     value: c
@@ -148,74 +169,85 @@ const launchAlgo = async (service, account, contract, config) => {
     accountName, symbol: symbolName, contracts,
     target: dailyTarget, risk: maxRisk,
     propfirm: account.propfirm || 'Unknown',
+    platform: account.platform || 'ProjectX',
     pnl: 0, trades: 0, wins: 0, losses: 0,
     latency: 0, connected: false,
     startTime: Date.now()  // Track start time for duration
   };
   
+  // Measure API latency (CLI <-> API)
+  const measureLatency = async () => {
+    try {
+      const start = Date.now();
+      await service.getPositions(account.accountId);
+      stats.latency = Date.now() - start;
+    } catch (e) {
+      stats.latency = 0;
+    }
+  };
+  
   let running = true;
   let stopReason = null;
   
-  const hqx = new HQXServerService();
-  const spinner = ora({ text: 'Connecting to HQX Server...', color: 'yellow' }).start();
-  
-  try {
-    const auth = await hqx.authenticate(account.accountId.toString(), account.propfirm || 'topstep');
-    if (!auth.success) throw new Error(auth.error || 'Auth failed');
-    
-    spinner.text = 'Connecting WebSocket...';
-    const conn = await hqx.connect();
-    if (!conn.success) throw new Error('WebSocket failed');
-    
-    spinner.succeed('Connected to HQX Server');
-    stats.connected = true;
-  } catch (err) {
-    spinner.warn('HQX Server unavailable - offline mode');
-  }
-  
-  // Event handlers
-  hqx.on('latency', (d) => { stats.latency = d.latency || 0; });
-  hqx.on('log', (d) => {
-    let msg = d.message;
-    if (!showName && account.accountName) msg = msg.replace(new RegExp(account.accountName, 'gi'), 'HQX *****');
-    ui.addLog(d.type || 'info', msg);
-  });
-  
-  // REAL P&L direct from Rithmic - no calculation
-  hqx.on('stats', (d) => {
-    if (d.realTimePnL) {
-      stats.pnl = d.realTimePnL.totalPnL;
+  // Local algo - no external server needed
+  ui.addLog('info', `Starting algo on ${stats.platform}...`);
+  ui.addLog('info', `Symbol: ${symbolName} | Qty: ${contracts}`);
+  ui.addLog('info', `Target: $${dailyTarget} | Risk: $${maxRisk}`);
+  stats.connected = true;
+  
+  // Poll P&L from API every 2 seconds
+  const pollPnL = async () => {
+    try {
+      // Get positions to check P&L
+      const posResult = await service.getPositions(account.accountId);
+      if (posResult.success && posResult.positions) {
+        // Find position for our symbol
+        const pos = posResult.positions.find(p => 
+          (p.contractId || p.symbol || '').includes(contract.name || contract.symbol)
+        );
+        if (pos && pos.profitAndLoss !== undefined) {
+          const prevPnL = stats.pnl;
+          stats.pnl = pos.profitAndLoss;
+          
+          // Detect trade completion
+          if (Math.abs(stats.pnl - prevPnL) > 0.01 && prevPnL !== 0) {
+            const tradePnL = stats.pnl - prevPnL;
+            stats.trades++;
+            if (tradePnL >= 0) {
+              stats.wins++;
+              ui.addLog('trade', `Trade closed: +$${tradePnL.toFixed(2)}`);
+            } else {
+              stats.losses++;
+              ui.addLog('loss', `Trade closed: -$${Math.abs(tradePnL).toFixed(2)}`);
+            }
+          }
+        }
+      }
+      
+      // Check target/risk limits
+      if (stats.pnl >= dailyTarget) {
+        stopReason = 'target';
+        running = false;
+        ui.addLog('success', `TARGET REACHED! +$${stats.pnl.toFixed(2)}`);
+      } else if (stats.pnl <= -maxRisk) {
+        stopReason = 'risk';
+        running = false;
+        ui.addLog('error', `MAX RISK HIT! -$${Math.abs(stats.pnl).toFixed(2)}`);
+      }
+    } catch (e) {
+      // Silent fail - will retry
     }
-    stats.trades = d.trades;
-    stats.wins = d.wins;
-    stats.losses = d.losses;
-  });
+  };
   
-  hqx.on('error', (d) => { ui.addLog('error', d.message || 'Error'); });
-  hqx.on('disconnected', () => { stats.connected = false; ui.addLog('warning', 'Disconnected'); });
+  const refreshInterval = setInterval(() => { if (running) ui.render(stats); }, 250);
   
-  // Start on server
-  if (stats.connected) {
-    ui.addLog('info', 'Starting algo...');
-    
-    // Get Rithmic credentials from the account's service
-    let rithmicCreds = null;
-    if (service && service.getRithmicCredentials) {
-      rithmicCreds = service.getRithmicCredentials();
-    }
-    
-    hqx.startAlgo({
-      accountId: account.accountId,
-      contractId: contract.id || contract.contractId,
-      symbol: contract.symbol || contract.name,
-      contracts, dailyTarget, maxRisk,
-      propfirm: account.propfirm || 'topstep',
-      propfirmToken: service.getToken?.() || null,
-      rithmicCredentials: rithmicCreds
-    });
-  }
+  // Measure API latency every 5 seconds
+  measureLatency(); // Initial measurement
+  const latencyInterval = setInterval(() => { if (running) measureLatency(); }, 5000);
   
-  const refreshInterval = setInterval(() => { if (running) ui.render(stats); }, 250);
+  // Poll P&L from API every 2 seconds
+  pollPnL(); // Initial poll
+  const pnlInterval = setInterval(() => { if (running) pollPnL(); }, 2000);
   
   // Keyboard
   const setupKeyHandler = () => {
@@ -243,8 +275,9 @@ const launchAlgo = async (service, account, contract, config) => {
   });
   
   clearInterval(refreshInterval);
+  clearInterval(latencyInterval);
+  clearInterval(pnlInterval);
   if (cleanupKeys) cleanupKeys();
-  if (stats.connected) { hqx.stopAlgo(); hqx.disconnect(); }
   ui.cleanup();
   
   // Calculate duration

package/src/pages/algo/ui.js

@@ -189,12 +189,20 @@ class AlgoUI {
     
     this._line(chalk.cyan(GM));
     
-    // Row 4: Trades | Propfirm
+    // Row 4: Trades | Latency (API response time)
     const r4c1t = ` Trades: ${chalk.cyan(stats.trades || 0)}  W/L: ${chalk.green(stats.wins || 0)}/${chalk.red(stats.losses || 0)}`;
     const r4c1p = ` Trades: ${stats.trades || 0}  W/L: ${stats.wins || 0}/${stats.losses || 0}`;
-    const r4c2 = buildCell('Propfirm', stats.propfirm || 'N/A', chalk.cyan, colR);
+    const r4c2 = buildCell('Latency', `${stats.latency || 0}ms`, latencyColor, colR);
     row(r4c1t + pad(colL - r4c1p.length), r4c2.padded);
     
+    this._line(chalk.cyan(GM));
+    
+    // Row 5: Platform | Propfirm
+    const platform = stats.platform || 'ProjectX';
+    const r5c1 = buildCell('Platform', platform, chalk.white, colL);
+    const r5c2 = buildCell('Propfirm', stats.propfirm || 'N/A', chalk.cyan, colR);
+    row(r5c1.padded, r5c2.padded);
+    
     this._line(chalk.cyan(GB));
   }