hedgequantx 2.6.161 → 2.6.162

package/package.json

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

package/src/menus/ai-agent-connect.js

@@ -0,0 +1,181 @@
+/**
+ * AI Agent Connection Setup
+ * @module menus/ai-agent-connect
+ * 
+ * Credential collection and connection validation flow.
+ */
+
+const chalk = require('chalk');
+const ora = require('ora');
+
+const { drawBoxHeaderContinue, drawBoxFooter, displayBanner } = require('../ui');
+const { prompts } = require('../utils');
+const aiService = require('../services/ai');
+const { makeLine, getBoxDimensions } = require('./ai-agent-ui');
+
+/**
+ * Get instructions for each credential type
+ */
+const getCredentialInstructions = (provider, option, field) => {
+  const instructions = {
+    apiKey: {
+      title: 'API KEY REQUIRED',
+      steps: ['1. CLICK THE LINK BELOW TO OPEN IN BROWSER', '2. SIGN IN OR CREATE AN ACCOUNT', '3. GENERATE A NEW API KEY', '4. COPY AND PASTE IT HERE']
+    },
+    sessionKey: {
+      title: 'SESSION KEY REQUIRED (SUBSCRIPTION PLAN)',
+      steps: ['1. OPEN THE LINK BELOW IN YOUR BROWSER', '2. SIGN IN WITH YOUR SUBSCRIPTION ACCOUNT', '3. OPEN DEVELOPER TOOLS (F12 OR CMD+OPT+I)', '4. GO TO APPLICATION > COOKIES', '5. FIND "sessionKey" OR SIMILAR TOKEN', '6. COPY THE VALUE AND PASTE IT HERE']
+    },
+    accessToken: {
+      title: 'ACCESS TOKEN REQUIRED (SUBSCRIPTION PLAN)',
+      steps: ['1. OPEN THE LINK BELOW IN YOUR BROWSER', '2. SIGN IN WITH YOUR SUBSCRIPTION ACCOUNT', '3. OPEN DEVELOPER TOOLS (F12 OR CMD+OPT+I)', '4. GO TO APPLICATION > COOKIES OR LOCAL STORAGE', '5. FIND "accessToken" OR "token"', '6. COPY THE VALUE AND PASTE IT HERE']
+    },
+    endpoint: {
+      title: 'ENDPOINT URL',
+      steps: ['1. ENTER THE API ENDPOINT URL', '2. USUALLY http://localhost:PORT FOR LOCAL']
+    },
+    model: {
+      title: 'MODEL NAME',
+      steps: ['1. ENTER THE MODEL NAME TO USE', '2. CHECK PROVIDER DOCS FOR AVAILABLE MODELS']
+    }
+  };
+  
+  return instructions[field] || { title: field.toUpperCase(), steps: [] };
+};
+
+/**
+ * Collect credentials from user
+ */
+const collectCredentials = async (provider, option, onBack) => {
+  const { boxWidth, W } = getBoxDimensions();
+  const credentials = {};
+  
+  for (const field of option.fields) {
+    console.clear();
+    displayBanner();
+    drawBoxHeaderContinue(`CONNECT TO ${provider.name}`, boxWidth);
+    
+    const instructions = getCredentialInstructions(provider, option, field);
+    
+    console.log(makeLine(W, chalk.yellow(instructions.title)));
+    console.log(makeLine(W, ''));
+    
+    for (const step of instructions.steps) {
+      console.log(makeLine(W, chalk.white(step)));
+    }
+    
+    console.log(makeLine(W, ''));
+    
+    if (option.url && (field === 'apiKey' || field === 'sessionKey' || field === 'accessToken')) {
+      console.log(makeLine(W, chalk.cyan('GET KEY: ') + chalk.white(option.url)));
+    }
+    
+    if (field === 'endpoint' && option.defaultEndpoint) {
+      console.log(makeLine(W, chalk.white(`DEFAULT: ${option.defaultEndpoint}`)));
+    }
+    
+    console.log(makeLine(W, ''));
+    console.log(makeLine(W, chalk.white('TYPE < TO GO BACK')));
+    
+    drawBoxFooter(boxWidth);
+    console.log();
+    
+    let value;
+    
+    switch (field) {
+      case 'apiKey':
+        value = await prompts.textInput(chalk.cyan('PASTE API KEY:'));
+        if (!value || value.trim() === '<' || value.trim() === '') return null;
+        credentials.apiKey = value.trim();
+        break;
+      case 'sessionKey':
+        value = await prompts.textInput(chalk.cyan('PASTE SESSION KEY:'));
+        if (!value || value.trim() === '<' || value.trim() === '') return null;
+        credentials.sessionKey = value.trim();
+        break;
+      case 'accessToken':
+        value = await prompts.textInput(chalk.cyan('PASTE ACCESS TOKEN:'));
+        if (!value || value.trim() === '<' || value.trim() === '') return null;
+        credentials.accessToken = value.trim();
+        break;
+      case 'endpoint':
+        const defaultEndpoint = option.defaultEndpoint || '';
+        value = await prompts.textInput(chalk.cyan(`ENDPOINT [${defaultEndpoint || 'required'}]:`));
+        if (!value || value.trim() === '<' || value.trim() === '') {
+          if (!defaultEndpoint) return null;
+        }
+        credentials.endpoint = (value && value.trim() !== '<' ? value : defaultEndpoint).trim();
+        if (!credentials.endpoint) return null;
+        break;
+      case 'model':
+        value = await prompts.textInput(chalk.cyan('MODEL NAME:'));
+        if (!value || value.trim() === '<' || value.trim() === '') return null;
+        credentials.model = value.trim();
+        break;
+    }
+  }
+  
+  return credentials;
+};
+
+/**
+ * Validate connection and fetch models
+ */
+const validateAndFetchModels = async (provider, option, credentials) => {
+  console.log();
+  const spinner = ora({ text: 'VALIDATING CONNECTION...', color: 'cyan' }).start();
+  
+  const validation = await aiService.validateConnection(provider.id, option.id, credentials);
+  
+  if (!validation.valid) {
+    spinner.fail(`CONNECTION FAILED: ${validation.error}`);
+    return { valid: false, error: validation.error };
+  }
+  
+  spinner.text = 'FETCHING AVAILABLE MODELS...';
+  
+  // Fetch models from real API
+  const { fetchAnthropicModels, fetchGeminiModels, fetchOpenAIModels } = require('../services/ai/client');
+  
+  let models = null;
+  if (provider.id === 'anthropic') {
+    models = await fetchAnthropicModels(credentials.apiKey);
+  } else if (provider.id === 'gemini') {
+    models = await fetchGeminiModels(credentials.apiKey);
+  } else {
+    const endpoint = credentials.endpoint || provider.endpoint;
+    models = await fetchOpenAIModels(endpoint, credentials.apiKey);
+  }
+  
+  if (!models || models.length === 0) {
+    spinner.fail('COULD NOT FETCH MODELS FROM API');
+    console.log(chalk.white('  Check your API key or network connection.'));
+    return { valid: false, error: 'No models found' };
+  }
+  
+  spinner.succeed(`FOUND ${models.length} MODELS`);
+  return { valid: true, models };
+};
+
+/**
+ * Add agent after successful connection
+ */
+const addConnectedAgent = async (provider, option, credentials, selectedModel) => {
+  try {
+    await aiService.addAgent(provider.id, option.id, credentials, selectedModel, provider.name);
+    
+    console.log(chalk.green(`\n  AGENT ADDED: ${provider.name}`));
+    console.log(chalk.white(`  MODEL: ${selectedModel}`));
+    return true;
+  } catch (error) {
+    console.log(chalk.red(`\n  FAILED TO SAVE: ${error.message}`));
+    return false;
+  }
+};
+
+module.exports = {
+  getCredentialInstructions,
+  collectCredentials,
+  validateAndFetchModels,
+  addConnectedAgent,
+};

