hedgequantx 2.6.163 → 2.7.0

package/src/services/ai/validation.js

@@ -1,250 +0,0 @@
-/**
- * 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

@@ -1,110 +0,0 @@
-/**
- * @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

@@ -1,217 +0,0 @@
-/**
- * @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

@@ -1,136 +0,0 @@
-/**
- * @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,
-};