hedgequantx 2.9.216 → 2.9.217

package/bin/cli.js

@@ -3,7 +3,13 @@
 /**
  * HedgeQuantX CLI - Entry Point
  * Prop Futures Algo Trading with Protected Strategy
- * @version 2.1.0
+ * 
+ * Modes:
+ *   hqx           - Start TUI (connects to daemon if available, or standalone)
+ *   hqx --daemon  - Start daemon in foreground (persistent Rithmic connection)
+ *   hqx --stop    - Stop running daemon
+ *   hqx --status  - Check daemon status
+ *   hqx -u        - Update HQX to latest version
  */
 
 'use strict';
@@ -34,7 +40,10 @@ program
   .name('hqx')
   .description('HedgeQuantX - Prop Futures Algo Trading CLI')
   .version(pkg.version)
-  .option('-u, --update', 'Update HQX to latest version');
+  .option('-u, --update', 'Update HQX to latest version')
+  .option('-d, --daemon', 'Start daemon (persistent Rithmic connection)')
+  .option('--stop', 'Stop running daemon')
+  .option('--status', 'Check daemon status');
 
 program
   .command('start', { isDefault: true })
@@ -51,12 +60,23 @@ program
     console.log(`HedgeQuantX CLI v${pkg.version}`);
   });
 
