hedgequantx 2.6.93 → 2.6.95

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.6.93",
+  "version": "2.6.95",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {

package/src/menus/ai-agent.js

@@ -15,6 +15,7 @@ const oauthOpenai = require('../services/ai/oauth-openai');
 const oauthGemini = require('../services/ai/oauth-gemini');
 const oauthQwen = require('../services/ai/oauth-qwen');
 const oauthIflow = require('../services/ai/oauth-iflow');
+const proxyManager = require('../services/ai/proxy-manager');
 
 /**
  * Main AI Agent menu
@@ -781,6 +782,7 @@ const getOAuthConfig = (providerId) => {
 
 /**
  * Setup OAuth connection for any provider with OAuth support
+ * Uses CLIProxyAPI for automatic token management
  */
 const setupOAuthConnection = async (provider) => {
   const config = getOAuthConfig(provider.id);
@@ -790,16 +792,188 @@ const setupOAuthConnection = async (provider) => {
     return await selectProviderOption(provider);
   }
   
-  // Use device flow for Qwen
-  if (config.isDeviceFlow) {
-    return await setupDeviceFlowOAuth(provider, config);
+  // Use the new proxy-based OAuth flow (automatic, no code copying needed)
+  // This works for all providers: Claude, ChatGPT, Gemini, Qwen, iFlow
+  return await setupProxyOAuth(provider, config);
+};
+
+/**
+ * Setup OAuth via CLIProxyAPI (automatic local proxy)
+ * This is the simplified flow for users with subscription plans
+ */
+const setupProxyOAuth = async (provider, config) => {
+  const boxWidth = getLogoWidth();
+  const W = boxWidth - 2;
+  
+  const makeLine = (content) => {
+    const plainLen = content.replace(/\x1b\[[0-9;]*m/g, '').length;
+    const padding = W - plainLen;
+    return chalk.cyan('║') + ' ' + content + ' '.repeat(Math.max(0, padding - 1)) + chalk.cyan('║');
+  };
+  
+  console.clear();
+  displayBanner();
+  drawBoxHeaderContinue(`CONNECT ${config.name}`, boxWidth);
+  
+  console.log(makeLine(chalk.yellow('AUTOMATIC SETUP')));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.white('PREPARING CONNECTION...')));
+  
+  drawBoxFooter(boxWidth);
+  
+  // Ensure proxy is running (will install if needed)
+  const spinner = ora({ text: 'Setting up AI connection...', color: 'cyan' }).start();
+  
+  try {
+    await proxyManager.ensureRunning((msg) => {
+      spinner.text = msg;
+    });
+  } catch (error) {
+    spinner.fail(`Setup failed: ${error.message}`);
+    await prompts.waitForEnter();
+    return await selectProviderOption(provider);
+  }
+  
+  // Get OAuth URL from proxy
+  spinner.text = 'Generating authorization link...';
+  
+  let authData;
+  try {
+    authData = await proxyManager.getAuthUrl(provider.id);
+  } catch (error) {
+    spinner.fail(`Failed to get auth URL: ${error.message}`);
+    await prompts.waitForEnter();
+    return await selectProviderOption(provider);
+  }
+  
+  spinner.stop();
+  
+  // Show URL to user
+  console.clear();
+  displayBanner();
+  drawBoxHeaderContinue(`CONNECT ${config.name}`, boxWidth);
+  
+  console.log(makeLine(chalk.yellow('LOGIN TO YOUR ACCOUNT')));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.white('1. OPEN THE LINK BELOW IN YOUR BROWSER')));
+  console.log(makeLine(chalk.white(`2. LOGIN WITH YOUR ${config.accountName.toUpperCase()} ACCOUNT`)));
+  console.log(makeLine(chalk.white('3. AUTHORIZE THE APPLICATION')));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.green('THE CONNECTION WILL BE AUTOMATIC!')));
+  console.log(makeLine(chalk.white('NO CODE TO COPY - JUST LOGIN AND AUTHORIZE')));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.white('PRESS ENTER AFTER YOU AUTHORIZED...')));
+  
+  drawBoxFooter(boxWidth);
+  
+  // Display URL outside the box for easy copy
+  console.log();
+  console.log(chalk.yellow('  OPEN THIS URL IN YOUR BROWSER:'));
+  console.log();
+  console.log(chalk.cyan(`  ${authData.url}`));
+  console.log();
+  
+  // Try to open browser automatically
+  const browserOpened = await openBrowser(authData.url);
+  if (browserOpened) {
+    console.log(chalk.green('  Browser opened automatically!'));
+    console.log();
+  }
+  
+  // Wait for user to press enter
+  await prompts.waitForEnter();
+  
+  // Check if auth was successful
+  const authSpinner = ora({ text: 'Checking authorization...', color: 'cyan' }).start();
+  
+  try {
+    // Poll for auth status (with timeout)
+    const startTime = Date.now();
+    const timeout = 60000; // 1 minute
+    
+    while (Date.now() - startTime < timeout) {
+      const status = await proxyManager.pollAuthStatus(authData.state);
+      
+      if (status.status === 'ok') {
+        authSpinner.succeed('Authorization successful!');
+        break;
+      } else if (status.status === 'error') {
+        authSpinner.fail(`Authorization failed: ${status.error}`);
+        await prompts.waitForEnter();
+        return await selectProviderOption(provider);
+      }
+      
+      // Still waiting
+      await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+  } catch (error) {
+    // If polling fails, try to get models anyway (user might have authorized)
+    authSpinner.text = 'Verifying connection...';
+  }
+  
+  // Fetch available models from proxy
+  authSpinner.text = 'Fetching available models...';
+  
+  let models = [];
+  try {
+    models = await proxyManager.getModels();
+  } catch (e) {
+    // Try again
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    models = await proxyManager.getModels();
+  }
+  
+  if (!models || models.length === 0) {
+    authSpinner.fail('No models available - authorization may have failed');
+    console.log(chalk.red('\n  Please try again and make sure to complete the login.'));
+    await prompts.waitForEnter();
+    return await selectProviderOption(provider);
+  }
+  
+  // Filter models for this provider
+  const providerModels = models.filter(m => {
+    const modelLower = m.toLowerCase();
+    if (provider.id === 'anthropic') return modelLower.includes('claude');
+    if (provider.id === 'openai') return modelLower.includes('gpt') || modelLower.includes('o1') || modelLower.includes('o3');
+    if (provider.id === 'gemini') return modelLower.includes('gemini');
+    if (provider.id === 'qwen') return modelLower.includes('qwen');
+    if (provider.id === 'iflow') return true; // iFlow has various models
+    return true;
+  });
+  
+  const finalModels = providerModels.length > 0 ? providerModels : models;
+  
+  authSpinner.succeed(`Found ${finalModels.length} models`);
+  
+  // Let user select model
+  const selectedModel = await selectModelFromList(finalModels, config.name);
+  if (!selectedModel) {
+    return await selectProviderOption(provider);
+  }
+  
+  // Save agent configuration (using proxy)
+  const credentials = {
+    useProxy: true,
+    proxyPort: proxyManager.PROXY_PORT
+  };
+  
+  try {
+    await aiService.addAgent(provider.id, config.optionId, credentials, selectedModel, config.agentName);
+    
+    console.log(chalk.green(`\n  CONNECTED TO ${config.name}`));
+    console.log(chalk.white(`  MODEL: ${selectedModel}`));
+    console.log(chalk.white('  UNLIMITED USAGE WITH YOUR SUBSCRIPTION'));
+  } catch (error) {
+    console.log(chalk.red(`\n  FAILED TO SAVE: ${error.message}`));
   }
   
-  return await setupBrowserOAuth(provider, config);
+  await prompts.waitForEnter();
+  return await aiAgentMenu();
 };
 
 /**
  * Setup OAuth with browser redirect flow (Claude, OpenAI, Gemini, iFlow)
+ * Legacy method - kept for API key users
  */
 const setupBrowserOAuth = async (provider, config) => {
   const boxWidth = getLogoWidth();

package/src/services/ai/client.js

@@ -3,6 +3,10 @@
  * 
  * STRICT RULE: No mock responses. Real API calls only.
  * If API fails → return null, not fake data.
+ * 
+ * Supports two modes:
+ * 1. Direct API calls (with API keys)
+ * 2. Proxy mode (via CLIProxyAPI for subscription accounts)
  */
 
 const https = require('https');
@@ -222,6 +226,45 @@ const callGemini = async (agent, prompt, systemPrompt) => {
   }
 };
 
