hedgequantx 1.3.2 → 1.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "Prop Futures Algo Trading CLI - Connect to Topstep, Alpha Futures, and other prop firms",
   "main": "src/app.js",
   "bin": {

package/src/app.js

@@ -70,30 +70,40 @@ const banner = async () => {
   const version = require('../package.json').version;
   
   // Get stats if connected (only active accounts: status === 0)
+  // STRICT: Only display values from API, no estimation
   let statsInfo = null;
   if (connections.count() > 0) {
     try {
       const allAccounts = await connections.getAllAccounts();
       const activeAccounts = allAccounts.filter(acc => acc.status === 0);
-      let totalBalance = 0;
-      let totalStartingBalance = 0;
-      let totalPnl = 0;
+      
+      // Sum only non-null values from API
+      let totalBalance = null;
+      let totalPnl = null;
+      let hasBalanceData = false;
+      let hasPnlData = false;
       
       activeAccounts.forEach(account => {
-        totalBalance += account.balance || 0;
-        totalStartingBalance += account.startingBalance || 0;
-        totalPnl += account.profitAndLoss || 0;
+        // Balance: only sum if API returned a value
+        if (account.balance !== null && account.balance !== undefined) {
+          totalBalance = (totalBalance || 0) + account.balance;
+          hasBalanceData = true;
+        }
+        
+        // P&L: only sum if API returned a value
+        if (account.profitAndLoss !== null && account.profitAndLoss !== undefined) {
+          totalPnl = (totalPnl || 0) + account.profitAndLoss;
+          hasPnlData = true;
+        }
       });
       
-      const pnl = totalPnl !== 0 ? totalPnl : (totalBalance - totalStartingBalance);
-      const pnlPercent = totalStartingBalance > 0 ? ((pnl / totalStartingBalance) * 100).toFixed(1) : '0.0';
-      
       statsInfo = {
         connections: connections.count(),
         accounts: activeAccounts.length,
-        balance: totalBalance,
-        pnl: pnl,
-        pnlPercent: pnlPercent
+        balance: hasBalanceData ? totalBalance : null,
+        pnl: hasPnlData ? totalPnl : null,
+        // No percentage calculation if no verified data
+        pnlPercent: null
       };
     } catch (e) {
       // Ignore errors
@@ -168,19 +178,33 @@ const banner = async () => {
   console.log(chalk.cyan('║') + chalk.white(centerText(tagline, innerWidth)) + chalk.cyan('║'));
   
   // Stats bar if connected
+  // STRICT: Only display verified values from API, show '--' for unavailable data
   if (statsInfo) {
     console.log(chalk.cyan('╠' + '═'.repeat(innerWidth) + '╣'));
     
-    const pnlColor = statsInfo.pnl >= 0 ? chalk.green : chalk.red;
-    const pnlSign = statsInfo.pnl >= 0 ? '+' : '';
-    
     const connStr = `Connections: ${statsInfo.connections}`;
     const accStr = `Accounts: ${statsInfo.accounts}`;
-    const balStr = `Balance: $${statsInfo.balance.toLocaleString()}`;
-    const pnlStr = `P&L: $${statsInfo.pnl.toLocaleString()} (${pnlSign}${statsInfo.pnlPercent}%)`;
+    
+    // Balance: show '--' if not available from API
+    const balStr = statsInfo.balance !== null 
+      ? `Balance: $${statsInfo.balance.toLocaleString()}` 
+      : `Balance: --`;
+    const balColor = statsInfo.balance !== null ? chalk.green : chalk.gray;
+    
+    // P&L: show '--' if not available from API
+    let pnlDisplay;
+    let pnlColor;
+    if (statsInfo.pnl !== null) {
+      const pnlSign = statsInfo.pnl >= 0 ? '+' : '';
+      pnlColor = statsInfo.pnl >= 0 ? chalk.green : chalk.red;
+      pnlDisplay = `$${statsInfo.pnl.toLocaleString()} (${pnlSign}${statsInfo.pnl.toFixed(1)})`;
+    } else {
+      pnlColor = chalk.gray;
+      pnlDisplay = '--';
+    }
     
     // Build full stats text and calculate padding
-    const statsText = `${connStr}    ${accStr}    ${balStr}    ${pnlStr}`;
+    const statsText = `${connStr}    ${accStr}    ${balStr}    P&L: ${pnlDisplay}`;
     const statsLen = statsText.length;
     const statsLeftPad = Math.floor((innerWidth - statsLen) / 2);
     const statsRightPad = innerWidth - statsLen - statsLeftPad;
@@ -188,9 +212,9 @@ const banner = async () => {
     console.log(chalk.cyan('║') + ' '.repeat(statsLeftPad) +
       chalk.white(connStr) + '    ' +
       chalk.white(accStr) + '    ' +
-      chalk.white('Balance: ') + chalk.green(`$${statsInfo.balance.toLocaleString()}`) + '    ' +
-      chalk.white('P&L: ') + pnlColor(`$${statsInfo.pnl.toLocaleString()} (${pnlSign}${statsInfo.pnlPercent}%)`) + 
-      ' '.repeat(statsRightPad) + chalk.cyan('║')
+      chalk.white('Balance: ') + balColor(statsInfo.balance !== null ? `$${statsInfo.balance.toLocaleString()}` : '--') + '    ' +
+      chalk.white('P&L: ') + pnlColor(pnlDisplay) + 
+      ' '.repeat(Math.max(0, statsRightPad)) + chalk.cyan('║')
     );
   }
   

package/src/services/projectx/index.js

@@ -1,10 +1,16 @@
 /**
  * ProjectX API Service
  * Main service for ProjectX prop firm connections
+ * 
+ * STRICT RULE: Display ONLY values returned by API. No estimation, no simulation.
  */
 
 const https = require('https');
 const { PROPFIRMS } = require('../../config');
+
+// Debug mode - set HQX_DEBUG=1 to enable
+const DEBUG = process.env.HQX_DEBUG === '1';
+const debug = (...args) => DEBUG && console.log('[ProjectX]', ...args);
 const { 
   validateUsername, 
   validatePassword, 
@@ -145,18 +151,145 @@ class ProjectXService {
 
   // ==================== ACCOUNTS ====================
 
+  /**
+   * Get trading accounts - ONLY returns values from API
+   * For banner display: returns basic account info quickly
+   * Use getAccountPnL() for detailed P&L data
+   */
   async getTradingAccounts() {
     try {
       const response = await this._request(this.propfirm.userApi, '/TradingAccount', 'GET');
-      if (response.statusCode === 200) {
-        return { success: true, accounts: Array.isArray(response.data) ? response.data : [] };
+      debug('getTradingAccounts response:', JSON.stringify(response.data, null, 2));
+      
+      if (response.statusCode !== 200) {
+        return { success: false, accounts: [], error: 'Failed to get accounts' };
       }
-      return { success: false, accounts: [], error: 'Failed to get accounts' };
+
+      const accounts = Array.isArray(response.data) ? response.data : [];
+      
+      // Return RAW API data only - no additional calls for speed
+      const enrichedAccounts = accounts.map(account => ({
+        accountId: account.accountId,
+        accountName: account.accountName,
+        balance: account.balance,  // From API
+        status: account.status,    // From API
+        type: account.type,        // From API
+        platform: 'ProjectX',
+        propfirm: this.propfirm.name,
+        // P&L not available from /TradingAccount endpoint
+        todayPnL: null,
+        openPnL: null,
+        profitAndLoss: null,
+        startingBalance: null,
+      }));
+
+      return { success: true, accounts: enrichedAccounts };
     } catch (error) {
       return { success: false, accounts: [], error: error.message };
     }
   }
 
+  /**
+   * Get detailed P&L for a specific account
+   * Call this separately when P&L details are needed (e.g., stats page)
+   */
+  async getAccountPnL(accountId) {
+    const todayPnL = await this._getTodayRealizedPnL(accountId);
+    const openPnL = await this._getOpenPositionsPnL(accountId);
+    
+    let totalPnL = null;
+    if (todayPnL !== null || openPnL !== null) {
+      totalPnL = (todayPnL || 0) + (openPnL || 0);
+    }
+    
+    debug(`Account ${accountId} P&L:`, { todayPnL, openPnL, totalPnL });
+    
+    return {
+      todayPnL,
+      openPnL,
+      profitAndLoss: totalPnL
+    };
+  }
+
+  /**
+   * Get today's realized P&L from Trade API
+   * Returns null if API fails (not 0)
+   * @private
+   */
+  async _getTodayRealizedPnL(accountId) {
+    try {
+      const now = new Date();
+      const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      
+      const response = await this._request(
+        this.propfirm.gatewayApi, '/api/Trade/search', 'POST',
+        { 
+          accountId: accountId, 
+          startTimestamp: startOfDay.toISOString(), 
+          endTimestamp: now.toISOString() 
+        }
+      );
+
+      if (response.statusCode === 200 && response.data) {
+        const trades = Array.isArray(response.data) 
+          ? response.data 
+          : (response.data.trades || []);
+        
+        debug(`_getTodayRealizedPnL: ${trades.length} trades found`);
+        
+        // Sum P&L from API response only
+        let totalPnL = 0;
+        for (const trade of trades) {
+          if (trade.profitAndLoss !== undefined && trade.profitAndLoss !== null) {
+            totalPnL += trade.profitAndLoss;
+            debug(`  Trade P&L: ${trade.profitAndLoss}`);
+          }
+        }
+        debug(`  Total realized P&L: ${totalPnL}`);
+        return totalPnL;
+      }
+      debug('_getTodayRealizedPnL: API failed or no data');
+      return null; // API failed - return null, not 0
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /**
+   * Get unrealized P&L from open positions API
+   * Returns null if API fails (not 0)
+   * @private
+   */
+  async _getOpenPositionsPnL(accountId) {
+    try {
+      const response = await this._request(
+        this.propfirm.gatewayApi, '/api/Position/searchOpen', 'POST',
+        { accountId: accountId }
+      );
+
+      if (response.statusCode === 200 && response.data) {
+        const positions = response.data.positions || response.data || [];
+        debug(`_getOpenPositionsPnL: ${positions.length} positions found`);
+        
+        if (Array.isArray(positions)) {
+          let totalPnL = 0;
+          for (const pos of positions) {
+            if (pos.profitAndLoss !== undefined && pos.profitAndLoss !== null) {
+              totalPnL += pos.profitAndLoss;
+              debug(`  Position ${pos.symbolId || 'unknown'} P&L: ${pos.profitAndLoss}`);
+            }
+          }
+          debug(`  Total open P&L: ${totalPnL}`);
+          return totalPnL;
+        }
+      }
+      debug('_getOpenPositionsPnL: API failed or no data');
+      return null;
+    } catch (e) {
+      return null;
+    }
+  }
+
   // ==================== TRADING ====================
 
   async getPositions(accountId) {

package/src/services/rithmic/accounts.js

@@ -1,10 +1,16 @@
 /**
  * Rithmic Accounts Module
  * Account fetching, PnL, and positions
+ * 
+ * STRICT RULE: Display ONLY values returned by API. No estimation, no simulation.
  */
 
 const { REQ } = require('./constants');
 
+// Debug mode - set HQX_DEBUG=1 to enable
+const DEBUG = process.env.HQX_DEBUG === '1';
+const debug = (...args) => DEBUG && console.log('[Rithmic]', ...args);
+
 /**
  * Hash account ID to numeric (for compatibility)
  */
@@ -60,10 +66,13 @@ const fetchAccounts = async (service) => {
 };
 
 /**
- * Get trading accounts formatted like ProjectX
+ * Get trading accounts - ONLY returns values from API
+ * No estimation, no simulation
+ * 
  * @param {RithmicService} service - The Rithmic service instance
  */
 const getTradingAccounts = async (service) => {
+  // Fetch accounts if not already loaded
   if (service.accounts.length === 0 && service.orderConn && service.loginInfo) {
     try {
       await fetchAccounts(service);
@@ -72,40 +81,72 @@ const getTradingAccounts = async (service) => {
     }
   }
 
-  let tradingAccounts = service.accounts.map((acc) => {
-    const pnl = service.accountPnL.get(acc.accountId) || {};
-    const balance = parseFloat(pnl.accountBalance || pnl.marginBalance || pnl.cashOnHand || 0) || service.propfirm.defaultBalance;
-    const startingBalance = service.propfirm.defaultBalance;
-    const profitAndLoss = balance - startingBalance;
+  // Request fresh P&L data from API
+  if (service.pnlConn && service.accounts.length > 0) {
+    await requestPnLSnapshot(service);
+  }
+
+  const tradingAccounts = service.accounts.map((acc) => {
+    // Get P&L data from API (stored in accountPnL map from handlers.js)
+    const pnlData = service.accountPnL.get(acc.accountId);
+    
+    // ONLY use values that came from API - null if not available
+    let balance = null;
+    let todayPnL = null;
+    let openPnL = null;
+    let closedPnL = null;
+    
+    if (pnlData) {
+      // These values come directly from Rithmic API via handleAccountPnLUpdate
+      balance = pnlData.accountBalance !== undefined ? pnlData.accountBalance : null;
+      openPnL = pnlData.openPositionPnl !== undefined ? pnlData.openPositionPnl : null;
+      closedPnL = pnlData.closedPositionPnl !== undefined ? pnlData.closedPositionPnl : null;
+      todayPnL = pnlData.dayPnl !== undefined ? pnlData.dayPnl : null;
+    }
+
+    // Total P&L from API only
+    let profitAndLoss = null;
+    if (todayPnL !== null) {
+      profitAndLoss = todayPnL;
+    } else if (openPnL !== null || closedPnL !== null) {
+      profitAndLoss = (openPnL || 0) + (closedPnL || 0);
+    }
 
     return {
       accountId: hashAccountId(acc.accountId),
       rithmicAccountId: acc.accountId,
       accountName: acc.accountName || acc.accountId,
       name: acc.accountName || acc.accountId,
+      // From API only - null if not available
       balance: balance,
-      startingBalance: startingBalance,
+      todayPnL: closedPnL,      // Realized P&L from API
+      openPnL: openPnL,         // Unrealized P&L from API  
       profitAndLoss: profitAndLoss,
+      // No estimation - these are null
+      startingBalance: null,
       status: 0,
       platform: 'Rithmic',
       propfirm: service.propfirm.name,
     };
   });
 
+  // Fallback if no accounts found
   if (tradingAccounts.length === 0 && service.user) {
     const userName = service.user.userName || 'Unknown';
-    tradingAccounts = [{
+    tradingAccounts.push({
       accountId: hashAccountId(userName),
       rithmicAccountId: userName,
       accountName: userName,
       name: userName,
-      balance: service.propfirm.defaultBalance,
-      startingBalance: service.propfirm.defaultBalance,
-      profitAndLoss: 0,
+      balance: null,
+      startingBalance: null,
+      todayPnL: null,
+      openPnL: null,
+      profitAndLoss: null,
       status: 0,
       platform: 'Rithmic',
       propfirm: service.propfirm.name,
-    }];
+    });
   }
 
   return { success: true, accounts: tradingAccounts };
@@ -128,7 +169,8 @@ const requestPnLSnapshot = async (service) => {
     });
   }
 
-  await new Promise(resolve => setTimeout(resolve, 2000));
+  // Wait for P&L data to arrive
+  await new Promise(resolve => setTimeout(resolve, 1500));
 };
 
 /**
@@ -151,10 +193,11 @@ const subscribePnLUpdates = (service) => {
 };
 
 /**
- * Get positions
+ * Get positions - ONLY returns values from API
  * @param {RithmicService} service - The Rithmic service instance
  */
 const getPositions = async (service) => {
+  // Ensure PnL connection is active
   if (!service.pnlConn && service.credentials) {
     await service.connectPnL(service.credentials.username, service.credentials.password);
     await requestPnLSnapshot(service);
@@ -165,8 +208,10 @@ const getPositions = async (service) => {
     exchange: pos.exchange,
     quantity: pos.quantity,
     averagePrice: pos.averagePrice,
-    unrealizedPnl: pos.openPnl,
-    realizedPnl: pos.closedPnl,
+    // From API only
+    unrealizedPnl: pos.openPnl !== undefined ? pos.openPnl : null,
+    realizedPnl: pos.closedPnl !== undefined ? pos.closedPnl : null,
+    dayPnl: pos.dayPnl !== undefined ? pos.dayPnl : null,
     side: pos.quantity > 0 ? 'LONG' : 'SHORT',
   }));
   

package/src/services/tradovate/index.js

@@ -1,6 +1,8 @@
 /**
  * Tradovate Service
  * Main service for Tradovate prop firm connections (Apex, TakeProfitTrader)
+ * 
+ * STRICT RULE: Display ONLY values returned by API. No estimation, no simulation.
  */
 
 const https = require('https');
@@ -112,7 +114,8 @@ class TradovateService extends EventEmitter {
   }
 
   /**
-   * Get trading accounts (formatted for HQX)
+   * Get trading accounts - ONLY returns values from API
+   * No estimation, no simulation
    */
   async getTradingAccounts() {
     if (this.accounts.length === 0) {
@@ -121,20 +124,34 @@ class TradovateService extends EventEmitter {
 
     const tradingAccounts = this.accounts.map((acc) => {
       const cb = acc.cashBalance || {};
-      const balance = cb.totalCashValue || cb.netLiquidatingValue || this.propfirm.defaultBalance;
-      const startingBalance = this.propfirm.defaultBalance;
-      const profitAndLoss = cb.totalPnL || (balance - startingBalance);
-      const openPnL = cb.openPnL || 0;
+      
+      // ONLY use values from API - null if not available
+      const balance = cb.totalCashValue !== undefined ? cb.totalCashValue : 
+                      (cb.netLiquidatingValue !== undefined ? cb.netLiquidatingValue : null);
+      
+      // P&L from API only - null if not available
+      const realizedPnL = cb.realizedPnL !== undefined ? cb.realizedPnL : null;
+      const openPnL = cb.openPnL !== undefined ? cb.openPnL : null;
+      
+      // Total P&L from API
+      let profitAndLoss = null;
+      if (cb.totalPnL !== undefined) {
+        profitAndLoss = cb.totalPnL;
+      } else if (realizedPnL !== null || openPnL !== null) {
+        profitAndLoss = (realizedPnL || 0) + (openPnL || 0);
+      }
 
       return {
         accountId: acc.id,
         tradovateAccountId: acc.id,
         accountName: acc.name,
         name: acc.name,
+        // From API only - null if not available
         balance: balance,
-        startingBalance: startingBalance,
-        profitAndLoss: profitAndLoss,
+        todayPnL: realizedPnL,
         openPnL: openPnL,
+        profitAndLoss: profitAndLoss,
+        startingBalance: null,  // API doesn't provide this
         status: acc.active ? 0 : 3,
         platform: 'Tradovate',
         propfirm: this.propfirm.name,

package/src/ui/index.js

@@ -29,16 +29,11 @@ const { createBoxMenu } = require('./menu');
  * This fixes input leaking to bash after session restore or algo trading
  */
 const prepareStdin = () => {
+  // Minimal intervention - just ensure stdin is flowing
   try {
-    // Remove any raw mode that might be left from previous operations
-    if (process.stdin.isTTY && process.stdin.isRaw) {
-      process.stdin.setRawMode(false);
+    if (process.stdin.isPaused()) {
+      process.stdin.resume();
     }
-    // Remove any lingering keypress listeners
-    process.stdin.removeAllListeners('keypress');
-    process.stdin.removeAllListeners('data');
-    // Pause stdin so inquirer can take control
-    process.stdin.pause();
   } catch (e) {
     // Ignore errors
   }