lumisjs 1.0.0

package/src/health/HealthChecker.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const { EventEmitter } = require('node:events');
+const Logger = require('../utils/Logger');
+
+/**
+ * Health Checker
+ * Monitors system health and provides health check endpoints.
+ */
+
+class HealthChecker extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      checkInterval: options.checkInterval || 30000, // 30 seconds
+      timeout: options.timeout || 5000, // 5 seconds
+      ...options,
+    };
+
+    this.logger = new Logger({ prefix: 'HealthCheck', level: 'info' });
+
+    this.checks = new Map();
+    this.status = 'healthy';
+    this.lastCheck = null;
+    this._interval = null;
+  }
+
+  /**
+   * Register a health check.
+   * @param {string} name
+   * @param {Function} checkFn - Function that returns a Promise resolving to { status: 'ok'|'degraded'|'down', message?: string }
+   */
+  register(name, checkFn) {
+    if (typeof checkFn !== 'function') {
+      throw new TypeError('Health check must be a function');
+    }
+    this.checks.set(name, checkFn);
+    this.logger.info(`Registered health check: ${name}`);
+  }
+
+  /**
+   * Unregister a health check.
+   * @param {string} name
+   */
+  unregister(name) {
+    this.checks.delete(name);
+    this.logger.info(`Unregistered health check: ${name}`);
+  }
+
+  /**
+   * Run all health checks.
+   * @returns {Promise<object>}
+   */
+  async check() {
+    const results = {};
+    let overallStatus = 'healthy';
+    const now = Date.now();
+
+    for (const [name, checkFn] of this.checks) {
+      try {
+        const result = await Promise.race([
+          checkFn(),
+          new Promise((_, reject) => 
+            setTimeout(() => reject(new Error('Health check timeout')), this.options.timeout)
+          ),
+        ]);
+
+        results[name] = {
+          status: result.status || 'ok',
+          message: result.message || '',
+          timestamp: now,
+        };
+
+        if (result.status === 'down') {
+          overallStatus = 'unhealthy';
+        } else if (result.status === 'degraded' && overallStatus === 'healthy') {
+          overallStatus = 'degraded';
+        }
+      } catch (error) {
+        results[name] = {
+          status: 'down',
+          message: error.message,
+          timestamp: now,
+        };
+        overallStatus = 'unhealthy';
+        this.logger.error(`Health check failed: ${name}`, error);
+      }
+    }
+
+    this.status = overallStatus;
+    this.lastCheck = now;
+
+    const healthReport = {
+      status: overallStatus,
+      timestamp: now,
+      uptime: process.uptime(),
+      checks: results,
+    };
+
+    this.emit('check', healthReport);
+
+    if (overallStatus !== 'healthy') {
+      this.emit('unhealthy', healthReport);
+    }
+
+    return healthReport;
+  }
+
+  /**
+   * Start periodic health checks.
+   */
+  start() {
+    if (this._interval) return;
+    
+    this._interval = setInterval(() => this.check(), this.options.checkInterval);
+    if (this._interval.unref) this._interval.unref();
+    
+    this.logger.info('Health checker started');
+    this.emit('start');
+  }
+
+  /**
+   * Stop periodic health checks.
+   */
+  stop() {
+    if (this._interval) {
+      clearInterval(this._interval);
+      this._interval = null;
+    }
+    
+    this.logger.info('Health checker stopped');
+    this.emit('stop');
+  }
+
+  /**
+   * Get current health status without running checks.
+   * @returns {object}
+   */
+  getStatus() {
+    return {
+      status: this.status,
+      lastCheck: this.lastCheck,
+      uptime: process.uptime(),
+    };
+  }
+
+  /**
+   * Get a simplified health report for quick checks.
+   * @returns {Promise<object>}
+   */
+  async quickCheck() {
+    const report = await this.check();
+    return {
+      status: report.status,
+      timestamp: report.timestamp,
+    };
+  }
+
+  /**
+   * Destroy the health checker.
+   */
+  destroy() {
+    this.stop();
+    this.checks.clear();
+    this.removeAllListeners();
+  }
+}
+
+module.exports = HealthChecker;

package/src/health/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const HealthChecker = require('./HealthChecker');
+
+module.exports = {
+  HealthChecker,
+};