+/**
+ * Call AI via local CLIProxyAPI proxy
+ * Used for subscription accounts (ChatGPT Plus, Claude Pro, etc.)
+ * @param {Object} agent - Agent configuration
+ * @param {string} prompt - User prompt
+ * @param {string} systemPrompt - System prompt
+ * @returns {Promise<string|null>} Response text or null on error
+ */
+const callViaProxy = async (agent, prompt, systemPrompt) => {
+  const proxyPort = agent.credentials?.proxyPort || 8317;
+  const model = agent.model;
+  
+  if (!model) return null;
+  
+  const url = `http://127.0.0.1:${proxyPort}/v1/chat/completions`;
+  
+  const headers = {
+    'Content-Type': 'application/json',
+    'Authorization': 'Bearer hqx-local-key'
+  };
+  
+  const body = {
+    model,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: prompt }
+    ],
+    temperature: 0.3,
+    max_tokens: 500
+  };
+  
+  try {
+    const response = await makeRequest(url, { headers, body, timeout: 30000 });
+    return response.choices?.[0]?.message?.content || null;
+  } catch (error) {
+    return null;
+  }
+};
+
 /**
  * Call AI provider based on agent configuration
  * @param {Object} agent - Agent with providerId and credentials
@@ -232,6 +275,11 @@ const callGemini = async (agent, prompt, systemPrompt) => {
 const callAI = async (agent, prompt, systemPrompt = '') => {
   if (!agent || !agent.providerId) return null;
   
+  // Check if using proxy mode (subscription accounts)
+  if (agent.credentials?.useProxy) {
+    return callViaProxy(agent, prompt, systemPrompt);
+  }
+  
   switch (agent.providerId) {
     case 'anthropic':
       return callAnthropic(agent, prompt, systemPrompt);
@@ -592,9 +640,16 @@ const fetchOpenAIModels = async (endpoint, apiKey) => {
 
 /**
  * Fetch available models for OAuth-authenticated providers
+ * Uses multiple API endpoints to discover available models
+ * 
  * @param {string} providerId - Provider ID (anthropic, openai, gemini, etc.)
  * @param {string} accessToken - OAuth access token
- * @returns {Promise<Array|null>} Array of model IDs or null on error
+ * @returns {Promise<Array|null>} Array of model IDs from API, null if unavailable
+ * 
+ * Data sources:
+ * - OpenAI: https://api.openai.com/v1/models (GET)
+ * - Anthropic: https://api.anthropic.com/v1/models (GET)
+ * - Gemini: https://generativelanguage.googleapis.com/v1/models (GET)
  */
 const fetchModelsWithOAuth = async (providerId, accessToken) => {
   if (!accessToken) return null;
@@ -604,17 +659,48 @@ const fetchModelsWithOAuth = async (providerId, accessToken) => {
       case 'anthropic':
         return await fetchAnthropicModelsOAuth(accessToken);
       
-      case 'openai':
-        // OpenAI OAuth uses the same endpoint as API key
-        return await fetchOpenAIModels('https://api.openai.com/v1', accessToken);
+      case 'openai': {
+        // Try OpenAI /v1/models endpoint with OAuth token
+        const openaiModels = await fetchOpenAIModels('https://api.openai.com/v1', accessToken);
+        if (openaiModels && openaiModels.length > 0) {
+          return openaiModels;
+        }
+        
+        // Try alternative: ChatGPT backend API (for Plus/Pro plans)
+        try {
+          const chatgptUrl = 'https://chatgpt.com/backend-api/models';
+          const chatgptHeaders = {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json'
+          };
+          const chatgptResponse = await makeRequest(chatgptUrl, { 
+            method: 'GET', 
+            headers: chatgptHeaders, 
+            timeout: 10000 
+          });
+          if (chatgptResponse.models && Array.isArray(chatgptResponse.models)) {
+            return chatgptResponse.models
+              .map(m => m.slug || m.id || m.name)
+              .filter(Boolean);
+          }
+        } catch (e) {
+          // ChatGPT backend not available
+        }
+        
+        return null;
+      }
       
-      case 'gemini':
-        // Gemini OAuth - try to fetch from API
+      case 'gemini': {
+        // Gemini OAuth - fetch from Generative Language API
         const geminiUrl = 'https://generativelanguage.googleapis.com/v1/models';
         const geminiHeaders = {
           'Authorization': `Bearer ${accessToken}`
         };
-        const geminiResponse = await makeRequest(geminiUrl, { method: 'GET', headers: geminiHeaders, timeout: 10000 });
+        const geminiResponse = await makeRequest(geminiUrl, { 
+          method: 'GET', 
+          headers: geminiHeaders, 
+          timeout: 10000 
+        });
         if (geminiResponse.models && Array.isArray(geminiResponse.models)) {
           return geminiResponse.models
             .filter(m => m.supportedGenerationMethods?.includes('generateContent'))
@@ -622,6 +708,55 @@ const fetchModelsWithOAuth = async (providerId, accessToken) => {
             .filter(Boolean);
         }
         return null;
+      }
+      
+      case 'qwen': {
+        // Qwen - try to fetch models from Alibaba Cloud API
+        try {
+          const qwenUrl = 'https://dashscope.aliyuncs.com/api/v1/models';
+          const qwenHeaders = {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json'
+          };
+          const qwenResponse = await makeRequest(qwenUrl, { 
+            method: 'GET', 
+            headers: qwenHeaders, 
+            timeout: 10000 
+          });
+          if (qwenResponse.data && Array.isArray(qwenResponse.data)) {
+            return qwenResponse.data
+              .map(m => m.id || m.model_id)
+              .filter(Boolean);
+          }
+        } catch (e) {
+          // Qwen API may not support model listing
+        }
+        return null;
+      }
+      
+      case 'iflow': {
+        // iFlow - fetch models from iFlow API
+        try {
+          const iflowUrl = 'https://apis.iflow.cn/v1/models';
+          const iflowHeaders = {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json'
+          };
+          const iflowResponse = await makeRequest(iflowUrl, { 
+            method: 'GET', 
+            headers: iflowHeaders, 
+            timeout: 10000 
+          });
+          if (iflowResponse.data && Array.isArray(iflowResponse.data)) {
+            return iflowResponse.data
+              .map(m => m.id)
+              .filter(Boolean);
+          }
+        } catch (e) {
+          // iFlow API may not support model listing
+        }
+        return null;
+      }
       
       default:
         return null;
@@ -631,8 +766,31 @@ const fetchModelsWithOAuth = async (providerId, accessToken) => {
   }
 };
 
+/**
+ * Fetch models via local CLIProxyAPI proxy
+ * @returns {Promise<Array|null>} Array of model IDs or null
+ */
+const fetchModelsViaProxy = async (proxyPort = 8317) => {
+  const url = `http://127.0.0.1:${proxyPort}/v1/models`;
+  
+  const headers = {
+    'Authorization': 'Bearer hqx-local-key'
+  };
+  
+  try {
+    const response = await makeRequest(url, { method: 'GET', headers, timeout: 10000 });
+    if (response.data && Array.isArray(response.data)) {
+      return response.data.map(m => m.id || m).filter(Boolean);
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
 module.exports = {
   callAI,
+  callViaProxy,
   analyzeTrading,
   analyzePerformance,
   getMarketAdvice,
@@ -644,5 +802,6 @@ module.exports = {
   fetchGeminiModels,
   fetchOpenAIModels,
   fetchModelsWithOAuth,
+  fetchModelsViaProxy,
   getValidOAuthToken
 };

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

@@ -0,0 +1,493 @@
+/**
+ * CLIProxyAPI Manager
+ * 
+ * Automatically downloads, installs, and manages CLIProxyAPI
+ * so users can connect their AI subscription accounts (ChatGPT Plus, Claude Pro, etc.)
+ * without needing to understand technical details.
+ * 
+ * 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 https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn, 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';
+
+// GitHub release URLs
+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);
+};
+
+/**
+ * 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();
+  });
+};
+
+/**
+ * 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) {
+          // Follow redirect
+          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();
+    });
+  });
+};
+
+/**
+ * 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
+  const config = `port: ${PROXY_PORT}
+auth-dir: "${PROXY_AUTH_DIR}"
+api-keys:
+  - "${API_KEY}"
+request-retry: 3
+quota-exceeded:
+  switch-project: true
+  switch-preview-model: true
+`;
+  
+  fs.writeFileSync(PROXY_CONFIG, config);
+  
+  // Cleanup archive
+  fs.unlinkSync(archivePath);
+  
+  onProgress('Installation complete');
+  
+  return true;
+};
+
+/**
+ * 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();
+    
+    // Wait for it to start
+    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 = () => {}) => {
+  if (await isRunning()) {
+    return true;
+  }
+  
+  if (!isInstalled()) {
+    onProgress('Installing AI proxy (one-time setup)...');
+    await install(onProgress);
+  }
+  
+  onProgress('Starting AI proxy...');
+  await start();
+  
+  return true;
+};
+
+/**
+ * Make request to local proxy
+ */
+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();
+  });
+};
+
+/**
+ * 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',
+    openai: '/v0/management/codex-auth-url',
+    gemini: '/v0/management/gemini-cli-auth-url',
+    qwen: '/v0/management/qwen-auth-url',
+    iflow: '/v0/management/iflow-auth-url'
+  };
+  
+  const endpoint = endpoints[provider];
+  if (!endpoint) {
+    throw new Error(`Unknown provider: ${provider}`);
+  }
+  
+  const response = await proxyRequest('GET', endpoint);
+  
+  if (response.status !== 'ok') {
+    throw new Error(response.error || 'Failed to get auth URL');
+  }
+  
+  return {
+    url: response.url,
+    state: response.state
+  };
+};
+
+/**
+ * Poll for OAuth authentication status
+ * @param {string} state - OAuth state from getAuthUrl
+ * @returns {Promise<{status: string, error?: string}>}
+ */
+const pollAuthStatus = async (state) => {
+  const response = await proxyRequest('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
+ * @returns {Promise<Array<string>>}
+ */
+const getModels = async () => {
+  await ensureRunning();
+  
+  const response = await proxyRequest('GET', '/v1/models');
+  
+  if (response.data && Array.isArray(response.data)) {
+    return response.data.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 proxyRequest('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 = {
+  isInstalled,
+  isRunning,
+  install,
+  start,
+  stop,
+  ensureRunning,
+  getAuthUrl,
+  pollAuthStatus,
+  waitForAuth,
+  getModels,
+  getAuthFiles,
+  chatCompletion,
+  hasConnectedAccounts,
+  getProviderFromAuthFile,
+  PROXY_PORT,
+  PROXY_DIR,
+  API_KEY
+};