hedgequantx 1.1.1

package/src/services/hqx-server.js

@@ -0,0 +1,351 @@
+/**
+ * HQX Server Service
+ * Secure WebSocket connection to HQX Algo Server
+ * All algo logic runs server-side - CLI only receives signals
+ */
+
+const WebSocket = require('ws');
+const crypto = require('crypto');
+const https = require('https');
+
+// HQX Server Configuration - Contabo Dedicated Server
+const HQX_CONFIG = {
+  apiUrl: process.env.HQX_API_URL || 'http://173.212.223.75:3500',
+  wsUrl: process.env.HQX_WS_URL || 'ws://173.212.223.75:3500/ws',
+  version: 'v1'
+};
+
+class HQXServerService {
+  constructor() {
+    this.ws = null;
+    this.token = null;
+    this.apiKey = null;
+    this.sessionId = null;
+    this.connected = false;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 5;
+    this.listeners = new Map();
+    this.heartbeatInterval = null;
+    this.messageQueue = [];
+  }
+
+  /**
+   * Generate device fingerprint for security
+   */
+  _generateDeviceId() {
+    const os = require('os');
+    const data = `${os.hostname()}-${os.platform()}-${os.arch()}-${os.cpus()[0]?.model || 'unknown'}`;
+    return crypto.createHash('sha256').update(data).digest('hex').substring(0, 32);
+  }
+
+  /**
+   * HTTPS request helper
+   */
+  _request(endpoint, method = 'GET', data = null) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(`${HQX_CONFIG.apiUrl}/${HQX_CONFIG.version}${endpoint}`);
+      
+      const options = {
+        hostname: url.hostname,
+        port: 443,
+        path: url.pathname,
+        method: method,
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json',
+          'X-Device-Id': this._generateDeviceId()
+        }
+      };
+
+      if (this.token) {
+        options.headers['Authorization'] = `Bearer ${this.token}`;
+      }
+      if (this.apiKey) {
+        options.headers['X-API-Key'] = this.apiKey;
+      }
+
+      const req = https.request(options, (res) => {
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try {
+            const json = JSON.parse(body);
+            resolve({ statusCode: res.statusCode, data: json });
+          } catch (e) {
+            resolve({ statusCode: res.statusCode, data: body });
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.setTimeout(15000, () => {
+        req.destroy();
+        reject(new Error('Request timeout'));
+      });
+
+      if (data) {
+        req.write(JSON.stringify(data));
+      }
+
+      req.end();
+    });
+  }
+
+  /**
+   * Authenticate with HQX Server
+   */
+  async authenticate(apiKey) {
+    try {
+      const response = await this._request('/auth/token', 'POST', {
+        apiKey: apiKey,
+        deviceId: this._generateDeviceId(),
+        timestamp: Date.now()
+      });
+
+      if (response.statusCode === 200 && response.data.success) {
+        this.token = response.data.token;
+        this.apiKey = apiKey;
+        this.sessionId = response.data.sessionId;
+        return { success: true, sessionId: this.sessionId };
+      } else {
+        return { 
+          success: false, 
+          error: response.data.error || 'Authentication failed' 
+        };
+      }
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Connect to WebSocket server
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      if (!this.token) {
+        reject(new Error('Not authenticated'));
+        return;
+      }
+
+      const wsUrl = `${HQX_CONFIG.wsUrl}?token=${this.token}&session=${this.sessionId}`;
+      
+      this.ws = new WebSocket(wsUrl, {
+        headers: {
+          'X-Device-Id': this._generateDeviceId(),
+          'X-API-Key': this.apiKey
+        }
+      });
+
+      this.ws.on('open', () => {
+        this.connected = true;
+        this.reconnectAttempts = 0;
+        this._startHeartbeat();
+        this._flushMessageQueue();
+        this._emit('connected', { sessionId: this.sessionId });
+        resolve({ success: true });
+      });
+
+      this.ws.on('message', (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          this._handleMessage(message);
+        } catch (e) {
+          // Invalid message format
+        }
+      });
+
+      this.ws.on('close', (code, reason) => {
+        this.connected = false;
+        this._stopHeartbeat();
+        this._emit('disconnected', { code, reason: reason.toString() });
+        this._attemptReconnect();
+      });
+
+      this.ws.on('error', (error) => {
+        this._emit('error', { message: error.message });
+        if (!this.connected) {
+          reject(error);
+        }
+      });
+
+      // Timeout for connection
+      setTimeout(() => {
+        if (!this.connected) {
+          this.ws.terminate();
+          reject(new Error('Connection timeout'));
+        }
+      }, 10000);
+    });
+  }
+
+  /**
+   * Handle incoming messages
+   */
+  _handleMessage(message) {
+    switch (message.type) {
+      case 'signal':
+        this._emit('signal', message.data);
+        break;
+      case 'trade':
+        this._emit('trade', message.data);
+        break;
+      case 'log':
+        this._emit('log', message.data);
+        break;
+      case 'stats':
+        this._emit('stats', message.data);
+        break;
+      case 'error':
+        this._emit('error', message.data);
+        break;
+      case 'pong':
+        // Heartbeat response
+        break;
+      default:
+        this._emit('message', message);
+    }
+  }
+
+  /**
+   * Send message to server
+   */
+  send(type, data) {
+    const message = {
+      type,
+      data,
+      timestamp: Date.now(),
+      sessionId: this.sessionId
+    };
+
+    if (this.connected && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(message));
+    } else {
+      this.messageQueue.push(message);
+    }
+  }
+
+  /**
+   * Start algo trading session
+   */
+  startAlgo(config) {
+    this.send('start_algo', {
+      accountId: config.accountId,
+      contractId: config.contractId,
+      symbol: config.symbol,
+      contracts: config.contracts,
+      dailyTarget: config.dailyTarget,
+      maxRisk: config.maxRisk,
+      propfirm: config.propfirm,
+      propfirmToken: config.propfirmToken
+    });
+  }
+
+  /**
+   * Stop algo trading session
+   */
+  stopAlgo() {
+    this.send('stop_algo', {});
+  }
+
+  /**
+   * Event listeners
+   */
+  on(event, callback) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    this.listeners.get(event).push(callback);
+  }
+
+  off(event, callback) {
+    if (this.listeners.has(event)) {
+      const callbacks = this.listeners.get(event);
+      const index = callbacks.indexOf(callback);
+      if (index > -1) {
+        callbacks.splice(index, 1);
+      }
+    }
+  }
+
+  _emit(event, data) {
+    if (this.listeners.has(event)) {
+      this.listeners.get(event).forEach(callback => {
+        try {
+          callback(data);
+        } catch (e) {
+          // Callback error
+        }
+      });
+    }
+  }
+
+  /**
+   * Heartbeat to keep connection alive
+   */
+  _startHeartbeat() {
+    this.heartbeatInterval = setInterval(() => {
+      if (this.connected) {
+        this.send('ping', { timestamp: Date.now() });
+      }
+    }, 30000);
+  }
+
+  _stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+
+  /**
+   * Flush queued messages after reconnect
+   */
+  _flushMessageQueue() {
+    while (this.messageQueue.length > 0) {
+      const message = this.messageQueue.shift();
+      if (this.ws.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify(message));
+      }
+    }
+  }
+
+  /**
+   * Attempt to reconnect
+   */
+  _attemptReconnect() {
+    if (this.reconnectAttempts < this.maxReconnectAttempts) {
+      this.reconnectAttempts++;
+      const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+      
+      setTimeout(() => {
+        this.connect().catch(() => {
+          // Reconnect failed
+        });
+      }, delay);
+    }
+  }
+
+  /**
+   * Disconnect from server
+   */
+  disconnect() {
+    this._stopHeartbeat();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+    this.token = null;
+    this.sessionId = null;
+  }
+
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected && this.ws && this.ws.readyState === WebSocket.OPEN;
+  }
+}
+
+module.exports = { HQXServerService, HQX_CONFIG };

