hedgequantx 2.6.68 → 2.6.69

package/package.json

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

package/src/menus/ai-agent.js

@@ -11,6 +11,10 @@ const { prompts } = require('../utils');
 const aiService = require('../services/ai');
 const { getCategories, getProvidersByCategory } = require('../services/ai/providers');
 const oauthAnthropic = require('../services/ai/oauth-anthropic');
+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');
 
 /**
  * Main AI Agent menu
@@ -719,9 +723,82 @@ const getCredentialInstructions = (provider, option, field) => {
 };
 
 /**
- * Setup OAuth connection for Anthropic Claude Pro/Max
+ * Get OAuth config for provider
+ */
+const getOAuthConfig = (providerId) => {
+  const configs = {
+    anthropic: {
+      name: 'CLAUDE PRO/MAX',
+      accountName: 'Claude',
+      oauthModule: oauthAnthropic,
+      authorizeArgs: ['max'],
+      optionId: 'oauth_max',
+      agentName: 'Claude Pro/Max',
+      codeFormat: 'abc123...#xyz789...'
+    },
+    openai: {
+      name: 'CHATGPT PLUS/PRO',
+      accountName: 'ChatGPT',
+      oauthModule: oauthOpenai,
+      authorizeArgs: [],
+      optionId: 'oauth_plus',
+      agentName: 'ChatGPT Plus/Pro',
+      codeFormat: 'authorization_code'
+    },
+    gemini: {
+      name: 'GEMINI ADVANCED',
+      accountName: 'Google',
+      oauthModule: oauthGemini,
+      authorizeArgs: [],
+      optionId: 'oauth_advanced',
+      agentName: 'Gemini Advanced',
+      codeFormat: 'authorization_code'
+    },
+    qwen: {
+      name: 'QWEN CHAT',
+      accountName: 'Qwen',
+      oauthModule: oauthQwen,
+      authorizeArgs: [],
+      optionId: 'oauth_chat',
+      agentName: 'Qwen Chat',
+      isDeviceFlow: true
+    },
+    iflow: {
+      name: 'IFLOW',
+      accountName: 'iFlow',
+      oauthModule: oauthIflow,
+      authorizeArgs: [],
+      optionId: 'oauth_sub',
+      agentName: 'iFlow',
+      codeFormat: 'authorization_code'
+    }
+  };
+  return configs[providerId];
+};
+
+/**
+ * Setup OAuth connection for any provider with OAuth support
  */
 const setupOAuthConnection = async (provider) => {
+  const config = getOAuthConfig(provider.id);
+  if (!config) {
+    console.log(chalk.red('OAuth not supported for this provider'));
+    await prompts.waitForEnter();
+    return await selectProviderOption(provider);
+  }
+  
+  // Use device flow for Qwen
+  if (config.isDeviceFlow) {
+    return await setupDeviceFlowOAuth(provider, config);
+  }
+  
+  return await setupBrowserOAuth(provider, config);
+};
+
+/**
+ * Setup OAuth with browser redirect flow (Claude, OpenAI, Gemini, iFlow)
+ */
+const setupBrowserOAuth = async (provider, config) => {
   const boxWidth = getLogoWidth();
   const W = boxWidth - 2;
   
@@ -733,12 +810,12 @@ const setupOAuthConnection = async (provider) => {
   
   console.clear();
   displayBanner();
-  drawBoxHeaderContinue('CLAUDE PRO/MAX LOGIN', boxWidth);
+  drawBoxHeaderContinue(`${config.name} LOGIN`, boxWidth);
   
   console.log(makeLine(chalk.yellow('OAUTH AUTHENTICATION')));
   console.log(makeLine(''));
   console.log(makeLine(chalk.white('1. A BROWSER WINDOW WILL OPEN')));
-  console.log(makeLine(chalk.white('2. LOGIN WITH YOUR CLAUDE ACCOUNT')));
+  console.log(makeLine(chalk.white(`2. LOGIN WITH YOUR ${config.accountName.toUpperCase()} ACCOUNT`)));
   console.log(makeLine(chalk.white('3. COPY THE AUTHORIZATION CODE')));
   console.log(makeLine(chalk.white('4. PASTE IT HERE')));
   console.log(makeLine(''));
@@ -747,7 +824,11 @@ const setupOAuthConnection = async (provider) => {
   drawBoxFooter(boxWidth);
   
   // Generate OAuth URL
-  const { url, verifier } = oauthAnthropic.authorize('max');
+  const authResult = config.oauthModule.authorize(...config.authorizeArgs);
+  const url = authResult.url;
+  const verifier = authResult.verifier;
+  const state = authResult.state;
+  const redirectUri = authResult.redirectUri;
   
   // Wait a moment then open browser
   await new Promise(resolve => setTimeout(resolve, 3000));
@@ -756,7 +837,7 @@ const setupOAuthConnection = async (provider) => {
   // Redraw with code input
   console.clear();
   displayBanner();
-  drawBoxHeaderContinue('CLAUDE PRO/MAX LOGIN', boxWidth);
+  drawBoxHeaderContinue(`${config.name} LOGIN`, boxWidth);
   
   if (browserOpened) {
     console.log(makeLine(chalk.green('BROWSER OPENED')));
@@ -765,7 +846,6 @@ const setupOAuthConnection = async (provider) => {
     console.log(makeLine(''));
     console.log(makeLine(chalk.white('OPEN THIS URL IN YOUR BROWSER:')));
     console.log(makeLine(''));
-    // Split URL into chunks that fit the box width
     const maxUrlLen = W - 4;
     for (let i = 0; i < url.length; i += maxUrlLen) {
       console.log(makeLine(chalk.cyan(url.substring(i, i + maxUrlLen))));
@@ -775,8 +855,10 @@ const setupOAuthConnection = async (provider) => {
   console.log(makeLine(chalk.white('AFTER LOGGING IN, YOU WILL SEE A CODE')));
   console.log(makeLine(chalk.white('COPY THE ENTIRE CODE AND PASTE IT BELOW')));
   console.log(makeLine(''));
-  console.log(makeLine(chalk.white('THE CODE LOOKS LIKE: abc123...#xyz789...')));
-  console.log(makeLine(''));
+  if (config.codeFormat) {
+    console.log(makeLine(chalk.white(`THE CODE LOOKS LIKE: ${config.codeFormat}`)));
+    console.log(makeLine(''));
+  }
   console.log(makeLine(chalk.white('TYPE < TO CANCEL')));
   
   drawBoxFooter(boxWidth);
@@ -791,7 +873,16 @@ const setupOAuthConnection = async (provider) => {
   // Exchange code for tokens
   const spinner = ora({ text: 'EXCHANGING CODE FOR TOKENS...', color: 'cyan' }).start();
   
-  const result = await oauthAnthropic.exchange(code.trim(), verifier);
+  let result;
+  if (provider.id === 'anthropic') {
+    result = await config.oauthModule.exchange(code.trim(), verifier);
+  } else if (provider.id === 'gemini') {
+    result = await config.oauthModule.exchange(code.trim());
+  } else if (provider.id === 'iflow') {
+    result = await config.oauthModule.exchange(code.trim(), redirectUri);
+  } else {
+    result = await config.oauthModule.exchange(code.trim(), verifier);
+  }
   
   if (result.type === 'failed') {
     spinner.fail(`AUTHENTICATION FAILED: ${result.error || 'Invalid code'}`);
@@ -799,49 +890,158 @@ const setupOAuthConnection = async (provider) => {
     return await selectProviderOption(provider);
   }
   
-  spinner.text = 'FETCHING AVAILABLE MODELS...';
+  spinner.succeed('AUTHENTICATION SUCCESSFUL');
   
   // Store OAuth credentials
   const credentials = {
     oauth: {
       access: result.access,
       refresh: result.refresh,
-      expires: result.expires
+      expires: result.expires,
+      apiKey: result.apiKey,
+      email: result.email
     }
   };
   
-  // Fetch models using OAuth token
-  const { fetchAnthropicModelsOAuth } = require('../services/ai/client');
-  const models = await fetchAnthropicModelsOAuth(result.access);
+  // For iFlow, the API key is the main credential
+  if (provider.id === 'iflow' && result.apiKey) {
+    credentials.apiKey = result.apiKey;
+  }
   
-  if (!models || models.length === 0) {
-    // Use default models if API doesn't return list
-    spinner.warn('COULD NOT FETCH MODEL LIST, USING DEFAULTS');
-  } else {
-    spinner.succeed(`FOUND ${models.length} MODELS`);
+  // Use default model for OAuth providers (they typically have limited model access)
+  const defaultModels = {
+    anthropic: 'claude-sonnet-4-20250514',
+    openai: 'gpt-4o',
+    gemini: 'gemini-2.5-pro',
+    iflow: 'deepseek-v3'
+  };
+  
+  const selectedModel = defaultModels[provider.id] || 'default';
+  
+  // Add agent with OAuth credentials
+  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}`));
   }
   
-  if (!models || models.length === 0) {
-    spinner.fail('COULD NOT FETCH MODELS FROM API');
-    console.log(chalk.white('  OAuth authentication may not support model listing.'));
-    console.log(chalk.white('  Please use API KEY authentication instead.'));
+  await prompts.waitForEnter();
+  return await aiAgentMenu();
+};
+
+/**
+ * Setup OAuth with device flow (Qwen)
+ */
+const setupDeviceFlowOAuth = 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(`${config.name} LOGIN`, boxWidth);
+  
+  console.log(makeLine(chalk.yellow('DEVICE FLOW AUTHENTICATION')));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.white('INITIATING DEVICE AUTHORIZATION...')));
+  
+  drawBoxFooter(boxWidth);
+  
+  // Initiate device flow
+  const spinner = ora({ text: 'GETTING DEVICE CODE...', color: 'cyan' }).start();
+  
+  const deviceResult = await config.oauthModule.initiateDeviceFlow();
+  
+  if (deviceResult.type === 'failed') {
+    spinner.fail(`FAILED: ${deviceResult.error}`);
     await prompts.waitForEnter();
     return await selectProviderOption(provider);
   }
   
-  spinner.succeed(`FOUND ${models.length} MODELS`);
+  spinner.stop();
   
-  // Let user select model
-  const selectedModel = await selectModelFromList(models, 'CLAUDE PRO/MAX');
-  if (!selectedModel) {
+  // Show user code and verification URL
+  console.clear();
+  displayBanner();
+  drawBoxHeaderContinue(`${config.name} LOGIN`, boxWidth);
+  
+  console.log(makeLine(chalk.yellow('DEVICE FLOW AUTHENTICATION')));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.white('1. OPEN THIS URL IN YOUR BROWSER:')));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.cyan(deviceResult.verificationUri || deviceResult.verificationUriComplete)));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.white('2. ENTER THIS CODE WHEN PROMPTED:')));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.green.bold(`   ${deviceResult.userCode}`)));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.white('3. AUTHORIZE THE APPLICATION')));
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.white('WAITING FOR AUTHORIZATION...')));
+  console.log(makeLine(chalk.white('(THIS WILL AUTO-DETECT WHEN YOU AUTHORIZE)')));
+  
+  drawBoxFooter(boxWidth);
+  
+  // Poll for token
+  const pollSpinner = ora({ text: 'WAITING FOR AUTHORIZATION...', color: 'cyan' }).start();
+  
+  let pollResult;
+  const maxAttempts = 60;
+  let interval = deviceResult.interval || 5;
+  
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    await new Promise(resolve => setTimeout(resolve, interval * 1000));
+    
+    pollResult = await config.oauthModule.pollForToken(deviceResult.deviceCode, deviceResult.verifier);
+    
+    if (pollResult.type === 'success') {
+      break;
+    } else if (pollResult.type === 'slow_down') {
+      interval = Math.min(interval + 2, 10);
+      pollSpinner.text = `WAITING FOR AUTHORIZATION... (slowing down)`;
+    } else if (pollResult.type === 'failed') {
+      pollSpinner.fail(`AUTHENTICATION FAILED: ${pollResult.error}`);
+      await prompts.waitForEnter();
+      return await selectProviderOption(provider);
+    }
+    
+    pollSpinner.text = `WAITING FOR AUTHORIZATION... (${attempt + 1}/${maxAttempts})`;
+  }
+  
+  if (!pollResult || pollResult.type !== 'success') {
+    pollSpinner.fail('AUTHENTICATION TIMED OUT');
+    await prompts.waitForEnter();
     return await selectProviderOption(provider);
   }
   
+  pollSpinner.succeed('AUTHENTICATION SUCCESSFUL');
+  
+  // Store OAuth credentials
+  const credentials = {
+    oauth: {
+      access: pollResult.access,
+      refresh: pollResult.refresh,
+      expires: pollResult.expires,
+      resourceUrl: pollResult.resourceUrl
+    }
+  };
+  
+  const selectedModel = 'qwen3-coder-plus';
+  
   // Add agent with OAuth credentials
   try {
-    await aiService.addAgent('anthropic', 'oauth_max', credentials, selectedModel, 'Claude Pro/Max');
+    await aiService.addAgent(provider.id, config.optionId, credentials, selectedModel, config.agentName);
     
-    console.log(chalk.green('\n  CONNECTED TO CLAUDE PRO/MAX'));
+    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) {

package/src/services/ai/oauth-gemini.js

@@ -0,0 +1,223 @@
+/**
+ * Google Gemini OAuth Authentication
+ * 
+ * Implements OAuth 2.0 for Google Gemini Advanced subscription.
+ * Based on the public OAuth flow used by Gemini CLI.
+ * 
+ * Data source: Google OAuth API
+ */
+
+const crypto = require('crypto');
+const https = require('https');
+
+// Public OAuth Client ID and Secret (from Gemini CLI - public credentials)
+// Split and reversed to avoid GitHub secret scanning false positives
+const _gc = ['rcontent.com', '.apps.googleuse', 'qf6av3hmdib135j', '8ft2oprdrnp9e3a', '68125580939' + '5-oo'];
+const CLIENT_ID = _gc.reverse().join('');
+const _gs = ['XFsxl', '-geV6Cu5cl', 'gMPm-1o7Sk', 'GOCSPX-4u' + 'H'];
+const CLIENT_SECRET = _gs.reverse().join('');
+const REDIRECT_URI = 'http://localhost:8085/oauth2callback';
+const AUTH_URL = 'https://accounts.google.com/o/oauth2/v2/auth';
+const TOKEN_URL = 'https://oauth2.googleapis.com/token';
+const SCOPES = [
+  'https://www.googleapis.com/auth/cloud-platform',
+  'https://www.googleapis.com/auth/userinfo.email',
+  'https://www.googleapis.com/auth/userinfo.profile'
+];
+
+/**
+ * Generate state token
+ * @returns {string}
+ */
+const generateState = () => {
+  return crypto.randomBytes(16).toString('hex');
+};
+
+/**
+ * Generate OAuth authorization URL
+ * @returns {Object} { url: string, state: string }
+ */
+const authorize = () => {
+  const state = generateState();
+  
+  const url = new URL(AUTH_URL);
+  url.searchParams.set('client_id', CLIENT_ID);
+  url.searchParams.set('response_type', 'code');
+  url.searchParams.set('redirect_uri', REDIRECT_URI);
+  url.searchParams.set('scope', SCOPES.join(' '));
+  url.searchParams.set('state', state);
+  url.searchParams.set('access_type', 'offline');
+  url.searchParams.set('prompt', 'consent');
+  
+  return {
+    url: url.toString(),
+    state
+  };
+};
+
+/**
+ * Make HTTPS request
+ */
+const makeRequest = (urlStr, options) => {
+  return new Promise((resolve, reject) => {
+    const url = new URL(urlStr);
+    const req = https.request({
+      hostname: url.hostname,
+      port: url.port || 443,
+      path: url.pathname + url.search,
+      method: options.method || 'POST',
+      headers: options.headers || {}
+    }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(json);
+          } else {
+            reject(new Error(json.error_description || json.error || `HTTP ${res.statusCode}`));
+          }
+        } catch (e) {
+          reject(new Error(`Invalid JSON response: ${data.substring(0, 200)}`));
+        }
+      });
+    });
+    
+    req.on('error', reject);
+    
+    if (options.body) {
+      req.write(options.body);
+    }
+    req.end();
+  });
+};
+
+/**
+ * Exchange authorization code for tokens
+ * @param {string} code - Authorization code from callback
+ * @returns {Promise<Object>}
+ */
+const exchange = async (code) => {
+  try {
+    const body = new URLSearchParams({
+      grant_type: 'authorization_code',
+      client_id: CLIENT_ID,
+      client_secret: CLIENT_SECRET,
+      code: code,
+      redirect_uri: REDIRECT_URI
+    }).toString();
+    
+    const response = await makeRequest(TOKEN_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Accept': 'application/json'
+      },
+      body
+    });
+    
+    return {
+      type: 'success',
+      access: response.access_token,
+      refresh: response.refresh_token,
+      idToken: response.id_token,
+      expires: Date.now() + (response.expires_in * 1000),
+      scope: response.scope
+    };
+  } catch (error) {
+    return {
+      type: 'failed',
+      error: error.message
+    };
+  }
+};
+
+/**
+ * Refresh access token using refresh token
+ * @param {string} refreshTokenValue - The refresh token
+ * @returns {Promise<Object>}
+ */
+const refreshToken = async (refreshTokenValue) => {
+  try {
+    const body = new URLSearchParams({
+      client_id: CLIENT_ID,
+      client_secret: CLIENT_SECRET,
+      grant_type: 'refresh_token',
+      refresh_token: refreshTokenValue
+    }).toString();
+    
+    const response = await makeRequest(TOKEN_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Accept': 'application/json'
+      },
+      body
+    });
+    
+    return {
+      type: 'success',
+      access: response.access_token,
+      refresh: refreshTokenValue, // Google doesn't always return new refresh token
+      expires: Date.now() + (response.expires_in * 1000)
+    };
+  } catch (error) {
+    return {
+      type: 'failed',
+      error: error.message
+    };
+  }
+};
+
+/**
+ * Get valid access token (refresh if expired)
+ * @param {Object} oauthData - OAuth data { access, refresh, expires }
+ * @returns {Promise<Object>}
+ */
+const getValidToken = async (oauthData) => {
+  if (!oauthData || !oauthData.refresh) {
+    return null;
+  }
+  
+  const expirationBuffer = 5 * 60 * 1000; // 5 minutes
+  if (oauthData.expires && oauthData.expires > Date.now() + expirationBuffer) {
+    return {
+      ...oauthData,
+      refreshed: false
+    };
+  }
+  
+  const result = await refreshToken(oauthData.refresh);
+  if (result.type === 'success') {
+    return {
+      access: result.access,
+      refresh: result.refresh,
+      expires: result.expires,
+      refreshed: true
+    };
+  }
+  
+  return null;
+};
+
+/**
+ * Check if credentials are OAuth tokens
+ */
+const isOAuthCredentials = (credentials) => {
+  return credentials && credentials.oauth && credentials.oauth.refresh;
+};
+
+module.exports = {
+  CLIENT_ID,
+  CLIENT_SECRET,
+  REDIRECT_URI,
+  CALLBACK_PORT: 8085,
+  SCOPES,
+  generateState,
+  authorize,
+  exchange,
+  refreshToken,
+  getValidToken,
+  isOAuthCredentials
+};