hedgequantx 2.7.22 → 2.7.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.7.22",
+  "version": "2.7.24",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {
@@ -64,6 +64,7 @@
     "inquirer": "^8.2.6",
     "ora": "^5.4.1",
     "protobufjs": "^8.0.0",
+    "tar": "^7.5.2",
     "uuid": "^9.0.1",
     "ws": "^8.18.3"
   },

package/src/pages/ai-agents-ui.js

@@ -60,14 +60,40 @@ const draw2ColTable = (title, titleColor, items, backText, W) => {
  * @param {Array} providers - List of AI providers
  * @param {Object} config - Current config
  * @param {number} boxWidth - Box width
+ * @param {string} cliproxyUrl - Current CLIProxy URL (optional)
  */
-const drawProvidersTable = (providers, config, boxWidth) => {
+const drawProvidersTable = (providers, config, boxWidth, cliproxyUrl = null) => {
   const W = boxWidth - 2;
+  
+  console.log(chalk.cyan('╔' + '═'.repeat(W) + '╗'));
+  console.log(chalk.cyan('║') + chalk.yellow.bold(centerText('AI AGENTS CONFIGURATION', W)) + chalk.cyan('║'));
+  
+  // Show CLIProxy URL if provided
+  if (cliproxyUrl) {
+    console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
+    const proxyText = chalk.gray('CLIProxy: ') + chalk.cyan(cliproxyUrl);
+    console.log(chalk.cyan('║') + centerText(proxyText, W) + chalk.cyan('║'));
+  }
+  
+  console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
+  
   const items = providers.map((p, i) => {
     const status = config.providers[p.id]?.active ? chalk.green(' ●') : '';
     return chalk.cyan(`[${i + 1}]`) + ' ' + chalk[p.color](p.name) + status;
   });
-  draw2ColTable('AI AGENTS CONFIGURATION', chalk.yellow.bold, items, '[B] Back to Menu', W);
+  
+  const rows = Math.ceil(items.length / 2);
+  for (let row = 0; row < rows; row++) {
+    const left = items[row];
+    const right = items[row + rows];
+    draw2ColRow(left || '', right || '', W);
+  }
+  
+  console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
+  console.log(chalk.cyan('║') + chalk.gray(centerText('[S] CLIProxy Status', W)) + chalk.cyan('║'));
+  console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
+  console.log(chalk.cyan('║') + chalk.red(centerText('[B] Back to Menu', W)) + chalk.cyan('║'));
+  console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
 };
 
 /**

package/src/pages/ai-agents.js

@@ -15,7 +15,7 @@ const { getLogoWidth } = require('../ui');
 const { prompts } = require('../utils');
 const { fetchModelsFromApi } = require('./ai-models');
 const { drawProvidersTable, drawModelsTable, drawProviderWindow } = require('./ai-agents-ui');
-const { isCliProxyRunning, fetchModelsFromCliProxy, getOAuthUrl, checkOAuthStatus } = require('../services/cliproxy');
+const cliproxy = require('../services/cliproxy');
 
 // Config file path
 const CONFIG_DIR = path.join(os.homedir(), '.hqx');
@@ -98,31 +98,53 @@ const activateProvider = (config, providerId, data) => {
   Object.assign(config.providers[providerId], data, { active: true, configuredAt: new Date().toISOString() });
 };
 
-/** Handle CLIProxy connection */
+/** Handle CLIProxy connection (with auto-install) */
 const handleCliProxyConnection = async (provider, config, boxWidth) => {
   console.log();
-  const spinner = ora({ text: 'Checking CLIProxy status...', color: 'yellow' }).start();
-  const proxyStatus = await isCliProxyRunning();
   
-  if (!proxyStatus.running) {
-    spinner.fail('CLIProxy is not running');
-    console.log(chalk.yellow('\n  CLIProxy must be running on localhost:8317'));
-    console.log(chalk.gray('  Install: https://help.router-for.me\n'));
-    await prompts.waitForEnter();
-    return false;
+  // Check if CLIProxyAPI is installed
+  if (!cliproxy.isInstalled()) {
+    console.log(chalk.yellow('  CLIProxyAPI not installed. Installing...'));
+    const spinner = ora({ text: 'Downloading CLIProxyAPI...', color: 'yellow' }).start();
+    
+    const installResult = await cliproxy.install((msg, percent) => {
+      spinner.text = `${msg} ${percent}%`;
+    });
+    
+    if (!installResult.success) {
+      spinner.fail(`Installation failed: ${installResult.error}`);
+      await prompts.waitForEnter();
+      return false;
+    }
+    spinner.succeed('CLIProxyAPI installed');
   }
   
-  spinner.succeed('CLIProxy is running');
-  const oauthResult = await getOAuthUrl(provider.id);
+  // Check if running, start if not
+  let status = await cliproxy.isRunning();
+  if (!status.running) {
+    const spinner = ora({ text: 'Starting CLIProxyAPI...', color: 'yellow' }).start();
+    const startResult = await cliproxy.start();
+    
+    if (!startResult.success) {
+      spinner.fail(`Failed to start: ${startResult.error}`);
+      await prompts.waitForEnter();
+      return false;
+    }
+    spinner.succeed('CLIProxyAPI started');
+  } else {
+    console.log(chalk.green('  ✓ CLIProxyAPI is running'));
+  }
   
-  if (!oauthResult.success) {
-    // OAuth not supported - try direct model fetch
-    console.log(chalk.gray(`  OAuth not available for ${provider.name}, checking models...`));
-    const modelsResult = await fetchModelsFromCliProxy();
+  // Check if provider supports OAuth
+  const oauthProviders = ['anthropic', 'openai', 'google', 'qwen'];
+  if (!oauthProviders.includes(provider.id)) {
+    // Try to fetch models directly
+    console.log(chalk.gray(`  Checking available models for ${provider.name}...`));
+    const modelsResult = await cliproxy.fetchProviderModels(provider.id);
     
     if (!modelsResult.success || modelsResult.models.length === 0) {
-      console.log(chalk.red(`  No models available via CLIProxy for ${provider.name}`));
-      console.log(chalk.gray(`  Error: ${modelsResult.error || 'Unknown'}`));
+      console.log(chalk.red(`  No models available for ${provider.name}`));
+      console.log(chalk.gray('  This provider may require API key connection.'));
       await prompts.waitForEnter();
       return false;
     }
@@ -144,42 +166,25 @@ const handleCliProxyConnection = async (provider, config, boxWidth) => {
     return true;
   }
   
-  // OAuth flow
-  console.log(chalk.cyan('\n  Open this URL in your browser to authenticate:\n'));
-  console.log(chalk.yellow(`  ${oauthResult.url}\n`));
-  console.log(chalk.gray('  Waiting for authentication... (Press Enter to cancel)'));
-  
-  let authenticated = false;
-  const maxWait = 120000, pollInterval = 3000;
-  let waited = 0;
-  
-  const pollPromise = (async () => {
-    while (waited < maxWait) {
-      await new Promise(r => setTimeout(r, pollInterval));
-      waited += pollInterval;
-      if (oauthResult.state) {
-        const statusResult = await checkOAuthStatus(oauthResult.state);
-        if (statusResult.success && statusResult.status === 'ok') { authenticated = true; return true; }
-        if (statusResult.status === 'error') {
-          console.log(chalk.red(`\n  Authentication error: ${statusResult.error || 'Unknown'}`));
-          return false;
-        }
-      }
-    }
-    return false;
-  })();
+  // OAuth flow - get login URL
+  console.log(chalk.cyan(`\n  Starting OAuth login for ${provider.name}...`));
+  const loginResult = await cliproxy.getLoginUrl(provider.id);
   
-  await Promise.race([pollPromise, prompts.waitForEnter()]);
-  
-  if (!authenticated) {
-    console.log(chalk.yellow('  Authentication cancelled or timed out.'));
+  if (!loginResult.success) {
+    console.log(chalk.red(`  OAuth error: ${loginResult.error}`));
     await prompts.waitForEnter();
     return false;
   }
   
-  console.log(chalk.green('  ✓ Authentication successful!'));
+  console.log(chalk.cyan('\n  Open this URL in your browser to authenticate:\n'));
+  console.log(chalk.yellow(`  ${loginResult.url}\n`));
+  console.log(chalk.gray('  After authenticating, press Enter to continue...'));
+  
+  await prompts.waitForEnter();
+  
+  // Try to fetch models after auth
+  const modelsResult = await cliproxy.fetchProviderModels(provider.id);
   
-  const modelsResult = await fetchModelsFromCliProxy();
   if (modelsResult.success && modelsResult.models.length > 0) {
     const selectedModel = await selectModelFromList(provider, modelsResult.models, boxWidth);
     if (selectedModel) {
@@ -189,17 +194,20 @@ const handleCliProxyConnection = async (provider, config, boxWidth) => {
         modelName: selectedModel.name
       });
       if (saveConfig(config)) {
-        console.log(chalk.green(`\n  ✓ ${provider.name} connected via CLIProxy.`));
+        console.log(chalk.green(`\n  ✓ ${provider.name} connected via Paid Plan.`));
         console.log(chalk.cyan(`    Model: ${selectedModel.name}`));
       }
     }
   } else {
+    // No models but auth might have worked
     activateProvider(config, provider.id, {
       connectionType: 'cliproxy',
       modelId: null,
-      modelName: 'Default'
+      modelName: 'Auto'
     });
-    if (saveConfig(config)) console.log(chalk.green(`\n  ✓ ${provider.name} connected via CLIProxy.`));
+    if (saveConfig(config)) {
+      console.log(chalk.green(`\n  ✓ ${provider.name} connected via Paid Plan.`));
+    }
   }
   
   await prompts.waitForEnter();
@@ -303,6 +311,26 @@ const getActiveProvider = () => {
 /** Count active AI agents */
 const getActiveAgentCount = () => getActiveProvider() ? 1 : 0;
 
+/** Show CLIProxy status */
+const showCliProxyStatus = async () => {
+  console.clear();
+  console.log(chalk.yellow('\n  CLIProxyAPI Status\n'));
+  
+  const installed = cliproxy.isInstalled();
+  console.log(chalk.gray('  Installed: ') + (installed ? chalk.green('Yes') : chalk.red('No')));
+  
+  if (installed) {
+    const status = await cliproxy.isRunning();
+    console.log(chalk.gray('  Running: ') + (status.running ? chalk.green('Yes') : chalk.red('No')));
+    console.log(chalk.gray('  Version: ') + chalk.cyan(cliproxy.CLIPROXY_VERSION));
+    console.log(chalk.gray('  Port: ') + chalk.cyan(cliproxy.DEFAULT_PORT));
+    console.log(chalk.gray('  Install dir: ') + chalk.cyan(cliproxy.INSTALL_DIR));
+  }
+  
+  console.log();
+  await prompts.waitForEnter();
+};
+
 /** Main AI Agents menu */
 const aiAgentsMenu = async () => {
   let config = loadConfig();
@@ -310,13 +338,20 @@ const aiAgentsMenu = async () => {
   
   while (true) {
     console.clear();
-    drawProvidersTable(AI_PROVIDERS, config, boxWidth);
+    const status = await cliproxy.isRunning();
+    const statusText = status.running ? `localhost:${cliproxy.DEFAULT_PORT}` : 'Not running';
+    drawProvidersTable(AI_PROVIDERS, config, boxWidth, statusText);
     
-    const input = await prompts.textInput(chalk.cyan('Select provider: '));
+    const input = await prompts.textInput(chalk.cyan('Select (1-8/S/B): '));
     const choice = (input || '').toLowerCase().trim();
     
     if (choice === 'b' || choice === '') break;
     
+    if (choice === 's') {
+      await showCliProxyStatus();
+      continue;
+    }
+    
     const num = parseInt(choice);
     if (!isNaN(num) && num >= 1 && num <= AI_PROVIDERS.length) {
       config = await handleProviderConfig(AI_PROVIDERS[num - 1], config);

package/src/services/cliproxy/index.js

@@ -0,0 +1,184 @@
+/**
+ * CLIProxy Service
+ * 
+ * Provides OAuth connections to paid AI plans (Claude Pro, ChatGPT Plus, etc.)
+ * via the embedded CLIProxyAPI binary.
+ */
+
+const http = require('http');
+const manager = require('./manager');
+
+// Re-export manager functions
+const {
+  CLIPROXY_VERSION,
+  INSTALL_DIR,
+  AUTH_DIR,
+  DEFAULT_PORT,
+  isInstalled,
+  install,
+  isRunning,
+  start,
+  stop,
+  ensureRunning,
+  getLoginUrl
+} = manager;
+
+/**
+ * Make HTTP request to local CLIProxyAPI
+ * @param {string} path - API path
+ * @param {string} method - HTTP method
+ * @param {Object} body - Request body (optional)
+ * @param {number} timeout - Timeout in ms (default 60000 per RULES.md #15)
+ * @returns {Promise<Object>} { success, data, error }
+ */
+const fetchLocal = (path, method = 'GET', body = null, timeout = 60000) => {
+  return new Promise((resolve) => {
+    const options = {
+      hostname: 'localhost',
+      port: DEFAULT_PORT,
+      path,
+      method,
+      headers: { 'Content-Type': 'application/json' },
+      timeout
+    };
+
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            const parsed = data ? JSON.parse(data) : {};
+            resolve({ success: true, data: parsed, error: null });
+          } else {
+            resolve({ success: false, error: `HTTP ${res.statusCode}`, data: null });
+          }
+        } catch (error) {
+          resolve({ success: false, error: 'Invalid JSON response', data: null });
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      if (error.code === 'ECONNREFUSED') {
+        resolve({ success: false, error: 'CLIProxyAPI not running', data: null });
+      } else {
+        resolve({ success: false, error: error.message, data: null });
+      }
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ success: false, error: 'Request timeout', data: null });
+    });
+
+    if (body) {
+      req.write(JSON.stringify(body));
+    }
+    
+    req.end();
+  });
+};
+
+/**
+ * Fetch available models from CLIProxyAPI
+ * @returns {Promise<Object>} { success, models, error }
+ */
+const fetchModels = async () => {
+  const result = await fetchLocal('/v1/models');
+  
+  if (!result.success) {
+    return { success: false, models: [], error: result.error };
+  }
+  
+  const data = result.data;
+  if (!data || !data.data || !Array.isArray(data.data)) {
+    return { success: false, models: [], error: 'Invalid response format' };
+  }
+  
+  const models = data.data
+    .filter(m => m.id)
+    .map(m => ({ id: m.id, name: m.id }));
+  
+  if (models.length === 0) {
+    return { success: false, models: [], error: 'No models available' };
+  }
+  
+  return { success: true, models, error: null };
+};
+
+/**
+ * Get provider-specific models
+ * @param {string} providerId - Provider ID
+ * @returns {Promise<Object>} { success, models, error }
+ */
+const fetchProviderModels = async (providerId) => {
+  const result = await fetchModels();
+  if (!result.success) return result;
+  
+  // Filter by provider prefix
+  const prefixMap = {
+    anthropic: 'claude',
+    openai: 'gpt',
+    google: 'gemini',
+    qwen: 'qwen'
+  };
+  
+  const prefix = prefixMap[providerId];
+  if (!prefix) return result;
+  
+  const filtered = result.models.filter(m => 
+    m.id.toLowerCase().includes(prefix)
+  );
+  
+  return { 
+    success: true, 
+    models: filtered.length > 0 ? filtered : result.models, 
+    error: null 
+  };
+};
+
+/**
+ * Chat completion request
+ * @param {string} model - Model ID
+ * @param {Array} messages - Chat messages
+ * @param {Object} options - Additional options
+ * @returns {Promise<Object>} { success, response, error }
+ */
+const chatCompletion = async (model, messages, options = {}) => {
+  const body = {
+    model,
+    messages,
+    stream: false,
+    ...options
+  };
+  
+  const result = await fetchLocal('/v1/chat/completions', 'POST', body);
+  
+  if (!result.success) {
+    return { success: false, response: null, error: result.error };
+  }
+  
+  return { success: true, response: result.data, error: null };
+};
+
+module.exports = {
+  // Manager
+  CLIPROXY_VERSION,
+  INSTALL_DIR,
+  AUTH_DIR,
+  DEFAULT_PORT,
+  isInstalled,
+  install,
+  isRunning,
+  start,
+  stop,
+  ensureRunning,
+  getLoginUrl,
+  
+  // API
+  fetchLocal,
+  fetchModels,
+  fetchProviderModels,
+  chatCompletion
+};

package/src/services/cliproxy/manager.js

@@ -0,0 +1,417 @@
+/**
+ * CLIProxyAPI Manager
+ * 
+ * Downloads, installs and manages CLIProxyAPI binary for OAuth connections
+ * to paid AI plans (Claude Pro, ChatGPT Plus, Gemini, etc.)
+ */
+
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const https = require('https');
+const http = require('http');
+const { spawn } = require('child_process');
+const { createGunzip } = require('zlib');
+const tar = require('tar');
+
+// CLIProxyAPI version and download URLs
+const CLIPROXY_VERSION = '6.6.88';
+const GITHUB_RELEASE_BASE = 'https://github.com/router-for-me/CLIProxyAPI/releases/download';
+
+// Installation directory
+const INSTALL_DIR = path.join(os.homedir(), '.hqx', 'cliproxy');
+const BINARY_NAME = process.platform === 'win32' ? 'cli-proxy-api.exe' : 'cli-proxy-api';
+const BINARY_PATH = path.join(INSTALL_DIR, BINARY_NAME);
+const PID_FILE = path.join(INSTALL_DIR, 'cliproxy.pid');
+const AUTH_DIR = path.join(INSTALL_DIR, 'auths');
+
+// Default port
+const DEFAULT_PORT = 8317;
+
+/**
+ * Get download URL for current platform
+ * @returns {Object} { url, filename } or null if unsupported
+ */
+const getDownloadUrl = () => {
+  const platform = process.platform;
+  const arch = process.arch;
+  
+  let osName, archName, ext;
+  
+  if (platform === 'darwin') {
+    osName = 'darwin';
+    ext = 'tar.gz';
+  } else if (platform === 'linux') {
+    osName = 'linux';
+    ext = 'tar.gz';
+  } else if (platform === 'win32') {
+    osName = 'windows';
+    ext = 'zip';
+  } else {
+    return null;
+  }
+  
+  if (arch === 'x64' || arch === 'amd64') {
+    archName = 'amd64';
+  } else if (arch === 'arm64') {
+    archName = 'arm64';
+  } else {
+    return null;
+  }
+  
+  const filename = `CLIProxyAPI_${CLIPROXY_VERSION}_${osName}_${archName}.${ext}`;
+  const url = `${GITHUB_RELEASE_BASE}/v${CLIPROXY_VERSION}/${filename}`;
+  
+  return { url, filename, ext };
+};
+
+/**
+ * Check if CLIProxyAPI is installed
+ * @returns {boolean}
+ */
+const isInstalled = () => {
+  return fs.existsSync(BINARY_PATH);
+};
+
+/**
+ * Download file from URL
+ * @param {string} url - URL to download
+ * @param {string} destPath - Destination path
+ * @param {Function} onProgress - Progress callback (percent)
+ * @returns {Promise<boolean>}
+ */
+const downloadFile = (url, destPath, onProgress = null) => {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(destPath);
+    
+    const request = (url.startsWith('https') ? https : http).get(url, (response) => {
+      // Handle redirects
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        file.close();
+        fs.unlinkSync(destPath);
+        return downloadFile(response.headers.location, destPath, onProgress)
+          .then(resolve)
+          .catch(reject);
+      }
+      
+      if (response.statusCode !== 200) {
+        file.close();
+        fs.unlinkSync(destPath);
+        return reject(new Error(`HTTP ${response.statusCode}`));
+      }
+      
+      const totalSize = parseInt(response.headers['content-length'], 10);
+      let downloadedSize = 0;
+      
+      response.on('data', (chunk) => {
+        downloadedSize += chunk.length;
+        if (onProgress && totalSize) {
+          onProgress(Math.round((downloadedSize / totalSize) * 100));
+        }
+      });
+      
+      response.pipe(file);
+      
+      file.on('finish', () => {
+        file.close();
+        resolve(true);
+      });
+    });
+    
+    request.on('error', (err) => {
+      file.close();
+      if (fs.existsSync(destPath)) fs.unlinkSync(destPath);
+      reject(err);
+    });
+    
+    request.setTimeout(120000, () => {
+      request.destroy();
+      reject(new Error('Download timeout'));
+    });
+  });
+};
+
+/**
+ * Extract tar.gz file
+ * @param {string} archivePath - Path to archive
+ * @param {string} destDir - Destination directory
+ * @returns {Promise<boolean>}
+ */
+const extractTarGz = (archivePath, destDir) => {
+  return new Promise((resolve, reject) => {
+    fs.createReadStream(archivePath)
+      .pipe(createGunzip())
+      .pipe(tar.extract({ cwd: destDir }))
+      .on('finish', () => resolve(true))
+      .on('error', reject);
+  });
+};
+
+/**
+ * Extract zip file (Windows)
+ * @param {string} archivePath - Path to archive
+ * @param {string} destDir - Destination directory
+ * @returns {Promise<boolean>}
+ */
+const extractZip = async (archivePath, destDir) => {
+  const { execSync } = require('child_process');
+  
+  if (process.platform === 'win32') {
+    // Use PowerShell on Windows
+    execSync(`powershell -Command "Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force"`, {
+      stdio: 'ignore'
+    });
+  } else {
+    // Use unzip on Unix
+    execSync(`unzip -o "${archivePath}" -d "${destDir}"`, { stdio: 'ignore' });
+  }
+  
+  return true;
+};
+
+/**
+ * Install CLIProxyAPI
+ * @param {Function} onProgress - Progress callback (message, percent)
+ * @returns {Promise<Object>} { success, error }
+ */
+const install = async (onProgress = null) => {
+  try {
+    const download = getDownloadUrl();
+    if (!download) {
+      return { success: false, error: 'Unsupported platform' };
+    }
+    
+    // Create install directory
+    if (!fs.existsSync(INSTALL_DIR)) {
+      fs.mkdirSync(INSTALL_DIR, { recursive: true });
+    }
+    if (!fs.existsSync(AUTH_DIR)) {
+      fs.mkdirSync(AUTH_DIR, { recursive: true });
+    }
+    
+    const archivePath = path.join(INSTALL_DIR, download.filename);
+    
+    // Download
+    if (onProgress) onProgress('Downloading CLIProxyAPI...', 0);
+    await downloadFile(download.url, archivePath, (percent) => {
+      if (onProgress) onProgress('Downloading CLIProxyAPI...', percent);
+    });
+    
+    // Extract
+    if (onProgress) onProgress('Extracting...', 100);
+    if (download.ext === 'tar.gz') {
+      await extractTarGz(archivePath, INSTALL_DIR);
+    } else {
+      await extractZip(archivePath, INSTALL_DIR);
+    }
+    
+    // Clean up archive
+    if (fs.existsSync(archivePath)) {
+      fs.unlinkSync(archivePath);
+    }
+    
+    // Make executable on Unix
+    if (process.platform !== 'win32' && fs.existsSync(BINARY_PATH)) {
+      fs.chmodSync(BINARY_PATH, '755');
+    }
+    
+    if (!fs.existsSync(BINARY_PATH)) {
+      return { success: false, error: 'Binary not found after extraction' };
+    }
+    
+    return { success: true, error: null };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+};
+
+/**
+ * Check if CLIProxyAPI is running
+ * @returns {Promise<Object>} { running, pid }
+ */
+const isRunning = async () => {
+  // Check PID file
+  if (fs.existsSync(PID_FILE)) {
+    try {
+      const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
+      // Check if process exists
+      process.kill(pid, 0);
+      return { running: true, pid };
+    } catch (e) {
+      // Process doesn't exist, clean up PID file
+      fs.unlinkSync(PID_FILE);
+    }
+  }
+  
+  // Also check by trying to connect
+  return new Promise((resolve) => {
+    const req = http.get(`http://localhost:${DEFAULT_PORT}/v1/models`, (res) => {
+      resolve({ running: res.statusCode === 200, pid: null });
+    });
+    req.on('error', () => resolve({ running: false, pid: null }));
+    req.setTimeout(2000, () => {
+      req.destroy();
+      resolve({ running: false, pid: null });
+    });
+  });
+};
+
+/**
+ * Start CLIProxyAPI
+ * @returns {Promise<Object>} { success, error, pid }
+ */
+const start = async () => {
+  if (!isInstalled()) {
+    return { success: false, error: 'CLIProxyAPI not installed', pid: null };
+  }
+  
+  const status = await isRunning();
+  if (status.running) {
+    return { success: true, error: null, pid: status.pid };
+  }
+  
+  try {
+    const args = [
+      '--port', String(DEFAULT_PORT),
+      '--auth-dir', AUTH_DIR
+    ];
+    
+    const child = spawn(BINARY_PATH, args, {
+      detached: true,
+      stdio: 'ignore',
+      cwd: INSTALL_DIR
+    });
+    
+    child.unref();
+    
+    // Save PID
+    fs.writeFileSync(PID_FILE, String(child.pid));
+    
+    // Wait for startup
+    await new Promise(r => setTimeout(r, 2000));
+    
+    const runStatus = await isRunning();
+    if (runStatus.running) {
+      return { success: true, error: null, pid: child.pid };
+    } else {
+      return { success: false, error: 'Failed to start CLIProxyAPI', pid: null };
+    }
+  } catch (error) {
+    return { success: false, error: error.message, pid: null };
+  }
+};
+
+/**
+ * Stop CLIProxyAPI
+ * @returns {Promise<Object>} { success, error }
+ */
+const stop = async () => {
+  const status = await isRunning();
+  if (!status.running) {
+    return { success: true, error: null };
+  }
+  
+  try {
+    if (status.pid) {
+      process.kill(status.pid, 'SIGTERM');
+    }
+    
+    if (fs.existsSync(PID_FILE)) {
+      fs.unlinkSync(PID_FILE);
+    }
+    
+    return { success: true, error: null };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+};
+
+/**
+ * Ensure CLIProxyAPI is installed and running
+ * @param {Function} onProgress - Progress callback
+ * @returns {Promise<Object>} { success, error }
+ */
+const ensureRunning = async (onProgress = null) => {
+  // Check if installed
+  if (!isInstalled()) {
+    if (onProgress) onProgress('Installing CLIProxyAPI...', 0);
+    const installResult = await install(onProgress);
+    if (!installResult.success) {
+      return installResult;
+    }
+  }
+  
+  // Check if running
+  const status = await isRunning();
+  if (status.running) {
+    return { success: true, error: null };
+  }
+  
+  // Start
+  if (onProgress) onProgress('Starting CLIProxyAPI...', 100);
+  return start();
+};
+
+/**
+ * Get OAuth login URL for a provider
+ * @param {string} provider - Provider ID (anthropic, openai, google, etc.)
+ * @returns {Promise<Object>} { success, url, error }
+ */
+const getLoginUrl = async (provider) => {
+  const providerFlags = {
+    anthropic: '--claude-login',
+    openai: '--codex-login',
+    google: '--gemini-login',
+    qwen: '--qwen-login'
+  };
+  
+  const flag = providerFlags[provider];
+  if (!flag) {
+    return { success: false, url: null, error: 'Provider not supported for OAuth' };
+  }
+  
+  // For headless/VPS, use --no-browser flag
+  return new Promise((resolve) => {
+    const args = [flag, '--no-browser'];
+    const child = spawn(BINARY_PATH, args, {
+      cwd: INSTALL_DIR,
+      env: { ...process.env, AUTH_DIR: AUTH_DIR }
+    });
+    
+    let output = '';
+    
+    child.stdout.on('data', (data) => {
+      output += data.toString();
+    });
+    
+    child.stderr.on('data', (data) => {
+      output += data.toString();
+    });
+    
+    // Look for URL in output
+    setTimeout(() => {
+      const urlMatch = output.match(/https?:\/\/[^\s]+/);
+      if (urlMatch) {
+        resolve({ success: true, url: urlMatch[0], error: null });
+      } else {
+        resolve({ success: false, url: null, error: 'Could not get login URL' });
+      }
+    }, 3000);
+  });
+};
+
+module.exports = {
+  CLIPROXY_VERSION,
+  INSTALL_DIR,
+  BINARY_PATH,
+  AUTH_DIR,
+  DEFAULT_PORT,
+  getDownloadUrl,
+  isInstalled,
+  install,
+  isRunning,
+  start,
+  stop,
+  ensureRunning,
+  getLoginUrl
+};

package/src/services/cliproxy.js

@@ -1,199 +0,0 @@
-/**
- * CLIProxy Service
- * 
- * Connects to CLIProxyAPI (localhost:8317) for AI provider access
- * via paid plans (Claude Pro, ChatGPT Plus, etc.)
- * 
- * Docs: https://help.router-for.me
- */
-
-const http = require('http');
-
-// CLIProxy default endpoint
-const CLIPROXY_BASE = 'http://localhost:8317';
-
-/**
- * Make HTTP request to CLIProxy
- * @param {string} path - API path
- * @param {string} method - HTTP method
- * @param {Object} headers - Request headers
- * @param {number} timeout - Timeout in ms (default 60000 per RULES.md #15)
- * @returns {Promise<Object>} { success, data, error }
- */
-const fetchCliProxy = (path, method = 'GET', headers = {}, timeout = 60000) => {
-  return new Promise((resolve) => {
-    const url = new URL(path, CLIPROXY_BASE);
-    const options = {
-      hostname: url.hostname,
-      port: url.port || 8317,
-      path: url.pathname + url.search,
-      method,
-      headers: {
-        'Content-Type': 'application/json',
-        ...headers
-      },
-      timeout
-    };
-
-    const req = http.request(options, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        try {
-          if (res.statusCode >= 200 && res.statusCode < 300) {
-            resolve({ success: true, data: JSON.parse(data) });
-          } else {
-            resolve({ success: false, error: `HTTP ${res.statusCode}`, data: null });
-          }
-        } catch (error) {
-          resolve({ success: false, error: 'Invalid JSON response', data: null });
-        }
-      });
-    });
-
-    req.on('error', (error) => {
-      if (error.code === 'ECONNREFUSED') {
-        resolve({ success: false, error: 'CLIProxy not running', data: null });
-      } else {
-        resolve({ success: false, error: error.message, data: null });
-      }
-    });
-
-    req.on('timeout', () => {
-      req.destroy();
-      resolve({ success: false, error: 'Request timeout', data: null });
-    });
-
-    req.end();
-  });
-};
-
-/**
- * Check if CLIProxy is running
- * @returns {Promise<Object>} { running, error }
- */
-const isCliProxyRunning = async () => {
-  const result = await fetchCliProxy('/v1/models', 'GET', {}, 5000);
-  return { 
-    running: result.success, 
-    error: result.success ? null : result.error 
-  };
-};
-
-/**
- * Fetch available models from CLIProxy
- * @returns {Promise<Object>} { success, models, error }
- */
-const fetchModelsFromCliProxy = async () => {
-  const result = await fetchCliProxy('/v1/models');
-  
-  if (!result.success) {
-    return { success: false, models: [], error: result.error };
-  }
-  
-  // Parse OpenAI-compatible format: { data: [{ id, ... }] }
-  const data = result.data;
-  if (!data || !data.data || !Array.isArray(data.data)) {
-    return { success: false, models: [], error: 'Invalid response format' };
-  }
-  
-  const models = data.data
-    .filter(m => m.id)
-    .map(m => ({
-      id: m.id,
-      name: m.id
-    }));
-  
-  if (models.length === 0) {
-    return { success: false, models: [], error: 'No models available' };
-  }
-  
-  return { success: true, models, error: null };
-};
-
-/**
- * Get OAuth URL for a provider
- * @param {string} providerId - Provider ID (anthropic, openai, google, etc.)
- * @returns {Promise<Object>} { success, url, state, error }
- */
-const getOAuthUrl = async (providerId) => {
-  // Map HQX provider IDs to CLIProxy endpoints
-  const oauthEndpoints = {
-    anthropic: '/v0/management/anthropic-auth-url',
-    openai: '/v0/management/codex-auth-url',
-    google: '/v0/management/gemini-cli-auth-url',
-    // Others may not have OAuth support in CLIProxy
-  };
-  
-  const endpoint = oauthEndpoints[providerId];
-  if (!endpoint) {
-    return { success: false, url: null, state: null, error: 'OAuth not supported for this provider' };
-  }
-  
-  const result = await fetchCliProxy(endpoint);
-  
-  if (!result.success) {
-    return { success: false, url: null, state: null, error: result.error };
-  }
-  
-  const data = result.data;
-  if (!data || !data.url) {
-    return { success: false, url: null, state: null, error: 'Invalid OAuth response' };
-  }
-  
-  return { 
-    success: true, 
-    url: data.url, 
-    state: data.state || null,
-    error: null 
-  };
-};
-
-/**
- * Check OAuth status
- * @param {string} state - OAuth state from getOAuthUrl
- * @returns {Promise<Object>} { success, status, error }
- */
-const checkOAuthStatus = async (state) => {
-  const result = await fetchCliProxy(`/v0/management/get-auth-status?state=${encodeURIComponent(state)}`);
-  
-  if (!result.success) {
-    return { success: false, status: null, error: result.error };
-  }
-  
-  const data = result.data;
-  // status can be: "wait", "ok", "error"
-  return { 
-    success: true, 
-    status: data.status || 'unknown',
-    error: data.error || null
-  };
-};
-
-/**
- * Get CLIProxy auth files (connected accounts)
- * @returns {Promise<Object>} { success, files, error }
- */
-const getAuthFiles = async () => {
-  const result = await fetchCliProxy('/v0/management/auth-files');
-  
-  if (!result.success) {
-    return { success: false, files: [], error: result.error };
-  }
-  
-  return { 
-    success: true, 
-    files: result.data?.files || [],
-    error: null 
-  };
-};
-
-module.exports = {
-  CLIPROXY_BASE,
-  isCliProxyRunning,
-  fetchModelsFromCliProxy,
-  getOAuthUrl,
-  checkOAuthStatus,
-  getAuthFiles,
-  fetchCliProxy
-};