hedgequantx 1.1.1 → 1.2.31

package/src/pages/positions.js

@@ -0,0 +1,115 @@
+/**
+ * @fileoverview Positions page
+ * @module pages/positions
+ */
+
+const chalk = require('chalk');
+const ora = require('ora');
+const inquirer = require('inquirer');
+
+const { connections } = require('../services');
+const { ORDER_SIDE } = require('../config');
+const { getLogoWidth, drawBoxHeader, drawBoxFooter, drawBoxRow, drawBoxSeparator, visibleLength, padText } = require('../ui');
+
+/**
+ * Shows all open positions from all connections
+ * @param {Object} service - Current service
+ */
+const showPositions = async (service) => {
+  const spinner = ora('Fetching positions...').start();
+  const boxWidth = getLogoWidth();
+  const innerWidth = boxWidth - 2;
+
+  // Get all accounts first
+  let allAccounts = [];
+  
+  if (connections.count() > 0) {
+    for (const conn of connections.getAll()) {
+      try {
+        const result = await conn.service.getTradingAccounts();
+        if (result.success && result.accounts) {
+          result.accounts.forEach(account => {
+            allAccounts.push({
+              ...account,
+              propfirm: conn.propfirm || conn.type,
+              service: conn.service
+            });
+          });
+        }
+      } catch (e) { /* ignore */ }
+    }
+  } else if (service) {
+    const result = await service.getTradingAccounts();
+    if (result.success && result.accounts) {
+      allAccounts = result.accounts.map(a => ({ ...a, service, propfirm: service.propfirm.name }));
+    }
+  }
+
+  // Get positions for each account
+  let allPositions = [];
+  
+  for (const account of allAccounts) {
+    try {
+      const result = await account.service.getPositions(account.accountId);
+      if (result.success && result.positions && result.positions.length > 0) {
+        result.positions.forEach(pos => {
+          allPositions.push({
+            ...pos,
+            accountName: account.accountName || account.name,
+            propfirm: account.propfirm
+          });
+        });
+      }
+    } catch (e) { /* ignore */ }
+  }
+
+  spinner.succeed(`Found ${allPositions.length} position(s)`);
+  console.log();
+
+  drawBoxHeader('OPEN POSITIONS', boxWidth);
+
+  if (allPositions.length === 0) {
+    drawBoxRow(chalk.gray('  No open positions'), boxWidth);
+  } else {
+    // Header row
+    const header = '  ' + 
+      'Symbol'.padEnd(15) + 
+      'Side'.padEnd(8) + 
+      'Size'.padEnd(8) + 
+      'Entry'.padEnd(12) + 
+      'P&L'.padEnd(12) + 
+      'Account';
+    drawBoxRow(chalk.white.bold(header), boxWidth);
+    drawBoxSeparator(boxWidth);
+
+    // Position rows
+    for (const pos of allPositions) {
+      const symbol = (pos.contractId || pos.symbol || 'Unknown').substring(0, 14);
+      const sideInfo = ORDER_SIDE[pos.side] || { text: 'Unknown', color: 'white' };
+      const size = Math.abs(pos.size || pos.quantity || 0);
+      const entry = pos.averagePrice || pos.entryPrice || 0;
+      const pnl = pos.profitAndLoss || pos.unrealizedPnl || 0;
+      const account = (pos.accountName || 'Unknown').substring(0, 15);
+
+      const pnlColor = pnl >= 0 ? chalk.green : chalk.red;
+      const pnlStr = (pnl >= 0 ? '+' : '') + '$' + pnl.toFixed(2);
+
+      const row = '  ' +
+        chalk.white(symbol.padEnd(15)) +
+        chalk[sideInfo.color](sideInfo.text.padEnd(8)) +
+        chalk.white(size.toString().padEnd(8)) +
+        chalk.white(entry.toFixed(2).padEnd(12)) +
+        pnlColor(pnlStr.padEnd(12)) +
+        chalk.gray(account);
+
+      drawBoxRow(row, boxWidth);
+    }
+  }
+
+  drawBoxFooter(boxWidth);
+  console.log();
+
+  await inquirer.prompt([{ type: 'input', name: 'c', message: 'Press Enter to continue...' }]);
+};
+
+module.exports = { showPositions };

