hedgequantx 1.3.1 → 1.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "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,6 +1,8 @@
 /**
  * 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');
@@ -145,18 +147,131 @@ class ProjectXService {
 
   // ==================== ACCOUNTS ====================
 
+  /**
+   * Get trading accounts - ONLY returns values from API
+   * P&L comes from: today's trades + open positions (both from API)
+   */
   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 : [] };
+      if (response.statusCode !== 200) {
+        return { success: false, accounts: [], error: 'Failed to get accounts' };
+      }
+
+      const accounts = Array.isArray(response.data) ? response.data : [];
+      const enrichedAccounts = [];
+
+      for (const account of accounts) {
+        // Start with RAW API data only
+        const enriched = {
+          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 fields - will be populated from API calls
+          todayPnL: null,
+          openPnL: null,
+          profitAndLoss: null,
+          startingBalance: null,
+        };
+
+        // Only fetch P&L for active accounts
+        if (account.status === 0) {
+          // Get today's realized P&L from trades API
+          const todayPnL = await this._getTodayRealizedPnL(account.accountId);
+          enriched.todayPnL = todayPnL;
+
+          // Get unrealized P&L from open positions API
+          const openPnL = await this._getOpenPositionsPnL(account.accountId);
+          enriched.openPnL = openPnL;
+
+          // Total P&L = realized + unrealized (both from API)
+          if (todayPnL !== null || openPnL !== null) {
+            enriched.profitAndLoss = (todayPnL || 0) + (openPnL || 0);
+          }
+        }
+
+        enrichedAccounts.push(enriched);
       }
-      return { success: false, accounts: [], error: 'Failed to get accounts' };
+
+      return { success: true, accounts: enrichedAccounts };
     } catch (error) {
       return { success: false, accounts: [], error: error.message };
     }
   }
 
+  /**
+   * 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 || []);
+        
+        // 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;
+          }
+        }
+        return totalPnL;
+      }
+      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 || [];
+        if (Array.isArray(positions)) {
+          let totalPnL = 0;
+          for (const pos of positions) {
+            if (pos.profitAndLoss !== undefined && pos.profitAndLoss !== null) {
+              totalPnL += pos.profitAndLoss;
+            }
+          }
+          return totalPnL;
+        }
+      }
+      return null;
+    } catch (e) {
+      return null;
+    }
+  }
+
   // ==================== TRADING ====================
 
   async getPositions(accountId) {

package/src/services/rithmic/accounts.js

@@ -1,6 +1,8 @@
 /**
  * Rithmic Accounts Module
  * Account fetching, PnL, and positions
+ * 
+ * STRICT RULE: Display ONLY values returned by API. No estimation, no simulation.
  */
 
 const { REQ } = require('./constants');
