hedgequantx 2.6.161 → 2.6.162

package/src/services/ai/proxy-remote.js

@@ -0,0 +1,161 @@
+/**
+ * @fileoverview Remote OAuth for CLIProxyAPI
+ * 
+ * For VPS/Server users without browser access
+ * Uses cli.hedgequantx.com as OAuth relay
+ */
+
+const https = require('https');
+
+const REMOTE_OAUTH_URL = 'https://cli.hedgequantx.com';
+
+/**
+ * Make HTTPS request
+ */
+const httpsRequest = (url, options, body = null) => {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const req = https.request({
+      hostname: parsedUrl.hostname,
+      port: 443,
+      path: parsedUrl.pathname + parsedUrl.search,
+      method: options.method || 'GET',
+      headers: options.headers || {}
+    }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          resolve(data);
+        }
+      });
+    });
+    
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+    
+    if (body) {
+      req.write(typeof body === 'string' ? body : JSON.stringify(body));
+    }
+    req.end();
+  });
+};
+
+/**
+ * Create Remote OAuth session
+ * @param {string} provider - Provider ID (anthropic, openai, gemini)
+ * @returns {Promise<{sessionId: string, authUrl: string}>}
+ */
+const createRemoteSession = async (provider) => {
+  const response = await httpsRequest(
+    `${REMOTE_OAUTH_URL}/oauth/session/create`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' }
+    },
+    JSON.stringify({ provider })
+  );
+  
+  if (response.error) {
+    throw new Error(response.error);
+  }
+  
+  return {
+    sessionId: response.sessionId,
+    authUrl: response.authUrl
+  };
+};
+
+/**
+ * Poll Remote OAuth session status
+ * @param {string} sessionId - Session ID from createRemoteSession
+ * @returns {Promise<{status: string, error?: string}>}
+ */
+const pollRemoteSession = async (sessionId) => {
+  const response = await httpsRequest(
+    `${REMOTE_OAUTH_URL}/oauth/session/${sessionId}/status`,
+    { method: 'GET' }
+  );
+  return response;
+};
+
+/**
+ * Get tokens from Remote OAuth session
+ * @param {string} sessionId - Session ID
+ * @returns {Promise<{provider: string, tokens: Object}>}
+ */
+const getRemoteTokens = async (sessionId) => {
+  const response = await httpsRequest(
+    `${REMOTE_OAUTH_URL}/oauth/session/${sessionId}/tokens`,
+    { method: 'GET' }
+  );
+  
+  if (response.error) {
+    throw new Error(response.error);
+  }
+  
+  return response;
+};
+
+/**
+ * Wait for Remote OAuth to complete
+ * @param {string} sessionId - Session ID
+ * @param {number} timeoutMs - Timeout in milliseconds
+ * @param {Function} onStatus - Status callback
+ * @returns {Promise<{provider: string, tokens: Object}>}
+ */
+const waitForRemoteAuth = async (sessionId, timeoutMs = 300000, onStatus = () => {}) => {
+  const startTime = Date.now();
+  
+  while (Date.now() - startTime < timeoutMs) {
+    const status = await pollRemoteSession(sessionId);
+    
+    if (status.status === 'success') {
+      return await getRemoteTokens(sessionId);
+    } else if (status.status === 'error') {
+      throw new Error(status.error || 'Authentication failed');
+    }
+    
+    onStatus('Waiting for authorization...');
+    await new Promise(resolve => setTimeout(resolve, 2000));
+  }
+  
+  throw new Error('Authentication timeout');
+};
+
+/**
+ * Detect if we're running on a server (no display/browser)
+ * @returns {boolean}
+ */
+const isServerEnvironment = () => {
+  if (process.env.SSH_CONNECTION || process.env.SSH_CLIENT) return true;
+  if (process.env.DISPLAY === undefined && process.platform === 'linux') return true;
+  if (process.env.TERM === 'dumb') return true;
+  if (process.env.HQX_REMOTE_OAUTH === '1') return true;
+  return false;
+};
+
+/**
+ * Detect if browser can be opened
+ * @returns {boolean}
+ */
+const canOpenBrowser = () => {
+  if (process.platform === 'darwin' || process.platform === 'win32') return true;
+  if (process.env.DISPLAY) return true;
+  return false;
+};
+
+module.exports = {
+  createRemoteSession,
+  pollRemoteSession,
+  getRemoteTokens,
+  waitForRemoteAuth,
+  isServerEnvironment,
+  canOpenBrowser,
+  REMOTE_OAUTH_URL
+};