package/src/menus/ai-agent-models.js

@@ -0,0 +1,219 @@
+/**
+ * AI Agent Model Selection
+ * Model selection and management for AI agents
+ */
+
+const chalk = require('chalk');
+
+const { displayBanner, drawBoxHeaderContinue, drawBoxFooter } = require('../ui');
+const { prompts } = require('../utils');
+const aiService = require('../services/ai');
+const { makeLine, getBoxDimensions } = require('./ai-agent-ui');
+
+/**
+ * Select model from a list (used when adding new agent)
+ * @param {Array} models - Array of model IDs from API
+ * @param {string} providerName - Provider name for display
+ * @returns {string|null} Selected model ID or null if cancelled
+ * 
+ * Data source: models array comes from provider API (/v1/models)
+ */
+const selectModelFromList = async (models, providerName) => {
+  const { boxWidth, W } = getBoxDimensions();
+  
+  console.clear();
+  displayBanner();
+  drawBoxHeaderContinue(`SELECT MODEL - ${providerName}`, boxWidth);
+  
+  if (!models || models.length === 0) {
+    console.log(makeLine(W, chalk.red('NO MODELS AVAILABLE')));
+    console.log(makeLine(W, chalk.white('[<] BACK')));
+    drawBoxFooter(boxWidth);
+    await prompts.waitForEnter();
+    return null;
+  }
+  
+  // Sort models (newest first)
+  const sortedModels = [...models].sort((a, b) => b.localeCompare(a));
+  
+  // Display models in 2 columns
+  const rows = Math.ceil(sortedModels.length / 2);
+  const colWidth = Math.floor((W - 4) / 2);
+  
+  for (let i = 0; i < rows; i++) {
+    const leftIndex = i;
+    const rightIndex = i + rows;
+    
+    // Left column
+    const leftModel = sortedModels[leftIndex];
+    const leftNum = chalk.cyan(`[${leftIndex + 1}]`);
+    const leftName = leftModel.length > colWidth - 6 
+      ? leftModel.substring(0, colWidth - 9) + '...' 
+      : leftModel;
+    const leftText = `${leftNum} ${chalk.yellow(leftName)}`;
+    const leftPlain = `[${leftIndex + 1}] ${leftName}`;
+    
+    // Right column (if exists)
+    let rightText = '';
+    let rightPlain = '';
+    if (rightIndex < sortedModels.length) {
+      const rightModel = sortedModels[rightIndex];
+      const rightNum = chalk.cyan(`[${rightIndex + 1}]`);
+      const rightName = rightModel.length > colWidth - 6 
+        ? rightModel.substring(0, colWidth - 9) + '...' 
+        : rightModel;
+      rightText = `${rightNum} ${chalk.yellow(rightName)}`;
+      rightPlain = `[${rightIndex + 1}] ${rightName}`;
+    }
+    
+    // Pad left column and combine
+    const leftPadding = colWidth - leftPlain.length;
+    const line = leftText + ' '.repeat(Math.max(2, leftPadding)) + rightText;
+    console.log(makeLine(W, line));
+  }
+  
+  console.log(makeLine(W, ''));
+  console.log(makeLine(W, chalk.white('[<] BACK')));
+  
+  drawBoxFooter(boxWidth);
+  
+  const choice = await prompts.textInput(chalk.cyan('SELECT MODEL:'));
+  
+  // Empty input or < = go back
+  if (!choice || choice.trim() === '' || choice === '<' || choice?.toLowerCase() === 'b') {
+    return null;
+  }
+  
+  const index = parseInt(choice) - 1;
+  if (isNaN(index) || index < 0 || index >= sortedModels.length) {
+    return await selectModelFromList(models, providerName);
+  }
+  
+  return sortedModels[index];
+};
+
+/**
+ * Select/change model for an existing agent
+ * Fetches available models from the provider's API
+ * @param {Object} agent - Agent object
+ * @param {Function} aiAgentMenuFn - Callback to return to main menu
+ */
+const selectModel = async (agent, aiAgentMenuFn) => {
+  const { boxWidth, W } = getBoxDimensions();
+  
+  console.clear();
+  displayBanner();
+  drawBoxHeaderContinue(`SELECT MODEL - ${agent.name}`, boxWidth);
+  
+  console.log(makeLine(W, chalk.white('FETCHING AVAILABLE MODELS FROM API...')));
+  drawBoxFooter(boxWidth);
+  
+  // Fetch models from real API
+  const { fetchAnthropicModels, fetchAnthropicModelsOAuth, fetchGeminiModels, fetchOpenAIModels } = require('../services/ai/client');
+  
+  let models = null;
+  const agentCredentials = aiService.getAgentCredentials(agent.id);
+  
+  if (agent.providerId === 'anthropic') {
+    const token = agentCredentials?.apiKey || agentCredentials?.accessToken || agentCredentials?.sessionKey;
+    const isOAuthToken = agentCredentials?.oauth?.access || (token && token.startsWith('sk-ant-oat'));
+    
+    if (isOAuthToken) {
+      const accessToken = agentCredentials?.oauth?.access || token;
+      models = await fetchAnthropicModelsOAuth(accessToken);
+    } else {
+      models = await fetchAnthropicModels(token);
+    }
+  } else if (agent.providerId === 'gemini') {
+    models = await fetchGeminiModels(agentCredentials?.apiKey);
+  } else {
+    const endpoint = agentCredentials?.endpoint || agent.provider?.endpoint;
+    models = await fetchOpenAIModels(endpoint, agentCredentials?.apiKey);
+  }
+  
+  // Redraw with results
+  console.clear();
+  displayBanner();
+  drawBoxHeaderContinue(`SELECT MODEL - ${agent.name}`, boxWidth);
+  
+  if (!models || models.length === 0) {
+    console.log(makeLine(W, chalk.red('COULD NOT FETCH MODELS FROM API')));
+    console.log(makeLine(W, chalk.white('Check your API key or network connection.')));
+    console.log(makeLine(W, ''));
+    console.log(makeLine(W, chalk.white('[<] BACK')));
+    drawBoxFooter(boxWidth);
+    
+    await prompts.waitForEnter();
+    return await aiAgentMenuFn();
+  }
+  
+  // Sort models (newest first typically)
+  models.sort((a, b) => b.localeCompare(a));
+  
+  // Display models in 2 columns
+  const rows = Math.ceil(models.length / 2);
+  const colWidth = Math.floor((W - 4) / 2);
+  
+  for (let i = 0; i < rows; i++) {
+    const leftIndex = i;
+    const rightIndex = i + rows;
+    
+    // Left column
+    const leftModel = models[leftIndex];
+    const leftNum = chalk.cyan(`[${leftIndex + 1}]`);
+    const leftCurrent = leftModel === agent.model ? chalk.green(' *') : '';
+    const leftName = leftModel.length > colWidth - 8 
+      ? leftModel.substring(0, colWidth - 11) + '...' 
+      : leftModel;
+    const leftText = `${leftNum} ${chalk.yellow(leftName)}${leftCurrent}`;
+    const leftPlain = `[${leftIndex + 1}] ${leftName}${leftModel === agent.model ? ' *' : ''}`;
+    
+    // Right column (if exists)
+    let rightText = '';
+    let rightPlain = '';
+    if (rightIndex < models.length) {
+      const rightModel = models[rightIndex];
+      const rightNum = chalk.cyan(`[${rightIndex + 1}]`);
+      const rightCurrent = rightModel === agent.model ? chalk.green(' *') : '';
+      const rightName = rightModel.length > colWidth - 8 
+        ? rightModel.substring(0, colWidth - 11) + '...' 
+        : rightModel;
+      rightText = `${rightNum} ${chalk.yellow(rightName)}${rightCurrent}`;
+      rightPlain = `[${rightIndex + 1}] ${rightName}${rightModel === agent.model ? ' *' : ''}`;
+    }
+    
+    // Pad left column and combine
+    const leftPadding = colWidth - leftPlain.length;
+    const line = leftText + ' '.repeat(Math.max(2, leftPadding)) + rightText;
+    console.log(makeLine(W, line));
+  }
+  
+  console.log(makeLine(W, ''));
+  console.log(makeLine(W, chalk.white('[<] BACK') + chalk.white('                                        * = CURRENT')));
+  
+  drawBoxFooter(boxWidth);
+  
+  const choice = await prompts.textInput(chalk.cyan('SELECT MODEL:'));
+  
+  // Empty input or < = go back
+  if (!choice || choice.trim() === '' || choice === '<' || choice?.toLowerCase() === 'b') {
+    return await aiAgentMenuFn();
+  }
+  
+  const index = parseInt(choice) - 1;
+  if (isNaN(index) || index < 0 || index >= models.length) {
+    return await selectModel(agent, aiAgentMenuFn);
+  }
+  
+  const selectedModel = models[index];
+  aiService.updateAgent(agent.id, { model: selectedModel });
+  
+  console.log(chalk.green(`\n  MODEL CHANGED TO: ${selectedModel}`));
+  await prompts.waitForEnter();
+  return await aiAgentMenuFn();
+};
+
+module.exports = {
+  selectModelFromList,
+  selectModel
+};

