hedgequantx 2.6.101 → 2.6.103

package/package.json

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

package/src/menus/ai-agent.js

@@ -782,7 +782,7 @@ const getOAuthConfig = (providerId) => {
 
 /**
  * Setup OAuth connection for any provider with OAuth support
- * Unified flow: copy code from URL (works on local and VPS)
+ * Uses CLIProxyAPI for proper OAuth handling and API access
  */
 const setupOAuthConnection = async (provider) => {
   const config = getOAuthConfig(provider.id);
@@ -792,8 +792,8 @@ const setupOAuthConnection = async (provider) => {
     return await selectProviderOption(provider);
   }
   
-  // Use unified manual flow for all providers and environments
-  return await setupRemoteOAuth(provider, config);
+  // Use CLIProxyAPI for OAuth flow - it handles token exchange and API calls
+  return await setupProxyOAuth(provider, config);
 };
 
 /**
@@ -948,12 +948,169 @@ const setupRemoteOAuth = async (provider, config) => {
 // NOTE: promptForModelName was removed - models MUST come from API (RULES.md)
 
 /**
- * Setup OAuth via Manual Code Entry (unified flow for local and VPS)
- * User copies the authorization code from the URL or page
+ * Setup OAuth using CLIProxyAPI
+ * CLIProxyAPI handles OAuth flow, token storage, and API calls
+ * Models are fetched from CLIProxyAPI /v1/models endpoint
  */
 const setupProxyOAuth = async (provider, config) => {
-  // Use the same flow as VPS - it works everywhere
-  return await setupRemoteOAuth(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('║');
+  };
+  
+  // Step 1: Ensure CLIProxyAPI is installed and running
+  const spinner = ora({ text: 'Setting up CLIProxyAPI...', color: 'cyan' }).start();
+  
+  try {
+    await proxyManager.ensureRunning();
+    spinner.succeed('CLIProxyAPI ready');
+  } catch (error) {
+    spinner.fail(`Failed to start CLIProxyAPI: ${error.message}`);
+    console.log();
+    console.log(chalk.yellow('  CLIProxyAPI is required for OAuth authentication.'));
+    console.log(chalk.gray('  It will be downloaded automatically on first use.'));
+    console.log();
+    await prompts.waitForEnter();
+    return await selectProviderOption(provider);
+  }
+  
+  // Step 2: Get OAuth URL from CLIProxyAPI
+  spinner.text = 'Getting authorization URL...';
+  spinner.start();
+  
+  let authUrl, authState;
+  try {
+    const authInfo = await proxyManager.getAuthUrl(provider.id);
+    authUrl = authInfo.url;
+    authState = authInfo.state;
+    spinner.succeed('Authorization URL ready');
+  } catch (error) {
+    spinner.fail(`Failed to get auth URL: ${error.message}`);
+    await prompts.waitForEnter();
+    return await selectProviderOption(provider);
+  }
+  
+  // Step 3: Show instructions to user
+  console.clear();
+  displayBanner();
+  drawBoxHeaderContinue(`CONNECT ${config.name}`, boxWidth);
+  
+  console.log(makeLine(chalk.yellow('CONNECT YOUR ACCOUNT')));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.white('1. OPEN THE LINK BELOW IN YOUR BROWSER')));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.white(`2. LOGIN WITH YOUR ${config.accountName.toUpperCase()} ACCOUNT`)));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.white('3. CLICK "AUTHORIZE"')));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.green('4. WAIT FOR CONFIRMATION HERE')));
+  console.log(makeLine(chalk.white('   (The page will close automatically)')));
+  console.log(makeLine(''));
+  
+  drawBoxFooter(boxWidth);
+  
+  // Display URL
+  console.log();
+  console.log(chalk.yellow('  OPEN THIS URL IN YOUR BROWSER:'));
+  console.log();
+  console.log(chalk.cyan(`  ${authUrl}`));
+  console.log();
+  
+  // Try to open browser automatically
+  const browserOpened = await openBrowser(authUrl);
+  if (browserOpened) {
+    console.log(chalk.gray('  (Browser opened automatically)'));
+  } else {
+    console.log(chalk.gray('  (Copy and paste the URL in your browser)'));
+  }
+  console.log();
+  
+  // Step 4: Wait for OAuth callback
+  const waitSpinner = ora({ text: 'Waiting for authorization...', color: 'cyan' }).start();
+  
+  try {
+    await proxyManager.waitForAuth(authState, 300000, (status) => {
+      waitSpinner.text = status;
+    });
+    waitSpinner.succeed('Authorization successful!');
+  } catch (error) {
+    waitSpinner.fail(`Authorization failed: ${error.message}`);
+    await prompts.waitForEnter();
+    return await selectProviderOption(provider);
+  }
+  
+  // Step 5: Fetch models from CLIProxyAPI
+  waitSpinner.text = 'Fetching available models from API...';
+  waitSpinner.start();
+  
+  let models = [];
+  try {
+    models = await proxyManager.getModels();
+  } catch (error) {
+    waitSpinner.fail(`Failed to fetch models: ${error.message}`);
+    await prompts.waitForEnter();
+    return await selectProviderOption(provider);
+  }
+  
+  // Filter models for this provider
+  const providerPrefixes = {
+    anthropic: ['claude'],
+    openai: ['gpt', 'o1', 'o3', 'o4'],
+    gemini: ['gemini'],
+    qwen: ['qwen'],
+    iflow: ['deepseek', 'kimi', 'glm']
+  };
+  
+  const prefixes = providerPrefixes[provider.id] || [];
+  const filteredModels = models.filter(m => {
+    const modelLower = m.toLowerCase();
+    return prefixes.some(p => modelLower.includes(p));
+  });
+  
+  // Use filtered models if available, otherwise use all models
+  const availableModels = filteredModels.length > 0 ? filteredModels : models;
+  
+  if (!availableModels || availableModels.length === 0) {
+    waitSpinner.fail('No models available');
+    console.log();
+    console.log(chalk.red('  ERROR: No models found for this provider'));
+    console.log(chalk.gray('  Make sure your subscription is active.'));
+    console.log();
+    await prompts.waitForEnter();
+    return await selectProviderOption(provider);
+  }
+  
+  waitSpinner.succeed(`Found ${availableModels.length} models`);
+  
+  // Step 6: Let user select model
+  const selectedModel = await selectModelFromList(availableModels, config.name);
+  if (!selectedModel) {
+    return await selectProviderOption(provider);
+  }
+  
+  // Step 7: Save agent config (CLIProxyAPI stores the actual tokens)
+  // We just save a reference to use the proxy
+  const credentials = {
+    useProxy: true,
+    provider: provider.id
+  };
+  
+  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}`));
+  }
+  
+  await prompts.waitForEnter();
+  return await aiAgentMenu();
 };
 
 /**

package/src/services/ai/client.js

@@ -527,13 +527,13 @@ const fetchAnthropicModels = async (apiKey) => {
  * Fetch available models from Anthropic API (OAuth auth)
  * 
  * @param {string} accessToken - OAuth access token
- * @returns {Promise<Array|null>} Array of model IDs from API, null if unavailable
+ * @returns {Promise<Object>} { models: Array, error: string|null }
  * 
  * Data source: https://api.anthropic.com/v1/models (GET with Bearer token)
  * NO HARDCODED FALLBACK - models must come from API only
  */
 const fetchAnthropicModelsOAuth = async (accessToken) => {
-  if (!accessToken) return null;
+  if (!accessToken) return { models: null, error: 'No access token provided' };
   
   const modelsUrl = 'https://api.anthropic.com/v1/models';
   
@@ -547,14 +547,11 @@ const fetchAnthropicModelsOAuth = async (accessToken) => {
     const response = await makeRequest(modelsUrl, { method: 'GET', headers, timeout: 15000 });
     if (response.data && Array.isArray(response.data)) {
       const models = response.data.map(m => m.id).filter(Boolean);
-      if (models.length > 0) return models;
+      if (models.length > 0) return { models, error: null };
     }
-    return null;
+    return { models: null, error: 'API returned empty or invalid response' };
   } catch (error) {
-    if (process.env.HQX_DEBUG) {
-      console.error('[DEBUG] fetchAnthropicModelsOAuth error:', error.message);
-    }
-    return null;
+    return { models: null, error: error.message };
   }
 };
 

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

@@ -27,6 +27,7 @@ const PROXY_BIN = path.join(PROXY_DIR, process.platform === 'win32' ? 'cli-proxy
 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';
 
 // GitHub release URLs
 const getDownloadUrl = () => {
@@ -202,6 +203,9 @@ const install = async (onProgress = () => {}) => {
 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
@@ -288,7 +292,7 @@ const ensureRunning = async (onProgress = () => {}) => {
 };
 
 /**
- * Make request to local proxy
+ * Make request to local proxy (API endpoints)
  */
 const proxyRequest = (method, endpoint, body = null) => {
   return new Promise((resolve, reject) => {
@@ -329,6 +333,58 @@ const proxyRequest = (method, endpoint, body = null) => {
   });
 };
 
+/**
+ * Make request to local proxy (Management API endpoints)
+ * Uses management key for authentication
+ */
+const managementRequest = (method, endpoint, body = null) => {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: '127.0.0.1',
+      port: PROXY_PORT,
+      path: endpoint,
+      method,
+      headers: {
+        'Authorization': `Bearer ${MANAGEMENT_KEY}`,
+        'Content-Type': 'application/json'
+      },
+      timeout: 30000
+    };
+    
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          if (res.statusCode >= 400) {
+            reject(new Error(json.error || `HTTP ${res.statusCode}`));
+          } else {
+            resolve(json);
+          }
+        } catch (e) {
+          if (res.statusCode >= 400) {
+            reject(new Error(`HTTP ${res.statusCode}: ${data}`));
+          } else {
+            resolve(data);
+          }
+        }
+      });
+    });
+    
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+    
+    if (body) {
+      req.write(JSON.stringify(body));
+    }
+    req.end();
+  });
+};
+
 /**
  * Get OAuth authorization URL for a provider
  * @param {string} provider - Provider ID (anthropic, openai, gemini, qwen, iflow)
@@ -350,7 +406,7 @@ const getAuthUrl = async (provider) => {
     throw new Error(`Unknown provider: ${provider}`);
   }
   
-  const response = await proxyRequest('GET', endpoint);
+  const response = await managementRequest('GET', endpoint);
   
   if (response.status !== 'ok') {
     throw new Error(response.error || 'Failed to get auth URL');
@@ -368,7 +424,7 @@ const getAuthUrl = async (provider) => {
  * @returns {Promise<{status: string, error?: string}>}
  */
 const pollAuthStatus = async (state) => {
-  const response = await proxyRequest('GET', `/v0/management/get-auth-status?state=${state}`);
+  const response = await managementRequest('GET', `/v0/management/get-auth-status?state=${state}`);
   return response;
 };
 
@@ -422,7 +478,7 @@ const getAuthFiles = async () => {
   await ensureRunning();
   
   try {
-    const response = await proxyRequest('GET', '/v0/management/auth-files');
+    const response = await managementRequest('GET', '/v0/management/auth-files');
     return response.files || [];
   } catch (e) {
     return [];