hedgequantx 2.6.161 → 2.6.162

package/src/services/ai/index.js

@@ -7,6 +7,7 @@ const { getProviders, getProvider } = require('./providers');
 const { storage } = require('../session');
 const AISupervisor = require('./supervisor');
 const StrategySupervisor = require('./strategy-supervisor');
+const { validateConnection } = require('./validation');
 
 // In-memory cache of connections
 let connectionsCache = null;
@@ -348,263 +349,7 @@ const getCredentials = () => {
   return agent?.credentials || null;
 };
 
-/**
- * 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);
-      // OpenAI-compatible providers (use same validation)
-      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 };
-  }
-};
-
-// Validation functions for each provider
-const validateAnthropic = async (credentials) => {
-  try {
-    const token = credentials.apiKey || credentials.sessionKey || credentials.accessToken;
-    if (!token) return { valid: false, error: 'No API key provided' };
-    
-    // Validate by fetching models from API - this proves the token works
-    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 };
-  }
-};
-
-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 };
-  }
-};
-
-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 };
-  }
-};
-
-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 };
-  }
-};
-
-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 };
-  }
-};
-
-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' };
-  }
-};
-
-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 };
-  }
-};
-
-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 };
-  }
-};
-
-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.' };
-  }
-};
-
-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 };
-  }
-};
+// validateConnection imported from ./validation
 
 module.exports = {
   // Provider info

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

@@ -0,0 +1,249 @@
+/**
+ * @fileoverview CLIProxyAPI Installation
+ * 
+ * Downloads, extracts, and configures CLIProxyAPI binary
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { exec } = require('child_process');
+
+// Configuration
+const PROXY_VERSION = 'v6.6.84';
+const PROXY_PORT = 8317;
+const PROXY_DIR = path.join(os.homedir(), '.hqx', 'proxy');
+const PROXY_BIN = path.join(PROXY_DIR, process.platform === 'win32' ? 'cli-proxy-api.exe' : 'cli-proxy-api');
+const PROXY_CONFIG = path.join(PROXY_DIR, 'config.yaml');
+const PROXY_AUTH_DIR = path.join(PROXY_DIR, 'auths');
+const API_KEY = 'hqx-local-key';
+const MANAGEMENT_KEY = 'hqx-mgmt-key';
+
+/**
+ * Get download URL for current platform
+ */
+const getDownloadUrl = () => {
+  const platform = process.platform;
+  const arch = process.arch;
+  
+  let osName, archName, ext;
+  
+  if (platform === 'darwin') {
+    osName = 'darwin';
+    archName = arch === 'arm64' ? 'arm64' : 'amd64';
+    ext = 'tar.gz';
+  } else if (platform === 'win32') {
+    osName = 'windows';
+    archName = arch === 'arm64' ? 'arm64' : 'amd64';
+    ext = 'zip';
+  } else {
+    osName = 'linux';
+    archName = arch === 'arm64' ? 'arm64' : 'amd64';
+    ext = 'tar.gz';
+  }
+  
+  const version = PROXY_VERSION.replace('v', '');
+  return `https://github.com/router-for-me/CLIProxyAPI/releases/download/${PROXY_VERSION}/CLIProxyAPI_${version}_${osName}_${archName}.${ext}`;
+};
+
+/**
+ * Check if CLIProxyAPI binary exists
+ */
+const isInstalled = () => {
+  return fs.existsSync(PROXY_BIN);
+};
+
+/**
+ * Download file from URL
+ */
+const downloadFile = (url, dest) => {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    
+    const request = (url) => {
+      https.get(url, (res) => {
+        if (res.statusCode === 302 || res.statusCode === 301) {
+          request(res.headers.location);
+          return;
+        }
+        
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode}`));
+          return;
+        }
+        
+        res.pipe(file);
+        file.on('finish', () => {
+          file.close();
+          resolve();
+        });
+      }).on('error', (err) => {
+        fs.unlink(dest, () => {});
+        reject(err);
+      });
+    };
+    
+    request(url);
+  });
+};
+
+/**
+ * Extract tar.gz archive
+ */
+const extractTarGz = (archive, dest) => {
+  return new Promise((resolve, reject) => {
+    exec(`tar -xzf "${archive}" -C "${dest}"`, (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+};
+
+/**
+ * Extract zip archive (Windows)
+ */
+const extractZip = (archive, dest) => {
+  return new Promise((resolve, reject) => {
+    exec(`powershell -command "Expand-Archive -Path '${archive}' -DestinationPath '${dest}' -Force"`, (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+};
+
+/**
+ * Generate config file content
+ */
+const getConfigContent = () => {
+  return `port: ${PROXY_PORT}
+auth-dir: "${PROXY_AUTH_DIR}"
+api-keys:
+  - "${API_KEY}"
+remote-management:
+  secret-key: "${MANAGEMENT_KEY}"
+allow-remote-management: false
+request-retry: 3
+quota-exceeded:
+  switch-project: true
+  switch-preview-model: true
+`;
+};
+
+/**
+ * Download and install CLIProxyAPI
+ * @param {Function} onProgress - Progress callback (message)
+ */
+const install = async (onProgress = () => {}) => {
+  // Create directories
+  if (!fs.existsSync(PROXY_DIR)) {
+    fs.mkdirSync(PROXY_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(PROXY_AUTH_DIR)) {
+    fs.mkdirSync(PROXY_AUTH_DIR, { recursive: true });
+  }
+  
+  onProgress('Downloading CLIProxyAPI...');
+  
+  const downloadUrl = getDownloadUrl();
+  const ext = process.platform === 'win32' ? 'zip' : 'tar.gz';
+  const archivePath = path.join(PROXY_DIR, `cliproxyapi.${ext}`);
+  
+  // Download
+  await downloadFile(downloadUrl, archivePath);
+  
+  onProgress('Extracting...');
+  
+  // Extract
+  if (ext === 'zip') {
+    await extractZip(archivePath, PROXY_DIR);
+  } else {
+    await extractTarGz(archivePath, PROXY_DIR);
+  }
+  
+  // Find the binary (it might be in a subdirectory)
+  const possibleBins = [
+    path.join(PROXY_DIR, 'cli-proxy-api'),
+    path.join(PROXY_DIR, 'cli-proxy-api.exe'),
+    path.join(PROXY_DIR, 'CLIProxyAPI', 'cli-proxy-api'),
+    path.join(PROXY_DIR, 'CLIProxyAPI', 'cli-proxy-api.exe')
+  ];
+  
+  for (const bin of possibleBins) {
+    if (fs.existsSync(bin) && bin !== PROXY_BIN) {
+      fs.renameSync(bin, PROXY_BIN);
+      break;
+    }
+  }
+  
+  // Make executable (Unix)
+  if (process.platform !== 'win32') {
+    fs.chmodSync(PROXY_BIN, 0o755);
+  }
+  
+  // Create config file
+  fs.writeFileSync(PROXY_CONFIG, getConfigContent());
+  
+  // Cleanup archive
+  fs.unlinkSync(archivePath);
+  
+  onProgress('Installation complete');
+  
+  return true;
+};
+
+/**
+ * Check if config has correct management key (plain text, not hashed)
+ * @returns {boolean}
+ */
+const isConfigValid = () => {
+  if (!fs.existsSync(PROXY_CONFIG)) return false;
+  
+  try {
+    const config = fs.readFileSync(PROXY_CONFIG, 'utf8');
+    
+    if (!config.includes('remote-management:') || !config.includes('secret-key:')) {
+      return false;
+    }
+    
+    // Check if key is hashed (bcrypt hashes start with $2a$, $2b$, or $2y$)
+    if (config.includes('$2a$') || config.includes('$2b$') || config.includes('$2y$')) {
+      return false;
+    }
+    
+    if (!config.includes(MANAGEMENT_KEY)) {
+      return false;
+    }
+    
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+/**
+ * Rewrite config file with correct settings
+ */
+const rewriteConfig = () => {
+  if (!fs.existsSync(PROXY_DIR)) {
+    fs.mkdirSync(PROXY_DIR, { recursive: true });
+  }
+  
+  fs.writeFileSync(PROXY_CONFIG, getConfigContent());
+};
+
+module.exports = {
+  PROXY_VERSION,
+  PROXY_PORT,
+  PROXY_DIR,
+  PROXY_BIN,
+  PROXY_CONFIG,
+  PROXY_AUTH_DIR,
+  API_KEY,
+  MANAGEMENT_KEY,
+  getDownloadUrl,
+  isInstalled,
+  install,
+  isConfigValid,
+  rewriteConfig,
+};