hedgequantx 2.6.102 → 2.6.104

package/package.json

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

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

@@ -27,6 +27,7 @@ const PROXY_BIN = path.join(PROXY_DIR, process.platform === 'win32' ? 'cli-proxy
 const PROXY_CONFIG = path.join(PROXY_DIR, 'config.yaml');
 const PROXY_AUTH_DIR = path.join(PROXY_DIR, 'auths');
 const API_KEY = 'hqx-local-key';
+const MANAGEMENT_KEY = 'hqx-mgmt-key';
 
 // GitHub release URLs
 const getDownloadUrl = () => {
@@ -202,6 +203,9 @@ const install = async (onProgress = () => {}) => {
 auth-dir: "${PROXY_AUTH_DIR}"
 api-keys:
   - "${API_KEY}"
+remote-management:
+  secret-key: "${MANAGEMENT_KEY}"
+allow-remote-management: false
 request-retry: 3
 quota-exceeded:
   switch-project: true
@@ -267,18 +271,92 @@ const stop = async () => {
   });
 };
 
+/**
+ * Check if config has correct management key (plain text, not hashed)
+ * CLIProxyAPI expects plain text key in config, it does bcrypt hashing internally
+ * @returns {boolean} true if config is correct, false if needs update
+ */
+const isConfigValid = () => {
+  if (!fs.existsSync(PROXY_CONFIG)) return false;
+  
+  try {
+    const config = fs.readFileSync(PROXY_CONFIG, 'utf8');
+    
+    // Check if management key section exists
+    if (!config.includes('remote-management:') || !config.includes('secret-key:')) {
+      return false;
+    }
+    
+    // Check if key is hashed (bcrypt hashes start with $2a$, $2b$, or $2y$)
+    // Plain text key should be 'hqx-mgmt-key', not a bcrypt hash
+    if (config.includes('$2a$') || config.includes('$2b$') || config.includes('$2y$')) {
+      return false; // Config has hashed key, needs to be plain text
+    }
+    
+    // Check if it has our expected management key
+    if (!config.includes(MANAGEMENT_KEY)) {
+      return false;
+    }
+    
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+/**
+ * Rewrite config file with correct settings
+ */
+const rewriteConfig = () => {
+  const config = `port: ${PROXY_PORT}
+auth-dir: "${PROXY_AUTH_DIR}"
+api-keys:
+  - "${API_KEY}"
+remote-management:
+  secret-key: "${MANAGEMENT_KEY}"
+allow-remote-management: false
+request-retry: 3
+quota-exceeded:
+  switch-project: true
+  switch-preview-model: true
+`;
+  
+  // Ensure directory exists
+  if (!fs.existsSync(PROXY_DIR)) {
+    fs.mkdirSync(PROXY_DIR, { recursive: true });
+  }
+  
+  fs.writeFileSync(PROXY_CONFIG, config);
+};
+
 /**
  * Ensure CLIProxyAPI is installed and running
  * @param {Function} onProgress - Progress callback
  */
 const ensureRunning = async (onProgress = () => {}) => {
+  // Check if config needs to be fixed (e.g., has hashed key instead of plain text)
+  const configValid = isConfigValid();
+  
   if (await isRunning()) {
+    if (!configValid) {
+      // Config is invalid but proxy is running - need to restart with correct config
+      onProgress('Updating proxy configuration...');
+      rewriteConfig();
+      await stop();
+      await new Promise(resolve => setTimeout(resolve, 1000)); // Wait for process to fully stop
+      onProgress('Restarting proxy with updated config...');
+      await start();
+    }
     return true;
   }
   
   if (!isInstalled()) {
     onProgress('Installing AI proxy (one-time setup)...');
     await install(onProgress);
+  } else if (!configValid) {
+    // Binary exists but config is invalid - fix it
+    onProgress('Fixing proxy configuration...');
+    rewriteConfig();
   }
   
   onProgress('Starting AI proxy...');
@@ -288,7 +366,7 @@ const ensureRunning = async (onProgress = () => {}) => {
 };
 
 /**
- * Make request to local proxy
+ * Make request to local proxy (API endpoints)
  */
 const proxyRequest = (method, endpoint, body = null) => {
   return new Promise((resolve, reject) => {
@@ -329,6 +407,58 @@ const proxyRequest = (method, endpoint, body = null) => {
   });
 };
 
+/**
+ * Make request to local proxy (Management API endpoints)
+ * Uses management key for authentication
+ */
+const managementRequest = (method, endpoint, body = null) => {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: '127.0.0.1',
+      port: PROXY_PORT,
+      path: endpoint,
+      method,
+      headers: {
+        'Authorization': `Bearer ${MANAGEMENT_KEY}`,
+        'Content-Type': 'application/json'
+      },
+      timeout: 30000
+    };
+    
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          if (res.statusCode >= 400) {
+            reject(new Error(json.error || `HTTP ${res.statusCode}`));
+          } else {
+            resolve(json);
+          }
+        } catch (e) {
+          if (res.statusCode >= 400) {
+            reject(new Error(`HTTP ${res.statusCode}: ${data}`));
+          } else {
+            resolve(data);
+          }
+        }
+      });
+    });
+    
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+    
+    if (body) {
+      req.write(JSON.stringify(body));
+    }
+    req.end();
+  });
+};
+
 /**
  * Get OAuth authorization URL for a provider
  * @param {string} provider - Provider ID (anthropic, openai, gemini, qwen, iflow)
@@ -350,7 +480,7 @@ const getAuthUrl = async (provider) => {
     throw new Error(`Unknown provider: ${provider}`);
   }
   
-  const response = await proxyRequest('GET', endpoint);
+  const response = await managementRequest('GET', endpoint);
   
   if (response.status !== 'ok') {
     throw new Error(response.error || 'Failed to get auth URL');
@@ -368,7 +498,7 @@ const getAuthUrl = async (provider) => {
  * @returns {Promise<{status: string, error?: string}>}
  */
 const pollAuthStatus = async (state) => {
-  const response = await proxyRequest('GET', `/v0/management/get-auth-status?state=${state}`);
+  const response = await managementRequest('GET', `/v0/management/get-auth-status?state=${state}`);
   return response;
 };
 
@@ -422,7 +552,7 @@ const getAuthFiles = async () => {
   await ensureRunning();
   
   try {
-    const response = await proxyRequest('GET', '/v0/management/auth-files');
+    const response = await managementRequest('GET', '/v0/management/auth-files');
     return response.files || [];
   } catch (e) {
     return [];