@@ -60,10 +62,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 +77,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 +165,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 +189,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 +204,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,12 +1,15 @@
 /**
  * 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');
-const WebSocket = require('ws');
 const EventEmitter = require('events');
 const { TRADOVATE_URLS, API_PATHS, WS_EVENTS, getBaseUrl, getTradingWebSocketUrl } = require('./constants');
+const { checkMarketHours, isDST } = require('./market');
+const { connectWebSocket, wsSend, disconnectWebSocket } = require('./websocket');
 
 class TradovateService extends EventEmitter {
   constructor(propfirmKey) {
@@ -21,6 +24,7 @@ class TradovateService extends EventEmitter {
     this.user = null;
     this.isDemo = true; // Default to demo
     this.ws = null;
+    this.wsRequestId = 1;
     this.renewalTimer = null;
     this.credentials = null; // Store for session restore
   }
@@ -39,9 +43,6 @@ class TradovateService extends EventEmitter {
 
   /**
    * Login to Tradovate
-   * @param {string} username - Tradovate username
-   * @param {string} password - Tradovate password
-   * @param {object} options - Optional { cid, sec } for API key auth
    */
   async login(username, password, options = {}) {
     try {
@@ -53,7 +54,6 @@ class TradovateService extends EventEmitter {
         deviceId: this.generateDeviceId(),
       };
 
-      // Add API key if provided
       if (options.cid) authData.cid = options.cid;
       if (options.sec) authData.sec = options.sec;
 
@@ -72,16 +72,12 @@ class TradovateService extends EventEmitter {
       this.userId = result.userId;
       this.tokenExpiration = new Date(result.expirationTime);
       this.user = { userName: result.name, userId: result.userId };
-      this.credentials = { username, password }; // Store for session restore
+      this.credentials = { username, password };
 
-      // Setup token renewal
       this.setupTokenRenewal();
-
-      // Fetch accounts
       await this.fetchAccounts();
 
       return { success: true };
-
     } catch (error) {
       return { success: false, error: error.message };
     }
@@ -97,7 +93,6 @@ class TradovateService extends EventEmitter {
       if (Array.isArray(accounts)) {
         this.accounts = accounts;
         
-        // Fetch cash balance for each account
         for (const acc of this.accounts) {
           try {
             const cashBalance = await this._request(
@@ -119,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) {
@@ -128,24 +124,38 @@ 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,
-        status: acc.active ? 0 : 3, // 0=Active, 3=Inactive
+        profitAndLoss: profitAndLoss,
+        startingBalance: null,  // API doesn't provide this
+        status: acc.active ? 0 : 3,
         platform: 'Tradovate',
         propfirm: this.propfirm.name,
-        accountType: acc.accountType, // 'Customer' or 'Demo'
+        accountType: acc.accountType,
       };
     });
 
@@ -263,7 +273,7 @@ class TradovateService extends EventEmitter {
    * Get market status
    */
   async getMarketStatus(accountId) {
-    const marketHours = this.checkMarketHours();
+    const marketHours = checkMarketHours();
     return {
       success: true,
       isOpen: marketHours.isOpen,
@@ -358,44 +368,6 @@ class TradovateService extends EventEmitter {
     }
   }
 
-  /**
-   * Check market hours (same logic as ProjectX)
-   */
-  checkMarketHours() {
-    const now = new Date();
-    const utcDay = now.getUTCDay();
-    const utcHour = now.getUTCHours();
-
-    const ctOffset = this.isDST(now) ? 5 : 6;
-    const ctHour = (utcHour - ctOffset + 24) % 24;
-    const ctDay = utcHour < ctOffset ? (utcDay + 6) % 7 : utcDay;
-
-    if (ctDay === 6) {
-      return { isOpen: false, message: 'Market closed (Saturday)' };
-    }
-
-    if (ctDay === 0 && ctHour < 17) {
-      return { isOpen: false, message: 'Market opens Sunday 5:00 PM CT' };
-    }
-
-    if (ctDay === 5 && ctHour >= 16) {
-      return { isOpen: false, message: 'Market closed (Friday after 4PM CT)' };
-    }
-
-    if (ctHour === 16 && ctDay >= 1 && ctDay <= 4) {
-      return { isOpen: false, message: 'Daily maintenance (4:00-5:00 PM CT)' };
-    }
-
-    return { isOpen: true, message: 'Market is open' };
-  }
-
-  isDST(date) {
-    const jan = new Date(date.getFullYear(), 0, 1);
-    const jul = new Date(date.getFullYear(), 6, 1);
-    const stdOffset = Math.max(jan.getTimezoneOffset(), jul.getTimezoneOffset());
-    return date.getTimezoneOffset() < stdOffset;
-  }
-
   /**
    * Setup automatic token renewal
    */
@@ -440,77 +412,14 @@ class TradovateService extends EventEmitter {
    * Connect to WebSocket for real-time updates
    */
   async connectWebSocket() {
-    return new Promise((resolve, reject) => {
-      const wsUrl = getTradingWebSocketUrl(this.isDemo);
-      this.ws = new WebSocket(wsUrl);
-
-      this.ws.on('open', () => {
-        // Authorize
-        this.wsSend('authorize', '', { token: this.accessToken });
-        resolve(true);
-      });
-
-      this.ws.on('message', (data) => {
-        this.handleWsMessage(data);
-      });
-
-      this.ws.on('error', (err) => {
-        this.emit('error', err);
-        reject(err);
-      });
-
-      this.ws.on('close', () => {
-        this.emit('disconnected');
-      });
-
-      setTimeout(() => reject(new Error('WebSocket timeout')), 10000);
-    });
+    return connectWebSocket(this);
   }
 
   /**
    * Send WebSocket message
    */
   wsSend(url, query = '', body = null) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
-
-    const msg = body
-      ? `${url}\n${this.wsRequestId++}\n${query}\n${JSON.stringify(body)}`
-      : `${url}\n${this.wsRequestId++}\n${query}\n`;
-
-    this.ws.send(msg);
-  }
-
-  wsRequestId = 1;
-
-  /**
-   * Handle WebSocket message
-   */
-  handleWsMessage(data) {
-    try {
-      const str = data.toString();
-      
-      // Tradovate WS format: frame\nid\ndata
-      if (str.startsWith('a')) {
-        const json = JSON.parse(str.slice(1));
-        if (Array.isArray(json)) {
-          json.forEach(msg => this.processWsEvent(msg));
-        }
-      }
-    } catch (e) {
-      // Ignore parse errors
-    }
-  }
-
-  /**
-   * Process WebSocket event
-   */
-  processWsEvent(msg) {
-    if (msg.e === 'props') {
-      // User data sync
-      if (msg.d?.orders) this.emit(WS_EVENTS.ORDER, msg.d.orders);
-      if (msg.d?.positions) this.emit(WS_EVENTS.POSITION, msg.d.positions);
-      if (msg.d?.cashBalances) this.emit(WS_EVENTS.CASH_BALANCE, msg.d.cashBalances);
-    }
+    return wsSend(this, url, query, body);
   }
 
   /**
@@ -522,10 +431,7 @@ class TradovateService extends EventEmitter {
       this.renewalTimer = null;
     }
 
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
+    disconnectWebSocket(this);
 
     this.accessToken = null;
     this.mdAccessToken = null;

package/src/services/tradovate/market.js

@@ -0,0 +1,47 @@
+/**
+ * Tradovate Market Hours
+ * CME Futures trading hours
+ */
+
+/**
+ * Check if currently in DST
+ */
+const isDST = (date) => {
+  const jan = new Date(date.getFullYear(), 0, 1);
+  const jul = new Date(date.getFullYear(), 6, 1);
+  const stdOffset = Math.max(jan.getTimezoneOffset(), jul.getTimezoneOffset());
+  return date.getTimezoneOffset() < stdOffset;
+};
+
+/**
+ * Check market hours (CME Futures)
+ */
+const checkMarketHours = () => {
+  const now = new Date();
+  const utcDay = now.getUTCDay();
+  const utcHour = now.getUTCHours();
+
+  const ctOffset = isDST(now) ? 5 : 6;
+  const ctHour = (utcHour - ctOffset + 24) % 24;
+  const ctDay = utcHour < ctOffset ? (utcDay + 6) % 7 : utcDay;
+
+  if (ctDay === 6) {
+    return { isOpen: false, message: 'Market closed (Saturday)' };
+  }
+
+  if (ctDay === 0 && ctHour < 17) {
+    return { isOpen: false, message: 'Market opens Sunday 5:00 PM CT' };
+  }
+
+  if (ctDay === 5 && ctHour >= 16) {
+    return { isOpen: false, message: 'Market closed (Friday after 4PM CT)' };
+  }
+
+  if (ctHour === 16 && ctDay >= 1 && ctDay <= 4) {
+    return { isOpen: false, message: 'Daily maintenance (4:00-5:00 PM CT)' };
+  }
+
+  return { isOpen: true, message: 'Market is open' };
+};
+
+module.exports = { checkMarketHours, isDST };

package/src/services/tradovate/websocket.js

@@ -0,0 +1,97 @@
+/**
+ * Tradovate WebSocket Module
+ * Real-time updates via WebSocket
+ */
+
+const WebSocket = require('ws');
+const { getTradingWebSocketUrl, WS_EVENTS } = require('./constants');
+
+/**
+ * Create WebSocket connection
+ * @param {TradovateService} service - The Tradovate service instance
+ */
+const connectWebSocket = async (service) => {
+  return new Promise((resolve, reject) => {
+    const wsUrl = getTradingWebSocketUrl(service.isDemo);
+    service.ws = new WebSocket(wsUrl);
+    service.wsRequestId = 1;
+
+    service.ws.on('open', () => {
+      wsSend(service, 'authorize', '', { token: service.accessToken });
+      resolve(true);
+    });
+
+    service.ws.on('message', (data) => {
+      handleWsMessage(service, data);
+    });
+
+    service.ws.on('error', (err) => {
+      service.emit('error', err);
+      reject(err);
+    });
+
+    service.ws.on('close', () => {
+      service.emit('disconnected');
+    });
+
+    setTimeout(() => reject(new Error('WebSocket timeout')), 10000);
+  });
+};
+
+/**
+ * Send WebSocket message
+ */
+const wsSend = (service, url, query = '', body = null) => {
+  if (!service.ws || service.ws.readyState !== WebSocket.OPEN) return;
+
+  const msg = body
+    ? `${url}\n${service.wsRequestId++}\n${query}\n${JSON.stringify(body)}`
+    : `${url}\n${service.wsRequestId++}\n${query}\n`;
+
+  service.ws.send(msg);
+};
+
+/**
+ * Handle WebSocket message
+ */
+const handleWsMessage = (service, data) => {
+  try {
+    const str = data.toString();
+    
+    if (str.startsWith('a')) {
+      const json = JSON.parse(str.slice(1));
+      if (Array.isArray(json)) {
+        json.forEach(msg => processWsEvent(service, msg));
+      }
+    }
+  } catch (e) {
+    // Ignore parse errors
+  }
+};
+
+/**
+ * Process WebSocket event
+ */
+const processWsEvent = (service, msg) => {
+  if (msg.e === 'props') {
+    if (msg.d?.orders) service.emit(WS_EVENTS.ORDER, msg.d.orders);
+    if (msg.d?.positions) service.emit(WS_EVENTS.POSITION, msg.d.positions);
+    if (msg.d?.cashBalances) service.emit(WS_EVENTS.CASH_BALANCE, msg.d.cashBalances);
+  }
+};
+
+/**
+ * Disconnect WebSocket
+ */
+const disconnectWebSocket = (service) => {
+  if (service.ws) {
+    service.ws.close();
+    service.ws = null;
+  }
+};
+
+module.exports = {
+  connectWebSocket,
+  wsSend,
+  disconnectWebSocket
+};

package/src/ui/index.js

@@ -37,8 +37,10 @@ const prepareStdin = () => {
     // Remove any lingering keypress listeners
     process.stdin.removeAllListeners('keypress');
     process.stdin.removeAllListeners('data');
-    // Pause stdin so inquirer can take control
-    process.stdin.pause();
+    // Resume stdin so inquirer can take control
+    if (process.stdin.isPaused()) {
+      process.stdin.resume();
+    }
   } catch (e) {
     // Ignore errors
   }