hedgequantx 1.8.49 → 2.3.0

package/src/utils/http.js

@@ -0,0 +1,236 @@
+/**
+ * @fileoverview Shared HTTP client for all services
+ * @module utils/http
+ */
+
+const https = require('https');
+const http = require('http');
+const { TIMEOUTS } = require('../config/settings');
+const { logger } = require('./logger');
+
+const log = logger.scope('HTTP');
+
+/**
+ * @typedef {Object} HttpResponse
+ * @property {number} statusCode - HTTP status code
+ * @property {Object|string} data - Response body
+ * @property {Object} headers - Response headers
+ */
+
+/**
+ * @typedef {Object} HttpOptions
+ * @property {string} [method='GET'] - HTTP method
+ * @property {Object} [headers] - Request headers
+ * @property {Object|string} [body] - Request body
+ * @property {number} [timeout] - Request timeout in ms
+ * @property {string} [token] - Bearer token for Authorization
+ * @property {string} [apiKey] - API key header
+ */
+
+/**
+ * Performs an HTTP/HTTPS request
+ * @param {string} url - Full URL to request
+ * @param {HttpOptions} [options={}] - Request options
+ * @returns {Promise<HttpResponse>}
+ */
+const request = (url, options = {}) => {
+  return new Promise((resolve, reject) => {
+    const {
+      method = 'GET',
+      headers = {},
+      body = null,
+      timeout = TIMEOUTS.API_REQUEST,
+      token = null,
+      apiKey = null,
+    } = options;
+
+    const parsedUrl = new URL(url);
+    const isHttps = parsedUrl.protocol === 'https:';
+    const client = isHttps ? https : http;
+    
+    const postData = body ? (typeof body === 'string' ? body : JSON.stringify(body)) : null;
+
+    const reqOptions = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port || (isHttps ? 443 : 80),
+      path: parsedUrl.pathname + parsedUrl.search,
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'User-Agent': 'HQX-CLI/2.0.0',
+        ...headers,
+      },
+      timeout,
+    };
+
+    if (postData) {
+      reqOptions.headers['Content-Length'] = Buffer.byteLength(postData);
+    }
+
+    if (token) {
+      reqOptions.headers['Authorization'] = `Bearer ${token}`;
+    }
+
+    if (apiKey) {
+      reqOptions.headers['X-API-Key'] = apiKey;
+    }
+
+    log.debug(`${method} ${parsedUrl.pathname}`);
+
+    const req = client.request(reqOptions, (res) => {
+      let data = '';
+      
+      res.on('data', chunk => { data += chunk; });
+      
+      res.on('end', () => {
+        let parsed;
+        try {
+          parsed = JSON.parse(data);
+        } catch {
+          parsed = data;
+        }
+        
+        log.debug(`Response ${res.statusCode}`, { 
+          path: parsedUrl.pathname,
+          status: res.statusCode 
+        });
+        
+        resolve({
+          statusCode: res.statusCode,
+          data: parsed,
+          headers: res.headers,
+        });
+      });
+    });
+
+    req.on('error', (err) => {
+      log.error(`Request failed: ${err.message}`, { path: parsedUrl.pathname });
+      reject(err);
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      const err = new Error(`Request timeout after ${timeout}ms`);
+      log.error(err.message, { path: parsedUrl.pathname });
+      reject(err);
+    });
+
+    if (postData) {
+      req.write(postData);
+    }
+
+    req.end();
+  });
+};
+
+/**
+ * Simplified request helper for common patterns
+ * @param {string} baseUrl - Base URL (e.g., 'https://api.example.com')
+ * @param {string} [basePath=''] - Base path prefix
+ * @returns {Object} Request methods bound to the base URL
+ */
+const createClient = (baseUrl, basePath = '') => {
+  const buildUrl = (path) => `${baseUrl}${basePath}${path}`;
+  
+  return {
+    /**
+     * GET request
+     * @param {string} path - Request path
+     * @param {HttpOptions} [options={}] - Options
+     */
+    get: (path, options = {}) => request(buildUrl(path), { ...options, method: 'GET' }),
+    
+    /**
+     * POST request
+     * @param {string} path - Request path
+     * @param {Object} [body] - Request body
+     * @param {HttpOptions} [options={}] - Options
+     */
+    post: (path, body, options = {}) => request(buildUrl(path), { ...options, method: 'POST', body }),
+    
+    /**
+     * PUT request
+     * @param {string} path - Request path
+     * @param {Object} [body] - Request body
+     * @param {HttpOptions} [options={}] - Options
+     */
+    put: (path, body, options = {}) => request(buildUrl(path), { ...options, method: 'PUT', body }),
+    
+    /**
+     * DELETE request
+     * @param {string} path - Request path
+     * @param {HttpOptions} [options={}] - Options
+     */
+    delete: (path, options = {}) => request(buildUrl(path), { ...options, method: 'DELETE' }),
+    
+    /**
+     * Sets authorization token for all subsequent requests
+     * @param {string} token - Bearer token
+     * @returns {Object} Client with token set
+     */
+    withToken: (token) => {
+      const client = createClient(baseUrl, basePath);
+      const wrapWithToken = (fn) => (path, bodyOrOpts, opts) => {
+        const options = opts || (typeof bodyOrOpts === 'object' && !bodyOrOpts?.method ? {} : bodyOrOpts) || {};
+        const body = opts ? bodyOrOpts : undefined;
+        return fn(path, body, { ...options, token });
+      };
+      client.get = (path, opts = {}) => request(buildUrl(path), { ...opts, method: 'GET', token });
+      client.post = (path, body, opts = {}) => request(buildUrl(path), { ...opts, method: 'POST', body, token });
+      client.put = (path, body, opts = {}) => request(buildUrl(path), { ...opts, method: 'PUT', body, token });
+      client.delete = (path, opts = {}) => request(buildUrl(path), { ...opts, method: 'DELETE', token });
+      return client;
+    },
+  };
+};
+
+/**
+ * Retries a request with exponential backoff
+ * @param {() => Promise<HttpResponse>} fn - Request function
+ * @param {Object} [options={}] - Retry options
+ * @param {number} [options.maxRetries=3] - Maximum retry attempts
+ * @param {number} [options.baseDelay=1000] - Base delay in ms
+ * @param {number[]} [options.retryOn=[502, 503, 504]] - Status codes to retry on
+ * @returns {Promise<HttpResponse>}
+ */
+const withRetry = async (fn, options = {}) => {
+  const {
+    maxRetries = 3,
+    baseDelay = 1000,
+    retryOn = [502, 503, 504],
+  } = options;
+
+  let lastError;
+  
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const result = await fn();
+      
+      if (retryOn.includes(result.statusCode) && attempt < maxRetries) {
+        const delay = baseDelay * Math.pow(2, attempt);
+        log.debug(`Retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})`);
+        await new Promise(r => setTimeout(r, delay));
+        continue;
+      }
+      
+      return result;
+    } catch (err) {
+      lastError = err;
+      
+      if (attempt < maxRetries) {
+        const delay = baseDelay * Math.pow(2, attempt);
+        log.debug(`Retrying after error in ${delay}ms`, { error: err.message });
+        await new Promise(r => setTimeout(r, delay));
+      }
+    }
+  }
+  
+  throw lastError;
+};
+
+module.exports = {
+  request,
+  createClient,
+  withRetry,
+};

