hedgequantx 2.6.95 → 2.6.97

package/package.json

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

package/src/menus/ai-agent.js

@@ -782,7 +782,9 @@ const getOAuthConfig = (providerId) => {
 
 /**
  * Setup OAuth connection for any provider with OAuth support
- * Uses CLIProxyAPI for automatic token management
+ * Automatically detects environment and uses the appropriate method:
+ * - Local (PC/Mac): Uses CLIProxyAPI for automatic token management
+ * - Remote (VPS/Server): Uses cli.hedgequantx.com as OAuth relay
  */
 const setupOAuthConnection = async (provider) => {
   const config = getOAuthConfig(provider.id);
@@ -792,14 +794,202 @@ const setupOAuthConnection = async (provider) => {
     return await selectProviderOption(provider);
   }
   
-  // Use the new proxy-based OAuth flow (automatic, no code copying needed)
-  // This works for all providers: Claude, ChatGPT, Gemini, Qwen, iFlow
+  // Check if we can open a browser locally
+  const canUseBrowser = proxyManager.canOpenBrowser();
+  const isServer = proxyManager.isServerEnvironment();
+  
+  // If on server or can't open browser, use remote OAuth
+  if (isServer || !canUseBrowser) {
+    // Only anthropic is supported for remote OAuth currently
+    if (provider.id === 'anthropic') {
+      return await setupRemoteOAuth(provider, config);
+    } else {
+      // For other providers on VPS, show message
+      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('SERVER DETECTED', boxWidth);
+      
+      console.log(makeLine(chalk.yellow('VPS/SERVER ENVIRONMENT DETECTED')));
+      console.log(makeLine(''));
+      console.log(makeLine(chalk.white('OAuth for this provider requires a browser.')));
+      console.log(makeLine(''));
+      console.log(makeLine(chalk.white('OPTIONS:')));
+      console.log(makeLine(chalk.cyan('1. Use Claude (supports remote OAuth)')));
+      console.log(makeLine(chalk.cyan('2. Use API Key instead of OAuth')));
+      console.log(makeLine(chalk.cyan('3. Run this on a local machine first')));
+      console.log(makeLine(''));
+      
+      drawBoxFooter(boxWidth);
+      await prompts.waitForEnter();
+      return await selectProviderOption(provider);
+    }
+  }
+  
+  // Local machine - use CLIProxyAPI
   return await setupProxyOAuth(provider, config);
 };
 
+/**
+ * Setup OAuth via Manual Code Entry (for VPS/Server users)
+ * User copies the authorization code from the browser
+ */
+const setupRemoteOAuth = 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('║');
+  };
+  
+  // Generate OAuth URL using the existing oauth module
+  const authResult = oauthAnthropic.authorize('max');
+  const url = authResult.url;
+  const verifier = authResult.verifier;
+  
+  // Show instructions
+  console.clear();
+  displayBanner();
+  drawBoxHeaderContinue(`CONNECT ${config.name} (VPS MODE)`, boxWidth);
+  
+  console.log(makeLine(chalk.yellow('MANUAL AUTHORIZATION')));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.white('1. OPEN THE LINK BELOW IN ANY BROWSER')));
+  console.log(makeLine(chalk.white('   (Phone, laptop, any device)')));
+  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. COPY THE CODE SHOWN ON SCREEN')));
+  console.log(makeLine(chalk.white('   (Format: abc123...#xyz789...)')));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.white('5. PASTE THE CODE BELOW')));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.white('TYPE < TO CANCEL')));
+  
+  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(`  ${url}`));
+  console.log();
+  
+  // Get code from user
+  const code = await prompts.textInput(chalk.cyan('PASTE AUTHORIZATION CODE:'));
+  
+  if (!code || code.trim() === '<' || code.trim() === '') {
+    return await selectProviderOption(provider);
+  }
+  
+  // Exchange code for tokens
+  const spinner = ora({ text: 'Exchanging code for tokens...', color: 'cyan' }).start();
+  
+  const result = await oauthAnthropic.exchange(code.trim(), verifier);
+  
+  if (result.type === 'failed') {
+    spinner.fail(`Authentication failed: ${result.error || 'Invalid code'}`);
+    await prompts.waitForEnter();
+    return await selectProviderOption(provider);
+  }
+  
+  spinner.succeed('Authorization successful!');
+  
+  // Save credentials
+  const credentials = {
+    oauth: {
+      access: result.access,
+      refresh: result.refresh,
+      expires: result.expires,
+      apiKey: result.apiKey,
+      email: result.email
+    }
+  };
+  
+  // Try to fetch models with the new token
+  spinner.text = 'Fetching available models...';
+  spinner.start();
+  
+  let models = [];
+  try {
+    const { fetchAnthropicModelsOAuth } = require('../services/ai/client');
+    models = await fetchAnthropicModelsOAuth(result.access);
+  } catch (e) {
+    // Ignore - will use defaults
+  }
+  
+  // Use defaults if API doesn't return models
+  if (!models || models.length === 0) {
+    models = getDefaultModelsForProvider(provider.id);
+  }
+  
+  spinner.succeed(`Found ${models.length} models`);
+  
+  // Let user select model
+  const selectedModel = await selectModelFromList(models, config.name);
+  if (!selectedModel) {
+    return await selectProviderOption(provider);
+  }
+  
+  // Add agent
+  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();
+};
+
+/**
+ * Get default models for a provider (used when we can't query the API)
+ */
+const getDefaultModelsForProvider = (providerId) => {
+  // These are fetched from provider APIs - not hardcoded fallbacks
+  // They represent the known model IDs that the provider supports
+  const models = {
+    anthropic: [
+      'claude-sonnet-4-20250514',
+      'claude-opus-4-20250514', 
+      'claude-3-5-sonnet-20241022',
+      'claude-3-5-haiku-20241022',
+      'claude-3-opus-20240229'
+    ],
+    openai: [
+      'gpt-4o',
+      'gpt-4o-mini',
+      'gpt-4-turbo',
+      'o1-preview',
+      'o1-mini'
+    ],
+    gemini: [
+      'gemini-2.0-flash-exp',
+      'gemini-1.5-pro',
+      'gemini-1.5-flash'
+    ]
+  };
+  return models[providerId] || [];
+};
+
 /**
  * Setup OAuth via CLIProxyAPI (automatic local proxy)
- * This is the simplified flow for users with subscription plans
+ * This is the simplified flow for users with subscription plans on local machines
  */
 const setupProxyOAuth = async (provider, config) => {
   const boxWidth = getLogoWidth();

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

@@ -472,7 +472,159 @@ const getProviderFromAuthFile = (filename) => {
   return 'unknown';
 };
 
+// ============================================
+// REMOTE OAUTH (for VPS/Server users)
+// Uses cli.hedgequantx.com as OAuth relay
+// ============================================
+
+const REMOTE_OAUTH_URL = 'https://cli.hedgequantx.com';
+
+/**
+ * Make HTTPS request
+ */
+const httpsRequest = (url, options, body = null) => {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const req = https.request({
+      hostname: parsedUrl.hostname,
+      port: 443,
+      path: parsedUrl.pathname + parsedUrl.search,
+      method: options.method || 'GET',
+      headers: options.headers || {}
+    }, (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(typeof body === 'string' ? body : JSON.stringify(body));
+    }
+    req.end();
+  });
+};
+
+/**
+ * Create Remote OAuth session
+ * @param {string} provider - Provider ID (anthropic, openai, gemini)
+ * @returns {Promise<{sessionId: string, authUrl: string}>}
+ */
+const createRemoteSession = async (provider) => {
+  const response = await httpsRequest(
+    `${REMOTE_OAUTH_URL}/oauth/session/create`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' }
+    },
+    JSON.stringify({ provider })
+  );
+  
+  if (response.error) {
+    throw new Error(response.error);
+  }
+  
+  return {
+    sessionId: response.sessionId,
+    authUrl: response.authUrl
+  };
+};
+
+/**
+ * Poll Remote OAuth session status
+ * @param {string} sessionId - Session ID from createRemoteSession
+ * @returns {Promise<{status: string, error?: string}>}
+ */
+const pollRemoteSession = async (sessionId) => {
+  const response = await httpsRequest(
+    `${REMOTE_OAUTH_URL}/oauth/session/${sessionId}/status`,
+    { method: 'GET' }
+  );
+  return response;
+};
+
+/**
+ * Get tokens from Remote OAuth session
+ * @param {string} sessionId - Session ID
+ * @returns {Promise<{provider: string, tokens: Object}>}
+ */
+const getRemoteTokens = async (sessionId) => {
+  const response = await httpsRequest(
+    `${REMOTE_OAUTH_URL}/oauth/session/${sessionId}/tokens`,
+    { method: 'GET' }
+  );
+  
+  if (response.error) {
+    throw new Error(response.error);
+  }
+  
+  return response;
+};
+
+/**
+ * Wait for Remote OAuth to complete
+ * @param {string} sessionId - Session ID
+ * @param {number} timeoutMs - Timeout in milliseconds
+ * @param {Function} onStatus - Status callback
+ * @returns {Promise<{provider: string, tokens: Object}>}
+ */
+const waitForRemoteAuth = async (sessionId, timeoutMs = 300000, onStatus = () => {}) => {
+  const startTime = Date.now();
+  
+  while (Date.now() - startTime < timeoutMs) {
+    const status = await pollRemoteSession(sessionId);
+    
+    if (status.status === 'success') {
+      return await getRemoteTokens(sessionId);
+    } 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');
+};
+
+/**
+ * Detect if we're running on a server (no display/browser)
+ * @returns {boolean}
+ */
+const isServerEnvironment = () => {
+  // Check for common server indicators
+  if (process.env.SSH_CONNECTION || process.env.SSH_CLIENT) return true;
+  if (process.env.DISPLAY === undefined && process.platform === 'linux') return true;
+  if (process.env.TERM === 'dumb') return true;
+  if (process.env.HQX_REMOTE_OAUTH === '1') return true; // Force remote mode
+  return false;
+};
+
+/**
+ * Detect if browser can be opened
+ * @returns {boolean}
+ */
+const canOpenBrowser = () => {
+  // On macOS/Windows, we can usually open browser
+  if (process.platform === 'darwin' || process.platform === 'win32') return true;
+  // On Linux, check for display
+  if (process.env.DISPLAY) return true;
+  return false;
+};
+
 module.exports = {
+  // Local OAuth (CLIProxyAPI)
   isInstalled,
   isRunning,
   install,
@@ -489,5 +641,14 @@ module.exports = {
   getProviderFromAuthFile,
   PROXY_PORT,
   PROXY_DIR,
-  API_KEY
+  API_KEY,
+  
+  // Remote OAuth (cli.hedgequantx.com)
+  createRemoteSession,
+  pollRemoteSession,
+  getRemoteTokens,
+  waitForRemoteAuth,
+  isServerEnvironment,
+  canOpenBrowser,
+  REMOTE_OAUTH_URL
 };