package/src/services/ai/supervisor-optimize.js

@@ -0,0 +1,215 @@
+/**
+ * @fileoverview AI Supervisor - Optimization & Market Advice
+ * 
+ * Methods for AI-driven strategy optimization and market analysis
+ * In CONSENSUS mode, only unanimous suggestions are applied
+ */
+
+const { analyzePerformance, getMarketAdvice: getMarketAdviceFromClient } = require('./client');
+
+/**
+ * Request strategy optimization from all agents
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {Object} performanceData - Strategy performance data
+ * @returns {Promise<Object|null>} Optimization suggestions
+ */
+const requestOptimization = async (supervisionSessions, performanceData) => {
+  if (supervisionSessions.size === 0) return null;
+  
+  const allSessions = Array.from(supervisionSessions.values());
+  const suggestions = [];
+  
+  // Get optimization suggestions from each agent
+  for (const session of allSessions) {
+    try {
+      const suggestion = await analyzePerformance(session.agent, performanceData);
+      if (suggestion) {
+        suggestions.push({
+          agentId: session.agentId,
+          agentName: session.agent.name,
+          ...suggestion
+        });
+      }
+    } catch (e) {
+      // Silent fail for individual agent
+    }
+  }
+  
+  if (suggestions.length === 0) return null;
+  
+  // If single agent, return its suggestion
+  if (suggestions.length === 1) {
+    return {
+      mode: 'INDIVIDUAL',
+      ...suggestions[0]
+    };
+  }
+  
+  // CONSENSUS MODE: Find common optimizations
+  const consensusOptimizations = [];
+  const allOptimizations = suggestions.flatMap(s => s.optimizations || []);
+  
+  // Group by parameter name
+  const paramGroups = {};
+  for (const opt of allOptimizations) {
+    if (!opt.param) continue;
+    if (!paramGroups[opt.param]) {
+      paramGroups[opt.param] = [];
+    }
+    paramGroups[opt.param].push(opt);
+  }
+  
+  // Find unanimous suggestions (all agents agree on direction)
+  for (const [param, opts] of Object.entries(paramGroups)) {
+    if (opts.length === suggestions.length) {
+      // All agents suggested this param - check if they agree on direction
+      const directions = opts.map(o => {
+        const current = parseFloat(o.current) || 0;
+        const suggested = parseFloat(o.suggested) || 0;
+        return suggested > current ? 'increase' : suggested < current ? 'decrease' : 'same';
+      });
+      
+      const allSame = directions.every(d => d === directions[0]);
+      if (allSame && directions[0] !== 'same') {
+        // Unanimous - use average of suggested values
+        const avgSuggested = opts.reduce((sum, o) => sum + (parseFloat(o.suggested) || 0), 0) / opts.length;
+        consensusOptimizations.push({
+          param,
+          current: opts[0].current,
+          suggested: avgSuggested.toFixed(2),
+          reason: `Unanimous (${suggestions.length} agents agree)`,
+          direction: directions[0]
+        });
+      }
+    }
+  }
+  
+  // Calculate average confidence
+  const avgConfidence = Math.round(
+    suggestions.reduce((sum, s) => sum + (s.confidence || 0), 0) / suggestions.length
+  );
+  
+  // Determine consensus market condition
+  const conditions = suggestions.map(s => s.marketCondition).filter(Boolean);
+  const conditionCounts = {};
+  for (const c of conditions) {
+    conditionCounts[c] = (conditionCounts[c] || 0) + 1;
+  }
+  const consensusCondition = Object.entries(conditionCounts)
+    .sort((a, b) => b[1] - a[1])[0]?.[0] || 'unknown';
+  
+  return {
+    mode: 'CONSENSUS',
+    agentCount: suggestions.length,
+    isUnanimous: consensusOptimizations.length > 0,
+    optimizations: consensusOptimizations,
+    marketCondition: consensusCondition,
+    confidence: avgConfidence,
+    individualSuggestions: suggestions
+  };
+};
+
+/**
+ * Get real-time market advice from all agents
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {Object} marketData - Current market data
+ * @returns {Promise<Object|null>} Market advice (consensus)
+ */
+const getMarketAdvice = async (supervisionSessions, marketData) => {
+  if (supervisionSessions.size === 0) return null;
+  
+  const allSessions = Array.from(supervisionSessions.values());
+  const advices = [];
+  
+  // Get advice from each agent
+  for (const session of allSessions) {
+    try {
+      const advice = await getMarketAdviceFromClient(session.agent, marketData);
+      if (advice) {
+        advices.push({
+          agentId: session.agentId,
+          agentName: session.agent.name,
+          ...advice
+        });
+      }
+    } catch (e) {
+      // Silent fail
+    }
+  }
+  
+  if (advices.length === 0) return null;
+  
+  // Single agent
+  if (advices.length === 1) {
+    return {
+      mode: 'INDIVIDUAL',
+      ...advices[0]
+    };
+  }
+  
+  // CONSENSUS: All agents must agree on action
+  const actions = advices.map(a => a.action);
+  const allSameAction = actions.every(a => a === actions[0]);
+  
+  if (allSameAction) {
+    // Unanimous action - average the size multiplier
+    const avgMultiplier = advices.reduce((sum, a) => sum + (a.sizeMultiplier || 1), 0) / advices.length;
+    const avgConfidence = Math.round(advices.reduce((sum, a) => sum + (a.confidence || 0), 0) / advices.length);
+    
+    return {
+      mode: 'CONSENSUS',
+      isUnanimous: true,
+      action: actions[0],
+      sizeMultiplier: Math.round(avgMultiplier * 100) / 100,
+      confidence: avgConfidence,
+      reason: `${advices.length} agents unanimous`,
+      agentCount: advices.length
+    };
+  } else {
+    // Agents disagree - be conservative
+    return {
+      mode: 'CONSENSUS',
+      isUnanimous: false,
+      action: 'CAUTIOUS',
+      sizeMultiplier: 0.5,
+      confidence: 0,
+      reason: 'Agents disagree - reducing exposure',
+      agentCount: advices.length,
+      votes: actions.reduce((acc, a) => { acc[a] = (acc[a] || 0) + 1; return acc; }, {})
+    };
+  }
+};
+
+/**
+ * Apply optimization to strategy
+ * @param {Object} strategy - Strategy instance
+ * @param {Object} optimization - Optimization to apply
+ * @returns {boolean} Success
+ */
+const applyOptimization = (strategy, optimization) => {
+  if (!strategy || !optimization) return false;
+  
+  try {
+    // Check if strategy has optimization method
+    if (typeof strategy.applyOptimization === 'function') {
+      strategy.applyOptimization(optimization);
+      return true;
+    }
+    
+    // Fallback: try to set individual parameters
+    if (typeof strategy.setParameter === 'function' && optimization.param) {
+      strategy.setParameter(optimization.param, optimization.suggested);
+      return true;
+    }
+    
+    return false;
+  } catch (e) {
+    return false;
+  }
+};
+
+module.exports = {
+  requestOptimization,
+  getMarketAdvice,
+  applyOptimization,
+};