package/src/menus/ai-agent-oauth.js

@@ -0,0 +1,292 @@
+/**
+ * AI Agent OAuth Flows
+ * OAuth authentication handling for AI providers via CLIProxyAPI
+ */
+
+const chalk = require('chalk');
+const ora = require('ora');
+
+const { displayBanner, drawBoxHeaderContinue, drawBoxFooter } = require('../ui');
+const { prompts } = require('../utils');
+const aiService = require('../services/ai');
+const proxyManager = require('../services/ai/proxy-manager');
+const { makeLine, getBoxDimensions, openBrowser, isRemoteEnvironment } = require('./ai-agent-ui');
+
+/**
+ * Get OAuth config for provider
+ * @param {string} providerId - Provider identifier
+ * @returns {Object|undefined} OAuth configuration
+ */
+const getOAuthConfig = (providerId) => {
+  const configs = {
+    anthropic: {
+      name: 'CLAUDE PRO/MAX',
+      accountName: 'Claude',
+      optionId: 'oauth_max',
+      agentName: 'Claude Pro/Max'
+    },
+    openai: {
+      name: 'CHATGPT PLUS/PRO',
+      accountName: 'ChatGPT',
+      optionId: 'oauth_plus',
+      agentName: 'ChatGPT Plus/Pro'
+    },
+    gemini: {
+      name: 'GEMINI ADVANCED',
+      accountName: 'Google',
+      optionId: 'oauth_advanced',
+      agentName: 'Gemini Advanced'
+    },
+    qwen: {
+      name: 'QWEN CHAT',
+      accountName: 'Qwen',
+      optionId: 'oauth_chat',
+      agentName: 'Qwen Chat'
+    },
+    iflow: {
+      name: 'IFLOW',
+      accountName: 'iFlow',
+      optionId: 'oauth_sub',
+      agentName: 'iFlow'
+    }
+  };
+  return configs[providerId];
+};
+
+/**
+ * Setup OAuth connection for any provider with OAuth support
+ * Uses CLIProxyAPI for proper OAuth handling and API access
+ * @param {Object} provider - Provider object
+ * @param {Function} selectProviderOptionFn - Callback to return to provider selection
+ * @param {Function} selectModelFromListFn - Callback to select model
+ * @param {Function} aiAgentMenuFn - Callback to return to main menu
+ */
+const setupOAuthConnection = async (provider, selectProviderOptionFn, selectModelFromListFn, aiAgentMenuFn) => {
+  const config = getOAuthConfig(provider.id);
+  if (!config) {
+    console.log(chalk.red('OAuth not supported for this provider'));
+    await prompts.waitForEnter();
+    return await selectProviderOptionFn(provider);
+  }
+  
+  const { boxWidth, W } = getBoxDimensions();
+  
+  // 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 selectProviderOptionFn(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 selectProviderOptionFn(provider);
+  }
+  
+  // Step 3: Show instructions to user
+  console.clear();
+  displayBanner();
+  drawBoxHeaderContinue(`CONNECT ${config.name}`, boxWidth);
+  
+  console.log(makeLine(W, chalk.yellow('CONNECT YOUR ACCOUNT')));
+  console.log(makeLine(W, ''));
+  console.log(makeLine(W, chalk.white('1. OPEN THE LINK BELOW IN YOUR BROWSER')));
+  console.log(makeLine(W, ''));
+  console.log(makeLine(W, chalk.white(`2. LOGIN WITH YOUR ${config.accountName.toUpperCase()} ACCOUNT`)));
+  console.log(makeLine(W, ''));
+  console.log(makeLine(W, chalk.white('3. CLICK "AUTHORIZE"')));
+  console.log(makeLine(W, ''));
+  console.log(makeLine(W, chalk.green('4. WAIT FOR CONFIRMATION HERE')));
+  console.log(makeLine(W, chalk.white('   (The page will close automatically)')));
+  console.log(makeLine(W, ''));
+  
+  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 isRemote = isRemoteEnvironment();
+  let authSuccess = false;
+  
+  if (isRemote) {
+    // Remote/VPS: Ask for callback URL directly
+    authSuccess = await handleRemoteOAuth(provider, selectProviderOptionFn);
+  } else {
+    // Local: Wait for automatic callback
+    authSuccess = await handleLocalOAuth(authState, selectProviderOptionFn, provider);
+  }
+  
+  if (!authSuccess) {
+    return await selectProviderOptionFn(provider);
+  }
+  
+  // Step 5: Fetch and select model, save agent
+  return await completeOAuthSetup(provider, config, selectProviderOptionFn, selectModelFromListFn, aiAgentMenuFn);
+};
+
+/**
+ * Handle OAuth callback for remote/VPS environment
+ */
+const handleRemoteOAuth = async (provider, selectProviderOptionFn) => {
+  console.log(chalk.yellow('  After authorizing, paste the callback URL from your browser:'));
+  console.log(chalk.gray('  (The page showing http://localhost:54545/callback?code=...)'));
+  console.log();
+  
+  const inquirer = require('inquirer');
+  let callbackUrl = '';
+  try {
+    const result = await inquirer.prompt([{
+      type: 'input',
+      name: 'callbackUrl',
+      message: 'Callback URL:',
+      prefix: ' '
+    }]);
+    callbackUrl = result.callbackUrl || '';
+  } catch (e) {
+    const readline = require('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    callbackUrl = await new Promise(resolve => {
+      rl.question('  Callback URL: ', answer => {
+        rl.close();
+        resolve(answer || '');
+      });
+    });
+  }
+  
+  if (!callbackUrl || !callbackUrl.trim()) {
+    console.log(chalk.gray('  Cancelled.'));
+    await prompts.waitForEnter();
+    return false;
+  }
+  
+  const submitSpinner = ora({ text: 'Submitting callback...', color: 'cyan' }).start();
+  try {
+    await proxyManager.submitCallback(callbackUrl.trim(), provider.id);
+    await new Promise(resolve => setTimeout(resolve, 500));
+    submitSpinner.succeed('Authorization successful!');
+    return true;
+  } catch (submitError) {
+    submitSpinner.fail(`Failed: ${submitError.message}`);
+    await prompts.waitForEnter();
+    return false;
+  }
+};
+
+/**
+ * Handle OAuth callback for local environment
+ */
+const handleLocalOAuth = async (authState, selectProviderOptionFn, provider) => {
+  const waitSpinner = ora({ text: 'Waiting for authorization...', color: 'cyan' }).start();
+  
+  try {
+    await proxyManager.waitForAuth(authState, 300000, (status) => {
+      waitSpinner.text = status;
+    });
+    waitSpinner.succeed('Authorization successful!');
+    return true;
+  } catch (error) {
+    waitSpinner.fail(`Authorization failed: ${error.message}`);
+    await prompts.waitForEnter();
+    return false;
+  }
+};
+
+/**
+ * Complete OAuth setup: fetch models and save agent
+ */
+const completeOAuthSetup = async (provider, config, selectProviderOptionFn, selectModelFromListFn, aiAgentMenuFn) => {
+  try {
+    // Fetch models from CLIProxyAPI
+    const modelSpinner = ora({ text: 'Fetching available models from API...', color: 'cyan' }).start();
+    
+    let models = [];
+    try {
+      models = await proxyManager.getModels(provider.id);
+      modelSpinner.succeed(`Found ${models.length} models for ${provider.name}`);
+    } catch (error) {
+      modelSpinner.fail(`Failed to fetch models: ${error.message}`);
+      await prompts.waitForEnter();
+      return await selectProviderOptionFn(provider);
+    }
+    
+    if (!models || models.length === 0) {
+      console.log();
+      console.log(chalk.red('  ERROR: No models found for this provider'));
+      console.log(chalk.gray('  Make sure your subscription is active and authorization completed.'));
+      console.log();
+      await prompts.waitForEnter();
+      return await selectProviderOptionFn(provider);
+    }
+    
+    // Let user select model
+    const selectedModel = await selectModelFromListFn(models, config.name);
+    if (!selectedModel) {
+      return await selectProviderOptionFn(provider);
+    }
+    
+    // Save agent config
+    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 aiAgentMenuFn();
+  } catch (unexpectedError) {
+    console.log();
+    console.log(chalk.red(`  UNEXPECTED ERROR: ${unexpectedError.message}`));
+    console.log(chalk.gray(`  Stack: ${unexpectedError.stack}`));
+    console.log();
+    await prompts.waitForEnter();
+    return await selectProviderOptionFn(provider);
+  }
+};
+
+module.exports = {
+  getOAuthConfig,
+  setupOAuthConnection
+};