package/src/utils/index.js

@@ -1,8 +1,17 @@
 /**
- * Utils module exports
+ * @fileoverview Utils module exports
+ * @module utils
  */
 
 const { logger, LEVELS } = require('./logger');
 const prompts = require('./prompts');
+const { request, createClient, withRetry } = require('./http');
 
-module.exports = { logger, LEVELS, prompts };
+module.exports = {
+  logger,
+  LEVELS,
+  prompts,
+  request,
+  createClient,
+  withRetry,
+};

package/src/utils/logger.js

@@ -1,70 +1,97 @@
 /**
- * HQX Logger - Centralized logging for debugging
+ * @fileoverview HQX Logger - Centralized logging for debugging
+ * @module utils/logger
  * 
  * Usage:
  *   HQX_DEBUG=1 hedgequantx   - Enable all debug logs
- *   HQX_LOG_FILE=1 hedgequantx - Also write to ~/.hedgequantx/debug.log
  */
 
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { SECURITY, DEBUG } = require('../config/settings');
 
-// Log levels
+/** Log levels */
 const LEVELS = {
   ERROR: 0,
   WARN: 1,
   INFO: 2,
   DEBUG: 3,
-  TRACE: 4
+  TRACE: 4,
 };
 
-// Colors for console output
+/** ANSI colors */
 const COLORS = {
-  ERROR: '\x1b[31m',   // Red
-  WARN: '\x1b[33m',    // Yellow
-  INFO: '\x1b[36m',    // Cyan
-  DEBUG: '\x1b[90m',   // Gray
-  TRACE: '\x1b[90m',   // Gray
-  RESET: '\x1b[0m'
+  ERROR: '\x1b[31m',
+  WARN: '\x1b[33m',
+  INFO: '\x1b[36m',
+  DEBUG: '\x1b[90m',
+  TRACE: '\x1b[90m',
+  RESET: '\x1b[0m',
 };
 
