hedgequantx 2.6.163 → 2.7.0

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

@@ -1,494 +0,0 @@
-/**
- * CLIProxyAPI Manager
- * 
- * Automatically manages CLIProxyAPI for connecting AI subscription accounts
- * (ChatGPT Plus, Claude Pro, etc.) without needing API keys.
- * 
- * Flow:
- * 1. User selects "Connect Account" in CLI
- * 2. We ensure CLIProxyAPI is installed and running
- * 3. Generate OAuth URL → User opens in browser → Logs in
- * 4. Callback to localhost → Token saved → Models available
- */
-
-const http = require('http');
-const { spawn, exec } = require('child_process');
-
-// Import from sub-modules
-const {
-  PROXY_PORT,
-  PROXY_DIR,
-  PROXY_BIN,
-  PROXY_CONFIG,
-  API_KEY,
-  MANAGEMENT_KEY,
-  isInstalled,
-  install,
-  isConfigValid,
-  rewriteConfig,
-} = require('./proxy-install');
-
-const {
-  createRemoteSession,
-  pollRemoteSession,
-  getRemoteTokens,
-  waitForRemoteAuth,
-  isServerEnvironment,
-  canOpenBrowser,
-  REMOTE_OAUTH_URL
-} = require('./proxy-remote');
-
-/**
- * Check if CLIProxyAPI is running
- */
-const isRunning = async () => {
-  return new Promise((resolve) => {
-    const req = http.request({
-      hostname: '127.0.0.1',
-      port: PROXY_PORT,
-      path: '/v1/models',
-      method: 'GET',
-      headers: {
-        'Authorization': `Bearer ${API_KEY}`
-      },
-      timeout: 2000
-    }, (res) => {
-      resolve(res.statusCode === 200);
-    });
-    
-    req.on('error', () => resolve(false));
-    req.on('timeout', () => {
-      req.destroy();
-      resolve(false);
-    });
-    req.end();
-  });
-};
-
-/**
- * Start CLIProxyAPI in background
- */
-const start = async () => {
-  if (await isRunning()) {
-    return true;
-  }
-  
-  if (!isInstalled()) {
-    throw new Error('CLIProxyAPI not installed');
-  }
-  
-  return new Promise((resolve, reject) => {
-    const proc = spawn(PROXY_BIN, ['--config', PROXY_CONFIG], {
-      detached: true,
-      stdio: 'ignore',
-      cwd: PROXY_DIR
-    });
-    
-    proc.unref();
-    
-    let attempts = 0;
-    const checkInterval = setInterval(async () => {
-      attempts++;
-      if (await isRunning()) {
-        clearInterval(checkInterval);
-        resolve(true);
-      } else if (attempts > 30) {
-        clearInterval(checkInterval);
-        reject(new Error('Failed to start CLIProxyAPI'));
-      }
-    }, 500);
-  });
-};
-
-/**
- * Stop CLIProxyAPI
- */
-const stop = async () => {
-  return new Promise((resolve) => {
-    if (process.platform === 'win32') {
-      exec('taskkill /F /IM cli-proxy-api.exe', () => resolve());
-    } else {
-      exec('pkill -f cli-proxy-api', () => resolve());
-    }
-  });
-};
-
-/**
- * Ensure CLIProxyAPI is installed and running
- * @param {Function} onProgress - Progress callback
- */
-const ensureRunning = async (onProgress = () => {}) => {
-  const configValid = isConfigValid();
-  
-  if (await isRunning()) {
-    if (!configValid) {
-      onProgress('Updating proxy configuration...');
-      rewriteConfig();
-      await stop();
-      await new Promise(resolve => setTimeout(resolve, 1000));
-      onProgress('Restarting proxy with updated config...');
-      await start();
-    }
-    return true;
-  }
-  
-  if (!isInstalled()) {
-    onProgress('Installing AI proxy (one-time setup)...');
-    await install(onProgress);
-  } else if (!configValid) {
-    onProgress('Fixing proxy configuration...');
-    rewriteConfig();
-  }
-  
-  onProgress('Starting AI proxy...');
-  await start();
-  
-  return true;
-};
-
-/**
- * Make request to local proxy (API endpoints)
- */
-const proxyRequest = (method, endpoint, body = null) => {
-  return new Promise((resolve, reject) => {
-    const options = {
-      hostname: '127.0.0.1',
-      port: PROXY_PORT,
-      path: endpoint,
-      method,
-      headers: {
-        'Authorization': `Bearer ${API_KEY}`,
-        'Content-Type': 'application/json'
-      },
-      timeout: 30000
-    };
-    
-    const req = http.request(options, (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(JSON.stringify(body));
-    }
-    req.end();
-  });
-};
-
-/**
- * Make request to local proxy (Management API endpoints)
- */
-const managementRequest = (method, endpoint, body = null) => {
-  return new Promise((resolve, reject) => {
-    const options = {
-      hostname: '127.0.0.1',
-      port: PROXY_PORT,
-      path: endpoint,
-      method,
-      headers: {
-        'Authorization': `Bearer ${MANAGEMENT_KEY}`,
-        'Content-Type': 'application/json'
-      },
-      timeout: 30000
-    };
-    
-    const req = http.request(options, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        try {
-          const json = JSON.parse(data);
-          if (res.statusCode >= 400) {
-            reject(new Error(json.error || `HTTP ${res.statusCode}`));
-          } else {
-            resolve(json);
-          }
-        } catch (e) {
-          if (res.statusCode >= 400) {
-            reject(new Error(`HTTP ${res.statusCode}: ${data}`));
-          } else {
-            resolve(data);
-          }
-        }
-      });
-    });
-    
-    req.on('error', reject);
-    req.on('timeout', () => {
-      req.destroy();
-      reject(new Error('Request timeout'));
-    });
-    
-    if (body) {
-      req.write(JSON.stringify(body));
-    }
-    req.end();
-  });
-};
-
-/**
- * Get OAuth authorization URL for a provider
- * @param {string} provider - Provider ID (anthropic, openai, gemini, qwen, iflow)
- * @returns {Promise<{url: string, state: string}>}
- */
-const getAuthUrl = async (provider) => {
-  await ensureRunning();
-  
-  const endpoints = {
-    anthropic: '/v0/management/anthropic-auth-url?is_webui=true',
-    openai: '/v0/management/codex-auth-url?is_webui=true',
-    gemini: '/v0/management/gemini-cli-auth-url?is_webui=true',
-    qwen: '/v0/management/qwen-auth-url?is_webui=true',
-    iflow: '/v0/management/iflow-auth-url?is_webui=true'
-  };
-  
-  const endpoint = endpoints[provider];
-  if (!endpoint) {
-    throw new Error(`Unknown provider: ${provider}`);
-  }
-  
-  const response = await managementRequest('GET', endpoint);
-  
-  if (response.status !== 'ok') {
-    throw new Error(response.error || 'Failed to get auth URL');
-  }
-  
-  return {
-    url: response.url,
-    state: response.state
-  };
-};
-
-/**
- * Submit OAuth callback
- * @param {string} callbackUrl - Full callback URL
- * @param {string} provider - Provider ID
- * @returns {Promise<boolean>}
- */
-const submitCallback = async (callbackUrl, provider = 'anthropic') => {
-  let url;
-  try {
-    url = new URL(callbackUrl);
-  } catch (e) {
-    throw new Error('Invalid callback URL format');
-  }
-  
-  const code = url.searchParams.get('code');
-  const state = url.searchParams.get('state');
-  
-  if (!code || !state) {
-    throw new Error('Missing code or state in callback URL');
-  }
-  
-  const providerConfig = {
-    anthropic: { port: 54545, path: '/callback' },
-    openai: { port: 1455, path: '/auth/callback' },
-    gemini: { port: 8085, path: '/oauth2callback' },
-    qwen: { port: 8087, path: '/oauth2callback' },
-    iflow: { port: 8088, path: '/callback' }
-  };
-  
-  const config = providerConfig[provider] || providerConfig.anthropic;
-  
-  return new Promise((resolve, reject) => {
-    const callbackPath = `${config.path}?${url.searchParams.toString()}`;
-    
-    const req = http.request({
-      hostname: '127.0.0.1',
-      port: config.port,
-      path: callbackPath,
-      method: 'GET',
-      timeout: 30000
-    }, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        if (res.statusCode === 200 || res.statusCode === 302 || res.statusCode === 301) {
-          resolve(true);
-        } else {
-          reject(new Error(`Callback failed with status ${res.statusCode}`));
-        }
-      });
-    });
-    
-    req.on('error', (e) => {
-      reject(new Error(`Failed to submit callback: ${e.message}`));
-    });
-    
-    req.on('timeout', () => {
-      req.destroy();
-      reject(new Error('Callback request timeout'));
-    });
-    
-    req.end();
-  });
-};
-
-/**
- * Poll OAuth authentication status
- * @param {string} state - OAuth state
- * @returns {Promise<{status: string, error?: string}>}
- */
-const pollAuthStatus = async (state) => {
-  const response = await managementRequest('GET', `/v0/management/get-auth-status?state=${state}`);
-  return response;
-};
-
-/**
- * Wait for OAuth authentication to complete
- * @param {string} state - OAuth state
- * @param {number} timeoutMs - Timeout in milliseconds
- * @param {Function} onStatus - Status callback
- * @returns {Promise<boolean>}
- */
-const waitForAuth = async (state, timeoutMs = 300000, onStatus = () => {}) => {
-  const startTime = Date.now();
-  
-  while (Date.now() - startTime < timeoutMs) {
-    const status = await pollAuthStatus(state);
-    
-    if (status.status === 'ok') {
-      return true;
-    } 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');
-};
-
-/**
- * Get available models from the proxy
- * @param {string} [provider] - Optional provider to filter by
- * @returns {Promise<Array<string>>}
- */
-const getModels = async (provider = null) => {
-  await ensureRunning();
-  
-  const response = await proxyRequest('GET', '/v1/models');
-  
-  if (response.data && Array.isArray(response.data)) {
-    let models = response.data;
-    
-    if (provider) {
-      const ownerMap = {
-        anthropic: 'anthropic',
-        openai: 'openai',
-        gemini: 'google',
-        qwen: 'qwen',
-        iflow: 'iflow'
-      };
-      const owner = ownerMap[provider] || provider;
-      models = models.filter(m => m.owned_by && m.owned_by.toLowerCase() === owner.toLowerCase());
-    }
-    
-    return models.map(m => m.id || m).filter(Boolean);
-  }
-  
-  return [];
-};
-
-/**
- * Get list of authenticated accounts
- * @returns {Promise<Array>}
- */
-const getAuthFiles = async () => {
-  await ensureRunning();
-  
-  try {
-    const response = await managementRequest('GET', '/v0/management/auth-files');
-    return response.files || [];
-  } catch (e) {
-    return [];
-  }
-};
-
-/**
- * Make chat completion request through proxy
- * @param {string} model - Model ID
- * @param {Array} messages - Chat messages
- * @param {Object} options - Additional options
- * @returns {Promise<Object>}
- */
-const chatCompletion = async (model, messages, options = {}) => {
-  await ensureRunning();
-  
-  const body = {
-    model,
-    messages,
-    ...options
-  };
-  
-  return proxyRequest('POST', '/v1/chat/completions', body);
-};
-
-/**
- * Check if user has any connected accounts
- */
-const hasConnectedAccounts = async () => {
-  try {
-    const files = await getAuthFiles();
-    return files.length > 0;
-  } catch (e) {
-    return false;
-  }
-};
-
-/**
- * Get provider name from auth file
- */
-const getProviderFromAuthFile = (filename) => {
-  if (filename.includes('claude') || filename.includes('anthropic')) return 'anthropic';
-  if (filename.includes('openai') || filename.includes('codex')) return 'openai';
-  if (filename.includes('gemini') || filename.includes('google')) return 'gemini';
-  if (filename.includes('qwen')) return 'qwen';
-  if (filename.includes('iflow')) return 'iflow';
-  return 'unknown';
-};
-
-module.exports = {
-  // Local OAuth (CLIProxyAPI)
-  isInstalled,
-  isRunning,
-  install,
-  start,
-  stop,
-  ensureRunning,
-  getAuthUrl,
-  pollAuthStatus,
-  waitForAuth,
-  submitCallback,
-  getModels,
-  getAuthFiles,
-  chatCompletion,
-  hasConnectedAccounts,
-  getProviderFromAuthFile,
-  PROXY_PORT,
-  PROXY_DIR,
-  API_KEY,
-  
-  // Remote OAuth (cli.hedgequantx.com)
-  createRemoteSession,
-  pollRemoteSession,
-  getRemoteTokens,
-  waitForRemoteAuth,
-  isServerEnvironment,
-  canOpenBrowser,
-  REMOTE_OAUTH_URL
-};

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

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