hedgequantx 2.9.226 → 2.9.228

package/dist/lib/m/ultra-scalping.js

@@ -151,9 +151,18 @@ class HQXUltraScalpingStrategy extends EventEmitter {
     // Add tick to buffer
     let ticks = this.tickBuffer.get(contractId);
     ticks.push(tick);
+    
+    // Track total ticks for status log
+    this._totalTicks = (this._totalTicks || 0) + 1;
+    
+    // Emit status log every second
+    const now = Date.now();
+    if (!this._lastStatusLog || now - this._lastStatusLog >= 1000) {
+      this._lastStatusLog = now;
+      this._emitStatusLog(contractId, tick.price);
+    }
 
     // Check if we should form a new bar
-    const now = Date.now();
     const lastBar = this.lastBarTime.get(contractId);
     
     if (now - lastBar >= this.barIntervalMs && ticks.length > 0) {
@@ -171,6 +180,72 @@ class HQXUltraScalpingStrategy extends EventEmitter {
     }
     return null;
   }
+  
+  /**
+   * Emit status log with QUANT metrics
+   */
+  _emitStatusLog(contractId, currentPrice) {
+    const prices = this.priceBuffer.get(contractId) || [];
+    const volumes = this.volumeBuffer.get(contractId) || [];
+    const bars = this.barHistory.get(contractId) || [];
+    
+    if (prices.length < 20) return; // Not enough data yet
+    
+    // Compute current metrics
+    const zscore = computeZScore(prices);
+    const vpin = volumes.length >= 10 ? computeVPIN(volumes, this.vpinWindow) : 0;
+    const ofi = bars.length >= 10 ? computeOrderFlowImbalance(bars, this.ofiLookback) : 0;
+    
+    // Determine market state
+    const absZ = Math.abs(zscore);
+    let zState = 'normal';
+    if (absZ >= 2.0) zState = 'EXTREME';
+    else if (absZ >= 1.5) zState = 'HIGH';
+    else if (absZ >= 1.0) zState = 'building';
+    
+    // Determine direction bias
+    let bias = 'neutral';
+    if (zscore < -1.5 && ofi > 0.1) bias = 'LONG setup';
+    else if (zscore > 1.5 && ofi < -0.1) bias = 'SHORT setup';
+    else if (zscore < -1.0) bias = 'oversold';
+    else if (zscore > 1.0) bias = 'overbought';
+    
+    // Extract symbol
+    const sym = (contractId || '').replace(/[A-Z]\d+$/, '');
+    
+    // Build message based on state
+    let message;
+    if (!this.tradingEnabled) {
+      message = `[${sym}] ${currentPrice.toFixed(2)} | PAUSED (${this.lossStreak} losses) | Cooldown active`;
+    } else if (absZ >= 2.0) {
+      const dir = zscore < 0 ? 'LONG' : 'SHORT';
+      const ofiPct = (Math.abs(ofi) * 100).toFixed(0);
+      const ofiConfirm = (zscore < 0 && ofi > 0.15) || (zscore > 0 && ofi < -0.15);
+      if (ofiConfirm) {
+        message = `[${sym}] ${currentPrice.toFixed(2)} | Z: ${zscore.toFixed(1)}σ ${zState} | ${dir} | OFI ${ofiPct}% confirms`;
+      } else {
+        message = `[${sym}] ${currentPrice.toFixed(2)} | Z: ${zscore.toFixed(1)}σ ${zState} | ${dir} signal | OFI ${ofiPct}% pending`;
+      }
+    } else if (absZ >= 1.5) {
+      message = `[${sym}] ${currentPrice.toFixed(2)} | Z: ${zscore.toFixed(1)}σ ${zState} | ${bias} | Monitoring`;
+    } else if (absZ >= 1.0) {
+      message = `[${sym}] ${currentPrice.toFixed(2)} | Z: ${zscore.toFixed(1)}σ ${zState} | Awaiting extremity`;
+    } else {
+      // Normal state - show different context messages
+      const vpinPct = (vpin * 100).toFixed(0);
+      const contexts = [
+        `VPIN ${vpinPct}% | Mean reversion scan`,
+        `OFI balanced | Price discovery`,
+        `Z normalized | Statistical scan`,
+        `Tick flow stable | Edge detection`,
+        `Volatility normal | Alpha scan`,
+      ];
+      const ctx = contexts[Math.floor(Date.now() / 5000) % contexts.length];
+      message = `[${sym}] ${currentPrice.toFixed(2)} | Z: ${zscore.toFixed(1)}σ | ${ctx}`;
+    }
+    
+    this.emit('log', { type: 'info', message });
+  }
 
   /**
    * Aggregate ticks into a bar

package/package.json

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

package/src/services/daemon/index.js

@@ -35,7 +35,8 @@
 'use strict';
 
 const fs = require('fs');
-const { spawn } = require('child_process');
+const path = require('path');
+const { spawn, execSync } = require('child_process');
 const { SOCKET_PATH, PID_FILE, SOCKET_DIR } = require('./constants');
 const { DaemonServer } = require('./server');
 const { DaemonClient, getDaemonClient } = require('./client');
@@ -43,6 +44,11 @@ const { logger } = require('../../utils/logger');
 
 const log = logger.scope('Daemon');
 
+/** Isolated daemon directory - survives npm updates */
+const DAEMON_INSTALL_DIR = path.join(SOCKET_DIR, 'daemon');
+const DAEMON_ENTRY = path.join(DAEMON_INSTALL_DIR, 'cli-daemon.js');
+const DAEMON_VERSION_FILE = path.join(DAEMON_INSTALL_DIR, 'version.txt');
+
 /**
  * Check if daemon is running
  * @returns {boolean}
@@ -86,6 +92,150 @@ function getDaemonPid() {
   }
 }
 
+/**
+ * Get current package version
+ * @returns {string}
+ */
+function getCurrentVersion() {
+  try {
+    const pkg = require('../../../package.json');
+    return pkg.version;
+  } catch (_) {
+    return '0.0.0';
+  }
+}
+
+/**
+ * Get installed daemon version
+ * @returns {string|null}
+ */
+function getInstalledDaemonVersion() {
+  try {
+    if (fs.existsSync(DAEMON_VERSION_FILE)) {
+      return fs.readFileSync(DAEMON_VERSION_FILE, 'utf8').trim();
+    }
+  } catch (_) {}
+  return null;
+}
+
+/**
+ * Install daemon to isolated directory
+ * This copies all necessary files so daemon survives npm updates
+ * @returns {boolean}
+ */
+function installDaemon() {
+  const currentVersion = getCurrentVersion();
+  const installedVersion = getInstalledDaemonVersion();
+  
+  // Skip if already installed with same version
+  if (installedVersion === currentVersion && fs.existsSync(DAEMON_ENTRY)) {
+    log.debug('Daemon already installed', { version: currentVersion });
+    return true;
+  }
+  
+  log.info('Installing daemon to isolated directory', { version: currentVersion });
+  
+  try {
+    // Create daemon directory
+    if (!fs.existsSync(DAEMON_INSTALL_DIR)) {
+      fs.mkdirSync(DAEMON_INSTALL_DIR, { recursive: true, mode: 0o700 });
+    }
+    
+    // Get source directory (where this package is installed)
+    const srcDir = path.resolve(__dirname, '../../..');
+    
+    // Files/directories to copy for daemon to work
+    const filesToCopy = [
+      'src/cli-daemon.js',
+      'src/services/daemon',
+      'src/services/rithmic',
+      'src/services/session.js',
+      'src/services/index.js',
+      'src/config',
+      'src/security',
+      'src/utils',
+      'package.json',
+    ];
+    
+    // Copy each file/directory
+    for (const file of filesToCopy) {
+      const srcPath = path.join(srcDir, file);
+      const destPath = path.join(DAEMON_INSTALL_DIR, file);
+      
+      if (!fs.existsSync(srcPath)) {
+        log.warn('Source not found', { file });
+        continue;
+      }
+      
+      // Create parent directory
+      const destDir = path.dirname(destPath);
+      if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+      }
+      
+      // Copy file or directory
+      if (fs.statSync(srcPath).isDirectory()) {
+        copyDirSync(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+    
+    // Copy node_modules that daemon needs
+    const nodeModulesDir = path.join(srcDir, 'node_modules');
+    const destNodeModules = path.join(DAEMON_INSTALL_DIR, 'node_modules');
+    
+    // Essential dependencies for daemon
+    const deps = ['protobufjs', 'ws', 'long', 'signale', 'chalk', 'figures'];
+    
+    if (!fs.existsSync(destNodeModules)) {
+      fs.mkdirSync(destNodeModules, { recursive: true });
+    }
+    
+    for (const dep of deps) {
+      const srcDep = path.join(nodeModulesDir, dep);
+      const destDep = path.join(destNodeModules, dep);
+      
+      if (fs.existsSync(srcDep) && !fs.existsSync(destDep)) {
+        copyDirSync(srcDep, destDep);
+      }
+    }
+    
+    // Write version file
+    fs.writeFileSync(DAEMON_VERSION_FILE, currentVersion);
+    
+    log.info('Daemon installed successfully');
+    return true;
+  } catch (err) {
+    log.error('Failed to install daemon', { error: err.message });
+    return false;
+  }
+}
+
+/**
+ * Recursively copy directory
+ * @param {string} src
+ * @param {string} dest
+ */
+function copyDirSync(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+  
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
 /**
  * Start daemon in foreground (blocking)
  * Used when running `hqx --daemon`
@@ -147,7 +297,7 @@ async function startDaemonForeground() {
 }
 
 /**
- * Start daemon in background
+ * Start daemon in background (from isolated directory)
  * @returns {Promise<boolean>}
  */
 async function startDaemonBackground() {
@@ -156,8 +306,60 @@ async function startDaemonBackground() {
     return true;
   }
   
+  // Install daemon to isolated directory first
+  const installed = installDaemon();
+  if (!installed) {
+    log.error('Failed to install daemon');
+    return false;
+  }
+  
+  // Check if isolated daemon entry exists
+  if (!fs.existsSync(DAEMON_ENTRY)) {
+    log.error('Daemon entry not found', { path: DAEMON_ENTRY });
+    // Fallback to direct execution
+    return startDaemonDirect();
+  }
+  
+  return new Promise((resolve) => {
+    // Spawn daemon from isolated directory (survives npm updates)
+    const daemon = spawn(process.execPath, [DAEMON_ENTRY], {
+      detached: true,
+      stdio: 'ignore',
+      cwd: DAEMON_INSTALL_DIR,
+      env: {
+        ...process.env,
+        NODE_PATH: path.join(DAEMON_INSTALL_DIR, 'node_modules'),
+      },
+    });
+    
+    daemon.unref();
+    
+    // Wait for daemon to start
+    let attempts = 0;
+    const maxAttempts = 30;
+    
+    const check = setInterval(() => {
+      attempts++;
+      
+      if (isDaemonRunning()) {
+        clearInterval(check);
+        log.debug('Daemon started from isolated directory');
+        resolve(true);
+      } else if (attempts >= maxAttempts) {
+        clearInterval(check);
+        log.error('Daemon failed to start');
+        resolve(false);
+      }
+    }, 100);
+  });
+}
+
+/**
+ * Start daemon directly (fallback if isolation fails)
+ * @returns {Promise<boolean>}
+ */
+function startDaemonDirect() {
   return new Promise((resolve) => {
-    // Spawn daemon process
     const daemon = spawn(process.execPath, [
       require.resolve('../../cli-daemon'),
     ], {
@@ -167,7 +369,6 @@ async function startDaemonBackground() {
     
     daemon.unref();
     
-    // Wait for daemon to start
     let attempts = 0;
     const maxAttempts = 20;
     
@@ -176,7 +377,7 @@ async function startDaemonBackground() {
       
       if (isDaemonRunning()) {
         clearInterval(check);
-        log.debug('Daemon started');
+        log.debug('Daemon started (direct mode)');
         resolve(true);
       } else if (attempts >= maxAttempts) {
         clearInterval(check);
@@ -248,6 +449,11 @@ module.exports = {
   getDaemonClient,
   ensureDaemon,
   
+  // Installation
+  installDaemon,
+  getCurrentVersion,
+  getInstalledDaemonVersion,
+  
   // Utilities
   isDaemonRunning,
   getDaemonPid,
@@ -255,4 +461,5 @@ module.exports = {
   // Constants
   SOCKET_PATH,
   PID_FILE,
+  DAEMON_INSTALL_DIR,
 };