-// Handle -u flag before parsing commands
-if (process.argv.includes('-u') || process.argv.includes('--update')) {
+program
+  .command('daemon')
+  .description('Start daemon in foreground')
+  .action(async () => {
+    const { startDaemonForeground } = require('../src/services/daemon');
+    await startDaemonForeground();
+  });
+
+// Handle special flags before parsing
+const args = process.argv;
+
+// Handle -u flag
+if (args.includes('-u') || args.includes('--update')) {
   const { execSync } = require('child_process');
   console.log('Updating HedgeQuantX...');
   try {
-    execSync('npm install -g @hedgequantx/cli@latest', { stdio: 'inherit' });
+    execSync('npm update -g hedgequantx', { stdio: 'inherit' });
     console.log('Update complete! Run "hqx" to start.');
   } catch (e) {
     console.error('Update failed:', e.message);
@@ -64,5 +84,34 @@ if (process.argv.includes('-u') || process.argv.includes('--update')) {
   process.exit(0);
 }
 
-// Parse and run
-program.parse(process.argv);
+// Handle --daemon flag
+if (args.includes('-d') || args.includes('--daemon')) {
+  const { startDaemonForeground } = require('../src/services/daemon');
+  startDaemonForeground().catch((err) => {
+    console.error('Daemon error:', err.message);
+    process.exit(1);
+  });
+} 
+// Handle --stop flag
+else if (args.includes('--stop')) {
+  const { stopDaemon } = require('../src/services/daemon');
+  stopDaemon();
+  process.exit(0);
+}
+// Handle --status flag
+else if (args.includes('--status')) {
+  const { isDaemonRunning, getDaemonPid, SOCKET_PATH } = require('../src/services/daemon');
+  
+  if (isDaemonRunning()) {
+    console.log('Daemon Status: RUNNING');
+    console.log('  PID:', getDaemonPid());
+    console.log('  Socket:', SOCKET_PATH);
+  } else {
+    console.log('Daemon Status: NOT RUNNING');
+  }
+  process.exit(0);
+}
+// Normal TUI startup
+else {
+  program.parse(process.argv);
+}

package/package.json

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

package/src/services/daemon/client.js

@@ -0,0 +1,413 @@
+/**
+ * @fileoverview Daemon Client - TUI connection to daemon
+ * @module services/daemon/client
+ * 
+ * Connects to the HQX daemon via Unix socket.
+ * Provides async request/response API for TUI.
+ * 
+ * NO MOCK DATA - All data comes from daemon (which gets it from Rithmic)
+ */
+
+'use strict';
+
+const net = require('net');
+const EventEmitter = require('events');
+const { SOCKET_PATH, MSG_TYPE, TIMEOUTS } = require('./constants');
+const { createMessage, encode, MessageParser, RequestHandler } = require('./protocol');
+const { logger } = require('../../utils/logger');
+
+const log = logger.scope('DaemonClient');
+
+/**
+ * Daemon Client for TUI
+ * Connects to daemon and provides async API
+ */
+class DaemonClient extends EventEmitter {
+  constructor() {
+    super();
+    
+    /** @type {net.Socket|null} */
+    this.socket = null;
+    
+    /** @type {MessageParser} */
+    this.parser = new MessageParser();
+    
+    /** @type {RequestHandler} */
+    this.requests = new RequestHandler();
+    
+    /** @type {boolean} */
+    this.connected = false;
+    
+    /** @type {NodeJS.Timeout|null} */
+    this.pingInterval = null;
+    
+    /** @type {Object|null} Cached daemon info */
+    this.daemonInfo = null;
+  }
+  
+  /**
+   * Connect to daemon
+   * @returns {Promise<boolean>}
+   */
+  async connect() {
+    if (this.connected) return true;
+    
+    return new Promise((resolve) => {
+      this.socket = net.createConnection(SOCKET_PATH);
+      
+      this.socket.on('connect', async () => {
+        log.debug('Connected to daemon');
+        this.connected = true;
+        
+        // Perform handshake
+        try {
+          this.daemonInfo = await this._request(MSG_TYPE.HANDSHAKE, null, TIMEOUTS.HANDSHAKE);
+          log.debug('Handshake complete', this.daemonInfo);
+          
+          // Start ping interval
+          this._startPing();
+          
+          resolve(true);
+        } catch (err) {
+          log.error('Handshake failed', { error: err.message });
+          this.disconnect();
+          resolve(false);
+        }
+      });
+      
+      this.socket.on('data', (data) => {
+        const messages = this.parser.feed(data);
+        for (const msg of messages) {
+          this._handleMessage(msg);
+        }
+      });
+      
+      this.socket.on('close', () => {
+        log.debug('Disconnected from daemon');
+        this._cleanup();
+        this.emit('disconnected');
+      });
+      
+      this.socket.on('error', (err) => {
+        if (err.code === 'ENOENT') {
+          log.debug('Daemon not running');
+        } else if (err.code === 'ECONNREFUSED') {
+          log.debug('Daemon connection refused');
+        } else {
+          log.warn('Socket error', { error: err.message });
+        }
+        this._cleanup();
+        resolve(false);
+      });
+    });
+  }
+  
+  /**
+   * Check if daemon is available
+   * @returns {Promise<boolean>}
+   */
+  async isAvailable() {
+    const connected = await this.connect();
+    return connected;
+  }
+  
+  /**
+   * Disconnect from daemon
+   */
+  disconnect() {
+    if (this.socket) {
+      this.socket.destroy();
+    }
+    this._cleanup();
+  }
+  
+  /**
+   * Cleanup state
+   */
+  _cleanup() {
+    this.connected = false;
+    this.requests.clear();
+    this.parser.reset();
+    
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+    
+    this.socket = null;
+  }
+  
+  /**
+   * Start ping interval
+   */
+  _startPing() {
+    this.pingInterval = setInterval(async () => {
+      try {
+        await this._request(MSG_TYPE.PING, null, TIMEOUTS.PING_TIMEOUT);
+      } catch (err) {
+        log.warn('Ping failed, disconnecting');
+        this.disconnect();
+      }
+    }, TIMEOUTS.PING_INTERVAL);
+  }
+  
+  /**
+   * Handle incoming message
+   * @param {Object} msg
+   */
+  _handleMessage(msg) {
+    const { type, data, replyTo } = msg;
+    
+    // Check if this is a response to a pending request
+    if (replyTo && this.requests.resolve(replyTo, data)) {
+      return;
+    }
+    
+    // Handle push events from daemon
+    switch (type) {
+      case MSG_TYPE.EVENT_ORDER_UPDATE:
+        this.emit('orderUpdate', data);
+        break;
+        
+      case MSG_TYPE.EVENT_POSITION_UPDATE:
+        this.emit('positionUpdate', data);
+        break;
+        
+      case MSG_TYPE.EVENT_PNL_UPDATE:
+        this.emit('pnlUpdate', data);
+        break;
+        
+      case MSG_TYPE.EVENT_FILL:
+        this.emit('fill', data);
+        break;
+        
+      case MSG_TYPE.EVENT_DISCONNECTED:
+        this.emit('rithmicDisconnected', data);
+        break;
+        
+      case MSG_TYPE.EVENT_RECONNECTED:
+        this.emit('rithmicReconnected', data);
+        break;
+        
+      case MSG_TYPE.MARKET_DATA:
+      case MSG_TYPE.TICK:
+        this.emit('marketData', data);
+        break;
+        
+      case MSG_TYPE.ALGO_LOG:
+        this.emit('algoLog', data);
+        break;
+        
+      case MSG_TYPE.PONG:
+        // Handled by request handler
+        break;
+        
+      default:
+        log.debug('Unhandled message', { type });
+    }
+  }
+  
+  /**
+   * Send request and wait for response
+   * @param {string} type - Message type
+   * @param {any} data - Request data
+   * @param {number} [timeout] - Timeout in ms
+   * @returns {Promise<any>} Response data
+   */
+  async _request(type, data, timeout = TIMEOUTS.REQUEST) {
+    if (!this.connected || !this.socket) {
+      throw new Error('Not connected to daemon');
+    }
+    
+    const msg = createMessage(type, data);
+    const promise = this.requests.createRequest(msg.id, timeout);
+    
+    this.socket.write(encode(msg));
+    
+    return promise;
+  }
+  
+  // ==================== PUBLIC API ====================
+  
+  /**
+   * Get daemon status
+   * @returns {Promise<Object>}
+   */
+  async getStatus() {
+    return this._request(MSG_TYPE.GET_STATUS);
+  }
+  
+  /**
+   * Login to Rithmic via daemon
+   * @param {string} propfirmKey
+   * @param {string} username
+   * @param {string} password
+   * @returns {Promise<Object>}
+   */
+  async login(propfirmKey, username, password) {
+    return this._request(MSG_TYPE.LOGIN, { propfirmKey, username, password }, TIMEOUTS.LOGIN);
+  }
+  
+  /**
+   * Restore session from storage
+   * @returns {Promise<Object>}
+   */
+  async restoreSession() {
+    return this._request(MSG_TYPE.RESTORE_SESSION, null, TIMEOUTS.LOGIN);
+  }
+  
+  /**
+   * Logout
+   * @returns {Promise<Object>}
+   */
+  async logout() {
+    return this._request(MSG_TYPE.LOGOUT);
+  }
+  
+  /**
+   * Get trading accounts
+   * @returns {Promise<Object>}
+   */
+  async getTradingAccounts() {
+    return this._request(MSG_TYPE.GET_ACCOUNTS);
+  }
+  
+  /**
+   * Get positions
+   * @returns {Promise<Object>}
+   */
+  async getPositions() {
+    return this._request(MSG_TYPE.GET_POSITIONS);
+  }
+  
+  /**
+   * Get orders
+   * @returns {Promise<Object>}
+   */
+  async getOrders() {
+    return this._request(MSG_TYPE.GET_ORDERS);
+  }
+  
+  /**
+   * Get P&L for account
+   * @param {string} accountId
+   * @returns {Promise<Object>}
+   */
+  async getPnL(accountId) {
+    return this._request(MSG_TYPE.GET_PNL, { accountId });
+  }
+  
+  /**
+   * Place order
+   * @param {Object} orderData
+   * @returns {Promise<Object>}
+   */
+  async placeOrder(orderData) {
+    return this._request(MSG_TYPE.PLACE_ORDER, orderData);
+  }
+  
+  /**
+   * Cancel order
+   * @param {string} orderId
+   * @returns {Promise<Object>}
+   */
+  async cancelOrder(orderId) {
+    return this._request(MSG_TYPE.CANCEL_ORDER, { orderId });
+  }
+  
+  /**
+   * Cancel all orders for account
+   * @param {string} accountId
+   * @returns {Promise<Object>}
+   */
+  async cancelAllOrders(accountId) {
+    return this._request(MSG_TYPE.CANCEL_ALL, { accountId });
+  }
+  
+  /**
+   * Close position
+   * @param {string} accountId
+   * @param {string} symbol
+   * @returns {Promise<Object>}
+   */
+  async closePosition(accountId, symbol) {
+    return this._request(MSG_TYPE.CLOSE_POSITION, { accountId, symbol });
+  }
+  
+  /**
+   * Get contracts
+   * @returns {Promise<Object>}
+   */
+  async getContracts() {
+    return this._request(MSG_TYPE.GET_CONTRACTS);
+  }
+  
+  /**
+   * Search contracts
+   * @param {string} search
+   * @returns {Promise<Object>}
+   */
+  async searchContracts(search) {
+    return this._request(MSG_TYPE.SEARCH_CONTRACTS, { search });
+  }
+  
+  /**
+   * Subscribe to market data
+   * @param {string} symbol
+   * @returns {Promise<Object>}
+   */
+  async subscribeMarket(symbol) {
+    return this._request(MSG_TYPE.SUBSCRIBE_MARKET, { symbol });
+  }
+  
+  /**
+   * Unsubscribe from market data
+   * @param {string} symbol
+   * @returns {Promise<Object>}
+   */
+  async unsubscribeMarket(symbol) {
+    return this._request(MSG_TYPE.UNSUBSCRIBE_MARKET, { symbol });
+  }
+  
+  /**
+   * Start algo trading
+   * @param {Object} config
+   * @returns {Promise<Object>}
+   */
+  async startAlgo(config) {
+    return this._request(MSG_TYPE.START_ALGO, config);
+  }
+  
+  /**
+   * Stop algo trading
+   * @param {string} algoId
+   * @returns {Promise<Object>}
+   */
+  async stopAlgo(algoId) {
+    return this._request(MSG_TYPE.STOP_ALGO, { algoId });
+  }
+  
+  /**
+   * Shutdown daemon
+   * @returns {Promise<Object>}
+   */
+  async shutdown() {
+    return this._request(MSG_TYPE.SHUTDOWN);
+  }
+}
+
+// Singleton instance
+let instance = null;
+
+/**
+ * Get daemon client instance
+ * @returns {DaemonClient}
+ */
+function getDaemonClient() {
+  if (!instance) {
+    instance = new DaemonClient();
+  }
+  return instance;
+}
+
+module.exports = { DaemonClient, getDaemonClient };

package/src/services/daemon/constants.js

@@ -0,0 +1,104 @@
+/**
+ * @fileoverview Daemon Constants
+ * @module services/daemon/constants
+ * 
+ * Configuration for HQX Daemon - persistent Rithmic connection service
+ */
+
+'use strict';
+
+const os = require('os');
+const path = require('path');
+
+/** Daemon socket path */
+const SOCKET_DIR = path.join(os.homedir(), '.hedgequantx');
+const SOCKET_PATH = path.join(SOCKET_DIR, 'hqx.sock');
+
+/** Daemon PID file */
+const PID_FILE = path.join(SOCKET_DIR, 'daemon.pid');
+
+/** IPC Protocol version */
+const PROTOCOL_VERSION = 1;
+
+/** Message types for IPC communication */
+const MSG_TYPE = {
+  // Connection
+  PING: 'ping',
+  PONG: 'pong',
+  HANDSHAKE: 'handshake',
+  HANDSHAKE_ACK: 'handshake_ack',
+  
+  // Auth
+  LOGIN: 'login',
+  LOGIN_RESULT: 'login_result',
+  LOGOUT: 'logout',
+  RESTORE_SESSION: 'restore_session',
+  
+  // Data requests
+  GET_ACCOUNTS: 'get_accounts',
+  GET_POSITIONS: 'get_positions',
+  GET_ORDERS: 'get_orders',
+  GET_PNL: 'get_pnl',
+  GET_STATUS: 'get_status',
+  GET_CONTRACTS: 'get_contracts',
+  SEARCH_CONTRACTS: 'search_contracts',
+  
+  // Data responses
+  ACCOUNTS: 'accounts',
+  POSITIONS: 'positions',
+  ORDERS: 'orders',
+  PNL: 'pnl',
+  STATUS: 'status',
+  CONTRACTS: 'contracts',
+  
+  // Trading
+  PLACE_ORDER: 'place_order',
+  CANCEL_ORDER: 'cancel_order',
+  CANCEL_ALL: 'cancel_all',
+  CLOSE_POSITION: 'close_position',
+  ORDER_RESULT: 'order_result',
+  
+  // Market data
+  SUBSCRIBE_MARKET: 'subscribe_market',
+  UNSUBSCRIBE_MARKET: 'unsubscribe_market',
+  MARKET_DATA: 'market_data',
+  TICK: 'tick',
+  
+  // Algo trading
+  START_ALGO: 'start_algo',
+  STOP_ALGO: 'stop_algo',
+  ALGO_STATUS: 'algo_status',
+  ALGO_LOG: 'algo_log',
+  
+  // Events (daemon → TUI push)
+  EVENT_ORDER_UPDATE: 'event_order_update',
+  EVENT_POSITION_UPDATE: 'event_position_update',
+  EVENT_PNL_UPDATE: 'event_pnl_update',
+  EVENT_FILL: 'event_fill',
+  EVENT_DISCONNECTED: 'event_disconnected',
+  EVENT_RECONNECTED: 'event_reconnected',
+  
+  // Errors
+  ERROR: 'error',
+  
+  // Daemon control
+  SHUTDOWN: 'shutdown',
+};
+
+/** Timeouts */
+const TIMEOUTS = {
+  HANDSHAKE: 5000,
+  REQUEST: 30000,
+  LOGIN: 60000,
+  PING_INTERVAL: 10000,
+  PING_TIMEOUT: 5000,
+};
+
+module.exports = {
+  SOCKET_DIR,
+  SOCKET_PATH,
+  PID_FILE,
+  PROTOCOL_VERSION,
+  MSG_TYPE,
+  TIMEOUTS,
+};