hedgequantx 2.6.161 → 2.6.163

package/src/services/ai/validation.js

@@ -0,0 +1,250 @@
+/**
+ * AI Provider Validation Functions
+ * @module services/ai/validation
+ * 
+ * API key and endpoint validation for all AI providers.
+ */
+
+const { getProvider } = require('./providers');
+
+/**
+ * Validate API key with provider
+ */
+const validateConnection = async (providerId, optionId, credentials) => {
+  const provider = getProvider(providerId);
+  if (!provider) return { valid: false, error: 'Invalid provider' };
+  
+  try {
+    switch (providerId) {
+      case 'anthropic':
+        return await validateAnthropic(credentials);
+      case 'openai':
+        return await validateOpenAI(credentials);
+      case 'gemini':
+        return await validateGemini(credentials);
+      case 'deepseek':
+        return await validateDeepSeek(credentials);
+      case 'groq':
+        return await validateGroq(credentials);
+      case 'ollama':
+        return await validateOllama(credentials);
+      case 'lmstudio':
+        return await validateLMStudio(credentials);
+      case 'custom':
+        return await validateCustom(credentials);
+      case 'openrouter':
+        return await validateOpenRouter(credentials);
+      case 'xai':
+      case 'mistral':
+      case 'perplexity':
+      case 'together':
+      case 'qwen':
+      case 'moonshot':
+      case 'yi':
+      case 'zhipu':
+      case 'baichuan':
+        return await validateOpenAICompatible(provider, credentials);
+      default:
+        return { valid: false, error: 'Unknown provider' };
+    }
+  } catch (error) {
+    return { valid: false, error: error.message };
+  }
+};
+
+/** Validate Anthropic API key */
+const validateAnthropic = async (credentials) => {
+  try {
+    const token = credentials.apiKey || credentials.sessionKey || credentials.accessToken;
+    if (!token) return { valid: false, error: 'No API key provided' };
+    
+    const response = await fetch('https://api.anthropic.com/v1/models', {
+      method: 'GET',
+      headers: {
+        'x-api-key': token,
+        'anthropic-version': '2023-06-01'
+      }
+    });
+    
+    if (response.ok) {
+      const data = await response.json();
+      if (data.data && Array.isArray(data.data) && data.data.length > 0) {
+        return { valid: true, tokenType: 'api_key' };
+      }
+      return { valid: false, error: 'API returned no models' };
+    }
+    
+    const error = await response.json();
+    return { valid: false, error: error.error?.message || 'Invalid API key' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+/** Validate OpenAI API key */
+const validateOpenAI = async (credentials) => {
+  try {
+    const response = await fetch('https://api.openai.com/v1/models', {
+      headers: {
+        'Authorization': `Bearer ${credentials.apiKey || credentials.accessToken}`
+      }
+    });
+    
+    if (response.ok) return { valid: true };
+    return { valid: false, error: 'Invalid API key' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+/** Validate Gemini API key */
+const validateGemini = async (credentials) => {
+  try {
+    const response = await fetch(
+      `https://generativelanguage.googleapis.com/v1/models?key=${credentials.apiKey}`
+    );
+    
+    if (response.ok) return { valid: true };
+    return { valid: false, error: 'Invalid API key' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+/** Validate DeepSeek API key */
+const validateDeepSeek = async (credentials) => {
+  try {
+    const response = await fetch('https://api.deepseek.com/v1/models', {
+      headers: { 'Authorization': `Bearer ${credentials.apiKey}` }
+    });
+    
+    if (response.ok) return { valid: true };
+    return { valid: false, error: 'Invalid API key' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+/** Validate Groq API key */
+const validateGroq = async (credentials) => {
+  try {
+    const response = await fetch('https://api.groq.com/openai/v1/models', {
+      headers: { 'Authorization': `Bearer ${credentials.apiKey}` }
+    });
+    
+    if (response.ok) return { valid: true };
+    return { valid: false, error: 'Invalid API key' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+/** Validate Ollama local instance */
+const validateOllama = async (credentials) => {
+  try {
+    const endpoint = credentials.endpoint || 'http://localhost:11434';
+    const response = await fetch(`${endpoint}/api/tags`);
+    
+    if (response.ok) {
+      const data = await response.json();
+      return { valid: true, models: data.models?.map(m => m.name) || [] };
+    }
+    
+    return { valid: false, error: 'Cannot connect to Ollama' };
+  } catch (e) {
+    return { valid: false, error: 'Ollama not running. Start with: ollama serve' };
+  }
+};
+
+/** Validate LM Studio local instance */
+const validateLMStudio = async (credentials) => {
+  try {
+    const endpoint = credentials.endpoint || 'http://localhost:1234/v1';
+    const response = await fetch(`${endpoint}/models`);
+    
+    if (response.ok) {
+      const data = await response.json();
+      return { valid: true, models: data.data?.map(m => m.id) || [] };
+    }
+    
+    return { valid: false, error: 'Cannot connect to LM Studio' };
+  } catch (e) {
+    return { valid: false, error: 'LM Studio not running. Start local server first.' };
+  }
+};
+
+/** Validate custom endpoint */
+const validateCustom = async (credentials) => {
+  try {
+    const response = await fetch(`${credentials.endpoint}/models`, {
+      headers: credentials.apiKey ? { 'Authorization': `Bearer ${credentials.apiKey}` } : {}
+    });
+    
+    if (response.ok) return { valid: true };
+    return { valid: false, error: 'Cannot connect to endpoint' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+/** Validate OpenRouter API key */
+const validateOpenRouter = async (credentials) => {
+  try {
+    const response = await fetch('https://openrouter.ai/api/v1/models', {
+      headers: { 'Authorization': `Bearer ${credentials.apiKey}` }
+    });
+    
+    if (response.ok) return { valid: true };
+    return { valid: false, error: 'Invalid API key' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+/** Validate OpenAI-compatible providers */
+const validateOpenAICompatible = async (provider, credentials) => {
+  try {
+    const endpoint = provider.endpoint;
+    const response = await fetch(`${endpoint}/models`, {
+      headers: {
+        'Authorization': `Bearer ${credentials.apiKey}`,
+        'Content-Type': 'application/json'
+      }
+    });
+    
+    if (response.ok) return { valid: true };
+    
+    // Some providers don't have /models endpoint, try a simple chat
+    const chatResponse = await fetch(`${endpoint}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${credentials.apiKey}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        model: provider.defaultModel,
+        messages: [{ role: 'user', content: 'hi' }],
+        max_tokens: 5
+      })
+    });
+    
+    if (chatResponse.ok) return { valid: true };
+    return { valid: false, error: 'Invalid API key or endpoint' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+module.exports = {
+  validateConnection,
+  validateAnthropic,
+  validateOpenAI,
+  validateGemini,
+  validateDeepSeek,
+  validateGroq,
+  validateOllama,
+  validateLMStudio,
+  validateCustom,
+  validateOpenRouter,
+  validateOpenAICompatible,
+};

package/src/services/hqx-server-events.js

@@ -0,0 +1,110 @@
+/**
+ * @fileoverview HQX Server Event Management
+ * @module services/hqx-server-events
+ * 
+ * Lightweight event emitter for HQX WebSocket service.
+ * Optimized for performance with inlined loops.
+ */
+
+/**
+ * Event emitter mixin for HQXServerService
+ * These functions should be called with .call(this) to bind to service instance
+ */
+
+/**
+ * Register event listener
+ * @param {Map} listeners - Listeners map
+ * @param {string} event - Event name
+ * @param {Function} callback - Callback function
+ */
+function on(listeners, event, callback) {
+  if (!listeners.has(event)) {
+    listeners.set(event, []);
+  }
+  listeners.get(event).push(callback);
+}
+
+/**
+ * Remove event listener
+ * @param {Map} listeners - Listeners map
+ * @param {string} event - Event name
+ * @param {Function} callback - Callback function
+ */
+function off(listeners, event, callback) {
+  const callbacks = listeners.get(event);
+  if (callbacks) {
+    const index = callbacks.indexOf(callback);
+    if (index > -1) callbacks.splice(index, 1);
+  }
+}
+
+/**
+ * Emit event (inlined for speed)
+ * @param {Map} listeners - Listeners map
+ * @param {string} event - Event name
+ * @param {*} data - Event data
+ */
+function emit(listeners, event, data) {
+  const callbacks = listeners.get(event);
+  if (!callbacks) return;
+  
+  for (let i = 0; i < callbacks.length; i++) {
+    try {
+      callbacks[i](data);
+    } catch {
+      // Don't let callback errors break the loop
+    }
+  }
+}
+
+/**
+ * Clear all listeners
+ * @param {Map} listeners - Listeners map
+ */
+function clearAll(listeners) {
+  listeners.clear();
+}
+
+/**
+ * Remove all listeners for a specific event
+ * @param {Map} listeners - Listeners map
+ * @param {string} event - Event name
+ */
+function removeAllListeners(listeners, event) {
+  if (event) {
+    listeners.delete(event);
+  } else {
+    listeners.clear();
+  }
+}
+
+/**
+ * Get listener count for an event
+ * @param {Map} listeners - Listeners map
+ * @param {string} event - Event name
+ * @returns {number}
+ */
+function listenerCount(listeners, event) {
+  const callbacks = listeners.get(event);
+  return callbacks ? callbacks.length : 0;
+}
+
+/**
+ * Check if event has listeners
+ * @param {Map} listeners - Listeners map
+ * @param {string} event - Event name
+ * @returns {boolean}
+ */
+function hasListeners(listeners, event) {
+  return listenerCount(listeners, event) > 0;
+}
+
+module.exports = {
+  on,
+  off,
+  emit,
+  clearAll,
+  removeAllListeners,
+  listenerCount,
+  hasListeners,
+};

package/src/services/hqx-server-handlers.js

@@ -0,0 +1,217 @@
+/**
+ * @fileoverview HQX Server Message Handlers
+ * @module services/hqx-server-handlers
+ * 
+ * Message parsing and handling for HQX WebSocket.
+ * Optimized for ultra-low latency trading signals.
+ */
+
+const { logger } = require('../utils/logger');
+const log = logger.scope('HQX');
+
+/** Message types as bytes for faster switching */
+const MSG_TYPE = {
+  // Outgoing
+  PING: 0x01,
+  START_ALGO: 0x10,
+  STOP_ALGO: 0x11,
+  START_COPY: 0x12,
+  ORDER: 0x20,
+  
+  // Incoming
+  PONG: 0x81,
+  SIGNAL: 0x90,
+  TRADE: 0x91,
+  FILL: 0x92,
+  LOG: 0xA0,
+  STATS: 0xA1,
+  ERROR: 0xFF,
+};
+
+/**
+ * Fast JSON parse with type hint
+ * @param {string|Buffer} data 
+ * @returns {Object}
+ */
+const fastParse = (data) => {
+  const str = typeof data === 'string' ? data : data.toString('utf8');
+  return JSON.parse(str);
+};
+
+/**
+ * Handle binary trading signal (zero-copy)
+ * @param {Buffer} data 
+ * @param {Function} emit - Emit function
+ */
+function handleBinarySignal(data, emit) {
+  // Binary format: [type:1][timestamp:8][side:1][price:8][qty:4]
+  if (data.length >= 22) {
+    const signal = {
+      timestamp: data.readBigInt64LE(1),
+      side: data.readUInt8(9),
+      price: data.readDoubleLE(10),
+      quantity: data.readUInt32LE(18),
+    };
+    emit('signal', signal);
+  }
+}
+
+/**
+ * Handle pong with latency calculation
+ * @param {Buffer} data 
+ * @param {bigint} receiveTime 
+ * @param {number} lastPingTime 
+ * @param {Function} updateLatency 
+ */
+function handlePong(data, receiveTime, lastPingTime, updateLatency) {
+  if (lastPingTime > 0) {
+    // Use high-resolution timer
+    const latency = Number(receiveTime - lastPingTime) / 1e6; // ns to ms
+    updateLatency(latency);
+  }
+}
+
+/**
+ * Handle JSON message
+ * @param {Object} message 
+ * @param {bigint} receiveTime 
+ * @param {Function} emit 
+ * @param {Function} updateLatency 
+ */
+function handleJsonMessage(message, receiveTime, emit, updateLatency) {
+  // Calculate latency from server timestamp
+  if (message.timestamp) {
+    const latency = Date.now() - message.timestamp;
+    if (latency >= 0 && latency < 5000) {
+      updateLatency(latency);
+    }
+  }
+  
+  // Fast dispatch
+  switch (message.type) {
+    case 'signal':
+      emit('signal', message.data);
+      break;
+    case 'trade':
+      emit('trade', message.data);
+      break;
+    case 'fill':
+      emit('fill', message.data);
+      break;
+    case 'log':
+      emit('log', message.data);
+      break;
+    case 'stats':
+      emit('stats', message.data);
+      break;
+    case 'error':
+      emit('error', message.data);
+      break;
+    case 'pong':
+      // Already handled in binary path
+      break;
+    default:
+      emit('message', message);
+  }
+}
+
+/**
+ * Process incoming message
+ * @param {Object} ctx - Service context
+ * @param {Buffer|string} data - Raw message data
+ * @param {Function} emit - Emit function
+ * @param {Function} updateLatency - Latency update function
+ */
+function processMessage(ctx, data, emit, updateLatency) {
+  const receiveTime = process.hrtime.bigint();
+  ctx.messagesReceived++;
+  ctx.bytesReceived += data.length;
+  
+  try {
+    // Try binary format first (faster)
+    if (Buffer.isBuffer(data) && data.length > 0) {
+      const msgType = data.readUInt8(0);
+      
+      // Fast path for pong
+      if (msgType === MSG_TYPE.PONG) {
+        handlePong(data, receiveTime, ctx.lastPingTime, updateLatency);
+        return;
+      }
+      
+      // Binary signal (fastest path)
+      if (msgType === MSG_TYPE.SIGNAL) {
+        handleBinarySignal(data, emit);
+        return;
+      }
+    }
+    
+    // JSON fallback
+    const message = fastParse(data);
+    handleJsonMessage(message, receiveTime, emit, updateLatency);
+    
+  } catch (err) {
+    log.warn('Message parse error', { error: err.message });
+  }
+}
+
+/**
+ * Build algo config payload
+ * @param {Object} config 
+ * @returns {Object}
+ */
+function buildAlgoPayload(config) {
+  return {
+    accountId: config.accountId,
+    contractId: config.contractId,
+    symbol: config.symbol,
+    contracts: config.contracts,
+    dailyTarget: config.dailyTarget,
+    maxRisk: config.maxRisk,
+    propfirm: config.propfirm,
+    propfirmToken: config.propfirmToken,
+    rithmicCredentials: config.rithmicCredentials || null,
+    copyTrading: config.copyTrading || false,
+    followerSymbol: config.followerSymbol,
+    followerContracts: config.followerContracts,
+  };
+}
+
+/**
+ * Build copy trading config payload
+ * @param {Object} config 
+ * @returns {Object}
+ */
+function buildCopyTradingPayload(config) {
+  return {
+    // Lead
+    leadAccountId: config.leadAccountId,
+    leadContractId: config.leadContractId,
+    leadSymbol: config.leadSymbol,
+    leadContracts: config.leadContracts,
+    leadPropfirm: config.leadPropfirm,
+    leadToken: config.leadToken,
+    leadRithmicCredentials: config.leadRithmicCredentials,
+    // Follower
+    followerAccountId: config.followerAccountId,
+    followerContractId: config.followerContractId,
+    followerSymbol: config.followerSymbol,
+    followerContracts: config.followerContracts,
+    followerPropfirm: config.followerPropfirm,
+    followerToken: config.followerToken,
+    followerRithmicCredentials: config.followerRithmicCredentials,
+    // Targets
+    dailyTarget: config.dailyTarget,
+    maxRisk: config.maxRisk,
+  };
+}
+
+module.exports = {
+  MSG_TYPE,
+  fastParse,
+  handleBinarySignal,
+  handlePong,
+  handleJsonMessage,
+  processMessage,
+  buildAlgoPayload,
+  buildCopyTradingPayload,
+};

package/src/services/hqx-server-latency.js

@@ -0,0 +1,136 @@
+/**
+ * @fileoverview HQX Server Latency Management
+ * @module services/hqx-server-latency
+ * 
+ * Handles latency tracking, adaptive heartbeat, and connection statistics.
+ */
+
+/**
+ * Latency manager mixin for HQXServerService
+ * Call with .call(this) to bind to service instance
+ */
+
+/**
+ * Update latency statistics
+ * @param {number} latency - Latency in ms
+ */
+function updateLatency(latency) {
+  this.latency = latency;
+  this.minLatency = Math.min(this.minLatency, latency);
+  this.maxLatency = Math.max(this.maxLatency, latency);
+  
+  // Rolling average (last 100 samples)
+  this.latencySamples.push(latency);
+  if (this.latencySamples.length > 100) {
+    this.latencySamples.shift();
+  }
+  this.avgLatency = this.latencySamples.reduce((a, b) => a + b, 0) / this.latencySamples.length;
+  
+  // Adapt heartbeat based on latency
+  adaptHeartbeat.call(this);
+  
+  this._emit('latency', { 
+    current: latency, 
+    min: this.minLatency, 
+    max: this.maxLatency, 
+    avg: this.avgLatency 
+  });
+}
+
+/**
+ * Adapt heartbeat interval based on connection quality
+ */
+function adaptHeartbeat() {
+  // Good connection: slower heartbeat (less overhead)
+  // Poor connection: faster heartbeat (detect issues quickly)
+  if (this.avgLatency < 10) {
+    this.adaptiveHeartbeat = 2000;  // <10ms: 2s heartbeat
+  } else if (this.avgLatency < 50) {
+    this.adaptiveHeartbeat = 1000;  // <50ms: 1s heartbeat
+  } else if (this.avgLatency < 100) {
+    this.adaptiveHeartbeat = 500;   // <100ms: 500ms heartbeat
+  } else {
+    this.adaptiveHeartbeat = 250;   // High latency: 250ms heartbeat
+  }
+}
+
+/**
+ * Start adaptive heartbeat
+ * @param {Function} sendPing - Function to send ping
+ */
+function startHeartbeat(sendPing) {
+  stopHeartbeat.call(this);
+  
+  const heartbeat = () => {
+    if (this.connected) {
+      sendPing();
+      
+      // Schedule next with adaptive interval
+      this.pingInterval = setTimeout(heartbeat, this.adaptiveHeartbeat);
+    }
+  };
+  
+  // First ping immediately
+  sendPing();
+  this.pingInterval = setTimeout(heartbeat, this.adaptiveHeartbeat);
+}
+
+/**
+ * Stop heartbeat
+ */
+function stopHeartbeat() {
+  if (this.pingInterval) {
+    clearTimeout(this.pingInterval);
+    this.pingInterval = null;
+  }
+}
+
+/**
+ * Get latency statistics
+ * @returns {Object}
+ */
+function getLatencyStats() {
+  return {
+    current: this.latency,
+    min: this.minLatency === Infinity ? 0 : this.minLatency,
+    max: this.maxLatency,
+    avg: this.avgLatency,
+    samples: this.latencySamples.length,
+  };
+}
+
+/**
+ * Get connection statistics
+ * @returns {Object}
+ */
+function getConnectionStats() {
+  return {
+    connected: this.connected,
+    messagesSent: this.messagesSent,
+    messagesReceived: this.messagesReceived,
+    bytesReceived: this.bytesReceived,
+    heartbeatInterval: this.adaptiveHeartbeat,
+    latency: getLatencyStats.call(this),
+  };
+}
+
+/**
+ * Reset latency stats
+ */
+function resetLatencyStats() {
+  this.latencySamples = [];
+  this.minLatency = Infinity;
+  this.maxLatency = 0;
+  this.avgLatency = 0;
+  this.latency = 0;
+}
+
+module.exports = {
+  updateLatency,
+  adaptHeartbeat,
+  startHeartbeat,
+  stopHeartbeat,
+  getLatencyStats,
+  getConnectionStats,
+  resetLatencyStats,
+};