hedgequantx 2.9.162 → 2.9.164

package/package.json

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

package/src/services/rithmic-broker/client.js

@@ -37,15 +37,20 @@ class RithmicBrokerClient extends EventEmitter {
     // Ensure daemon is running
     const daemonStatus = await manager.ensureRunning();
     if (!daemonStatus.success) {
-      return { success: false, error: daemonStatus.error || 'Failed to start daemon' };
+      const errorMsg = daemonStatus.error || 'Failed to start daemon';
+      return { success: false, error: `Daemon error: ${errorMsg}` };
     }
     
     return new Promise((resolve) => {
-      this.ws = new WebSocket(`ws://127.0.0.1:${BROKER_PORT}`);
+      try {
+        this.ws = new WebSocket(`ws://127.0.0.1:${BROKER_PORT}`);
+      } catch (err) {
+        return resolve({ success: false, error: `WebSocket create error: ${err.message}` });
+      }
       
       const timeout = setTimeout(() => {
         this.ws?.terminate();
-        resolve({ success: false, error: 'Connection timeout' });
+        resolve({ success: false, error: `Connection timeout (port ${BROKER_PORT})` });
       }, 5000);
       
       this.ws.on('open', () => {
@@ -64,7 +69,7 @@ class RithmicBrokerClient extends EventEmitter {
       this.ws.on('error', (err) => {
         clearTimeout(timeout);
         this.connected = false;
-        resolve({ success: false, error: err.message });
+        resolve({ success: false, error: `Daemon connection failed: ${err.message}` });
       });
     });
   }

package/src/services/rithmic-broker/daemon-reconnect.js

@@ -240,6 +240,22 @@ class ReconnectManager {
     this.reconnectState.set(propfirmKey, state);
   }
 
+  /**
+   * Validate cached accounts - ensure all fields are proper strings
+   */
+  _validateAccounts(accounts) {
+    if (!Array.isArray(accounts)) return [];
+    
+    return accounts.filter(acc => {
+      // Must have accountId as string
+      if (!acc || typeof acc.accountId !== 'string') return false;
+      // fcmId and ibId should be strings if present
+      if (acc.fcmId && typeof acc.fcmId !== 'string') return false;
+      if (acc.ibId && typeof acc.ibId !== 'string') return false;
+      return true;
+    });
+  }
+
   /**
    * Restore connections from state with retry logic
    */
@@ -254,28 +270,51 @@ class ReconnectManager {
 
         this.log('INFO', 'Restoring connection', { propfirm: saved.propfirmKey });
         
+        // Validate cached accounts to prevent crashes from corrupted data
+        const validAccounts = this._validateAccounts(saved.accounts);
+        if (saved.accounts?.length && validAccounts.length !== saved.accounts.length) {
+          this.log('WARN', 'Some cached accounts invalid, will re-fetch', { 
+            propfirm: saved.propfirmKey,
+            original: saved.accounts?.length || 0,
+            valid: validAccounts.length
+          });
+        }
+        
         let success = false;
         let attempts = 0;
 
         while (!success && attempts < RECONNECT_CONFIG.RESTORE_MAX_ATTEMPTS) {
           attempts++;
           
-          const result = await this.daemon._handleLogin({
-            ...saved.credentials,
-            propfirmKey: saved.propfirmKey,
-            cachedAccounts: saved.accounts  // Use cached accounts!
-          }, null);
-
-          if (result.payload?.success) {
-            success = true;
-            this.log('INFO', 'Connection restored', { propfirm: saved.propfirmKey });
-          } else {
-            this.log('WARN', 'Restore attempt failed', {
-              propfirm: saved.propfirmKey,
+          try {
+            const result = await this.daemon._handleLogin({
+              ...saved.credentials,
+              propfirmKey: saved.propfirmKey,
+              // Only use cached accounts if they are valid, otherwise re-fetch
+              cachedAccounts: validAccounts.length > 0 ? validAccounts : null
+            }, null);
+
+            if (result.payload?.success) {
+              success = true;
+              this.log('INFO', 'Connection restored', { propfirm: saved.propfirmKey });
+            } else {
+              this.log('WARN', 'Restore attempt failed', {
+                propfirm: saved.propfirmKey,
+                attempt: attempts,
+                error: result.payload?.error || result.error
+              });
+
+              if (attempts < RECONNECT_CONFIG.RESTORE_MAX_ATTEMPTS) {
+                await new Promise(r => setTimeout(r, RECONNECT_CONFIG.RESTORE_RETRY_DELAY));
+              }
+            }
+          } catch (e) {
+            this.log('ERROR', 'Restore attempt error', { 
+              propfirm: saved.propfirmKey, 
               attempt: attempts,
-              error: result.payload?.error || result.error
+              error: e.message 
             });
-
+            
             if (attempts < RECONNECT_CONFIG.RESTORE_MAX_ATTEMPTS) {
               await new Promise(r => setTimeout(r, RECONNECT_CONFIG.RESTORE_RETRY_DELAY));
             }
@@ -288,13 +327,15 @@ class ReconnectManager {
             service: null,
             credentials: saved.credentials,
             connectedAt: null,
-            accounts: saved.accounts || [],
+            accounts: validAccounts,
             status: 'disconnected',
           });
         }
       }
     } catch (e) {
       this.log('ERROR', 'Restore failed', { error: e.message });
+      // Delete corrupted state file
+      try { fs.unlinkSync(stateFile); } catch (e2) { /* ignore */ }
     }
   }
 

package/src/services/rithmic-broker/daemon.js

@@ -67,16 +67,35 @@ class RithmicBrokerDaemon {
     
     if (!fs.existsSync(BROKER_DIR)) fs.mkdirSync(BROKER_DIR, { recursive: true });
     fs.writeFileSync(PID_FILE, String(process.pid));
+    log('INFO', 'Starting daemon...', { pid: process.pid });
     
     // Restore connections from state (with cached accounts - no API spam)
-    await this.reconnectManager.restoreConnections(STATE_FILE);
+    try {
+      await this.reconnectManager.restoreConnections(STATE_FILE);
+    } catch (e) {
+      log('WARN', 'Failed to restore connections', { error: e.message });
+    }
+    
+    // Create WebSocket server with proper error handling
+    try {
+      this.wss = new WebSocket.Server({ port: BROKER_PORT, host: '127.0.0.1' });
+    } catch (e) {
+      log('ERROR', 'Failed to create WebSocket server', { error: e.message, port: BROKER_PORT });
+      throw e;
+    }
+    
+    // Wait for server to be listening
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error('WSS listen timeout')), 5000);
+      this.wss.on('listening', () => { clearTimeout(timeout); resolve(); });
+      this.wss.on('error', (err) => { clearTimeout(timeout); reject(err); });
+    });
     
-    this.wss = new WebSocket.Server({ port: BROKER_PORT, host: '127.0.0.1' });
     this.wss.on('connection', (ws) => this._handleClient(ws));
     this.wss.on('error', (err) => log('ERROR', 'WSS error', { error: err.message }));
     
     this.running = true;
-    log('INFO', 'Daemon started', { pid: process.pid, port: BROKER_PORT });
+    log('INFO', 'Daemon started successfully', { pid: process.pid, port: BROKER_PORT });
     
     // Save state on ANY termination signal
     const gracefulShutdown = (signal) => {
@@ -364,6 +383,22 @@ class RithmicBrokerDaemon {
     return { type: 'credentials', payload: creds, requestId };
   }
 
+  /**
+   * Sanitize account for safe serialization - ensure all fields are proper types
+   */
+  _sanitizeAccount(acc) {
+    if (!acc || typeof acc !== 'object') return null;
+    if (!acc.accountId) return null;
+    
+    return {
+      accountId: String(acc.accountId),
+      fcmId: acc.fcmId ? String(acc.fcmId) : undefined,
+      ibId: acc.ibId ? String(acc.ibId) : undefined,
+      accountName: acc.accountName ? String(acc.accountName) : undefined,
+      currency: acc.currency ? String(acc.currency) : undefined,
+    };
+  }
+
   /**
    * Save state including accounts (for reconnection without API calls)
    * CRITICAL: This state allows reconnection without hitting Rithmic's 2000 GetAccounts limit
@@ -372,10 +407,15 @@ class RithmicBrokerDaemon {
     const state = { connections: [], savedAt: new Date().toISOString() };
     for (const [key, conn] of this.connections) {
       if (conn.credentials) {
+        // Sanitize accounts to prevent corrupted data
+        const accounts = (conn.accounts || [])
+          .map(a => this._sanitizeAccount(a))
+          .filter(Boolean);
+        
         state.connections.push({ 
           propfirmKey: key, 
           credentials: conn.credentials,
-          accounts: conn.accounts || [],  // Save accounts to avoid fetchAccounts on restore
+          accounts,
           connectedAt: conn.connectedAt,
           propfirm: conn.service?.propfirm?.name || key
         });
@@ -392,8 +432,31 @@ class RithmicBrokerDaemon {
 
 // Main entry point
 if (require.main === module) {
-  const daemon = new RithmicBrokerDaemon();
-  daemon.start().catch((e) => { console.error('Daemon failed:', e.message); process.exit(1); });
+  // Ensure log directory exists early
+  if (!fs.existsSync(BROKER_DIR)) {
+    fs.mkdirSync(BROKER_DIR, { recursive: true });
+  }
+  
+  // Log startup attempt
+  const startupLog = (msg) => {
+    const ts = new Date().toISOString();
+    fs.appendFileSync(LOG_FILE, `[${ts}] [STARTUP] ${msg}\n`);
+  };
+  
+  startupLog(`Daemon starting (pid=${process.pid}, node=${process.version})`);
+  
+  try {
+    const daemon = new RithmicBrokerDaemon();
+    daemon.start().catch((e) => { 
+      startupLog(`FATAL: start() failed - ${e.message}`);
+      console.error('Daemon failed:', e.message); 
+      process.exit(1); 
+    });
+  } catch (e) {
+    startupLog(`FATAL: constructor failed - ${e.message}`);
+    console.error('Daemon failed:', e.message);
+    process.exit(1);
+  }
 }
 
 module.exports = { RithmicBrokerDaemon, BROKER_PORT, BROKER_DIR, PID_FILE, LOG_FILE, STATE_FILE };

package/src/services/rithmic-broker/manager.js

@@ -86,21 +86,29 @@ const start = async () => {
     child.unref();
     fs.closeSync(logFd);
     
-    // Wait for daemon to start
-    await new Promise(r => setTimeout(r, 2000));
+    // Wait for daemon to start (poll every 500ms, max 5s)
+    let attempts = 0;
+    const maxAttempts = 10;
+    let runStatus = { running: false, pid: null };
     
-    const runStatus = await isRunning();
-    if (runStatus.running) {
-      return { success: true, error: null, pid: runStatus.pid || child.pid };
-    } else {
-      // Read log for error details
-      let errorDetail = 'Failed to start RithmicBroker daemon';
-      if (fs.existsSync(LOG_FILE)) {
-        const log = fs.readFileSync(LOG_FILE, 'utf8').slice(-500);
-        if (log) errorDetail += `: ${log.split('\n').filter(l => l).pop()}`;
+    while (attempts < maxAttempts) {
+      await new Promise(r => setTimeout(r, 500));
+      runStatus = await isRunning();
+      if (runStatus.running) {
+        return { success: true, error: null, pid: runStatus.pid || child.pid };
       }
-      return { success: false, error: errorDetail, pid: null };
+      attempts++;
     }
+    
+    // Read log for error details
+    let errorDetail = 'Daemon failed to start';
+    if (fs.existsSync(LOG_FILE)) {
+      const logContent = fs.readFileSync(LOG_FILE, 'utf8');
+      const lines = logContent.split('\n').filter(l => l.trim());
+      const lastLines = lines.slice(-5).join(' | ');
+      if (lastLines) errorDetail += ` - Log: ${lastLines}`;
+    }
+    return { success: false, error: errorDetail, pid: null };
   } catch (error) {
     return { success: false, error: error.message, pid: null };
   }