package/src/services/index.js

@@ -0,0 +1,12 @@
+/**
+ * Services Module Exports
+ */
+
+const { ProjectXService } = require('./projectx');
+const { storage, connections } = require('./session');
+
+module.exports = {
+  ProjectXService,
+  storage,
+  connections
+};

package/src/services/local-storage.js

@@ -0,0 +1,309 @@
+/**
+ * Local Storage Service
+ * Stores user data locally on their machine
+ * - Saved connections (PropFirm credentials)
+ * - Session history
+ * - User preferences
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const os = require('os');
+
+// Storage directory in user's home folder
+const STORAGE_DIR = path.join(os.homedir(), '.hedgequantx');
+const CONNECTIONS_FILE = path.join(STORAGE_DIR, 'connections.enc');
+const SETTINGS_FILE = path.join(STORAGE_DIR, 'settings.json');
+const HISTORY_FILE = path.join(STORAGE_DIR, 'history.json');
+
+// Encryption key derived from machine ID
+const getEncryptionKey = () => {
+  const machineId = `${os.hostname()}-${os.platform()}-${os.userInfo().username}`;
+  return crypto.createHash('sha256').update(machineId).digest();
+};
+
+class LocalStorageService {
+  constructor() {
+    this._ensureStorageDir();
+  }
+
+  /**
+   * Ensure storage directory exists
+   */
+  _ensureStorageDir() {
+    if (!fs.existsSync(STORAGE_DIR)) {
+      fs.mkdirSync(STORAGE_DIR, { recursive: true, mode: 0o700 });
+    }
+  }
+
+  /**
+   * Encrypt data
+   */
+  _encrypt(data) {
+    const key = getEncryptionKey();
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
+    let encrypted = cipher.update(JSON.stringify(data), 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    return iv.toString('hex') + ':' + encrypted;
+  }
+
+  /**
+   * Decrypt data
+   */
+  _decrypt(encryptedData) {
+    try {
+      const key = getEncryptionKey();
+      const [ivHex, encrypted] = encryptedData.split(':');
+      const iv = Buffer.from(ivHex, 'hex');
+      const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
+      let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+      decrypted += decipher.final('utf8');
+      return JSON.parse(decrypted);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  // ==================== CONNECTIONS ====================
+
+  /**
+   * Save a PropFirm connection
+   */
+  saveConnection(connection) {
+    const connections = this.getConnections();
+    
+    // Check if connection already exists
+    const existingIndex = connections.findIndex(
+      c => c.propfirm === connection.propfirm && c.username === connection.username
+    );
+    
+    const connectionData = {
+      id: connection.id || crypto.randomUUID(),
+      propfirm: connection.propfirm,
+      propfirmName: connection.propfirmName,
+      username: connection.username,
+      password: connection.password, // Encrypted in file
+      lastUsed: Date.now(),
+      createdAt: connection.createdAt || Date.now()
+    };
+    
+    if (existingIndex >= 0) {
+      connections[existingIndex] = connectionData;
+    } else {
+      connections.push(connectionData);
+    }
+    
+    // Save encrypted
+    const encrypted = this._encrypt(connections);
+    fs.writeFileSync(CONNECTIONS_FILE, encrypted, { mode: 0o600 });
+    
+    return connectionData;
+  }
+
+  /**
+   * Get all saved connections
+   */
+  getConnections() {
+    try {
+      if (!fs.existsSync(CONNECTIONS_FILE)) {
+        return [];
+      }
+      const encrypted = fs.readFileSync(CONNECTIONS_FILE, 'utf8');
+      return this._decrypt(encrypted) || [];
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * Get connection by ID
+   */
+  getConnection(id) {
+    const connections = this.getConnections();
+    return connections.find(c => c.id === id);
+  }
+
+  /**
+   * Delete a connection
+   */
+  deleteConnection(id) {
+    const connections = this.getConnections();
+    const filtered = connections.filter(c => c.id !== id);
+    
+    if (filtered.length === connections.length) {
+      return false; // Not found
+    }
+    
+    const encrypted = this._encrypt(filtered);
+    fs.writeFileSync(CONNECTIONS_FILE, encrypted, { mode: 0o600 });
+    return true;
+  }
+
+  /**
+   * Update last used timestamp
+   */
+  updateConnectionLastUsed(id) {
+    const connections = this.getConnections();
+    const connection = connections.find(c => c.id === id);
+    
+    if (connection) {
+      connection.lastUsed = Date.now();
+      const encrypted = this._encrypt(connections);
+      fs.writeFileSync(CONNECTIONS_FILE, encrypted, { mode: 0o600 });
+    }
+  }
+
+  // ==================== SETTINGS ====================
+
+  /**
+   * Save user settings
+   */
+  saveSettings(settings) {
+    const currentSettings = this.getSettings();
+    const merged = { ...currentSettings, ...settings };
+    fs.writeFileSync(SETTINGS_FILE, JSON.stringify(merged, null, 2), { mode: 0o600 });
+    return merged;
+  }
+
+  /**
+   * Get user settings
+   */
+  getSettings() {
+    try {
+      if (!fs.existsSync(SETTINGS_FILE)) {
+        return this._getDefaultSettings();
+      }
+      const data = fs.readFileSync(SETTINGS_FILE, 'utf8');
+      return { ...this._getDefaultSettings(), ...JSON.parse(data) };
+    } catch (error) {
+      return this._getDefaultSettings();
+    }
+  }
+
+  /**
+   * Default settings
+   */
+  _getDefaultSettings() {
+    return {
+      defaultContracts: 1,
+      defaultDailyTarget: 500,
+      defaultMaxRisk: 250,
+      autoConnect: false,
+      theme: 'dark',
+      notifications: true,
+      analyticsEnabled: true // User can opt-out
+    };
+  }
+
+  // ==================== HISTORY ====================
+
+  /**
+   * Add to trading history
+   */
+  addToHistory(entry) {
+    const history = this.getHistory();
+    
+    history.push({
+      id: crypto.randomUUID(),
+      timestamp: Date.now(),
+      ...entry
+    });
+    
+    // Keep last 1000 entries
+    const trimmed = history.slice(-1000);
+    fs.writeFileSync(HISTORY_FILE, JSON.stringify(trimmed, null, 2), { mode: 0o600 });
+    
+    return entry;
+  }
+
+  /**
+   * Get trading history
+   */
+  getHistory(limit = 100) {
+    try {
+      if (!fs.existsSync(HISTORY_FILE)) {
+        return [];
+      }
+      const data = fs.readFileSync(HISTORY_FILE, 'utf8');
+      const history = JSON.parse(data);
+      return history.slice(-limit);
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * Get stats from history
+   */
+  getLocalStats() {
+    const history = this.getHistory(1000);
+    const trades = history.filter(h => h.type === 'trade');
+    
+    const totalTrades = trades.length;
+    const wins = trades.filter(t => t.pnl > 0).length;
+    const losses = trades.filter(t => t.pnl < 0).length;
+    const totalPnl = trades.reduce((sum, t) => sum + (t.pnl || 0), 0);
+    
+    return {
+      totalTrades,
+      wins,
+      losses,
+      winRate: totalTrades > 0 ? ((wins / totalTrades) * 100).toFixed(1) : 0,
+      totalPnl: totalPnl.toFixed(2),
+      avgPnl: totalTrades > 0 ? (totalPnl / totalTrades).toFixed(2) : 0
+    };
+  }
+
+  /**
+   * Clear all history
+   */
+  clearHistory() {
+    if (fs.existsSync(HISTORY_FILE)) {
+      fs.unlinkSync(HISTORY_FILE);
+    }
+  }
+
+  // ==================== UTILITIES ====================
+
+  /**
+   * Get storage path info
+   */
+  getStoragePath() {
+    return STORAGE_DIR;
+  }
+
+  /**
+   * Check if storage exists
+   */
+  hasStoredData() {
+    return fs.existsSync(CONNECTIONS_FILE) || fs.existsSync(HISTORY_FILE);
+  }
+
+  /**
+   * Export all data (for backup)
+   */
+  exportData() {
+    return {
+      connections: this.getConnections(),
+      settings: this.getSettings(),
+      history: this.getHistory(1000),
+      exportedAt: Date.now()
+    };
+  }
+
+  /**
+   * Clear all data
+   */
+  clearAll() {
+    if (fs.existsSync(CONNECTIONS_FILE)) fs.unlinkSync(CONNECTIONS_FILE);
+    if (fs.existsSync(SETTINGS_FILE)) fs.unlinkSync(SETTINGS_FILE);
+    if (fs.existsSync(HISTORY_FILE)) fs.unlinkSync(HISTORY_FILE);
+  }
+}
+
+// Singleton
+const localStorage = new LocalStorageService();
+
+module.exports = { LocalStorageService, localStorage };