+/**
+ * Logger class with file and console output
+ */
 class Logger {
   constructor() {
-    this.consoleEnabled = process.env.HQX_DEBUG === '1';
+    this.consoleEnabled = DEBUG.enabled;
     this.level = LEVELS.DEBUG;
-    this.logFile = path.join(os.homedir(), '.hedgequantx', 'debug.log');
-    
-    // Always write to file (logs are always saved)
-    const dir = path.dirname(this.logFile);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+    this.logDir = path.join(os.homedir(), SECURITY.SESSION_DIR);
+    this.logFile = path.join(this.logDir, DEBUG.LOG_FILE);
+    this._initLogFile();
+  }
+
+  /**
+   * Initialize log file
+   * @private
+   */
+  _initLogFile() {
+    try {
+      if (!fs.existsSync(this.logDir)) {
+        fs.mkdirSync(this.logDir, { recursive: true, mode: SECURITY.DIR_PERMISSIONS });
+      }
+      
+      const header = [
+        `=== HQX Log Started ${new Date().toISOString()} ===`,
+        `Platform: ${process.platform}, Node: ${process.version}`,
+        `CWD: ${process.cwd()}`,
+        '',
+      ].join('\n');
+      
+      fs.writeFileSync(this.logFile, header, { mode: SECURITY.FILE_PERMISSIONS });
+    } catch {
+      // Ignore init errors - logging is optional
     }
-    // Clear log file on start
-    fs.writeFileSync(this.logFile, `=== HQX Log Started ${new Date().toISOString()} ===\n`);
-    fs.appendFileSync(this.logFile, `Platform: ${process.platform}, Node: ${process.version}\n`);
-    fs.appendFileSync(this.logFile, `CWD: ${process.cwd()}\n\n`);
   }
 
+  /**
+   * Format log message
+   * @private
+   */
   _format(level, module, message, data) {
-    const timestamp = new Date().toISOString().substr(11, 12); // HH:MM:SS.mmm
-    const dataStr = data !== undefined ? ' ' + JSON.stringify(data) : '';
-    return `[${timestamp}] [${level}] [${module}]${dataStr ? ' ' + message + dataStr : ' ' + message}`;
+    const timestamp = new Date().toISOString().slice(11, 23);
+    const dataStr = data !== undefined ? ` ${JSON.stringify(data)}` : '';
+    return `[${timestamp}] [${level}] [${module}] ${message}${dataStr}`;
   }
 
+  /**
+   * Write log entry
+   * @private
+   */
   _log(level, levelName, module, message, data) {
     if (level > this.level) return;
 
     const formatted = this._format(levelName, module, message, data);
-    
-    // Always write to file (survives crashes)
+
+    // Write to file (survives crashes)
     try {
       fs.appendFileSync(this.logFile, formatted + '\n');
-    } catch (e) {
-      // Ignore file write errors
+    } catch {
+      // Ignore file errors
     }
-    
-    // Console output only if HQX_DEBUG=1
+
+    // Console output only if enabled
     if (this.consoleEnabled) {
       const color = COLORS[levelName] || COLORS.RESET;
       console.error(`${color}${formatted}${COLORS.RESET}`);
@@ -91,7 +118,11 @@ class Logger {
     this._log(LEVELS.TRACE, 'TRACE', module, message, data);
   }
 
-  // Create a scoped logger for a specific module
+  /**
+   * Create a scoped logger for a specific module
+   * @param {string} moduleName - Module name
+   * @returns {Object} Scoped logger methods
+   */
   scope(moduleName) {
     return {
       error: (msg, data) => this.error(moduleName, msg, data),
@@ -103,7 +134,7 @@ class Logger {
   }
 }
 
-// Singleton instance
+/** Singleton instance */
 const logger = new Logger();
 
 module.exports = { logger, LEVELS };

package/src/utils/prompts.js

@@ -1,33 +1,16 @@
 /**
- * Centralized prompts utility
+ * @fileoverview Centralized prompts utility
+ * @module utils/prompts
+ * 
  * Uses native readline for reliable stdin handling
  */
 
 const inquirer = require('inquirer');
 const readline = require('readline');
 
-// Shared readline instance
+/** @type {readline.Interface|null} */
 let rl = null;
 
-// Prevent readline from exiting on SIGINT during prompts
-process.on('SIGINT', () => {
-  // Let the main app handle SIGINT
-});
-
-/**
- * Get or create readline interface
- */
-const getReadline = () => {
-  if (!rl || rl.closed) {
-    rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      terminal: true
-    });
-  }
-  return rl;
-};
-
 /**
  * Ensure stdin is ready and flush any buffered input
  */
@@ -37,56 +20,68 @@ const prepareStdin = () => {
     if (process.stdin.isTTY && process.stdin.setRawMode) {
       process.stdin.setRawMode(false);
     }
-    // Flush any buffered input by reading without waiting
     process.stdin.read();
-  } catch (e) {}
+  } catch {
+    // Ignore stdin errors
+  }
+};
+
+/**
+ * Close existing readline if open
+ * @private
+ */
+const closeReadline = () => {
+  if (rl && !rl.closed) {
+    try {
+      rl.close();
+    } catch {
+      // Ignore close errors
+    }
+    rl = null;
+  }
 };
 
 /**
  * Native readline prompt
+ * @param {string} message - Prompt message
+ * @returns {Promise<string>}
  */
 const nativePrompt = (message) => {
   return new Promise((resolve) => {
     try {
       prepareStdin();
-      
-      // Always create a fresh readline for each prompt to avoid state issues
-      if (rl && !rl.closed) {
-        try { rl.close(); } catch (e) {}
-        rl = null;
-      }
-      
+      closeReadline();
+
       rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
-        terminal: true
+        terminal: true,
       });
-      
+
       let answered = false;
-      
-      rl.question(message + ' ', (answer) => {
+
+      rl.question(`${message} `, (answer) => {
         answered = true;
-        try { rl.close(); } catch (e) {}
-        rl = null;
+        closeReadline();
         resolve(answer || '');
       });
-      
-      // Handle readline close (e.g., Ctrl+C)
+
       rl.on('close', () => {
         if (!answered) {
           rl = null;
           resolve('');
         }
       });
-      
-    } catch (e) {
+    } catch {
       resolve('');
     }
   });
 };
 
 /**
- * Wait for Enter
+ * Wait for Enter key
+ * @param {string} [message='Press Enter to continue...'] - Message to display
+ * @returns {Promise<void>}
  */
 const waitForEnter = async (message = 'Press Enter to continue...') => {
   await nativePrompt(message);
@@ -94,6 +89,9 @@ const waitForEnter = async (message = 'Press Enter to continue...') => {
 
 /**
  * Text input
+ * @param {string} message - Prompt message
+ * @param {string} [defaultVal=''] - Default value
+ * @returns {Promise<string>}
  */
 const textInput = async (message, defaultVal = '') => {
   const value = await nativePrompt(message);
@@ -101,48 +99,63 @@ const textInput = async (message, defaultVal = '') => {
 };
 
 /**
- * Password input
+ * Password input (masked)
+ * @param {string} message - Prompt message
+ * @returns {Promise<string>}
  */
 const passwordInput = async (message) => {
-  if (rl && !rl.closed) { rl.close(); rl = null; }
+  closeReadline();
   prepareStdin();
+
   const { value } = await inquirer.prompt([{
     type: 'password',
     name: 'value',
     message,
     mask: '*',
-    prefix: ''
+    prefix: '',
   }]);
+
   return value;
 };
 
 /**
- * Confirm - arrow keys selection
+ * Confirm prompt with arrow keys
+ * @param {string} message - Prompt message
+ * @param {boolean} [defaultVal=true] - Default value
+ * @returns {Promise<boolean>}
  */
 const confirmPrompt = async (message, defaultVal = true) => {
-  if (rl && !rl.closed) { rl.close(); rl = null; }
+  closeReadline();
   prepareStdin();
-  const choices = defaultVal 
+
+  const choices = defaultVal
     ? [{ name: 'Yes', value: true }, { name: 'No', value: false }]
     : [{ name: 'No', value: false }, { name: 'Yes', value: true }];
-  
+
   const { value } = await inquirer.prompt([{
     type: 'list',
     name: 'value',
     message,
     choices,
     prefix: '',
-    loop: false
+    loop: false,
   }]);
+
   return value;
 };
 
 /**
- * Number input
+ * Number input with validation
+ * @param {string} message - Prompt message
+ * @param {number} [defaultVal=1] - Default value
+ * @param {number} [min=1] - Minimum value
+ * @param {number} [max=1000] - Maximum value
+ * @returns {Promise<number>}
  */
 const numberInput = async (message, defaultVal = 1, min = 1, max = 1000) => {
-  if (rl && !rl.closed) { rl.close(); rl = null; }
+  closeReadline();
   prepareStdin();
+
   const { value } = await inquirer.prompt([{
     type: 'input',
     name: 'value',
@@ -150,39 +163,34 @@ const numberInput = async (message, defaultVal = 1, min = 1, max = 1000) => {
     default: String(defaultVal),
     prefix: '',
     validate: (v) => {
-      const n = parseInt(v);
+      const n = parseInt(v, 10);
       if (isNaN(n)) return 'Enter a number';
       if (n < min) return `Min: ${min}`;
       if (n > max) return `Max: ${max}`;
       return true;
-    }
+    },
   }]);
-  return parseInt(value) || defaultVal;
+
+  return parseInt(value, 10) || defaultVal;
 };
 
 /**
- * Select - arrow keys navigation
- * Supports disabled options (separators) via opt.disabled
+ * Select from options with arrow keys
+ * @param {string} message - Prompt message
+ * @param {Array<{label: string, value: any, disabled?: boolean}>} options - Options
+ * @returns {Promise<any>}
  */
 const selectOption = async (message, options) => {
-  // Close shared readline before inquirer to avoid conflicts
-  if (rl && !rl.closed) {
-    rl.close();
-    rl = null;
-  }
+  closeReadline();
   prepareStdin();
-  
+
   const choices = options.map(opt => {
     if (opt.disabled) {
-      // Use inquirer Separator for disabled items (category headers)
       return new inquirer.Separator(opt.label);
     }
-    return {
-      name: opt.label,
-      value: opt.value
-    };
+    return { name: opt.label, value: opt.value };
   });
-  
+
   const { value } = await inquirer.prompt([{
     type: 'list',
     name: 'value',
@@ -190,9 +198,9 @@ const selectOption = async (message, options) => {
     choices,
     prefix: '',
     loop: false,
-    pageSize: 20  // Increased to show more symbols
+    pageSize: 20,
   }]);
-  
+
   return value;
 };
 
@@ -203,5 +211,5 @@ module.exports = {
   passwordInput,
   confirmPrompt,
   numberInput,
-  selectOption
+  selectOption,
 };