hedgequantx 2.9.215 → 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.215",
+  "version": "2.9.217",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {

package/src/lib/smart-logs-engine.js

@@ -8,6 +8,16 @@
  * - Uses smartLogs.getLiveAnalysisLog() for varied, non-repetitive messages
  * 
  * Only logs when something SIGNIFICANT happens - no spam, no repetitive messages
+ * 
+ * COLOR SCHEME:
+ * - Symbols: cyan (NQ, ES, CL, GC)
+ * - Prices: white bold
+ * - Bullish/Long: green
+ * - Bearish/Short: red
+ * - Neutral/System: gray/dim
+ * - Signals: yellow/magenta
+ * - Risk/Warnings: red bold
+ * - Values: blue (Z-Score, VPIN, OFI numbers)
  */
 
 'use strict';
@@ -16,6 +26,39 @@ const chalk = require('chalk');
 const smartLogs = require('./smart-logs');
 const { getContextualMessage } = require('./smart-logs-context');
 
+// Color helpers for consistent styling
+const C = {
+  // Symbols & identifiers
+  sym: (s) => chalk.cyan.bold(s),
+  
+  // Prices
+  price: (p) => chalk.white.bold(p),
+  
+  // Direction
+  long: (s) => chalk.green.bold(s),
+  short: (s) => chalk.red.bold(s),
+  bull: (s) => chalk.green(s),
+  bear: (s) => chalk.red(s),
+  
+  // Values & metrics
+  val: (v) => chalk.blue(v),
+  valHigh: (v) => chalk.magenta.bold(v),
+  
+  // Status
+  ok: (s) => chalk.green(s),
+  warn: (s) => chalk.yellow(s),
+  danger: (s) => chalk.red.bold(s),
+  
+  // System/neutral
+  dim: (s) => chalk.dim(s),
+  info: (s) => chalk.gray(s),
+  
+  // Special
+  signal: (s) => chalk.yellow.bold(s),
+  zone: (s) => chalk.magenta(s),
+  regime: (s) => chalk.cyan(s),
+};
+
 const CONFIG = { 
   SESSION_LOG_INTERVAL: 10,
   // HQX-2B thresholds
@@ -84,11 +127,14 @@ class SmartLogsEngine {
 
     // Active position - same for all strategies
     if (position !== 0) {
-      const side = position > 0 ? 'LONG' : 'SHORT';
-      const flow = (position > 0 && delta > 0) || (position < 0 && delta < 0) ? 'FAVOR' : 'ADVERSE';
+      const isLong = position > 0;
+      const side = isLong ? C.long('LONG') : C.short('SHORT');
+      const flowFavor = (isLong && delta > 0) || (!isLong && delta < 0);
+      const flowLabel = flowFavor ? C.ok('FAVOR') : C.danger('ADVERSE');
+      const deltaStr = delta > 0 ? C.bull(`+${delta}`) : C.bear(`${delta}`);
       return {
         type: 'trade',
-        message: `[${sym}] ${side} ACTIVE @ ${price} | Delta: ${delta > 0 ? '+' : ''}${delta} | Flow: ${flow}`,
+        message: `[${C.sym(sym)}] ${side} ACTIVE @ ${C.price(price)} | Delta: ${deltaStr} | Flow: ${flowLabel}`,
         logToSession: true
       };
     }
@@ -116,35 +162,37 @@ class SmartLogsEngine {
       this.warmupLogged = true;
       event = 'warmup';
       const warmupMsg = getContextualMessage(this.symbolCode, this.strategyId, 'warmup');
-      message = `[${sym}] 2B ready | ${bars} bars | ${warmupMsg}`;
+      message = `[${C.sym(sym)}] ${C.ok('2B ready')} | ${C.val(bars)} bars | ${C.dim(warmupMsg)}`;
       logType = 'system';
     }
     // EVENT 2: New zone created
     else if (zones > this.lastZones && zones > 0) {
       event = 'new_zone';
       const signalMsg = getContextualMessage(this.symbolCode, this.strategyId, 'signal');
-      message = `[${sym}] ${price} | Zone #${zones} | ${signalMsg}`;
+      message = `[${C.sym(sym)}] ${C.price(price)} | ${C.zone('Zone #' + zones)} | ${C.signal(signalMsg)}`;
       logType = 'signal';
     }
     // EVENT 3: New swing detected
     else if (swings > this.lastSwings && swings > 0) {
       event = 'new_swing';
       const scanMsg = getContextualMessage(this.symbolCode, this.strategyId, 'scanning');
-      message = `[${sym}] ${price} | Swing #${swings} | ${scanMsg}`;
+      message = `[${C.sym(sym)}] ${C.price(price)} | ${C.info('Swing #' + swings)} | ${C.dim(scanMsg)}`;
     }
     // EVENT 4: Zone approach (price near zone)
     else if (nearZone && !this.lastNearZone && zones > 0) {
       event = 'zone_approach';
       const signalMsg = getContextualMessage(this.symbolCode, this.strategyId, 'signal');
-      message = `[${sym}] ${price} | Zone approach | ${signalMsg}`;
+      message = `[${C.sym(sym)}] ${C.price(price)} | ${C.warn('Zone approach')} | ${C.signal(signalMsg)}`;
       logType = 'signal';
     }
     // EVENT 5: Bias flip
     else if (this.lastBias && trend !== this.lastBias && trend !== 'neutral' && this.lastBias !== 'neutral') {
       event = 'bias_flip';
-      const arrow = trend === 'bullish' ? chalk.green('▲') : chalk.red('▼');
+      const arrow = trend === 'bullish' ? C.bull('▲') : C.bear('▼');
+      const oldBias = this.lastBias === 'bullish' ? C.bull(this.lastBias) : C.bear(this.lastBias);
+      const newBias = trend === 'bullish' ? C.bull(trend) : C.bear(trend);
       const flipMsg = getContextualMessage(this.symbolCode, this.strategyId, trend);
-      message = `[${sym}] ${arrow} ${this.lastBias} → ${trend} | ${flipMsg}`;
+      message = `[${C.sym(sym)}] ${arrow} ${oldBias} → ${newBias} | ${C.dim(flipMsg)}`;
     }
 
     // Update state tracking
@@ -176,12 +224,22 @@ class SmartLogsEngine {
     let logType = 'analysis';
     let message = null;
 
+    // Helper for Z-Score color
+    const zColor = (z) => {
+      const absVal = Math.abs(z);
+      const formatted = `${z.toFixed(1)}σ`;
+      if (absVal >= CONFIG.Z_EXTREME) return C.valHigh(formatted);
+      if (absVal >= CONFIG.Z_HIGH) return C.warn(formatted);
+      if (absVal >= CONFIG.Z_BUILDING) return C.val(formatted);
+      return C.dim(formatted);
+    };
+
     // EVENT 1: Warmup complete (250 ticks for QUANT models)
     if (ticks >= CONFIG.QUANT_WARMUP_TICKS && !this.warmupLogged) {
       this.warmupLogged = true;
       event = 'warmup';
       const warmupMsg = getContextualMessage(this.symbolCode, this.strategyId, 'warmup');
-      message = `[${sym}] QUANT ready | ${ticks} ticks | ${warmupMsg}`;
+      message = `[${C.sym(sym)}] ${C.ok('QUANT ready')} | ${C.val(ticks)} ticks | ${C.dim(warmupMsg)}`;
       logType = 'system';
     }
     // EVENT 2: Z-Score regime change
@@ -193,34 +251,37 @@ class SmartLogsEngine {
       
       if (zRegime === 'extreme') {
         logType = 'signal';
-        const dir = zScore < 0 ? 'LONG' : 'SHORT';
+        const dir = zScore < 0 ? C.long('LONG') : C.short('SHORT');
         const signalMsg = getContextualMessage(this.symbolCode, this.strategyId, 'signal');
-        message = `[${sym}] ${price} | Z: ${zScore.toFixed(1)}σ | ${dir} | ${signalMsg}`;
+        message = `[${C.sym(sym)}] ${C.price(price)} | Z: ${zColor(zScore)} ${C.signal('EXTREME')} | ${dir} | ${C.signal(signalMsg)}`;
       } else if (zRegime === 'high') {
         logType = 'signal';
-        message = `[${sym}] ${price} | Z: ${zScore.toFixed(1)}σ | ${instrumentMsg}`;
+        message = `[${C.sym(sym)}] ${C.price(price)} | Z: ${zColor(zScore)} ${C.warn('HIGH')} | ${C.dim(instrumentMsg)}`;
       } else if (zRegime === 'building') {
-        message = `[${sym}] ${price} | Z building (${zScore.toFixed(1)}σ) | ${instrumentMsg}`;
+        message = `[${C.sym(sym)}] ${C.price(price)} | Z: ${zColor(zScore)} ${C.info('building')} | ${C.dim(instrumentMsg)}`;
       } else {
         const scanMsg = getContextualMessage(this.symbolCode, this.strategyId, 'scanning');
-        message = `[${sym}] ${price} | Z normalized | ${scanMsg}`;
+        message = `[${C.sym(sym)}] ${C.price(price)} | Z: ${C.ok('normalized')} | ${C.dim(scanMsg)}`;
       }
     }
     // EVENT 3: Bias flip (OFI direction change)
     else if (this.lastBias !== null && bias !== this.lastBias && bias !== 'neutral' && this.lastBias !== 'neutral') {
       event = 'bias_flip';
-      const arrow = bias === 'bullish' ? chalk.green('▲') : chalk.red('▼');
+      const arrow = bias === 'bullish' ? C.bull('▲') : C.bear('▼');
+      const oldBias = this.lastBias === 'bullish' ? C.bull(this.lastBias) : C.bear(this.lastBias);
+      const newBias = bias === 'bullish' ? C.bull(bias) : C.bear(bias);
       const flipMsg = getContextualMessage(this.symbolCode, this.strategyId, bias);
-      message = `[${sym}] ${arrow} OFI: ${this.lastBias} → ${bias} | ${flipMsg}`;
+      message = `[${C.sym(sym)}] ${arrow} OFI: ${oldBias} → ${newBias} | ${C.dim(flipMsg)}`;
     }
     // EVENT 4: VPIN toxicity change
     else if (this.lastVpinToxic !== null && vpinToxic !== this.lastVpinToxic) {
       event = 'vpin';
+      const vpinPct = (vpin * 100).toFixed(0);
       if (vpinToxic) {
-        message = `[${sym}] ${price} | VPIN toxic (${(vpin * 100).toFixed(0)}%) - informed flow detected`;
+        message = `[${C.sym(sym)}] ${C.price(price)} | VPIN: ${C.danger(vpinPct + '%')} ${C.danger('TOXIC')} - informed flow`;
         logType = 'risk';
       } else {
-        message = `[${sym}] ${price} | VPIN clean (${(vpin * 100).toFixed(0)}%) - normal flow`;
+        message = `[${C.sym(sym)}] ${C.price(price)} | VPIN: ${C.ok(vpinPct + '%')} ${C.ok('clean')} - normal flow`;
       }
     }
 

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 };