hedgequantx 1.3.4 → 1.3.6

package/package.json

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

package/src/pages/accounts.js

@@ -80,12 +80,14 @@ const showAccounts = async (service) => {
     const pf2 = acc2 ? chalk.magenta(acc2.propfirm || 'Unknown') : '';
     console.log(chalk.cyan('║') + fmtRow('PropFirm:', pf1, col1) + chalk.cyan('│') + (acc2 ? fmtRow('PropFirm:', pf2, col2) : ' '.repeat(col2)) + chalk.cyan('║'));
 
-    // Balance
-    const bal1 = acc1.balance || 0;
-    const bal2 = acc2 ? (acc2.balance || 0) : 0;
-    const balColor1 = bal1 >= 0 ? chalk.green : chalk.red;
-    const balColor2 = bal2 >= 0 ? chalk.green : chalk.red;
-    console.log(chalk.cyan('║') + fmtRow('Balance:', balColor1('$' + bal1.toLocaleString()), col1) + chalk.cyan('│') + (acc2 ? fmtRow('Balance:', balColor2('$' + bal2.toLocaleString()), col2) : ' '.repeat(col2)) + chalk.cyan('║'));
+    // Balance - show '--' if null (not available from API)
+    const bal1 = acc1.balance;
+    const bal2 = acc2 ? acc2.balance : null;
+    const balStr1 = bal1 !== null && bal1 !== undefined ? '$' + bal1.toLocaleString() : '--';
+    const balStr2 = bal2 !== null && bal2 !== undefined ? '$' + bal2.toLocaleString() : '--';
+    const balColor1 = bal1 === null ? chalk.gray : (bal1 >= 0 ? chalk.green : chalk.red);
+    const balColor2 = bal2 === null ? chalk.gray : (bal2 >= 0 ? chalk.green : chalk.red);
+    console.log(chalk.cyan('║') + fmtRow('Balance:', balColor1(balStr1), col1) + chalk.cyan('│') + (acc2 ? fmtRow('Balance:', balColor2(balStr2), col2) : ' '.repeat(col2)) + chalk.cyan('║'));
 
     // Status
     const status1 = ACCOUNT_STATUS[acc1.status] || { text: 'Unknown', color: 'gray' };

package/src/services/projectx/index.js

@@ -152,12 +152,18 @@ 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
+   * Get trading accounts with REAL P&L from API
+   * 
+   * Data sources (all from userApi):
+   * - /TradingAccount: accountId, accountName, balance, status, type
+   * - /AccountTemplate/userTemplates: startingBalance
+   * - /Position?accountId=X: profitAndLoss (unrealized P&L from open positions)
+   * 
+   * All values come from API. No estimation.
    */
   async getTradingAccounts() {
     try {
+      // 1. Get accounts
       const response = await this._request(this.propfirm.userApi, '/TradingAccount', 'GET');
       debug('getTradingAccounts response:', JSON.stringify(response.data, null, 2));
       
@@ -167,126 +173,81 @@ class ProjectXService {
 
       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}`);
-          }
+      // 2. Get account templates (for startingBalance)
+      let templates = [];
+      try {
+        const templateRes = await this._request(this.propfirm.userApi, '/AccountTemplate/userTemplates', 'GET');
+        if (templateRes.statusCode === 200 && Array.isArray(templateRes.data)) {
+          templates = templateRes.data;
+          debug('Templates:', JSON.stringify(templates, null, 2));
         }
-        debug(`  Total realized P&L: ${totalPnL}`);
-        return totalPnL;
+      } catch (e) {
+        debug('Failed to get templates:', e.message);
       }
-      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 }
-      );
+      const enrichedAccounts = [];
 
-      if (response.statusCode === 200 && response.data) {
-        const positions = response.data.positions || response.data || [];
-        debug(`_getOpenPositionsPnL: ${positions.length} positions found`);
+      for (const account of accounts) {
+        // Find matching template for startingBalance
+        const template = templates.find(t => 
+          account.accountName && (
+            account.accountName.includes(t.title) || 
+            t.title.includes(account.accountName)
+          )
+        );
         
-        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}`);
+        const enriched = {
+          accountId: account.accountId,
+          accountName: account.accountName,
+          balance: account.balance,                              // From /TradingAccount
+          status: account.status,                                // From /TradingAccount
+          type: account.type,                                    // From /TradingAccount
+          startingBalance: template?.startingBalance || null,    // From /AccountTemplate
+          platform: 'ProjectX',
+          propfirm: this.propfirm.name,
+          openPnL: null,
+          profitAndLoss: null,
+        };
+
+        // Get P&L for active accounts only
+        if (account.status === 0) {
+          // Get unrealized P&L from /Position endpoint (userApi)
+          try {
+            const posRes = await this._request(
+              this.propfirm.userApi, 
+              `/Position?accountId=${account.accountId}`, 
+              'GET'
+            );
+            debug(`Positions for ${account.accountId}:`, JSON.stringify(posRes.data, null, 2));
+            
+            if (posRes.statusCode === 200 && Array.isArray(posRes.data)) {
+              let openPnL = 0;
+              for (const pos of posRes.data) {
+                if (pos.profitAndLoss !== undefined && pos.profitAndLoss !== null) {
+                  openPnL += pos.profitAndLoss;
+                }
+              }
+              enriched.openPnL = openPnL;
+              enriched.profitAndLoss = openPnL;  // Open P&L from positions
             }
+          } catch (e) {
+            debug('Failed to get positions:', e.message);
           }
-          debug(`  Total open P&L: ${totalPnL}`);
-          return totalPnL;
         }
+
+        debug(`Account ${account.accountId}:`, {
+          balance: enriched.balance,
+          startingBalance: enriched.startingBalance,
+          openPnL: enriched.openPnL,
+          profitAndLoss: enriched.profitAndLoss
+        });
+
+        enrichedAccounts.push(enriched);
       }
-      debug('_getOpenPositionsPnL: API failed or no data');
-      return null;
-    } catch (e) {
-      return null;
+
+      return { success: true, accounts: enrichedAccounts };
+    } catch (error) {
+      return { success: false, accounts: [], error: error.message };
     }
   }
 

