hedgequantx 2.7.82 → 2.7.83

package/package.json

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

package/src/pages/ai-agents.js

@@ -104,6 +104,22 @@ const activateProvider = (config, providerId, data) => {
   Object.assign(config.providers[providerId], data, { active: true, configuredAt: new Date().toISOString() });
 };
 
+/** Wait for child process to exit */
+const waitForProcessExit = (childProcess, timeoutMs = 15000, intervalMs = 500) => {
+  return new Promise((resolve) => {
+    if (!childProcess) return resolve();
+    let elapsed = 0;
+    const checkInterval = setInterval(() => {
+      elapsed += intervalMs;
+      if (childProcess.exitCode !== null || childProcess.killed || elapsed >= timeoutMs) {
+        clearInterval(checkInterval);
+        if (elapsed >= timeoutMs) try { childProcess.kill(); } catch (e) { /* ignore */ }
+        resolve();
+      }
+    }, intervalMs);
+  });
+};
+
 /** Handle CLIProxy connection (with auto-install) */
 const handleCliProxyConnection = async (provider, config, boxWidth) => {
   console.log();
@@ -160,8 +176,6 @@ const handleCliProxyConnection = async (provider, config, boxWidth) => {
   
   const existingModels = await cliproxy.fetchProviderModels(provider.id);
   
-  // Debug output
-  console.log(chalk.gray(`  > RESULT: success=${existingModels.success}, models=${existingModels.models?.length || 0}, error=${existingModels.error || 'none'}`));
   
   if (existingModels.success && existingModels.models.length > 0) {
     // Models already available - skip OAuth, go directly to model selection
@@ -205,74 +219,67 @@ const handleCliProxyConnection = async (provider, config, boxWidth) => {
   console.log(chalk.cyan('\n  OPEN THIS URL IN YOUR BROWSER TO AUTHENTICATE:\n'));
   console.log(chalk.yellow(`  ${loginResult.url}\n`));
   
+  // Get callback port for this provider
+  const callbackPort = cliproxy.getCallbackPort(provider.id);
+  const isPollingAuth = (provider.id === 'qwen'); // Qwen uses polling, not callback
+  
   // 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('  1. OPEN THE URL ABOVE IN YOUR LOCAL BROWSER'));
-    console.log(chalk.white('  2. AUTHORIZE THE APPLICATION'));
-    console.log(chalk.white('  3. YOU WILL SEE A BLANK PAGE - THIS IS NORMAL'));
-    console.log(chalk.white('  4. COPY THE FULL URL FROM YOUR BROWSER ADDRESS BAR'));
-    console.log(chalk.white('     (IT STARTS WITH: http://localhost:' + cliproxy.CALLBACK_PORT + '/...)'));
-    console.log(chalk.white('  5. 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();
+    if (isPollingAuth) {
+      // Qwen uses polling - just wait for user to authorize
+      console.log(chalk.white('  1. OPEN THE URL ABOVE IN YOUR BROWSER'));
+      console.log(chalk.white('  2. AUTHORIZE THE APPLICATION'));
+      console.log(chalk.white('  3. WAIT FOR AUTHENTICATION TO COMPLETE'));
+      console.log(chalk.white('  4. PRESS ENTER WHEN DONE\n'));
       await prompts.waitForEnter();
-      return false;
-    }
-    
-    // Process the callback - send to the login process listening on CALLBACK_PORT
-    const spinner = ora({ text: 'PROCESSING CALLBACK...', color: 'yellow' }).start();
-    
-    try {
-      const callbackResult = await cliproxy.processCallback(callbackUrl.trim());
       
-      if (!callbackResult.success) {
-        spinner.fail(`CALLBACK FAILED: ${callbackResult.error}`);
+      const spinner = ora({ text: 'WAITING FOR AUTHENTICATION...', color: 'yellow' }).start();
+      await waitForProcessExit(loginResult.childProcess, 90000, 1000);
+      spinner.succeed('AUTHENTICATION COMPLETED!');
+    } else {
+      // Standard OAuth with callback
+      console.log(chalk.white('  1. OPEN THE URL ABOVE IN YOUR LOCAL BROWSER'));
+      console.log(chalk.white('  2. AUTHORIZE THE APPLICATION'));
+      console.log(chalk.white('  3. YOU WILL SEE A BLANK PAGE - THIS IS NORMAL'));
+      console.log(chalk.white('  4. COPY THE FULL URL FROM YOUR BROWSER ADDRESS BAR'));
+      console.log(chalk.white(`     (IT STARTS WITH: http://localhost:${callbackPort}/...)`));
+      console.log(chalk.white('  5. 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;
       }
       
-      spinner.text = 'EXCHANGING TOKEN...';
+      // Process the callback - send to the login process
+      const spinner = ora({ text: 'PROCESSING CALLBACK...', color: 'yellow' }).start();
       
-      // Wait for login process to exit naturally (it saves auth file then exits)
-      // Process typically exits 1-2 seconds after callback
-      await new Promise((resolve) => {
-        if (!loginResult.childProcess) return resolve();
+      try {
+        const callbackResult = await cliproxy.processCallback(callbackUrl.trim(), provider.id);
         
-        // Check every 500ms if process is still running, max 15s
-        let elapsed = 0;
-        const checkInterval = setInterval(() => {
-          elapsed += 500;
-          
-          // Check if process exited (exitCode is set when process exits)
-          if (loginResult.childProcess.exitCode !== null || loginResult.childProcess.killed) {
-            clearInterval(checkInterval);
-            resolve();
-            return;
-          }
-          
-          // Safety timeout after 15s
-          if (elapsed >= 15000) {
-            clearInterval(checkInterval);
-            try { loginResult.childProcess.kill(); } catch (e) { /* ignore */ }
-            resolve();
-          }
-        }, 500);
-      });
-      
-      spinner.succeed('AUTHENTICATION SUCCESSFUL!');
-    } catch (err) {
-      spinner.fail(`ERROR: ${err.message}`);
-      if (loginResult.childProcess) loginResult.childProcess.kill();
-      await prompts.waitForEnter();
-      return false;
+        if (!callbackResult.success) {
+          spinner.fail(`CALLBACK FAILED: ${callbackResult.error}`);
+          if (loginResult.childProcess) loginResult.childProcess.kill();
+          await prompts.waitForEnter();
+          return false;
+        }
+        
+        spinner.text = 'EXCHANGING TOKEN...';
+        await waitForProcessExit(loginResult.childProcess);
+        spinner.succeed('AUTHENTICATION SUCCESSFUL!');
+      } catch (err) {
+        spinner.fail(`ERROR: ${err.message}`);
+        if (loginResult.childProcess) loginResult.childProcess.kill();
+        await prompts.waitForEnter();
+        return false;
+      }
     }
     
   } else {
@@ -280,31 +287,8 @@ const handleCliProxyConnection = async (provider, config, boxWidth) => {
     console.log(chalk.gray('  AFTER AUTHENTICATING IN YOUR BROWSER, PRESS ENTER...'));
     await prompts.waitForEnter();
     
-    // Wait for login process to finish saving auth file
     const spinner = ora({ text: 'SAVING AUTHENTICATION...', color: 'yellow' }).start();
-    
-    await new Promise((resolve) => {
-      if (!loginResult.childProcess) return resolve();
-      
-      let elapsed = 0;
-      const checkInterval = setInterval(() => {
-        elapsed += 500;
-        
-        if (loginResult.childProcess.exitCode !== null || loginResult.childProcess.killed) {
-          clearInterval(checkInterval);
-          resolve();
-          return;
-        }
-        
-        // Safety timeout after 15s
-        if (elapsed >= 15000) {
-          clearInterval(checkInterval);
-          try { loginResult.childProcess.kill(); } catch (e) { /* ignore */ }
-          resolve();
-        }
-      }, 500);
-    });
-    
+    await waitForProcessExit(loginResult.childProcess);
     spinner.succeed('AUTHENTICATION SAVED');
   }
   

package/src/services/cliproxy/index.js

@@ -14,7 +14,8 @@ const {
   INSTALL_DIR,
   AUTH_DIR,
   DEFAULT_PORT,
-  CALLBACK_PORT,
+  CALLBACK_PORTS,
+  CALLBACK_PATHS,
   isInstalled,
   isHeadless,
   install,
@@ -23,6 +24,7 @@ const {
   stop,
   ensureRunning,
   getLoginUrl,
+  getCallbackPort,
   processCallback
 } = manager;
 
@@ -178,7 +180,8 @@ module.exports = {
   INSTALL_DIR,
   AUTH_DIR,
   DEFAULT_PORT,
-  CALLBACK_PORT,
+  CALLBACK_PORTS,
+  CALLBACK_PATHS,
   isInstalled,
   isHeadless,
   install,
@@ -187,6 +190,7 @@ module.exports = {
   stop,
   ensureRunning,
   getLoginUrl,
+  getCallbackPort,
   processCallback,
   
   // API

package/src/services/cliproxy/manager.js

@@ -26,104 +26,59 @@ const AUTH_DIR = path.join(os.homedir(), '.cli-proxy-api');
 
 // Default port
 const DEFAULT_PORT = 8317;
-const CALLBACK_PORT = 54545;
 
-/**
- * Detect if running in headless/VPS environment (no browser access)
- * @returns {boolean}
- */
+// OAuth callback ports per provider (from CLIProxyAPI)
+const CALLBACK_PORTS = {
+  anthropic: 54545,    // Claude: /callback
+  openai: 1455,        // Codex: /auth/callback
+  google: 8085,        // Gemini: /oauth2callback
+  qwen: null,          // Qwen uses polling, no callback
+  antigravity: 51121,  // Antigravity: /oauth-callback
+  iflow: 11451         // iFlow: /oauth2callback
+};
+
+// OAuth callback paths per provider
+const CALLBACK_PATHS = {
+  anthropic: '/callback',
+  openai: '/auth/callback',
+  google: '/oauth2callback',
+  qwen: null,
+  antigravity: '/oauth-callback',
+  iflow: '/oauth2callback'
+};
+
+/** Detect if running in headless/VPS environment (no browser access) */
 const isHeadless = () => {
-  // 1. SSH connection = definitely VPS/remote
-  if (process.env.SSH_CLIENT || process.env.SSH_TTY || process.env.SSH_CONNECTION) {
-    return true;
-  }
-  
-  // 2. Docker/container environment
-  if (process.env.DOCKER_CONTAINER || process.env.KUBERNETES_SERVICE_HOST) {
-    return true;
-  }
-  
-  // 3. Common CI/CD environments
-  if (process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI) {
-    return true;
-  }
-  
-  // 4. Check for display on Linux
+  // SSH/Docker/CI = headless
+  if (process.env.SSH_CLIENT || process.env.SSH_TTY || process.env.SSH_CONNECTION) return true;
+  if (process.env.DOCKER_CONTAINER || process.env.KUBERNETES_SERVICE_HOST) return true;
+  if (process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI) return true;
+  // Linux without display = headless
   if (process.platform === 'linux') {
-    // Has display = local with GUI
-    if (process.env.DISPLAY || process.env.WAYLAND_DISPLAY) {
-      return false;
-    }
-    // No display on Linux = likely headless/VPS
-    return true;
-  }
-  
-  // 5. macOS - check if running in terminal with GUI access
-  if (process.platform === 'darwin') {
-    // macOS always has GUI unless SSH (checked above)
-    return false;
-  }
-  
-  // 6. Windows - usually has GUI
-  if (process.platform === 'win32') {
-    return false;
+    return !(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
   }
-  
-  // Default: assume local
+  // macOS/Windows = local with GUI
   return false;
 };
 
-/**
- * Get download URL for current platform
- * @returns {Object} { url, filename } or null if unsupported
- */
+/** Get download URL for current platform */
 const getDownloadUrl = () => {
-  const platform = process.platform;
-  const arch = process.arch;
+  const platform = process.platform, arch = process.arch;
+  const osMap = { darwin: 'darwin', linux: 'linux', win32: 'windows' };
+  const extMap = { darwin: 'tar.gz', linux: 'tar.gz', win32: 'zip' };
+  const archMap = { x64: 'amd64', amd64: 'amd64', arm64: 'arm64' };
   
-  let osName, archName, ext;
-  
-  if (platform === 'darwin') {
-    osName = 'darwin';
-    ext = 'tar.gz';
-  } else if (platform === 'linux') {
-    osName = 'linux';
-    ext = 'tar.gz';
-  } else if (platform === 'win32') {
-    osName = 'windows';
-    ext = 'zip';
-  } else {
-    return null;
-  }
-  
-  if (arch === 'x64' || arch === 'amd64') {
-    archName = 'amd64';
-  } else if (arch === 'arm64') {
-    archName = 'arm64';
-  } else {
-    return null;
-  }
+  const osName = osMap[platform], ext = extMap[platform], archName = archMap[arch];
+  if (!osName || !archName) return null;
   
   const filename = `CLIProxyAPI_${CLIPROXY_VERSION}_${osName}_${archName}.${ext}`;
-  const url = `${GITHUB_RELEASE_BASE}/v${CLIPROXY_VERSION}/${filename}`;
-  
-  return { url, filename, ext };
-};
-
-/**
- * Check if CLIProxyAPI is installed
- * @returns {boolean}
- */
-const isInstalled = () => {
-  return fs.existsSync(BINARY_PATH);
+  return { url: `${GITHUB_RELEASE_BASE}/v${CLIPROXY_VERSION}/${filename}`, filename, ext };
 };
 
+/** Check if CLIProxyAPI is installed */
+const isInstalled = () => fs.existsSync(BINARY_PATH);
 
-/**
- * Install CLIProxyAPI
- * @param {Function} onProgress - Progress callback (message, percent)
- * @returns {Promise<Object>} { success, error }
- */
+/** Install CLIProxyAPI */
 const install = async (onProgress = null) => {
   try {
     const download = getDownloadUrl();
@@ -175,61 +130,39 @@ const install = async (onProgress = null) => {
   }
 };
 
-/**
- * Check if CLIProxyAPI is running
- * @returns {Promise<Object>} { running, pid }
- */
+/** Check if CLIProxyAPI is running */
 const isRunning = async () => {
-  // Check PID file
   if (fs.existsSync(PID_FILE)) {
     try {
       const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
-      // Check if process exists
       process.kill(pid, 0);
       return { running: true, pid };
-    } catch (e) {
-      // Process doesn't exist, clean up PID file
-      fs.unlinkSync(PID_FILE);
-    }
+    } catch (e) { fs.unlinkSync(PID_FILE); }
   }
-  
-  // Also check by trying to connect (accept 200, 401, 403 as "running")
   return new Promise((resolve) => {
     const req = http.get(`http://127.0.0.1:${DEFAULT_PORT}/v1/models`, (res) => {
-      const running = res.statusCode === 200 || res.statusCode === 401 || res.statusCode === 403;
-      resolve({ running, pid: null });
+      resolve({ running: [200, 401, 403].includes(res.statusCode), pid: null });
     });
     req.on('error', () => resolve({ running: false, pid: null }));
-    req.setTimeout(2000, () => {
-      req.destroy();
-      resolve({ running: false, pid: null });
-    });
+    req.setTimeout(2000, () => { req.destroy(); resolve({ running: false, pid: null }); });
   });
 };
 
-// Config file path
 const CONFIG_PATH = path.join(INSTALL_DIR, 'config.yaml');
 
-/**
- * Create or update config file
- */
+/** Create or update config file */
 const ensureConfig = () => {
-  // Always write config to ensure auth-dir is correct
-  const config = `# HQX CLIProxyAPI Config
+  fs.writeFileSync(CONFIG_PATH, `# HQX CLIProxyAPI Config
 host: "127.0.0.1"
 port: ${DEFAULT_PORT}
 auth-dir: "${AUTH_DIR}"
 debug: false
 api-keys:
   - "hqx-internal-key"
-`;
-  fs.writeFileSync(CONFIG_PATH, config);
+`);
 };
 
-/**
- * Start CLIProxyAPI
- * @returns {Promise<Object>} { success, error, pid }
- */
+/** Start CLIProxyAPI */
 const start = async () => {
   if (!isInstalled()) {
     return { success: false, error: 'CLIProxyAPI not installed', pid: null };
@@ -283,10 +216,7 @@ const start = async () => {
   }
 };
 
-/**
- * Stop CLIProxyAPI
- * @returns {Promise<Object>} { success, error }
- */
+/** Stop CLIProxyAPI */
 const stop = async () => {
   const status = await isRunning();
   if (!status.running) {
@@ -341,144 +271,76 @@ const stop = async () => {
   }
 };
 
-/**
- * Ensure CLIProxyAPI is installed and running
- * @param {Function} onProgress - Progress callback
- * @returns {Promise<Object>} { success, error }
- */
+/** Ensure CLIProxyAPI is installed and running */
 const ensureRunning = async (onProgress = null) => {
-  // Check if installed
   if (!isInstalled()) {
     if (onProgress) onProgress('Installing CLIProxyAPI...', 0);
     const installResult = await install(onProgress);
-    if (!installResult.success) {
-      return installResult;
-    }
+    if (!installResult.success) return installResult;
   }
-  
-  // Check if running
   const status = await isRunning();
-  if (status.running) {
-    return { success: true, error: null };
-  }
-  
-  // Start
+  if (status.running) return { success: true, error: null };
   if (onProgress) onProgress('Starting CLIProxyAPI...', 100);
   return start();
 };
 
-/**
- * Get OAuth login URL for a provider
- * @param {string} provider - Provider ID (anthropic, openai, google, etc.)
- * @returns {Promise<Object>} { success, url, childProcess, isHeadless, error }
- */
+/** Get OAuth login URL for a provider */
 const getLoginUrl = async (provider) => {
-  // CLIProxyAPI login flags per provider (from --help)
   const providerFlags = {
-    anthropic: '-claude-login',    // Claude Code
-    openai: '-codex-login',        // OpenAI Codex
-    google: '-login',              // Gemini CLI (Google Account)
-    qwen: '-qwen-login',           // Qwen Code
-    antigravity: '-antigravity-login',  // Antigravity
-    iflow: '-iflow-login'          // iFlow
+    anthropic: '-claude-login', openai: '-codex-login', google: '-login',
+    qwen: '-qwen-login', antigravity: '-antigravity-login', iflow: '-iflow-login'
   };
-  
   const flag = providerFlags[provider];
-  if (!flag) {
-    return { success: false, url: null, childProcess: null, isHeadless: false, error: 'Provider not supported for OAuth' };
-  }
+  if (!flag) return { success: false, url: null, childProcess: null, isHeadless: false, error: 'Provider not supported for OAuth' };
   
   const headless = isHeadless();
-  
-  // For headless/VPS, use -no-browser flag only (don't pass config to avoid port conflict)
   return new Promise((resolve) => {
-    const args = [flag, '-no-browser'];
-    const child = spawn(BINARY_PATH, args, {
-      cwd: INSTALL_DIR
-    });
-    
-    let output = '';
-    let resolved = false;
+    const child = spawn(BINARY_PATH, [flag, '-no-browser'], { cwd: INSTALL_DIR });
+    let output = '', 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();
-    });
-    
-    child.on('error', (err) => {
-      if (!resolved) {
-        resolved = true;
-        resolve({ success: false, url: null, childProcess: null, isHeadless: headless, error: err.message });
-      }
-    });
-    
-    child.on('close', (code) => {
-      if (!resolved) {
-        resolved = true;
-        resolve({ success: false, url: null, childProcess: null, isHeadless: headless, error: `Process exited with code ${code}` });
-      }
-    });
+    child.stdout.on('data', (data) => { output += data.toString(); checkForUrl(); });
+    child.stderr.on('data', (data) => { output += data.toString(); checkForUrl(); });
+    child.on('error', (err) => { if (!resolved) { resolved = true; resolve({ success: false, url: null, childProcess: null, isHeadless: headless, error: err.message }); }});
+    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) => {
+/** Get callback port for a provider */
+const getCallbackPort = (provider) => CALLBACK_PORTS[provider] || null;
+
+/** Process OAuth callback URL manually (for VPS/headless) */
+const processCallback = (callbackUrl, provider = 'anthropic') => {
   return new Promise((resolve) => {
     try {
-      // Parse the callback URL
       const url = new URL(callbackUrl);
-      const params = url.searchParams;
+      const urlPort = url.port || (url.protocol === 'https:' ? 443 : 80);
+      const urlPath = url.pathname + url.search;
+      const expectedPort = CALLBACK_PORTS[provider];
       
-      // Extract query string to forward
-      const queryString = url.search;
+      if (!expectedPort) { resolve({ success: true, error: null }); return; } // Qwen uses polling
       
-      // Make request to local callback endpoint
-      const callbackPath = `/callback${queryString}`;
-      
-      const req = http.get(`http://127.0.0.1:${CALLBACK_PORT}${callbackPath}`, (res) => {
+      const targetPort = parseInt(urlPort) || expectedPort;
+      const req = http.get(`http://127.0.0.1:${targetPort}${urlPath}`, (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}` });
-          }
+          resolve(res.statusCode === 200 || res.statusCode === 302 
+            ? { success: true, error: null } 
+            : { 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}` });
-    }
+      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}` }); }
   });
 };
 
@@ -488,7 +350,8 @@ module.exports = {
   BINARY_PATH,
   AUTH_DIR,
   DEFAULT_PORT,
-  CALLBACK_PORT,
+  CALLBACK_PORTS,
+  CALLBACK_PATHS,
   getDownloadUrl,
   isInstalled,
   isHeadless,
@@ -498,5 +361,6 @@ module.exports = {
   stop,
   ensureRunning,
   getLoginUrl,
+  getCallbackPort,
   processCallback
 };