package/src/pages/stats.js

@@ -57,6 +57,23 @@ const showStats = async (service) => {
     return;
   }
 
+  // Remove duplicates by accountId
+  const seen = new Set();
+  allAccountsData = allAccountsData.filter(acc => {
+    if (seen.has(acc.accountId)) return false;
+    seen.add(acc.accountId);
+    return true;
+  });
+
+  // Filter only active accounts (status === 0)
+  const activeAccounts = allAccountsData.filter(acc => acc.status === 0);
+  
+  if (activeAccounts.length === 0) {
+    spinner.fail('No active accounts found');
+    await inquirer.prompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    return;
+  }
+
   // Collect stats
   let totalBalance = 0;
   let totalStartingBalance = 0;
@@ -68,7 +85,7 @@ const showStats = async (service) => {
 
   spinner.text = 'Fetching detailed stats...';
 
-  for (const account of allAccountsData) {
+  for (const account of activeAccounts) {
     const svc = account.service;
     const currentBalance = account.balance || 0;
     totalBalance += currentBalance;
@@ -137,7 +154,7 @@ const showStats = async (service) => {
     longTrades: 0, shortTrades: 0, longWins: 0, shortWins: 0
   };
   
-  for (const account of allAccountsData) {
+  for (const account of activeAccounts) {
     if (account.lifetimeStats) {
       const s = account.lifetimeStats;
       stats.totalTrades += s.totalTrades || 0;
@@ -210,6 +227,49 @@ const showStats = async (service) => {
   const longWinRate = stats.longTrades > 0 ? ((stats.longWins / stats.longTrades) * 100).toFixed(1) : '0.0';
   const shortWinRate = stats.shortTrades > 0 ? ((stats.shortWins / stats.shortTrades) * 100).toFixed(1) : '0.0';
   
+  // Advanced quantitative metrics
+  const tradePnLs = allTrades.map(t => t.profitAndLoss || t.pnl || 0);
+  const avgReturn = tradePnLs.length > 0 ? tradePnLs.reduce((a, b) => a + b, 0) / tradePnLs.length : 0;
+  
+  // Standard deviation
+  const variance = tradePnLs.length > 0 
+    ? tradePnLs.reduce((sum, pnl) => sum + Math.pow(pnl - avgReturn, 2), 0) / tradePnLs.length 
+    : 0;
+  const stdDev = Math.sqrt(variance);
+  
+  // Downside deviation (for Sortino)
+  const downsideReturns = tradePnLs.filter(pnl => pnl < 0);
+  const downsideVariance = downsideReturns.length > 0 
+    ? downsideReturns.reduce((sum, pnl) => sum + Math.pow(pnl, 2), 0) / downsideReturns.length 
+    : 0;
+  const downsideDev = Math.sqrt(downsideVariance);
+  
+  // Sharpe Ratio (simplified - assumes risk-free rate = 0)
+  const sharpeRatio = stdDev > 0 ? (avgReturn / stdDev).toFixed(2) : '0.00';
+  
+  // Sortino Ratio
+  const sortinoRatio = downsideDev > 0 ? (avgReturn / downsideDev).toFixed(2) : '0.00';
+  
+  // Max Drawdown
+  let maxDrawdown = 0;
+  let peak = totalStartingBalance;
+  let equity = totalStartingBalance;
+  tradePnLs.forEach(pnl => {
+    equity += pnl;
+    if (equity > peak) peak = equity;
+    const drawdown = (peak - equity) / peak * 100;
+    if (drawdown > maxDrawdown) maxDrawdown = drawdown;
+  });
+  
+  // Expectancy (average profit per trade)
+  const expectancy = stats.totalTrades > 0 ? netPnL / stats.totalTrades : 0;
+  
+  // Risk/Reward Ratio
+  const riskRewardRatio = parseFloat(avgLoss) > 0 ? (parseFloat(avgWin) / parseFloat(avgLoss)).toFixed(2) : '0.00';
+  
+  // Calmar Ratio (return / max drawdown)
+  const calmarRatio = maxDrawdown > 0 ? (parseFloat(returnPercent) / maxDrawdown).toFixed(2) : '0.00';
+  
   const totalBalanceColor = totalBalance >= 0 ? chalk.green : chalk.red;
   const pnlColor = totalPnL >= 0 ? chalk.green : chalk.red;
   
@@ -218,7 +278,7 @@ const showStats = async (service) => {
   draw2ColHeader('ACCOUNT OVERVIEW', 'TRADING PERFORMANCE', boxWidth);
   
   console.log(chalk.cyan('\u2551') + fmtRow('Connections:', chalk.cyan(connections.count().toString() || '1'), col1) + chalk.cyan('\u2502') + fmtRow('Total Trades:', chalk.white(stats.totalTrades.toString()), col2) + chalk.cyan('\u2551'));
-  console.log(chalk.cyan('\u2551') + fmtRow('Total Accounts:', chalk.cyan(allAccountsData.length.toString()), col1) + chalk.cyan('\u2502') + fmtRow('Winning Trades:', chalk.green(stats.winningTrades.toString()), col2) + chalk.cyan('\u2551'));
+  console.log(chalk.cyan('\u2551') + fmtRow('Total Accounts:', chalk.cyan(activeAccounts.length.toString()), col1) + chalk.cyan('\u2502') + fmtRow('Winning Trades:', chalk.green(stats.winningTrades.toString()), col2) + chalk.cyan('\u2551'));
   console.log(chalk.cyan('\u2551') + fmtRow('Total Balance:', totalBalanceColor('$' + totalBalance.toLocaleString()), col1) + chalk.cyan('\u2502') + fmtRow('Losing Trades:', chalk.red(stats.losingTrades.toString()), col2) + chalk.cyan('\u2551'));
   console.log(chalk.cyan('\u2551') + fmtRow('Starting Balance:', chalk.white('$' + totalStartingBalance.toLocaleString()), col1) + chalk.cyan('\u2502') + fmtRow('Win Rate:', parseFloat(winRate) >= 50 ? chalk.green(winRate + '%') : chalk.yellow(winRate + '%'), col2) + chalk.cyan('\u2551'));
   console.log(chalk.cyan('\u2551') + fmtRow('Total P&L:', pnlColor('$' + totalPnL.toLocaleString() + ' (' + returnPercent + '%)'), col1) + chalk.cyan('\u2502') + fmtRow('Long Trades:', chalk.white(stats.longTrades + ' (' + longWinRate + '%)'), col2) + chalk.cyan('\u2551'));
@@ -237,6 +297,20 @@ const showStats = async (service) => {
   console.log(chalk.cyan('\u2551') + fmtRow('Avg Win:', chalk.green('$' + avgWin), col1) + chalk.cyan('\u2502') + fmtRow('Best Trade:', chalk.green('$' + stats.bestTrade.toFixed(2)), col2) + chalk.cyan('\u2551'));
   console.log(chalk.cyan('\u2551') + fmtRow('Avg Loss:', chalk.red('-$' + avgLoss), col1) + chalk.cyan('\u2502') + fmtRow('Worst Trade:', chalk.red('$' + stats.worstTrade.toFixed(2)), col2) + chalk.cyan('\u2551'));
   
+  // Quantitative Metrics
+  draw2ColSeparator(boxWidth);
+  draw2ColHeader('QUANTITATIVE METRICS', 'ADVANCED RATIOS', boxWidth);
+  
+  const sharpeColor = parseFloat(sharpeRatio) >= 1 ? chalk.green : parseFloat(sharpeRatio) >= 0.5 ? chalk.yellow : chalk.red;
+  const sortinoColor = parseFloat(sortinoRatio) >= 1.5 ? chalk.green : parseFloat(sortinoRatio) >= 0.5 ? chalk.yellow : chalk.red;
+  const ddColor = maxDrawdown <= 5 ? chalk.green : maxDrawdown <= 15 ? chalk.yellow : chalk.red;
+  const rrColor = parseFloat(riskRewardRatio) >= 2 ? chalk.green : parseFloat(riskRewardRatio) >= 1 ? chalk.yellow : chalk.red;
+  
+  console.log(chalk.cyan('\u2551') + fmtRow('Sharpe Ratio:', sharpeColor(sharpeRatio), col1) + chalk.cyan('\u2502') + fmtRow('Risk/Reward:', rrColor(riskRewardRatio), col2) + chalk.cyan('\u2551'));
+  console.log(chalk.cyan('\u2551') + fmtRow('Sortino Ratio:', sortinoColor(sortinoRatio), col1) + chalk.cyan('\u2502') + fmtRow('Calmar Ratio:', chalk.white(calmarRatio), col2) + chalk.cyan('\u2551'));
+  console.log(chalk.cyan('\u2551') + fmtRow('Max Drawdown:', ddColor(maxDrawdown.toFixed(2) + '%'), col1) + chalk.cyan('\u2502') + fmtRow('Expectancy:', expectancy >= 0 ? chalk.green('$' + expectancy.toFixed(2)) : chalk.red('$' + expectancy.toFixed(2)), col2) + chalk.cyan('\u2551'));
+  console.log(chalk.cyan('\u2551') + fmtRow('Std Deviation:', chalk.white('$' + stdDev.toFixed(2)), col1) + chalk.cyan('\u2502') + fmtRow('Avg Trade:', avgReturn >= 0 ? chalk.green('$' + avgReturn.toFixed(2)) : chalk.red('$' + avgReturn.toFixed(2)), col2) + chalk.cyan('\u2551'));
+  
   drawBoxFooter(boxWidth);
   
   // Equity Curve
@@ -280,6 +354,141 @@ const showStats = async (service) => {
     console.log(chalk.cyan('\u2551') + chalk.gray(msg) + ' '.repeat(chartInnerWidth - msg.length) + chalk.cyan('\u2551'));
   }
   
+  drawBoxFooter(boxWidth);
+  
+  // Trades History
+  console.log();
+  drawBoxHeader('TRADES HISTORY', boxWidth);
+  
+  const innerWidth = boxWidth - 2;
+  
+  if (allTrades.length > 0) {
+    // Column widths
+    const colTime = 12;
+    const colSymbol = 10;
+    const colEntry = 10;
+    const colExit = 10;
+    const colEntryP = 10;
+    const colExitP = 10;
+    const colPnL = 10;
+    const colDir = 6;
+    const colID = innerWidth - colTime - colSymbol - colEntry - colExit - colEntryP - colExitP - colPnL - colDir - 9;
+    
+    // Header
+    const header = 
+      chalk.white(' Time'.padEnd(colTime)) + chalk.gray('|') +
+      chalk.white('Symbol'.padEnd(colSymbol)) + chalk.gray('|') +
+      chalk.white('Entry'.padEnd(colEntry)) + chalk.gray('|') +
+      chalk.white('Exit'.padEnd(colExit)) + chalk.gray('|') +
+      chalk.white('Entry $'.padEnd(colEntryP)) + chalk.gray('|') +
+      chalk.white('Exit $'.padEnd(colExitP)) + chalk.gray('|') +
+      chalk.white('P&L'.padEnd(colPnL)) + chalk.gray('|') +
+      chalk.white('Dir'.padEnd(colDir)) + chalk.gray('|') +
+      chalk.white('ID'.padEnd(colID));
+    
+    console.log(chalk.cyan('\u2551') + header + chalk.cyan('\u2551'));
+    console.log(chalk.cyan('\u2551') + chalk.gray('\u2500'.repeat(innerWidth)) + chalk.cyan('\u2551'));
+    
+    // Show last 10 trades
+    const recentTrades = allTrades.slice(-10).reverse();
+    
+    for (const trade of recentTrades) {
+      const time = trade.exitTime ? new Date(trade.exitTime).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' }) : '--:--';
+      const symbol = (trade.contractName || trade.symbol || 'N/A').substring(0, colSymbol - 1);
+      const entryTime = trade.entryTime ? new Date(trade.entryTime).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' }) : '--:--';
+      const exitTime = trade.exitTime ? new Date(trade.exitTime).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' }) : '--:--';
+      const entryPrice = trade.entryPrice ? trade.entryPrice.toFixed(2) : 'N/A';
+      const exitPrice = trade.exitPrice ? trade.exitPrice.toFixed(2) : 'N/A';
+      const pnl = trade.profitAndLoss || trade.pnl || 0;
+      const pnlStr = pnl >= 0 ? chalk.green('+$' + pnl.toFixed(0)) : chalk.red('-$' + Math.abs(pnl).toFixed(0));
+      const direction = trade.side === 0 ? chalk.green('LONG') : trade.side === 1 ? chalk.red('SHORT') : chalk.gray('N/A');
+      const tradeId = (trade.id || trade.tradeId || 'N/A').toString().substring(0, colID - 1);
+      
+      const row = 
+        (' ' + time).padEnd(colTime) + chalk.gray('|') +
+        symbol.padEnd(colSymbol) + chalk.gray('|') +
+        entryTime.padEnd(colEntry) + chalk.gray('|') +
+        exitTime.padEnd(colExit) + chalk.gray('|') +
+        entryPrice.padEnd(colEntryP) + chalk.gray('|') +
+        exitPrice.padEnd(colExitP) + chalk.gray('|') +
+        pnlStr.padEnd(colPnL + 10) + chalk.gray('|') + // +10 for color codes
+        direction.padEnd(colDir + 10) + chalk.gray('|') + // +10 for color codes
+        tradeId.padEnd(colID);
+      
+      // Calculate visible length and pad
+      const visLen = row.replace(/\x1b\[[0-9;]*m/g, '').length;
+      const padding = innerWidth - visLen;
+      
+      console.log(chalk.cyan('\u2551') + row + ' '.repeat(Math.max(0, padding)) + chalk.cyan('\u2551'));
+    }
+    
+    if (allTrades.length > 10) {
+      const moreMsg = `  ... and ${allTrades.length - 10} more trades`;
+      console.log(chalk.cyan('\u2551') + chalk.gray(moreMsg) + ' '.repeat(innerWidth - moreMsg.length) + chalk.cyan('\u2551'));
+    }
+  } else {
+    const msg = '  No trade history available';
+    console.log(chalk.cyan('\u2551') + chalk.gray(msg) + ' '.repeat(innerWidth - msg.length) + chalk.cyan('\u2551'));
+  }
+  
+  drawBoxFooter(boxWidth);
+  
+  // HQX Score
+  console.log();
+  drawBoxHeader('HQX SCORE', boxWidth);
+  
+  // Calculate scores (0-100)
+  const winRateScore = Math.min(100, parseFloat(winRate) * 1.5); // 66% win rate = 100
+  const profitFactorScore = Math.min(100, parseFloat(profitFactor) * 40); // 2.5 PF = 100
+  const consistencyScore = stats.maxConsecutiveLosses > 0 ? Math.max(0, 100 - (stats.maxConsecutiveLosses * 15)) : 100;
+  const riskScore = stats.worstTrade !== 0 && totalStartingBalance > 0 
+    ? Math.max(0, 100 - (Math.abs(stats.worstTrade) / totalStartingBalance * 1000)) 
+    : 50;
+  const volumeScore = Math.min(100, stats.totalTrades * 2); // 50 trades = 100
+  const returnScore = Math.min(100, Math.max(0, parseFloat(returnPercent) * 10 + 50)); // 5% return = 100
+  
+  // Overall HQX Score
+  const hqxScore = Math.round((winRateScore + profitFactorScore + consistencyScore + riskScore + volumeScore + returnScore) / 6);
+  const scoreColor = hqxScore >= 70 ? chalk.green : hqxScore >= 50 ? chalk.yellow : chalk.red;
+  const scoreGrade = hqxScore >= 90 ? 'S' : hqxScore >= 80 ? 'A' : hqxScore >= 70 ? 'B' : hqxScore >= 60 ? 'C' : hqxScore >= 50 ? 'D' : 'F';
+  
+  // Progress bar helper
+  const makeBar = (score, width = 20) => {
+    const filled = Math.round((score / 100) * width);
+    const empty = width - filled;
+    const color = score >= 70 ? chalk.green : score >= 50 ? chalk.yellow : chalk.red;
+    return color('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+  };
+  
+  // Metrics with progress bars
+  const metrics = [
+    { name: 'Win Rate', score: winRateScore },
+    { name: 'Profit Factor', score: profitFactorScore },
+    { name: 'Consistency', score: consistencyScore },
+    { name: 'Risk Management', score: riskScore },
+    { name: 'Volume', score: volumeScore },
+    { name: 'Returns', score: returnScore }
+  ];
+  
+  const barWidth = 30;
+  const labelWidth = 18;
+  
+  // Display overall score
+  const overallLine = `  OVERALL SCORE: ${scoreColor(hqxScore.toString())} / 100  [Grade: ${scoreColor(scoreGrade)}]`;
+  const overallVisLen = overallLine.replace(/\x1b\[[0-9;]*m/g, '').length;
+  console.log(chalk.cyan('\u2551') + overallLine + ' '.repeat(innerWidth - overallVisLen) + chalk.cyan('\u2551'));
+  console.log(chalk.cyan('\u2551') + chalk.gray('─'.repeat(innerWidth)) + chalk.cyan('\u2551'));
+  
+  // Display each metric
+  for (const metric of metrics) {
+    const label = ('  ' + metric.name + ':').padEnd(labelWidth);
+    const bar = makeBar(metric.score, barWidth);
+    const pct = (metric.score.toFixed(0) + '%').padStart(5);
+    const line = label + bar + ' ' + pct;
+    const visLen = line.replace(/\x1b\[[0-9;]*m/g, '').length;
+    console.log(chalk.cyan('\u2551') + chalk.white(label) + bar + ' ' + chalk.white(pct) + ' '.repeat(innerWidth - visLen) + chalk.cyan('\u2551'));
+  }
+  
   drawBoxFooter(boxWidth);
   console.log();
   

package/src/pages/user.js

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview User info page
+ * @module pages/user
+ */
+
+const chalk = require('chalk');
+const ora = require('ora');
+const inquirer = require('inquirer');
+
+const { connections } = require('../services');
+const { getLogoWidth, getColWidths, drawBoxHeader, drawBoxFooter, draw2ColHeader, visibleLength, padText } = require('../ui');
+
+/**
+ * Shows user information
+ * @param {Object} service - Current service
+ */
+const showUserInfo = async (service) => {
+  const spinner = ora('Fetching user info...').start();
+  const boxWidth = getLogoWidth();
+  const { col1, col2 } = getColWidths(boxWidth);
+
+  // Helper for row formatting
+  const fmtRow = (label, value, colW) => {
+    const labelStr = ' ' + label.padEnd(14);
+    const valueVisible = visibleLength(value || '');
+    const totalVisible = labelStr.length + valueVisible;
+    const padding = Math.max(0, colW - totalVisible);
+    return chalk.white(labelStr) + value + ' '.repeat(padding);
+  };
+
+  // Get user info
+  let userInfo = null;
+  let accountCount = 0;
+
+  if (service && service.user) {
+    userInfo = service.user;
+  } else if (service) {
+    const result = await service.getUser();
+    if (result.success) {
+      userInfo = result.user;
+    }
+  }
+
+  // Get account count
+  if (connections.count() > 0) {
+    const accounts = await connections.getAllAccounts();
+    accountCount = accounts.length;
+  } else if (service) {
+    const result = await service.getTradingAccounts();
+    if (result.success) {
+      accountCount = result.accounts.length;
+    }
+  }
+
+  spinner.succeed('User info loaded');
+  console.log();
+
+  drawBoxHeader('USER INFO', boxWidth);
+
+  if (!userInfo) {
+    console.log(chalk.cyan('║') + padText(chalk.gray('  No user info available'), boxWidth - 2) + chalk.cyan('║'));
+  } else {
+    draw2ColHeader('PROFILE', 'CONNECTIONS', boxWidth);
+
+    // Username
+    const username = userInfo.userName || userInfo.username || 'Unknown';
+    const connCount = connections.count() || 1;
+    console.log(chalk.cyan('║') + fmtRow('Username:', chalk.cyan(username.toUpperCase()), col1) + chalk.cyan('│') + fmtRow('Connections:', chalk.cyan(connCount.toString()), col2) + chalk.cyan('║'));
+
+    // Email
+    const email = userInfo.email || 'N/A';
+    console.log(chalk.cyan('║') + fmtRow('Email:', chalk.white(email), col1) + chalk.cyan('│') + fmtRow('Accounts:', chalk.cyan(accountCount.toString()), col2) + chalk.cyan('║'));
+
+    // User ID
+    const userId = userInfo.userId || userInfo.id || 'N/A';
+    const platform = service.propfirm?.name || 'ProjectX';
+    console.log(chalk.cyan('║') + fmtRow('User ID:', chalk.gray(userId.toString()), col1) + chalk.cyan('│') + fmtRow('Platform:', chalk.magenta(platform), col2) + chalk.cyan('║'));
+
+    // First/Last Name
+    const firstName = userInfo.firstName || '';
+    const lastName = userInfo.lastName || '';
+    const fullName = (firstName + ' ' + lastName).trim() || 'N/A';
+    console.log(chalk.cyan('║') + fmtRow('Name:', chalk.white(fullName), col1) + chalk.cyan('│') + padText('', col2) + chalk.cyan('║'));
+  }
+
+  drawBoxFooter(boxWidth);
+  console.log();
+
+  await inquirer.prompt([{ type: 'input', name: 'c', message: 'Press Enter to continue...' }]);
+};
+
+module.exports = { showUserInfo };

package/src/security/encryption.js

@@ -0,0 +1,168 @@
+/**
+ * @fileoverview Encryption utilities for secure data storage
+ * @module security/encryption
+ */
+
+const crypto = require('crypto');
+const os = require('os');
+
+// Algorithm configuration
+const ALGORITHM = 'aes-256-gcm';
+const IV_LENGTH = 16;
+const AUTH_TAG_LENGTH = 16;
+const SALT_LENGTH = 32;
+const KEY_LENGTH = 32;
+const ITERATIONS = 100000;
+
+/**
+ * Derives a unique machine key from hardware identifiers
+ * @returns {string} Machine-specific key
+ * @private
+ */
+const getMachineKey = () => {
+  const components = [
+    os.hostname(),
+    os.platform(),
+    os.arch(),
+    os.cpus()[0]?.model || 'unknown',
+    os.homedir(),
+    process.env.USER || process.env.USERNAME || 'user'
+  ];
+  return crypto.createHash('sha256').update(components.join('|')).digest('hex');
+};
+
+/**
+ * Derives encryption key from password and salt using PBKDF2
+ * @param {string} password - Password to derive key from
+ * @param {Buffer} salt - Salt for key derivation
+ * @returns {Buffer} Derived key
+ * @private
+ */
+const deriveKey = (password, salt) => {
+  return crypto.pbkdf2Sync(password, salt, ITERATIONS, KEY_LENGTH, 'sha512');
+};
+
+/**
+ * Encrypts data using AES-256-GCM
+ * @param {string} plaintext - Data to encrypt
+ * @param {string} [password] - Optional password (uses machine key if not provided)
+ * @returns {string} Encrypted data as hex string (salt:iv:authTag:ciphertext)
+ */
+const encrypt = (plaintext, password = null) => {
+  if (!plaintext) return '';
+  
+  const secret = password || getMachineKey();
+  const salt = crypto.randomBytes(SALT_LENGTH);
+  const key = deriveKey(secret, salt);
+  const iv = crypto.randomBytes(IV_LENGTH);
+  
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+  let encrypted = cipher.update(plaintext, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+  
+  const authTag = cipher.getAuthTag();
+  
+  // Format: salt:iv:authTag:ciphertext (all in hex)
+  return [
+    salt.toString('hex'),
+    iv.toString('hex'),
+    authTag.toString('hex'),
+    encrypted
+  ].join(':');
+};
+
+/**
+ * Decrypts data encrypted with AES-256-GCM
+ * @param {string} encryptedData - Encrypted data as hex string
+ * @param {string} [password] - Optional password (uses machine key if not provided)
+ * @returns {string|null} Decrypted plaintext or null if decryption fails
+ */
+const decrypt = (encryptedData, password = null) => {
+  if (!encryptedData) return null;
+  
+  try {
+    const parts = encryptedData.split(':');
+    if (parts.length !== 4) return null;
+    
+    const [saltHex, ivHex, authTagHex, ciphertext] = parts;
+    
+    const salt = Buffer.from(saltHex, 'hex');
+    const iv = Buffer.from(ivHex, 'hex');
+    const authTag = Buffer.from(authTagHex, 'hex');
+    
+    const secret = password || getMachineKey();
+    const key = deriveKey(secret, salt);
+    
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(authTag);
+    
+    let decrypted = decipher.update(ciphertext, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    
+    return decrypted;
+  } catch (error) {
+    // Decryption failed (wrong key, tampered data, etc.)
+    return null;
+  }
+};
+
+/**
+ * Hashes a password using SHA-512 with salt
+ * @param {string} password - Password to hash
+ * @returns {string} Hashed password (salt:hash in hex)
+ */
+const hashPassword = (password) => {
+  const salt = crypto.randomBytes(SALT_LENGTH);
+  const hash = crypto.pbkdf2Sync(password, salt, ITERATIONS, 64, 'sha512');
+  return salt.toString('hex') + ':' + hash.toString('hex');
+};
+
+/**
+ * Verifies a password against a hash
+ * @param {string} password - Password to verify
+ * @param {string} storedHash - Stored hash (salt:hash)
+ * @returns {boolean} True if password matches
+ */
+const verifyPassword = (password, storedHash) => {
+  try {
+    const [saltHex, hashHex] = storedHash.split(':');
+    const salt = Buffer.from(saltHex, 'hex');
+    const hash = crypto.pbkdf2Sync(password, salt, ITERATIONS, 64, 'sha512');
+    return hash.toString('hex') === hashHex;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Generates a secure random token
+ * @param {number} [length=32] - Token length in bytes
+ * @returns {string} Random token as hex string
+ */
+const generateToken = (length = 32) => {
+  return crypto.randomBytes(length).toString('hex');
+};
+
+/**
+ * Masks sensitive data for logging
+ * @param {string} data - Data to mask
+ * @param {number} [visibleChars=4] - Number of visible characters at start/end
+ * @returns {string} Masked data
+ */
+const maskSensitive = (data, visibleChars = 4) => {
+  if (!data || data.length <= visibleChars * 2) {
+    return '****';
+  }
+  const start = data.substring(0, visibleChars);
+  const end = data.substring(data.length - visibleChars);
+  return `${start}****${end}`;
+};
+
+module.exports = {
+  encrypt,
+  decrypt,
+  hashPassword,
+  verifyPassword,
+  generateToken,
+  maskSensitive
+};