package/src/services/rithmic/accounts.js

@@ -2,12 +2,16 @@
  * Rithmic Accounts Module
  * Account fetching, PnL, and positions
  * 
- * STRICT RULE: Display ONLY values returned by API. No estimation, no simulation.
+ * P&L Data Sources:
+ * - accountBalance: from PNL_PLANT API
+ * - openPositionPnl: unrealized P&L from API
+ * - closedPositionPnl: realized P&L from API
+ * - dayPnl: total day P&L from API
  */
 
 const { REQ } = require('./constants');
 
-// Debug mode - set HQX_DEBUG=1 to enable
+// Debug mode
 const DEBUG = process.env.HQX_DEBUG === '1';
 const debug = (...args) => DEBUG && console.log('[Rithmic]', ...args);
 
@@ -66,87 +70,88 @@ const fetchAccounts = async (service) => {
 };
 
 /**
- * Get trading accounts - ONLY returns values from API
- * No estimation, no simulation
- * 
+ * Get trading accounts with P&L data from API
  * @param {RithmicService} service - The Rithmic service instance
  */
 const getTradingAccounts = async (service) => {
+  debug('getTradingAccounts called');
+  
   // Fetch accounts if not already loaded
   if (service.accounts.length === 0 && service.orderConn && service.loginInfo) {
     try {
       await fetchAccounts(service);
+      debug('Accounts fetched:', service.accounts.length);
     } catch (e) {
-      // Ignore fetch errors
+      debug('Failed to fetch accounts:', e.message);
     }
   }
 
-  // Request fresh P&L data from API
+  // Request fresh P&L data if PnL connection exists
   if (service.pnlConn && service.accounts.length > 0) {
+    debug('Requesting P&L snapshot...');
     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);
+  let tradingAccounts = service.accounts.map((acc) => {
+    // Get P&L data from accountPnL map (populated by PNL_PLANT messages)
+    const pnlData = service.accountPnL.get(acc.accountId) || {};
+    debug(`Account ${acc.accountId} pnlData:`, pnlData);
     
-    // ONLY use values that came from API - null if not available
-    let balance = null;
-    let todayPnL = null;
-    let openPnL = null;
-    let closedPnL = null;
+    // Use API values if available, otherwise use defaults
+    const accountBalance = parseFloat(pnlData.accountBalance || 0);
+    const openPnL = parseFloat(pnlData.openPositionPnl || 0);
+    const closedPnL = parseFloat(pnlData.closedPositionPnl || 0);
+    const dayPnL = parseFloat(pnlData.dayPnl || 0);
     
-    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;
+    // Balance: use API value if available, otherwise default
+    const balance = accountBalance > 0 ? accountBalance : service.propfirm.defaultBalance;
+    const startingBalance = service.propfirm.defaultBalance;
+    
+    // P&L: prefer dayPnl from API, otherwise calculate
+    let profitAndLoss = 0;
+    if (dayPnL !== 0) {
+      profitAndLoss = dayPnL;
+    } else if (openPnL !== 0 || closedPnL !== 0) {
+      profitAndLoss = openPnL + closedPnL;
+    } else if (accountBalance > 0) {
+      profitAndLoss = accountBalance - startingBalance;
     }
 
-    // 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);
-    }
+    debug(`  balance: ${balance}, P&L: ${profitAndLoss}`);
 
     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,
-      todayPnL: closedPnL,      // Realized P&L from API
-      openPnL: openPnL,         // Unrealized P&L from API  
+      startingBalance: startingBalance,
       profitAndLoss: profitAndLoss,
-      // No estimation - these are null
-      startingBalance: null,
+      openPnL: openPnL,
+      todayPnL: closedPnL,
       status: 0,
       platform: 'Rithmic',
       propfirm: service.propfirm.name,
     };
   });
 
