hedgequantx 1.8.48 → 2.3.0

package/src/ui/index.js

@@ -2,6 +2,7 @@
  * UI Module Exports
  */
 
+const chalk = require('chalk');
 const { detectDevice, getDevice, getSeparator } = require('./device');
 const {
   getLogoWidth,
@@ -24,6 +25,55 @@ const {
 } = require('./table');
 const { createBoxMenu } = require('./menu');
 
+/**
+ * Display HQX Banner (without closing border)
+ */
+const displayBanner = () => {
+  console.clear();
+  const termWidth = process.stdout.columns || 100;
+  const isMobile = termWidth < 60;
+  const boxWidth = isMobile ? Math.max(termWidth - 2, 40) : Math.max(getLogoWidth(), 98);
+  const innerWidth = boxWidth - 2;
+  
+  let version = '1.0.0';
+  try { version = require('../../package.json').version; } catch (e) {}
+  
+  console.log(chalk.cyan('╔' + '═'.repeat(innerWidth) + '╗'));
+  
+  if (isMobile) {
+    const logoHQ = ['██╗  ██╗ ██████╗ ','██║  ██║██╔═══██╗','███████║██║   ██║','██╔══██║██║▄▄ ██║','██║  ██║╚██████╔╝','╚═╝  ╚═╝ ╚══▀▀═╝ '];
+    const logoX = ['██╗  ██╗','╚██╗██╔╝',' ╚███╔╝ ',' ██╔██╗ ','██╔╝ ██╗','╚═╝  ╚═╝'];
+    logoHQ.forEach((line, i) => {
+      const fullLine = chalk.cyan(line) + chalk.yellow(logoX[i]);
+      const totalLen = line.length + logoX[i].length;
+      const padding = innerWidth - totalLen;
+      const leftPad = Math.floor(padding / 2);
+      console.log(chalk.cyan('║') + ' '.repeat(leftPad) + fullLine + ' '.repeat(padding - leftPad) + chalk.cyan('║'));
+    });
+  } else {
+    const logo = [
+      '██╗  ██╗███████╗██████╗  ██████╗ ███████╗ ██████╗ ██╗   ██╗ █████╗ ███╗   ██╗████████╗',
+      '██║  ██║██╔════╝██╔══██╗██╔════╝ ██╔════╝██╔═══██╗██║   ██║██╔══██╗████╗  ██║╚══██╔══╝',
+      '███████║█████╗  ██║  ██║██║  ███╗█████╗  ██║   ██║██║   ██║███████║██╔██╗ ██║   ██║   ',
+      '██╔══██║██╔══╝  ██║  ██║██║   ██║██╔══╝  ██║▄▄ ██║██║   ██║██╔══██║██║╚██╗██║   ██║   ',
+      '██║  ██║███████╗██████╔╝╚██████╔╝███████╗╚██████╔╝╚██████╔╝██║  ██║██║ ╚████║   ██║   ',
+      '╚═╝  ╚═╝╚══════╝╚═════╝  ╚═════╝ ╚══════╝ ╚══▀▀═╝  ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═══╝   ╚═╝   '
+    ];
+    const logoX = ['██╗  ██╗','╚██╗██╔╝',' ╚███╔╝ ',' ██╔██╗ ','██╔╝ ██╗','╚═╝  ╚═╝'];
+    logo.forEach((line, i) => {
+      const fullLine = chalk.cyan(line) + chalk.yellow(logoX[i]);
+      const totalLen = line.length + logoX[i].length;
+      const padding = innerWidth - totalLen;
+      const leftPad = Math.floor(padding / 2);
+      console.log(chalk.cyan('║') + ' '.repeat(leftPad) + fullLine + ' '.repeat(padding - leftPad) + chalk.cyan('║'));
+    });
+  }
+  
+  console.log(chalk.cyan('╠' + '═'.repeat(innerWidth) + '╣'));
+  const tagline = isMobile ? `HQX v${version}` : `Prop Futures Algo Trading  v${version}`;
+  console.log(chalk.cyan('║') + chalk.white(centerText(tagline, innerWidth)) + chalk.cyan('║'));
+};
+
 /**
  * Ensure stdin is ready for inquirer prompts
  * This fixes input leaking to bash after session restore or algo trading
@@ -69,5 +119,7 @@ module.exports = {
   // Menu
   createBoxMenu,
   // Stdin
-  prepareStdin
+  prepareStdin,
+  // Banner
+  displayBanner
 };

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 };