hedgequantx 2.7.22 → 2.7.23

package/package.json

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

package/src/pages/ai-agents-ui.js

@@ -60,14 +60,40 @@ const draw2ColTable = (title, titleColor, items, backText, W) => {
  * @param {Array} providers - List of AI providers
  * @param {Object} config - Current config
  * @param {number} boxWidth - Box width
+ * @param {string} cliproxyUrl - Current CLIProxy URL (optional)
  */
-const drawProvidersTable = (providers, config, boxWidth) => {
+const drawProvidersTable = (providers, config, boxWidth, cliproxyUrl = null) => {
   const W = boxWidth - 2;
+  
+  console.log(chalk.cyan('╔' + '═'.repeat(W) + '╗'));
+  console.log(chalk.cyan('║') + chalk.yellow.bold(centerText('AI AGENTS CONFIGURATION', W)) + chalk.cyan('║'));
+  
+  // Show CLIProxy URL if provided
+  if (cliproxyUrl) {
+    console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
+    const proxyText = chalk.gray('CLIProxy: ') + chalk.cyan(cliproxyUrl);
+    console.log(chalk.cyan('║') + centerText(proxyText, W) + chalk.cyan('║'));
+  }
+  
+  console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
+  
   const items = providers.map((p, i) => {
     const status = config.providers[p.id]?.active ? chalk.green(' ●') : '';
     return chalk.cyan(`[${i + 1}]`) + ' ' + chalk[p.color](p.name) + status;
   });
-  draw2ColTable('AI AGENTS CONFIGURATION', chalk.yellow.bold, items, '[B] Back to Menu', W);
+  
+  const rows = Math.ceil(items.length / 2);
+  for (let row = 0; row < rows; row++) {
+    const left = items[row];
+    const right = items[row + rows];
+    draw2ColRow(left || '', right || '', W);
+  }
+  
+  console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
+  console.log(chalk.cyan('║') + chalk.gray(centerText('[C] Configure CLIProxy URL', W)) + chalk.cyan('║'));
+  console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
+  console.log(chalk.cyan('║') + chalk.red(centerText('[B] Back to Menu', W)) + chalk.cyan('║'));
+  console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
 };
 
 /**

package/src/pages/ai-agents.js

@@ -15,7 +15,7 @@ const { getLogoWidth } = require('../ui');
 const { prompts } = require('../utils');
 const { fetchModelsFromApi } = require('./ai-models');
 const { drawProvidersTable, drawModelsTable, drawProviderWindow } = require('./ai-agents-ui');
-const { isCliProxyRunning, fetchModelsFromCliProxy, getOAuthUrl, checkOAuthStatus } = require('../services/cliproxy');
+const { isCliProxyRunning, fetchModelsFromCliProxy, getOAuthUrl, checkOAuthStatus, getCliProxyUrl, setCliProxyUrl, DEFAULT_CLIPROXY_URL } = require('../services/cliproxy');
 
 // Config file path
 const CONFIG_DIR = path.join(os.homedir(), '.hqx');
@@ -101,18 +101,63 @@ const activateProvider = (config, providerId, data) => {
 /** Handle CLIProxy connection */
 const handleCliProxyConnection = async (provider, config, boxWidth) => {
   console.log();
-  const spinner = ora({ text: 'Checking CLIProxy status...', color: 'yellow' }).start();
-  const proxyStatus = await isCliProxyRunning();
+  const currentUrl = getCliProxyUrl();
+  const spinner = ora({ text: `Checking CLIProxy at ${currentUrl}...`, color: 'yellow' }).start();
+  let proxyStatus = await isCliProxyRunning();
   
   if (!proxyStatus.running) {
-    spinner.fail('CLIProxy is not running');
-    console.log(chalk.yellow('\n  CLIProxy must be running on localhost:8317'));
-    console.log(chalk.gray('  Install: https://help.router-for.me\n'));
-    await prompts.waitForEnter();
-    return false;
+    spinner.fail(`CLIProxy not reachable at ${currentUrl}`);
+    console.log();
+    console.log(chalk.yellow('  CLIProxy Options:'));
+    console.log(chalk.gray('  [1] Local  - localhost:8317 (default)'));
+    console.log(chalk.gray('  [2] Remote - Enter custom URL (e.g., http://your-pc-ip:8317)'));
+    console.log(chalk.gray('  [B] Back'));
+    console.log();
+    
+    const urlChoice = await prompts.textInput(chalk.cyan('  Select option: '));
+    
+    if (!urlChoice || urlChoice.toLowerCase() === 'b') {
+      return false;
+    }
+    
+    let newUrl = null;
+    if (urlChoice === '1') {
+      newUrl = DEFAULT_CLIPROXY_URL;
+    } else if (urlChoice === '2') {
+      console.log(chalk.gray('\n  Enter CLIProxy URL (e.g., http://192.168.1.100:8317):'));
+      const customUrl = await prompts.textInput(chalk.cyan('  URL: '));
+      if (!customUrl || customUrl.trim() === '') {
+        console.log(chalk.gray('  Cancelled.'));
+        await prompts.waitForEnter();
+        return false;
+      }
+      newUrl = customUrl.trim();
+      // Add http:// if missing
+      if (!newUrl.startsWith('http://') && !newUrl.startsWith('https://')) {
+        newUrl = 'http://' + newUrl;
+      }
+    }
+    
+    if (newUrl) {
+      const testSpinner = ora({ text: `Testing connection to ${newUrl}...`, color: 'yellow' }).start();
+      proxyStatus = await isCliProxyRunning(newUrl);
+      
+      if (!proxyStatus.running) {
+        testSpinner.fail(`Cannot connect to ${newUrl}`);
+        console.log(chalk.gray(`  Error: ${proxyStatus.error || 'Connection failed'}`));
+        console.log(chalk.yellow('\n  Make sure CLIProxy is running and accessible.'));
+        await prompts.waitForEnter();
+        return false;
+      }
+      
+      testSpinner.succeed(`Connected to CLIProxy at ${newUrl}`);
+      setCliProxyUrl(newUrl);
+    } else {
+      return false;
+    }
+  } else {
+    spinner.succeed(`CLIProxy connected at ${currentUrl}`);
   }
-  
-  spinner.succeed('CLIProxy is running');
   const oauthResult = await getOAuthUrl(provider.id);
   
   if (!oauthResult.success) {
@@ -303,6 +348,66 @@ const getActiveProvider = () => {
 /** Count active AI agents */
 const getActiveAgentCount = () => getActiveProvider() ? 1 : 0;
 
+/** Configure CLIProxy URL */
+const configureCliProxyUrl = async () => {
+  const currentUrl = getCliProxyUrl();
+  console.clear();
+  console.log(chalk.yellow('\n  Configure CLIProxy URL\n'));
+  console.log(chalk.gray(`  Current: ${currentUrl}`));
+  console.log();
+  console.log(chalk.white('  [1] Local  - localhost:8317 (default)'));
+  console.log(chalk.white('  [2] Remote - Enter custom URL'));
+  console.log(chalk.white('  [B] Back'));
+  console.log();
+  
+  const choice = await prompts.textInput(chalk.cyan('  Select option: '));
+  
+  if (!choice || choice.toLowerCase() === 'b') return;
+  
+  if (choice === '1') {
+    setCliProxyUrl(DEFAULT_CLIPROXY_URL);
+    console.log(chalk.green(`\n  ✓ CLIProxy URL set to ${DEFAULT_CLIPROXY_URL}`));
+    await prompts.waitForEnter();
+    return;
+  }
+  
+  if (choice === '2') {
+    console.log(chalk.gray('\n  Enter CLIProxy URL (e.g., http://192.168.1.100:8317):'));
+    const customUrl = await prompts.textInput(chalk.cyan('  URL: '));
+    
+    if (!customUrl || customUrl.trim() === '') {
+      console.log(chalk.gray('  Cancelled.'));
+      await prompts.waitForEnter();
+      return;
+    }
+    
+    let newUrl = customUrl.trim();
+    if (!newUrl.startsWith('http://') && !newUrl.startsWith('https://')) {
+      newUrl = 'http://' + newUrl;
+    }
+    
+    // Test connection
+    const spinner = ora({ text: `Testing connection to ${newUrl}...`, color: 'yellow' }).start();
+    const status = await isCliProxyRunning(newUrl);
+    
+    if (status.running) {
+      spinner.succeed(`Connected to ${newUrl}`);
+      setCliProxyUrl(newUrl);
+      console.log(chalk.green(`\n  ✓ CLIProxy URL saved.`));
+    } else {
+      spinner.warn(`Cannot connect to ${newUrl}`);
+      console.log(chalk.gray(`  Error: ${status.error || 'Connection failed'}`));
+      console.log(chalk.yellow('\n  Save anyway? (URL will be used when CLIProxy is available)'));
+      const save = await prompts.textInput(chalk.cyan('  Save? (y/N): '));
+      if (save && save.toLowerCase() === 'y') {
+        setCliProxyUrl(newUrl);
+        console.log(chalk.green('  ✓ URL saved.'));
+      }
+    }
+    await prompts.waitForEnter();
+  }
+};
+
 /** Main AI Agents menu */
 const aiAgentsMenu = async () => {
   let config = loadConfig();
@@ -310,13 +415,19 @@ const aiAgentsMenu = async () => {
   
   while (true) {
     console.clear();
-    drawProvidersTable(AI_PROVIDERS, config, boxWidth);
+    const cliproxyUrl = getCliProxyUrl();
+    drawProvidersTable(AI_PROVIDERS, config, boxWidth, cliproxyUrl);
     
-    const input = await prompts.textInput(chalk.cyan('Select provider: '));
+    const input = await prompts.textInput(chalk.cyan('Select (1-8/C/B): '));
     const choice = (input || '').toLowerCase().trim();
     
     if (choice === 'b' || choice === '') break;
     
+    if (choice === 'c') {
+      await configureCliProxyUrl();
+      continue;
+    }
+    
     const num = parseInt(choice);
     if (!isNaN(num) && num >= 1 && num <= AI_PROVIDERS.length) {
       config = await handleProviderConfig(AI_PROVIDERS[num - 1], config);

package/src/services/cliproxy.js

@@ -1,16 +1,61 @@
 /**
  * CLIProxy Service
  * 
- * Connects to CLIProxyAPI (localhost:8317) for AI provider access
+ * Connects to CLIProxyAPI for AI provider access
  * via paid plans (Claude Pro, ChatGPT Plus, etc.)
  * 
+ * Supports both local (localhost:8317) and remote connections.
  * Docs: https://help.router-for.me
  */
 
 const http = require('http');
+const https = require('https');
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
 
-// CLIProxy default endpoint
-const CLIPROXY_BASE = 'http://localhost:8317';
+// Config file path (same as ai-agents)
+const CONFIG_DIR = path.join(os.homedir(), '.hqx');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'ai-config.json');
+
+// Default CLIProxy endpoint
+const DEFAULT_CLIPROXY_URL = 'http://localhost:8317';
+
+/**
+ * Get CLIProxy URL from config or default
+ * @returns {string} CLIProxy base URL
+ */
+const getCliProxyUrl = () => {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+      if (config.cliproxyUrl && config.cliproxyUrl.trim()) {
+        return config.cliproxyUrl.trim();
+      }
+    }
+  } catch (error) { /* ignore */ }
+  return DEFAULT_CLIPROXY_URL;
+};
+
+/**
+ * Set CLIProxy URL in config
+ * @param {string} url - CLIProxy URL
+ * @returns {boolean} Success status
+ */
+const setCliProxyUrl = (url) => {
+  try {
+    let config = { providers: {} };
+    if (fs.existsSync(CONFIG_FILE)) {
+      config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    }
+    if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    config.cliproxyUrl = url;
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
 
 /**
  * Make HTTP request to CLIProxy
@@ -18,24 +63,30 @@ const CLIPROXY_BASE = 'http://localhost:8317';
  * @param {string} method - HTTP method
  * @param {Object} headers - Request headers
  * @param {number} timeout - Timeout in ms (default 60000 per RULES.md #15)
+ * @param {string} baseUrl - Optional base URL override
  * @returns {Promise<Object>} { success, data, error }
  */
-const fetchCliProxy = (path, method = 'GET', headers = {}, timeout = 60000) => {
+const fetchCliProxy = (path, method = 'GET', headers = {}, timeout = 60000, baseUrl = null) => {
   return new Promise((resolve) => {
-    const url = new URL(path, CLIPROXY_BASE);
+    const base = baseUrl || getCliProxyUrl();
+    const url = new URL(path, base);
+    const isHttps = url.protocol === 'https:';
+    const httpModule = isHttps ? https : http;
+    
     const options = {
       hostname: url.hostname,
-      port: url.port || 8317,
+      port: url.port || (isHttps ? 443 : 8317),
       path: url.pathname + url.search,
       method,
       headers: {
         'Content-Type': 'application/json',
         ...headers
       },
-      timeout
+      timeout,
+      rejectUnauthorized: false // Allow self-signed certs for remote
     };
 
-    const req = http.request(options, (res) => {
+    const req = httpModule.request(options, (res) => {
       let data = '';
       res.on('data', chunk => data += chunk);
       res.on('end', () => {
@@ -53,7 +104,7 @@ const fetchCliProxy = (path, method = 'GET', headers = {}, timeout = 60000) => {
 
     req.on('error', (error) => {
       if (error.code === 'ECONNREFUSED') {
-        resolve({ success: false, error: 'CLIProxy not running', data: null });
+        resolve({ success: false, error: 'CLIProxy not reachable', data: null });
       } else {
         resolve({ success: false, error: error.message, data: null });
       }
@@ -69,14 +120,17 @@ const fetchCliProxy = (path, method = 'GET', headers = {}, timeout = 60000) => {
 };
 
 /**
- * Check if CLIProxy is running
- * @returns {Promise<Object>} { running, error }
+ * Check if CLIProxy is running/reachable
+ * @param {string} url - Optional URL to test (uses config if not provided)
+ * @returns {Promise<Object>} { running, error, url }
  */
-const isCliProxyRunning = async () => {
-  const result = await fetchCliProxy('/v1/models', 'GET', {}, 5000);
+const isCliProxyRunning = async (url = null) => {
+  const testUrl = url || getCliProxyUrl();
+  const result = await fetchCliProxy('/v1/models', 'GET', {}, 5000, testUrl);
   return { 
     running: result.success, 
-    error: result.success ? null : result.error 
+    error: result.success ? null : result.error,
+    url: testUrl
   };
 };
 
@@ -189,7 +243,9 @@ const getAuthFiles = async () => {
 };
 
 module.exports = {
-  CLIPROXY_BASE,
+  DEFAULT_CLIPROXY_URL,
+  getCliProxyUrl,
+  setCliProxyUrl,
   isCliProxyRunning,
   fetchModelsFromCliProxy,
   getOAuthUrl,