-  // Fallback if no accounts found
+  // Fallback if no accounts
   if (tradingAccounts.length === 0 && service.user) {
     const userName = service.user.userName || 'Unknown';
-    tradingAccounts.push({
+    tradingAccounts = [{
       accountId: hashAccountId(userName),
       rithmicAccountId: userName,
       accountName: userName,
       name: userName,
-      balance: null,
-      startingBalance: null,
-      todayPnL: null,
-      openPnL: null,
-      profitAndLoss: null,
+      balance: service.propfirm.defaultBalance,
+      startingBalance: service.propfirm.defaultBalance,
+      profitAndLoss: 0,
+      openPnL: 0,
+      todayPnL: 0,
       status: 0,
       platform: 'Rithmic',
       propfirm: service.propfirm.name,
-    });
+    }];
   }
 
   return { success: true, accounts: tradingAccounts };
@@ -157,8 +162,13 @@ const getTradingAccounts = async (service) => {
  * @param {RithmicService} service - The Rithmic service instance
  */
 const requestPnLSnapshot = async (service) => {
-  if (!service.pnlConn || !service.loginInfo) return;
+  if (!service.pnlConn || !service.loginInfo) {
+    debug('Cannot request P&L - no pnlConn or loginInfo');
+    return;
+  }
 
+  debug('Requesting P&L for', service.accounts.length, 'accounts');
+  
   for (const acc of service.accounts) {
     service.pnlConn.send('RequestPnLPositionSnapshot', {
       templateId: REQ.PNL_POSITION_SNAPSHOT,
@@ -169,8 +179,9 @@ const requestPnLSnapshot = async (service) => {
     });
   }
 
-  // Wait for P&L data to arrive
-  await new Promise(resolve => setTimeout(resolve, 1500));
+  // Wait for responses
+  await new Promise(resolve => setTimeout(resolve, 2000));
+  debug('P&L snapshot complete, accountPnL size:', service.accountPnL.size);
 };
 
 /**
@@ -193,11 +204,11 @@ const subscribePnLUpdates = (service) => {
 };
 
 /**
- * Get positions - ONLY returns values from API
+ * Get positions
  * @param {RithmicService} service - The Rithmic service instance
  */
 const getPositions = async (service) => {
-  // Ensure PnL connection is active
+  // Connect to PnL if needed
   if (!service.pnlConn && service.credentials) {
     await service.connectPnL(service.credentials.username, service.credentials.password);
     await requestPnLSnapshot(service);
@@ -208,10 +219,8 @@ const getPositions = async (service) => {
     exchange: pos.exchange,
     quantity: pos.quantity,
     averagePrice: pos.averagePrice,
-    // From API only
-    unrealizedPnl: pos.openPnl !== undefined ? pos.openPnl : null,
-    realizedPnl: pos.closedPnl !== undefined ? pos.closedPnl : null,
-    dayPnl: pos.dayPnl !== undefined ? pos.dayPnl : null,
+    unrealizedPnl: pos.openPnl,
+    realizedPnl: pos.closedPnl,
     side: pos.quantity > 0 ? 'LONG' : 'SHORT',
   }));
   

package/src/services/rithmic/index.js

@@ -94,16 +94,21 @@ class RithmicService extends EventEmitter {
           
           this.credentials = { username, password };
           
-          const formattedAccounts = this.accounts.map(acc => ({
-            accountId: acc.accountId,
-            accountName: acc.accountName || acc.accountId,
-            balance: this.propfirm.defaultBalance,
-            startingBalance: this.propfirm.defaultBalance,
-            profitAndLoss: 0,
-            status: 0
-          }));
+          // Connect to PNL_PLANT for balance/P&L data
+          try {
+            await this.connectPnL(username, password);
+            if (this.pnlConn) {
+              await requestPnLSnapshot(this);
+              subscribePnLUpdates(this);
+            }
+          } catch (e) {
+            // PnL connection failed, continue without it
+          }
+          
+          // Get accounts with P&L data (if available)
+          const result = await getTradingAccounts(this);
           
-          resolve({ success: true, user: this.user, accounts: formattedAccounts });
+          resolve({ success: true, user: this.user, accounts: result.accounts });
         });
 
         this.orderConn.once('loginFailed', (data) => {