hedgequantx 2.6.105 → 2.6.107

package/package.json

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

package/src/menus/ai-agent.js

@@ -1029,17 +1029,65 @@ const setupProxyOAuth = async (provider, config) => {
   }
   console.log();
   
-  // Step 4: Wait for OAuth callback
+  // Step 4: Wait for OAuth callback (with manual fallback for VPS/remote)
   const waitSpinner = ora({ text: 'Waiting for authorization...', color: 'cyan' }).start();
   
+  let authSuccess = false;
+  
+  // First try: wait 45 seconds for automatic callback
   try {
-    await proxyManager.waitForAuth(authState, 300000, (status) => {
+    await proxyManager.waitForAuth(authState, 45000, (status) => {
       waitSpinner.text = status;
     });
+    authSuccess = true;
     waitSpinner.succeed('Authorization successful!');
   } catch (error) {
-    waitSpinner.fail(`Authorization failed: ${error.message}`);
-    await prompts.waitForEnter();
+    // Timeout - offer manual callback entry
+    if (error.message === 'Authentication timeout') {
+      waitSpinner.stop();
+      console.log();
+      console.log(chalk.yellow('  ⚠ Callback not received automatically.'));
+      console.log(chalk.gray('    If you\'re on a remote server (VPS), the callback cannot reach this machine.'));
+      console.log();
+      console.log(chalk.white('  After authorizing, you should see a page with URL like:'));
+      console.log(chalk.cyan('    http://localhost:54545/callback?code=xxx&state=yyy'));
+      console.log();
+      console.log(chalk.white('  Paste that full URL below (or press Enter to cancel):'));
+      console.log();
+      
+      const callbackUrl = await prompts.input('  Callback URL: ');
+      
+      if (callbackUrl && callbackUrl.trim()) {
+        const submitSpinner = ora({ text: 'Submitting callback...', color: 'cyan' }).start();
+        try {
+          await proxyManager.submitCallback(callbackUrl.trim());
+          submitSpinner.text = 'Verifying authorization...';
+          
+          // Wait a bit for the proxy to process the callback
+          await new Promise(resolve => setTimeout(resolve, 2000));
+          
+          // Verify auth status
+          await proxyManager.waitForAuth(authState, 10000, () => {});
+          authSuccess = true;
+          submitSpinner.succeed('Authorization successful!');
+        } catch (submitError) {
+          submitSpinner.fail(`Failed: ${submitError.message}`);
+          await prompts.waitForEnter();
+          return await selectProviderOption(provider);
+        }
+      } else {
+        console.log(chalk.gray('  Cancelled.'));
+        await prompts.waitForEnter();
+        return await selectProviderOption(provider);
+      }
+    } else {
+      waitSpinner.fail(`Authorization failed: ${error.message}`);
+      await prompts.waitForEnter();
+      return await selectProviderOption(provider);
+    }
+  }
+  
+  if (!authSuccess) {
     return await selectProviderOption(provider);
   }
   

package/src/pages/algo/ui.js

@@ -48,19 +48,19 @@ const LOG_ICONS = {
   win: '✔ WIN  ',
   loss: '✘ LOSS ',
   be: '★ BE   ',
-  entry: '➡ ENTRY ',
+  entry: '➡ ENTRY',
   filled: '✔ FILL ',
   connected: '✔ CONN ',
-  ready: '✔ READY ',
-  error: '✘ ERR  ',
-  reject: '✘ REJ  ',
+  ready: '✔ READY',
+  error: '✘ ERROR',
+  reject: '✘ REJCT',
   info: '➡ INFO ',
-  system: '★ SYS  ',
-  signal: '★ SIG  ',
-  trade: '✔ TRADE ',
-  success: '✔ OK   ',
-  warning: '⬅ WARN ',
-  analysis: '★ ANLYS '
+  system: '★ SYSTM',
+  signal: '★ SIGNL',
+  trade: '✔ TRADE',
+  success: '✔ SUCCS',
+  warning: '⬅ WARNG',
+  analysis: '★ ANLYS'
 };
 
 /**
@@ -365,12 +365,12 @@ class AlgoUI {
     } else {
       visible.forEach(log => {
         const color = LOG_COLORS[log.type] || chalk.gray;
-        const icon = LOG_ICONS[log.type] || 'INFO  ';
+        const icon = LOG_ICONS[log.type] || '➡ INFO ';
         // HF style: TIME | COLORED TYPE | MESSAGE with colored numbers
         const coloredIcon = color.bold(icon);
         // Color numbers: positive=cyan, negative=red, symbols=yellow
         const coloredMessage = colorizeMessage(log.message);
-        const line = ` ${chalk.gray(log.timestamp)} ${coloredIcon}${coloredMessage}`;
+        const line = ` ${chalk.gray(log.timestamp)} ${coloredIcon} ${coloredMessage}`;
         this._line(chalk.cyan(BOX.V) + fitToWidth(line, W) + chalk.cyan(BOX.V));
       });
       for (let i = visible.length; i < maxLogs; i++) {

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

@@ -530,6 +530,64 @@ const waitForAuth = async (state, timeoutMs = 300000, onStatus = () => {}) => {
   throw new Error('Authentication timeout');
 };
 
+/**
+ * Submit OAuth callback URL manually (for remote/VPS use)
+ * Extracts code and state from callback URL and submits to local proxy
+ * @param {string} callbackUrl - Full callback URL (http://localhost:54545/callback?code=xxx&state=yyy)
+ * @returns {Promise<boolean>}
+ */
+const submitCallback = async (callbackUrl) => {
+  // Parse the callback URL
+  let url;
+  try {
+    url = new URL(callbackUrl);
+  } catch (e) {
+    throw new Error('Invalid callback URL format');
+  }
+  
+  const code = url.searchParams.get('code');
+  const state = url.searchParams.get('state');
+  
+  if (!code || !state) {
+    throw new Error('Missing code or state in callback URL');
+  }
+  
+  // Submit to local callback server
+  return new Promise((resolve, reject) => {
+    const callbackPath = `/callback?code=${encodeURIComponent(code)}&state=${encodeURIComponent(state)}`;
+    
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port: 54545,
+      path: callbackPath,
+      method: 'GET',
+      timeout: 30000
+    }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        // Success if we get a redirect or success page
+        if (res.statusCode === 200 || res.statusCode === 302 || res.statusCode === 301) {
+          resolve(true);
+        } else {
+          reject(new Error(`Callback failed with status ${res.statusCode}`));
+        }
+      });
+    });
+    
+    req.on('error', (e) => {
+      reject(new Error(`Failed to submit callback: ${e.message}`));
+    });
+    
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Callback request timeout'));
+    });
+    
+    req.end();
+  });
+};
+
 /**
  * Get available models from the proxy
  * @returns {Promise<Array<string>>}
@@ -766,6 +824,7 @@ module.exports = {
   getAuthUrl,
   pollAuthStatus,
   waitForAuth,
+  submitCallback,
   getModels,
   getAuthFiles,
   chatCompletion,