package/src/services/ai/supervisor-sync.js

@@ -0,0 +1,178 @@
+/**
+ * @fileoverview AI Supervisor - Strategy Sync
+ * 
+ * Methods to sync AI supervision with trading strategy in real-time
+ * Agents receive the same data as the strategy
+ */
+
+/**
+ * Feed market tick to all sessions
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {Object} tick - Market tick { price, bid, ask, volume, timestamp }
+ */
+const feedTick = (supervisionSessions, tick) => {
+  if (supervisionSessions.size === 0) return;
+  
+  for (const [agentId, session] of supervisionSessions.entries()) {
+    if (!session.marketData) {
+      session.marketData = { ticks: [], lastTick: null };
+    }
+    session.marketData.lastTick = tick;
+    session.marketData.ticks.push(tick);
+    
+    // Keep only last 1000 ticks to prevent memory bloat
+    if (session.marketData.ticks.length > 1000) {
+      session.marketData.ticks = session.marketData.ticks.slice(-1000);
+    }
+  }
+};
+
+/**
+ * Feed strategy signal to all sessions
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {Object} signal - Strategy signal
+ */
+const feedSignal = (supervisionSessions, signal) => {
+  if (supervisionSessions.size === 0) return;
+  
+  const signalData = {
+    timestamp: Date.now(),
+    direction: signal.direction,
+    entry: signal.entry,
+    stopLoss: signal.stopLoss,
+    takeProfit: signal.takeProfit,
+    confidence: signal.confidence
+  };
+  
+  for (const [agentId, session] of supervisionSessions.entries()) {
+    if (!session.signals) {
+      session.signals = [];
+    }
+    session.signals.push(signalData);
+    
+    // Keep only last 100 signals
+    if (session.signals.length > 100) {
+      session.signals = session.signals.slice(-100);
+    }
+  }
+};
+
+/**
+ * Feed trade execution to all sessions
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {Object} trade - Trade data
+ */
+const feedTrade = (supervisionSessions, trade) => {
+  if (supervisionSessions.size === 0) return;
+  
+  const tradeData = {
+    timestamp: Date.now(),
+    side: trade.side,
+    qty: trade.qty,
+    price: trade.price,
+    pnl: trade.pnl,
+    symbol: trade.symbol
+  };
+  
+  for (const [agentId, session] of supervisionSessions.entries()) {
+    if (!session.trades) {
+      session.trades = [];
+    }
+    session.trades.push(tradeData);
+  }
+};
+
+/**
+ * Update current position for all sessions
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {Object} position - Position data
+ */
+const updatePosition = (supervisionSessions, position) => {
+  if (supervisionSessions.size === 0) return;
+  
+  for (const [agentId, session] of supervisionSessions.entries()) {
+    session.currentPosition = {
+      timestamp: Date.now(),
+      qty: position.qty,
+      side: position.side,
+      entryPrice: position.entryPrice,
+      pnl: position.pnl
+    };
+  }
+};
+
+/**
+ * Update P&L for all sessions
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {number} pnl - Current session P&L
+ * @param {number} balance - Account balance
+ */
+const updatePnL = (supervisionSessions, pnl, balance) => {
+  if (supervisionSessions.size === 0) return;
+  
+  for (const [agentId, session] of supervisionSessions.entries()) {
+    session.currentPnL = pnl;
+    session.currentBalance = balance;
+  }
+};
+
+/**
+ * Check if agents recommend intervention
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {Function} getConsensus - Function to get consensus
+ * @returns {Object} Intervention check result
+ */
+const checkIntervention = (supervisionSessions, getConsensus) => {
+  if (supervisionSessions.size === 0) {
+    return { shouldContinue: true, action: 'CONTINUE', reason: 'No AI supervision active' };
+  }
+  
+  const consensus = getConsensus();
+  
+  if (consensus && consensus.isUnanimous) {
+    if (consensus.action === 'PAUSE' || consensus.action === 'STOP') {
+      return { shouldContinue: false, action: consensus.action, reason: 'AI agents recommend pause' };
+    }
+    if (consensus.action === 'REDUCE_SIZE') {
+      return { shouldContinue: true, action: 'REDUCE_SIZE', reason: 'AI agents recommend reducing size' };
+    }
+  } else if (consensus && !consensus.isUnanimous) {
+    return { shouldContinue: false, action: 'HOLD', reason: 'AI agents disagree - waiting for consensus' };
+  }
+  
+  return { shouldContinue: true, action: 'CONTINUE', reason: 'AI supervision active' };
+};
+
+/**
+ * Get real-time sync status
+ * @param {Map} supervisionSessions - Sessions map
+ * @returns {Object} Sync status
+ */
+const getSyncStatus = (supervisionSessions) => {
+  if (supervisionSessions.size === 0) {
+    return { synced: false, agents: 0 };
+  }
+  
+  const firstSession = supervisionSessions.values().next().value;
+  
+  return {
+    synced: true,
+    agents: supervisionSessions.size,
+    lastTick: firstSession?.marketData?.lastTick?.timestamp || null,
+    tickCount: firstSession?.marketData?.ticks?.length || 0,
+    signalCount: firstSession?.signals?.length || 0,
+    tradeCount: firstSession?.trades?.length || 0,
+    currentPnL: firstSession?.currentPnL || 0,
+    currentPosition: firstSession?.currentPosition || null
+  };
+};
+
+module.exports = {
+  feedTick,
+  feedSignal,
+  feedTrade,
+  updatePosition,
+  updatePnL,
+  checkIntervention,
+  getSyncStatus,
+};