hedgequantx 2.7.28 → 2.7.30

package/package.json

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

package/src/app.js

@@ -42,7 +42,15 @@ const restoreTerminal = () => {
 };
 
 process.on('exit', restoreTerminal);
-process.on('SIGINT', () => { restoreTerminal(); process.exit(0); });
+process.on('SIGINT', () => { 
+  restoreTerminal();
+  // Draw bottom border before exit
+  const termWidth = process.stdout.columns || 100;
+  const boxWidth = termWidth < 60 ? Math.max(termWidth - 2, 40) : Math.max(getLogoWidth(), 98);
+  console.log(chalk.cyan('\n╚' + '═'.repeat(boxWidth - 2) + '╝'));
+  console.log(chalk.gray('GOODBYE!'));
+  process.exit(0);
+});
 process.on('SIGTERM', () => { restoreTerminal(); process.exit(0); });
 
 process.on('uncaughtException', (err) => {
@@ -162,20 +170,26 @@ const run = async () => {
   try {
     log.info('Starting HQX CLI');
     
-    // First launch - show banner with loading spinner
+    // First launch - show banner with loading
     await banner();
     const boxWidth = getLogoWidth();
     const innerWidth = boxWidth - 2;
+    
+    // Show loading inside the box
     console.log(chalk.cyan('╠' + '═'.repeat(innerWidth) + '╣'));
+    const loadingText = '  LOADING DASHBOARD...';
+    const loadingPad = innerWidth - loadingText.length;
+    process.stdout.write(chalk.cyan('║') + chalk.yellow(loadingText) + ' '.repeat(loadingPad) + chalk.cyan('║'));
     
-    const spinner = ora({ text: ' Loading...', color: 'yellow' }).start();
     const restored = await connections.restoreFromStorage();
 
     if (restored) {
       currentService = connections.getAll()[0].service;
       await refreshStats();
     }
-    spinner.stop();
+    
+    // Clear loading line
+    process.stdout.write('\r' + ' '.repeat(boxWidth + 2) + '\r');
 
     // Main loop
     while (true) {
@@ -234,13 +248,13 @@ const run = async () => {
           }
           
           console.log(chalk.cyan('╠' + '─'.repeat(innerWidth) + '╣'));
-          console.log(chalk.cyan('║') + chalk.red(centerText('[X] Exit', innerWidth)) + chalk.cyan('║'));
+          console.log(chalk.cyan('║') + chalk.red(centerText('[X] EXIT', innerWidth)) + chalk.cyan('║'));
           console.log(chalk.cyan('╚' + '═'.repeat(innerWidth) + '╝'));
           
-          const input = await prompts.textInput(chalk.cyan('Select number (or X):'));
+          const input = await prompts.textInput(chalk.cyan('SELECT (1-' + numbered.length + '/X): '));
           
           if (!input || input.toLowerCase() === 'x') {
-            console.log(chalk.gray('Goodbye!'));
+            console.log(chalk.gray('GOODBYE!'));
             process.exit(0);
           }
           

package/src/pages/ai-agents.js

@@ -11,12 +11,18 @@ const path = require('path');
 const fs = require('fs');
 const ora = require('ora');
 
-const { getLogoWidth } = require('../ui');
+const { getLogoWidth, displayBanner } = require('../ui');
 const { prompts } = require('../utils');
 const { fetchModelsFromApi } = require('./ai-models');
 const { drawProvidersTable, drawModelsTable, drawProviderWindow } = require('./ai-agents-ui');
 const cliproxy = require('../services/cliproxy');
 
+/** Clear screen and show banner */
+const clearWithBanner = () => {
+  console.clear();
+  displayBanner();
+};
+
 // Config file path
 const CONFIG_DIR = path.join(os.homedir(), '.hqx');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'ai-config.json');
@@ -57,10 +63,10 @@ const saveConfig = (config) => {
 /** Select a model from a pre-fetched list */
 const selectModelFromList = async (provider, models, boxWidth) => {
   while (true) {
-    console.clear();
+    clearWithBanner();
     drawModelsTable(provider, models, boxWidth);
     
-    const input = await prompts.textInput(chalk.cyan('Select model: '));
+    const input = await prompts.textInput(chalk.cyan('SELECT MODEL: '));
     const choice = (input || '').toLowerCase().trim();
     
     if (choice === 'b' || choice === '') return null;
@@ -68,7 +74,7 @@ const selectModelFromList = async (provider, models, boxWidth) => {
     const num = parseInt(choice);
     if (!isNaN(num) && num >= 1 && num <= models.length) return models[num - 1];
     
-    console.log(chalk.red('  Invalid option.'));
+    console.log(chalk.red('  INVALID OPTION'));
     await new Promise(r => setTimeout(r, 1000));
   }
 };
@@ -76,16 +82,16 @@ const selectModelFromList = async (provider, models, boxWidth) => {
 /** Select a model for a provider (fetches from API) */
 const selectModel = async (provider, apiKey) => {
   const boxWidth = getLogoWidth();
-  const spinner = ora({ text: 'Fetching models from API...', color: 'yellow' }).start();
+  const spinner = ora({ text: 'FETCHING MODELS FROM API...', color: 'yellow' }).start();
   const result = await fetchModelsFromApi(provider.id, apiKey);
   
   if (!result.success || result.models.length === 0) {
-    spinner.fail(result.error || 'No models available');
+    spinner.fail(result.error || 'NO MODELS AVAILABLE');
     await prompts.waitForEnter();
     return null;
   }
   
-  spinner.succeed(`Found ${result.models.length} models`);
+  spinner.succeed(`FOUND ${result.models.length} MODELS`);
   return selectModelFromList(provider, result.models, boxWidth);
 };
 
@@ -104,47 +110,47 @@ const handleCliProxyConnection = async (provider, config, boxWidth) => {
   
   // 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();
+    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}%`;
+      spinner.text = `${msg.toUpperCase()} ${percent}%`;
     });
     
     if (!installResult.success) {
-      spinner.fail(`Installation failed: ${installResult.error}`);
+      spinner.fail(`INSTALLATION FAILED: ${installResult.error.toUpperCase()}`);
       await prompts.waitForEnter();
       return false;
     }
-    spinner.succeed('CLIProxyAPI installed');
+    spinner.succeed('CLIPROXYAPI INSTALLED');
   }
   
   // Check if running, start if not
   let status = await cliproxy.isRunning();
   if (!status.running) {
-    const spinner = ora({ text: 'Starting CLIProxyAPI...', color: 'yellow' }).start();
+    const spinner = ora({ text: 'STARTING CLIPROXYAPI...', color: 'yellow' }).start();
     const startResult = await cliproxy.start();
     
     if (!startResult.success) {
-      spinner.fail(`Failed to start: ${startResult.error}`);
+      spinner.fail(`FAILED TO START: ${startResult.error.toUpperCase()}`);
       await prompts.waitForEnter();
       return false;
     }
-    spinner.succeed('CLIProxyAPI started');
+    spinner.succeed('CLIPROXYAPI STARTED');
   } else {
-    console.log(chalk.green('  ✓ CLIProxyAPI is running'));
+    console.log(chalk.green('  ✓ CLIPROXYAPI IS RUNNING'));
   }
   
   // 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}...`));
+    console.log(chalk.gray(`  CHECKING AVAILABLE MODELS FOR ${provider.name.toUpperCase()}...`));
     const modelsResult = await cliproxy.fetchProviderModels(provider.id);
     
     if (!modelsResult.success || modelsResult.models.length === 0) {
-      console.log(chalk.red(`  No models available for ${provider.name}`));
-      console.log(chalk.gray('  This provider may require API key connection.'));
+      console.log(chalk.red(`  NO MODELS AVAILABLE FOR ${provider.name.toUpperCase()}`));
+      console.log(chalk.gray('  THIS PROVIDER MAY REQUIRE API KEY CONNECTION.'));
       await prompts.waitForEnter();
       return false;
     }
@@ -159,28 +165,68 @@ const handleCliProxyConnection = async (provider, config, boxWidth) => {
     });
     
     if (saveConfig(config)) {
-      console.log(chalk.green(`\n  ✓ ${provider.name} connected via CLIProxy.`));
-      console.log(chalk.cyan(`    Model: ${selectedModel.name}`));
+      console.log(chalk.green(`\n  ✓ ${provider.name.toUpperCase()} CONNECTED VIA CLIPROXY`));
+      console.log(chalk.cyan(`    MODEL: ${selectedModel.name.toUpperCase()}`));
     }
     await prompts.waitForEnter();
     return true;
   }
   
   // OAuth flow - get login URL
-  console.log(chalk.cyan(`\n  Starting OAuth login for ${provider.name}...`));
+  console.log(chalk.cyan(`\n  STARTING OAUTH LOGIN FOR ${provider.name.toUpperCase()}...`));
   const loginResult = await cliproxy.getLoginUrl(provider.id);
   
   if (!loginResult.success) {
-    console.log(chalk.red(`  OAuth error: ${loginResult.error}`));
+    console.log(chalk.red(`  OAUTH ERROR: ${loginResult.error.toUpperCase()}`));
     await prompts.waitForEnter();
     return false;
   }
   
-  console.log(chalk.cyan('\n  Open this URL in your browser to authenticate:\n'));
+  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();
+  // Different flow for VPS/headless vs local
+  if (loginResult.isHeadless) {
+    console.log(chalk.magenta('  ══════════════════════════════════════════════════════'));
+    console.log(chalk.magenta('  VPS/SSH DETECTED - MANUAL CALLBACK REQUIRED'));
+    console.log(chalk.magenta('  ══════════════════════════════════════════════════════\n'));
+    console.log(chalk.white('  AFTER AUTHORIZING IN BROWSER, YOU WILL SEE A BLANK PAGE.'));
+    console.log(chalk.white('  COPY THE URL FROM BROWSER ADDRESS BAR (STARTS WITH LOCALHOST)'));
+    console.log(chalk.white('  AND PASTE IT BELOW:\n'));
+    
+    const callbackUrl = await prompts.textInput(chalk.cyan('  CALLBACK URL: '));
+    
+    if (!callbackUrl || !callbackUrl.includes('localhost')) {
+      console.log(chalk.red('\n  INVALID CALLBACK URL'));
+      if (loginResult.childProcess) loginResult.childProcess.kill();
+      await prompts.waitForEnter();
+      return false;
+    }
+    
+    // Process the callback
+    const spinner = ora({ text: 'PROCESSING CALLBACK...', color: 'yellow' }).start();
+    const callbackResult = await cliproxy.processCallback(callbackUrl.trim());
+    
+    if (!callbackResult.success) {
+      spinner.fail(`CALLBACK FAILED: ${callbackResult.error.toUpperCase()}`);
+      if (loginResult.childProcess) loginResult.childProcess.kill();
+      await prompts.waitForEnter();
+      return false;
+    }
+    
+    spinner.succeed('AUTHENTICATION SUCCESSFUL!');
+    
+    // Wait for CLIProxyAPI to process the token
+    await new Promise(r => setTimeout(r, 2000));
+  } else {
+    console.log(chalk.gray('  AFTER AUTHENTICATING, PRESS ENTER TO CONTINUE...'));
+    await prompts.waitForEnter();
+  }
+  
+  // Kill the login child process if still running
+  if (loginResult.childProcess) {
+    try { loginResult.childProcess.kill(); } catch (e) { /* ignore */ }
+  }
   
   // Try to fetch models after auth
   const modelsResult = await cliproxy.fetchProviderModels(provider.id);
@@ -194,8 +240,8 @@ const handleCliProxyConnection = async (provider, config, boxWidth) => {
         modelName: selectedModel.name
       });
       if (saveConfig(config)) {
-        console.log(chalk.green(`\n  ✓ ${provider.name} connected via Paid Plan.`));
-        console.log(chalk.cyan(`    Model: ${selectedModel.name}`));
+        console.log(chalk.green(`\n  ✓ ${provider.name.toUpperCase()} CONNECTED VIA PAID PLAN`));
+        console.log(chalk.cyan(`    MODEL: ${selectedModel.name.toUpperCase()}`));
       }
     }
   } else {
@@ -203,10 +249,10 @@ const handleCliProxyConnection = async (provider, config, boxWidth) => {
     activateProvider(config, provider.id, {
       connectionType: 'cliproxy',
       modelId: null,
-      modelName: 'Auto'
+      modelName: 'AUTO'
     });
     if (saveConfig(config)) {
-      console.log(chalk.green(`\n  ✓ ${provider.name} connected via Paid Plan.`));
+      console.log(chalk.green(`\n  ✓ ${provider.name.toUpperCase()} CONNECTED VIA PAID PLAN`));
     }
   }
   
@@ -216,20 +262,20 @@ const handleCliProxyConnection = async (provider, config, boxWidth) => {
 
 /** Handle API Key connection */
 const handleApiKeyConnection = async (provider, config) => {
-  console.clear();
-  console.log(chalk.yellow(`\n  Enter your ${provider.name} API key:`));
-  console.log(chalk.gray('  (Press Enter to cancel)\n'));
+  clearWithBanner();
+  console.log(chalk.yellow(`\n  ENTER YOUR ${provider.name.toUpperCase()} API KEY:`));
+  console.log(chalk.gray('  (PRESS ENTER TO CANCEL)\n'));
   
-  const apiKey = await prompts.textInput(chalk.cyan('  API Key: '), true);
+  const apiKey = await prompts.textInput(chalk.cyan('  API KEY: '), true);
   
   if (!apiKey || apiKey.trim() === '') {
-    console.log(chalk.gray('  Cancelled.'));
+    console.log(chalk.gray('  CANCELLED'));
     await prompts.waitForEnter();
     return false;
   }
   
   if (apiKey.length < 20) {
-    console.log(chalk.red('  Invalid API key format (too short).'));
+    console.log(chalk.red('  INVALID API KEY FORMAT (TOO SHORT)'));
     await prompts.waitForEnter();
     return false;
   }
@@ -245,10 +291,10 @@ const handleApiKeyConnection = async (provider, config) => {
   });
   
   if (saveConfig(config)) {
-    console.log(chalk.green(`\n  ✓ ${provider.name} connected via API Key.`));
-    console.log(chalk.cyan(`    Model: ${selectedModel.name}`));
+    console.log(chalk.green(`\n  ✓ ${provider.name.toUpperCase()} CONNECTED VIA API KEY`));
+    console.log(chalk.cyan(`    MODEL: ${selectedModel.name.toUpperCase()}`));
   } else {
-    console.log(chalk.red('\n  Failed to save config.'));
+    console.log(chalk.red('\n  FAILED TO SAVE CONFIG'));
   }
   await prompts.waitForEnter();
   return true;
@@ -259,10 +305,10 @@ const handleProviderConfig = async (provider, config) => {
   const boxWidth = getLogoWidth();
   
   while (true) {
-    console.clear();
+    clearWithBanner();
     drawProviderWindow(provider, config, boxWidth);
     
-    const input = await prompts.textInput(chalk.cyan('Select option: '));
+    const input = await prompts.textInput(chalk.cyan('SELECT OPTION: '));
     const choice = (input || '').toLowerCase().trim();
     
     if (choice === 'b' || choice === '') break;
@@ -270,7 +316,7 @@ const handleProviderConfig = async (provider, config) => {
     if (choice === 'd' && config.providers[provider.id]) {
       config.providers[provider.id].active = false;
       saveConfig(config);
-      console.log(chalk.yellow(`\n  ${provider.name} disconnected.`));
+      console.log(chalk.yellow(`\n  ${provider.name.toUpperCase()} DISCONNECTED`));
       await prompts.waitForEnter();
       continue;
     }
@@ -313,18 +359,18 @@ const getActiveAgentCount = () => getActiveProvider() ? 1 : 0;
 
 /** Show CLIProxy status */
 const showCliProxyStatus = async () => {
-  console.clear();
-  console.log(chalk.yellow('\n  CLIProxyAPI Status\n'));
+  clearWithBanner();
+  console.log(chalk.yellow('\n  CLIPROXYAPI STATUS\n'));
   
   const installed = cliproxy.isInstalled();
-  console.log(chalk.gray('  Installed: ') + (installed ? chalk.green('Yes') : chalk.red('No')));
+  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(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();
@@ -337,12 +383,12 @@ const aiAgentsMenu = async () => {
   const boxWidth = getLogoWidth();
   
   while (true) {
-    console.clear();
+    clearWithBanner();
     const status = await cliproxy.isRunning();
-    const statusText = status.running ? `localhost:${cliproxy.DEFAULT_PORT}` : 'Not running';
+    const statusText = status.running ? `LOCALHOST:${cliproxy.DEFAULT_PORT}` : 'NOT RUNNING';
     drawProvidersTable(AI_PROVIDERS, config, boxWidth, statusText);
     
-    const input = await prompts.textInput(chalk.cyan('Select (1-8/S/B): '));
+    const input = await prompts.textInput(chalk.cyan('SELECT (1-8/S/B): '));
     const choice = (input || '').toLowerCase().trim();
     
     if (choice === 'b' || choice === '') break;
@@ -358,7 +404,7 @@ const aiAgentsMenu = async () => {
       continue;
     }
     
-    console.log(chalk.red('  Invalid option.'));
+    console.log(chalk.red('  INVALID OPTION'));
     await new Promise(r => setTimeout(r, 1000));
   }
 };

package/src/services/cliproxy/installer.js

@@ -0,0 +1,111 @@
+/**
+ * CLIProxyAPI Installer
+ * 
+ * Handles downloading and extracting CLIProxyAPI binary
+ */
+
+const fs = require('fs');
+const https = require('https');
+const http = require('http');
+const { createGunzip } = require('zlib');
+const tar = require('tar');
+
+/**
+ * Download file from URL with redirect support
+ * @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') {
+    execSync(`powershell -Command "Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force"`, {
+      stdio: 'ignore'
+    });
+  } else {
+    execSync(`unzip -o "${archivePath}" -d "${destDir}"`, { stdio: 'ignore' });
+  }
+  
+  return true;
+};
+
+module.exports = {
+  downloadFile,
+  extractTarGz,
+  extractZip
+};

package/src/services/cliproxy/manager.js

@@ -8,11 +8,9 @@
 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');
+const { downloadFile, extractTarGz, extractZip } = require('./installer');
 
 // CLIProxyAPI version and download URLs
 const CLIPROXY_VERSION = '6.6.88';
@@ -27,6 +25,29 @@ const AUTH_DIR = path.join(INSTALL_DIR, 'auths');
 
 // Default port
 const DEFAULT_PORT = 8317;
+const CALLBACK_PORT = 54545;
+
+/**
+ * Detect if running in headless/VPS environment (no display)
+ * @returns {boolean}
+ */
+const isHeadless = () => {
+  // Check for common display environment variables
+  if (process.env.DISPLAY) return false;
+  if (process.env.WAYLAND_DISPLAY) return false;
+  
+  // Check if running via SSH
+  if (process.env.SSH_CLIENT || process.env.SSH_TTY || process.env.SSH_CONNECTION) return true;
+  
+  // Check platform-specific indicators
+  if (process.platform === 'linux') {
+    // No DISPLAY usually means headless on Linux
+    return true;
+  }
+  
+  // macOS/Windows usually have a display
+  return false;
+};
 
 /**
  * Get download URL for current platform
@@ -73,101 +94,6 @@ 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
@@ -388,48 +314,112 @@ const ensureRunning = async (onProgress = null) => {
 /**
  * Get OAuth login URL for a provider
  * @param {string} provider - Provider ID (anthropic, openai, google, etc.)
- * @returns {Promise<Object>} { success, url, error }
+ * @returns {Promise<Object>} { success, url, childProcess, isHeadless, error }
  */
 const getLoginUrl = async (provider) => {
   const providerFlags = {
-    anthropic: '--claude-login',
-    openai: '--codex-login',
-    google: '--gemini-login',
-    qwen: '--qwen-login'
+    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' };
+    return { success: false, url: null, childProcess: null, isHeadless: false, error: 'Provider not supported for OAuth' };
   }
   
-  // For headless/VPS, use --no-browser flag
+  const headless = isHeadless();
+  
+  // For headless/VPS, use -no-browser flag
   return new Promise((resolve) => {
-    const args = [flag, '--no-browser'];
+    const args = [flag, '-no-browser'];
     const child = spawn(BINARY_PATH, args, {
-      cwd: INSTALL_DIR,
-      env: { ...process.env, AUTH_DIR: AUTH_DIR }
+      cwd: INSTALL_DIR
     });
     
     let output = '';
+    let resolved = false;
+    
+    const checkForUrl = () => {
+      if (resolved) return;
+      const urlMatch = output.match(/https?:\/\/[^\s]+/);
+      if (urlMatch) {
+        resolved = true;
+        // Return child process so caller can wait for auth completion
+        resolve({ success: true, url: urlMatch[0], childProcess: child, isHeadless: headless, error: null });
+      }
+    };
     
     child.stdout.on('data', (data) => {
       output += data.toString();
+      checkForUrl();
     });
     
     child.stderr.on('data', (data) => {
       output += data.toString();
+      checkForUrl();
     });
     
-    // 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' });
+    child.on('error', (err) => {
+      if (!resolved) {
+        resolved = true;
+        resolve({ success: false, url: null, childProcess: null, isHeadless: headless, error: err.message });
       }
-    }, 3000);
+    });
+    
+    child.on('close', (code) => {
+      if (!resolved) {
+        resolved = true;
+        resolve({ success: false, url: null, childProcess: null, isHeadless: headless, error: `Process exited with code ${code}` });
+      }
+    });
+  });
+};
+
+/**
+ * Process OAuth callback URL manually (for VPS/headless)
+ * The callback URL looks like: http://localhost:54545/callback?code=xxx&state=yyy
+ * We need to forward this to the waiting CLIProxyAPI process
+ * @param {string} callbackUrl - The callback URL from the browser
+ * @returns {Promise<Object>} { success, error }
+ */
+const processCallback = (callbackUrl) => {
+  return new Promise((resolve) => {
+    try {
+      // Parse the callback URL
+      const url = new URL(callbackUrl);
+      const params = url.searchParams;
+      
+      // Extract query string to forward
+      const queryString = url.search;
+      
+      // Make request to local callback endpoint
+      const callbackPath = `/callback${queryString}`;
+      
+      const req = http.get(`http://127.0.0.1:${CALLBACK_PORT}${callbackPath}`, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          if (res.statusCode === 200 || res.statusCode === 302) {
+            resolve({ success: true, error: null });
+          } else {
+            resolve({ success: false, error: `Callback returned ${res.statusCode}: ${data}` });
+          }
+        });
+      });
+      
+      req.on('error', (err) => {
+        resolve({ success: false, error: `Callback error: ${err.message}` });
+      });
+      
+      req.setTimeout(10000, () => {
+        req.destroy();
+        resolve({ success: false, error: 'Callback timeout' });
+      });
+    } catch (err) {
+      resolve({ success: false, error: `Invalid URL: ${err.message}` });
+    }
   });
 };
 
@@ -439,12 +429,15 @@ module.exports = {
   BINARY_PATH,
   AUTH_DIR,
   DEFAULT_PORT,
+  CALLBACK_PORT,
   getDownloadUrl,
   isInstalled,
+  isHeadless,
   install,
   isRunning,
   start,
   stop,
   ensureRunning,
-  getLoginUrl
+  getLoginUrl,
+  processCallback
 };

package/src/ui/index.js

@@ -26,10 +26,10 @@ const {
 const { createBoxMenu } = require('./menu');
 
 /**
- * Display HQX Banner (without closing border)
- * Note: console.clear() is handled by app.js banner() to avoid terminal bugs
+ * Display HQX Banner (without closing border by default)
+ * @param {boolean} closed - If true, add bottom border
  */
-const displayBanner = () => {
+const displayBanner = (closed = false) => {
   const termWidth = process.stdout.columns || 100;
   const isMobile = termWidth < 60;
   const boxWidth = isMobile ? Math.max(termWidth - 2, 40) : Math.max(getLogoWidth(), 98);
@@ -72,6 +72,11 @@ const displayBanner = () => {
   console.log(chalk.cyan('╠' + '═'.repeat(innerWidth) + '╣'));
   const tagline = isMobile ? `HQX v${version}` : `Prop Futures Algo Trading  v${version}`;
   console.log(chalk.cyan('║') + chalk.white(centerText(tagline, innerWidth)) + chalk.cyan('║'));
+  
+  // Close the box if requested
+  if (closed) {
+    console.log(chalk.cyan('╚' + '═'.repeat(innerWidth) + '╝'));
+  }
 };
 
 /**