hedgequantx 1.3.6 → 1.3.8

package/package.json

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

package/src/menus/dashboard.js

@@ -113,6 +113,10 @@ const dashboardMenu = async (service) => {
   console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
   console.log();
 
+  // Small delay to ensure stdin is ready
+  await new Promise(resolve => setTimeout(resolve, 50));
+  prepareStdin();
+
   const { action } = await inquirer.prompt([
     {
       type: 'input',

package/src/services/rithmic/accounts.js

@@ -95,29 +95,30 @@ const getTradingAccounts = async (service) => {
   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);
+    debug(`Account ${acc.accountId} pnlData:`, JSON.stringify(pnlData));
+    debug(`  accountPnL map size:`, service.accountPnL.size);
     
-    // Use API values if available, otherwise use defaults
+    // Use API values if available
     const accountBalance = parseFloat(pnlData.accountBalance || 0);
     const openPnL = parseFloat(pnlData.openPositionPnl || 0);
     const closedPnL = parseFloat(pnlData.closedPositionPnl || 0);
     const dayPnL = parseFloat(pnlData.dayPnl || 0);
     
-    // Balance: use API value if available, otherwise default
-    const balance = accountBalance > 0 ? accountBalance : service.propfirm.defaultBalance;
+    // Balance: use API value if > 0, otherwise default
+    // Most prop firms don't report balance via PnL stream, so we use default
     const startingBalance = service.propfirm.defaultBalance;
+    const balance = accountBalance > 0 ? accountBalance : startingBalance;
     
-    // P&L: prefer dayPnl from API, otherwise calculate
+    // P&L: prefer dayPnl from API, otherwise calculate from open+closed
     let profitAndLoss = 0;
     if (dayPnL !== 0) {
       profitAndLoss = dayPnL;
     } else if (openPnL !== 0 || closedPnL !== 0) {
       profitAndLoss = openPnL + closedPnL;
-    } else if (accountBalance > 0) {
-      profitAndLoss = accountBalance - startingBalance;
     }
+    // Don't calculate P&L from balance difference - that's estimation
 
-    debug(`  balance: ${balance}, P&L: ${profitAndLoss}`);
+    debug(`  balance: ${balance}, startingBalance: ${startingBalance}, P&L: ${profitAndLoss}`);
 
     return {
       accountId: hashAccountId(acc.accountId),

package/src/services/rithmic/handlers.js

@@ -6,6 +6,10 @@
 const { proto, decodeAccountPnL, decodeInstrumentPnL } = require('./protobuf');
 const { RES, STREAM } = require('./constants');
 
+// Debug mode
+const DEBUG = process.env.HQX_DEBUG === '1';
+const debug = (...args) => DEBUG && console.log('[Rithmic:Handler]', ...args);
+
 /**
  * Create ORDER_PLANT message handler
  * @param {RithmicService} service - The Rithmic service instance
@@ -44,18 +48,24 @@ const createOrderHandler = (service) => {
 const createPnLHandler = (service) => {
   return (msg) => {
     const { templateId, data } = msg;
+    
+    debug('PNL message received, templateId:', templateId);
 
     switch (templateId) {
       case RES.PNL_POSITION_SNAPSHOT:
       case RES.PNL_POSITION_UPDATES:
-        // OK response, nothing to do
+        debug('PNL snapshot/updates response OK');
         break;
       case STREAM.ACCOUNT_PNL_UPDATE:
+        debug('Account PNL update received');
         handleAccountPnLUpdate(service, data);
         break;
       case STREAM.INSTRUMENT_PNL_UPDATE:
+        debug('Instrument PNL update received');
         handleInstrumentPnLUpdate(service, data);
         break;
+      default:
+        debug('Unknown PNL templateId:', templateId);
     }
   };
 };
@@ -136,19 +146,25 @@ const handleShowOrdersResponse = (service, data) => {
 const handleAccountPnLUpdate = (service, data) => {
   try {
     const pnl = decodeAccountPnL(data);
+    debug('Decoded Account PNL:', JSON.stringify(pnl));
+    
     if (pnl.accountId) {
-      service.accountPnL.set(pnl.accountId, {
+      const pnlData = {
         accountBalance: parseFloat(pnl.accountBalance || 0),
         cashOnHand: parseFloat(pnl.cashOnHand || 0),
         marginBalance: parseFloat(pnl.marginBalance || 0),
         openPositionPnl: parseFloat(pnl.openPositionPnl || 0),
         closedPositionPnl: parseFloat(pnl.closedPositionPnl || 0),
         dayPnl: parseFloat(pnl.dayPnl || 0),
-      });
+      };
+      debug('Storing PNL for account:', pnl.accountId, pnlData);
+      service.accountPnL.set(pnl.accountId, pnlData);
       service.emit('pnlUpdate', pnl);
+    } else {
+      debug('No accountId in PNL response');
     }
   } catch (e) {
-    // Ignore decode errors
+    debug('Error decoding Account PNL:', e.message);
   }
 };
 

package/src/services/rithmic/index.js

@@ -10,6 +10,10 @@ const { createOrderHandler, createPnLHandler } = require('./handlers');
 const { fetchAccounts, getTradingAccounts, requestPnLSnapshot, subscribePnLUpdates, getPositions, hashAccountId } = require('./accounts');
 const { placeOrder, cancelOrder, getOrders, getOrderHistory, closePosition } = require('./orders');
 
+// Debug mode
+const DEBUG = process.env.HQX_DEBUG === '1';
+const debug = (...args) => DEBUG && console.log('[Rithmic:Service]', ...args);
+
 // PropFirm configurations
 const PROPFIRM_CONFIGS = {
   'apex': { name: 'Apex Trader Funding', systemName: 'Apex', defaultBalance: 300000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
@@ -94,19 +98,28 @@ class RithmicService extends EventEmitter {
           
           this.credentials = { username, password };
           
+          debug('Accounts found:', this.accounts.length);
+          debug('Account IDs:', this.accounts.map(a => a.accountId));
+          
           // Connect to PNL_PLANT for balance/P&L data
           try {
-            await this.connectPnL(username, password);
+            debug('Connecting to PNL_PLANT...');
+            const pnlConnected = await this.connectPnL(username, password);
+            debug('PNL_PLANT connected:', pnlConnected, 'pnlConn:', !!this.pnlConn);
+            
             if (this.pnlConn) {
+              debug('Requesting P&L snapshot...');
               await requestPnLSnapshot(this);
+              debug('accountPnL map size after snapshot:', this.accountPnL.size);
               subscribePnLUpdates(this);
             }
           } catch (e) {
-            // PnL connection failed, continue without it
+            debug('PnL connection failed:', e.message);
           }
           
           // Get accounts with P&L data (if available)
           const result = await getTradingAccounts(this);
+          debug('Final accounts:', result.accounts.length);
           
           resolve({ success: true, user: this.user, accounts: result.accounts });
         });

package/src/ui/index.js

@@ -29,11 +29,32 @@ 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 {
+    // Ensure stdin is flowing
     if (process.stdin.isPaused()) {
       process.stdin.resume();
     }
+    
+    // Reset stdin to proper state for inquirer
+    if (process.stdin.isTTY) {
+      // Disable raw mode if it was left on
+      if (process.stdin.isRaw) {
+        process.stdin.setRawMode(false);
+      }
+    }
+    
+    // Clear any buffered input by removing old listeners temporarily
+    const oldListeners = process.stdin.listeners('data');
+    process.stdin.removeAllListeners('data');
+    
+    // Restore listeners after a tick
+    setImmediate(() => {
+      oldListeners.forEach(listener => {
+        if (!process.stdin.listeners('data').includes(listener)) {
+          process.stdin.on('data', listener);
+        }
+      });
+    });
   } catch (e) {
     // Ignore errors
   }