package/src/performance/PerformanceMonitor.js

@@ -0,0 +1,244 @@
+'use strict';
+
+const { EventEmitter } = require('node:events');
+const Logger = require('../utils/Logger');
+
+/**
+ * Performance Monitor
+ * Tracks and reports performance metrics for the application.
+ */
+
+class PerformanceMonitor extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      sampleInterval: options.sampleInterval || 1000,
+      historySize: options.historySize || 60,
+      alertThresholds: options.alertThresholds || {
+        cpu: 80, // percentage
+        memory: 80, // percentage
+        eventLoopDelay: 100, // milliseconds
+      },
+      ...options,
+    };
+
+    this.logger = new Logger({ prefix: 'PerfMon', level: 'info' });
+
+    this.metrics = {
+      cpu: [],
+      memory: [],
+      eventLoopDelay: [],
+      eventLoopUtilization: [],
+    };
+
+    this._monitoring = false;
+    this._interval = null;
+  }
+
+  /**
+   * Start performance monitoring.
+   */
+  start() {
+    if (this._monitoring) return;
+    
+    this._monitoring = true;
+    this._interval = setInterval(() => this._sample(), this.options.sampleInterval);
+    if (this._interval.unref) this._interval.unref();
+    
+    this.logger.info('Performance monitoring started');
+    this.emit('start');
+  }
+
+  /**
+   * Stop performance monitoring.
+   */
+  stop() {
+    if (!this._monitoring) return;
+    
+    this._monitoring = false;
+    if (this._interval) {
+      clearInterval(this._interval);
+      this._interval = null;
+    }
+    
+    this.logger.info('Performance monitoring stopped');
+    this.emit('stop');
+  }
+
+  /**
+   * Get current performance metrics.
+   * @returns {Promise<object>}
+   */
+  async getMetrics() {
+    const cpuUsage = process.cpuUsage();
+    const memoryUsage = process.memoryUsage();
+    
+    return {
+      cpu: {
+        user: cpuUsage.user,
+        system: cpuUsage.system,
+        percent: this._calculateCPUPercent(cpuUsage),
+      },
+      memory: {
+        rss: memoryUsage.rss,
+        heapTotal: memoryUsage.heapTotal,
+        heapUsed: memoryUsage.heapUsed,
+        external: memoryUsage.external,
+        arrayBuffers: memoryUsage.arrayBuffers,
+        percent: (memoryUsage.heapUsed / memoryUsage.heapTotal) * 100,
+      },
+      eventLoop: {
+        delay: await this._measureEventLoopDelay(),
+        utilization: await this._measureEventLoopUtilization(),
+      },
+      uptime: process.uptime(),
+      timestamp: Date.now(),
+    };
+  }
+
+  /**
+   * Get historical metrics.
+   * @returns {object}
+   */
+  getHistory() {
+    return {
+      cpu: [...this.metrics.cpu],
+      memory: [...this.metrics.memory],
+      eventLoopDelay: [...this.metrics.eventLoopDelay],
+      eventLoopUtilization: [...this.metrics.eventLoopUtilization],
+    };
+  }
+
+  /**
+   * Get performance summary.
+   * @returns {object}
+   */
+  getSummary() {
+    const avgCPU = this._average(this.metrics.cpu);
+    const avgMemory = this._average(this.metrics.memory);
+    const avgEventLoopDelay = this._average(this.metrics.eventLoopDelay);
+    const avgEventLoopUtil = this._average(this.metrics.eventLoopUtilization);
+
+    return {
+      cpu: {
+        average: avgCPU,
+        max: Math.max(...this.metrics.cpu, 0),
+        min: Math.min(...this.metrics.cpu, 100),
+      },
+      memory: {
+        average: avgMemory,
+        max: Math.max(...this.metrics.memory, 0),
+        min: Math.min(...this.metrics.memory, 100),
+      },
+      eventLoop: {
+        averageDelay: avgEventLoopDelay,
+        maxDelay: Math.max(...this.metrics.eventLoopDelay, 0),
+        averageUtilization: avgEventLoopUtil,
+        maxUtilization: Math.max(...this.metrics.eventLoopUtilization, 0),
+      },
+      monitoring: this._monitoring,
+      samples: this.metrics.cpu.length,
+    };
+  }
+
+  /**
+   * Reset metrics history.
+   */
+  reset() {
+    this.metrics = {
+      cpu: [],
+      memory: [],
+      eventLoopDelay: [],
+      eventLoopUtilization: [],
+    };
+    
+    this.emit('reset');
+  }
+
+  /** @private */
+  async _sample() {
+    const metrics = await this.getMetrics();
+    
+    // Add to history
+    this._addToHistory('cpu', metrics.cpu.percent);
+    this._addToHistory('memory', metrics.memory.percent);
+    this._addToHistory('eventLoopDelay', metrics.eventLoop.delay);
+    this._addToHistory('eventLoopUtilization', metrics.eventLoop.utilization);
+
+    // Check thresholds
+    this._checkThresholds(metrics);
+
+    this.emit('sample', metrics);
+  }
+
+  /** @private */
+  _addToHistory(type, value) {
+    this.metrics[type].push(value);
+    
+    if (this.metrics[type].length > this.options.historySize) {
+      this.metrics[type].shift();
+    }
+  }
+
+  /** @private */
+  _calculateCPUPercent(cpuUsage) {
+    const total = cpuUsage.user + cpuUsage.system;
+    // This is a simplified calculation
+    return (total / 1000000) * 100;
+  }
+
+  /** @private */
+  async _measureEventLoopDelay() {
+    return new Promise((resolve) => {
+      const start = process.hrtime.bigint();
+      setImmediate(() => {
+        const delay = Number(process.hrtime.bigint() - start) / 1000000; // Convert to ms
+        resolve(delay);
+      });
+    });
+  }
+
+  /** @private */
+  async _measureEventLoopUtilization() {
+    if (process.eventLoopUtilization) {
+      const utilization = process.eventLoopUtilization();
+      return utilization.utilization;
+    }
+    return 0;
+  }
+
+  /** @private */
+  _average(arr) {
+    if (arr.length === 0) return 0;
+    return arr.reduce((a, b) => a + b, 0) / arr.length;
+  }
+
+  /** @private */
+  _checkThresholds(metrics) {
+    const thresholds = this.options.alertThresholds;
+    
+    if (metrics.cpu.percent > thresholds.cpu) {
+      this.emit('alert', { type: 'cpu', value: metrics.cpu.percent, threshold: thresholds.cpu });
+    }
+    
+    if (metrics.memory.percent > thresholds.memory) {
+      this.emit('alert', { type: 'memory', value: metrics.memory.percent, threshold: thresholds.memory });
+    }
+    
+    if (metrics.eventLoop.delay > thresholds.eventLoopDelay) {
+      this.emit('alert', { type: 'eventLoop', value: metrics.eventLoop.delay, threshold: thresholds.eventLoopDelay });
+    }
+  }
+
+  /**
+   * Destroy the monitor.
+   */
+  destroy() {
+    this.stop();
+    this.reset();
+    this.removeAllListeners();
+  }
+}
+
+module.exports = PerformanceMonitor;

package/src/performance/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const PerformanceMonitor = require('./PerformanceMonitor');
+
+module.exports = {
+  PerformanceMonitor,
+};

package/src/security/InputSanitizer.js

@@ -0,0 +1,185 @@
+'use strict';
+
+/**
+ * Input Sanitizer
+ * Provides utilities for sanitizing user input to prevent XSS, injection attacks, etc.
+ */
+
+class InputSanitizer {
+  /**
+   * Sanitize a string by removing potentially dangerous characters.
+   * @param {string} input
+   * @param {object} [options]
+   * @param {boolean} [options.allowHTML=false]
+   * @param {boolean} [options.allowScript=false]
+   * @param {number} [options.maxLength=1000]
+   * @returns {string}
+   */
+  static sanitize(input, options = {}) {
+    if (typeof input !== 'string') return '';
+    
+    const {
+      allowHTML = false,
+      allowScript = false,
+      maxLength = 1000,
+    } = options;
+
+    let sanitized = input;
+
+    // Truncate if too long
+    if (sanitized.length > maxLength) {
+      sanitized = sanitized.substring(0, maxLength);
+    }
+
+    // Remove script tags
+    if (!allowScript) {
+      sanitized = sanitized.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '');
+    }
+
+    // Remove dangerous HTML tags if not allowed
+    if (!allowHTML) {
+      const dangerousTags = ['<script', '<iframe', '<object', '<embed', '<form', '<input', '<button'];
+      for (const tag of dangerousTags) {
+        sanitized = sanitized.replace(new RegExp(tag, 'gi'), '');
+      }
+      // Remove all HTML tags
+      sanitized = sanitized.replace(/<[^>]*>/g, '');
+    } else {
+      // Still remove dangerous attributes
+      sanitized = sanitized.replace(/on\w+\s*=/gi, '');
+      sanitized = sanitized.replace(/javascript:/gi, '');
+      sanitized = sanitized.replace(/data:/gi, '');
+    }
+
+    // Remove null bytes and other control characters
+    sanitized = sanitized.replace(/[\x00-\x1F\x7F]/g, '');
+
+    return sanitized.trim();
+  }
+
+  /**
+   * Sanitize a number to prevent injection.
+   * @param {any} input
+   * @param {object} [options]
+   * @param {number} [options.min]
+   * @param {number} [options.max]
+   * @param {boolean} [options.allowFloat=true]
+   * @returns {number|null}
+   */
+  static sanitizeNumber(input, options = {}) {
+    const { min, max, allowFloat = true } = options;
+    
+    let num = allowFloat ? parseFloat(input) : parseInt(input, 10);
+    
+    if (isNaN(num)) return null;
+    
+    if (min !== undefined && num < min) num = min;
+    if (max !== undefined && num > max) num = max;
+    
+    return num;
+  }
+
+  /**
+   * Sanitize a boolean value.
+   * @param {any} input
+   * @returns {boolean}
+   */
+  static sanitizeBoolean(input) {
+    if (typeof input === 'boolean') return input;
+    if (typeof input === 'string') {
+      return input.toLowerCase() === 'true' || input === '1';
+    }
+    return Boolean(input);
+  }
+
+  /**
+   * Sanitize an object by recursively sanitizing all string values.
+   * @param {object} obj
+   * @param {object} [options]
+   * @returns {object}
+   */
+  static sanitizeObject(obj, options = {}) {
+    if (obj === null || typeof obj !== 'object') return obj;
+    
+    if (Array.isArray(obj)) {
+      return obj.map(item => this.sanitizeObject(item, options));
+    }
+    
+    const sanitized = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (typeof value === 'string') {
+        sanitized[key] = this.sanitize(value, options);
+      } else if (typeof value === 'object') {
+        sanitized[key] = this.sanitizeObject(value, options);
+      } else {
+        sanitized[key] = value;
+      }
+    }
+    
+    return sanitized;
+  }
+
+  /**
+   * Validate and sanitize a Discord ID.
+   * @param {string} input
+   * @returns {string|null}
+   */
+  static sanitizeDiscordId(input) {
+    if (typeof input !== 'string') return null;
+    
+    // Discord IDs are numeric strings, typically 17-19 digits
+    const match = input.match(/^\d{17,19}$/);
+    return match ? match[0] : null;
+  }
+
+  /**
+   * Validate and sanitize a URL.
+   * @param {string} input
+   * @param {object} [options]
+   * @param {string[]} [options.allowedProtocols=['https', 'http']]
+   * @returns {string|null}
+   */
+  static sanitizeURL(input, options = {}) {
+    if (typeof input !== 'string') return null;
+    
+    const { allowedProtocols = ['https', 'http'] } = options;
+    
+    try {
+      const url = new URL(input);
+      
+      if (!allowedProtocols.includes(url.protocol.replace(':', ''))) {
+        return null;
+      }
+      
+      // Remove javascript: and data: protocols
+      if (url.protocol === 'javascript:' || url.protocol === 'data:') {
+        return null;
+      }
+      
+      return url.toString();
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Escape special characters for regex.
+   * @param {string} string
+   * @returns {string}
+   */
+  static escapeRegex(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+
+  /**
+   * Validate input against a whitelist of allowed values.
+   * @param {any} input
+   * @param {any[]} allowedValues
+   * @returns {any|null}
+   */
+  static validateWhitelist(input, allowedValues) {
+    return allowedValues.includes(input) ? input : null;
+  }
+}
+
+module.exports = InputSanitizer;