@omindu/yaksha 1.0.0

package/src/utils/config.js

@@ -0,0 +1,205 @@
+'use strict';
+
+/**
+ * Yaksha Configuration Manager
+ * Handles configuration with validation and environment variable support
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Default configuration
+const DEFAULT_CONFIG = {
+  // Server settings
+  server: {
+    host: '0.0.0.0',
+    port: 8443,
+    maxConnections: 10000,
+    keepaliveInterval: 30000,
+    timeout: 60000
+  },
+
+  // Client settings
+  client: {
+    autoReconnect: true,
+    reconnectDelay: 1000,
+    maxReconnectDelay: 30000,
+    reconnectBackoff: 2.0,
+    keepaliveInterval: 30000
+  },
+
+  // Security settings
+  security: {
+    level: 'medium', // low, medium, high
+    authMethod: 'token', // password, token, certificate
+    rateLimit: {
+      enabled: true,
+      maxAttempts: 5,
+      windowMs: 60000
+    }
+  },
+
+  // Features
+  features: {
+    sniSpoofing: true,
+    trafficObfuscation: true,
+    multiPath: true,
+    dnsOverride: true,
+    tlsCamouflage: true,
+    firewallEvasion: true
+  },
+
+  // Performance
+  performance: {
+    bufferPooling: true,
+    zeroCopy: true,
+    compression: false
+  },
+
+  // Logging
+  logging: {
+    level: 'info', // debug, info, warn, error, none
+    timestamps: true,
+    colors: true
+  }
+};
+
+class Config {
+  constructor(customConfig = {}) {
+    this.config = this._merge(DEFAULT_CONFIG, customConfig);
+    this._loadFromEnv();
+  }
+
+  /**
+   * Deep merge two objects
+   */
+  _merge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+      if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        result[key] = this._merge(target[key] || {}, source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Load configuration from environment variables
+   */
+  _loadFromEnv() {
+    // Server
+    if (process.env.YAKSHA_HOST) {
+      this.config.server.host = process.env.YAKSHA_HOST;
+    }
+    if (process.env.YAKSHA_PORT) {
+      this.config.server.port = parseInt(process.env.YAKSHA_PORT, 10);
+    }
+
+    // Security
+    if (process.env.YAKSHA_SECURITY_LEVEL) {
+      this.config.security.level = process.env.YAKSHA_SECURITY_LEVEL.toLowerCase();
+    }
+    if (process.env.YAKSHA_AUTH_METHOD) {
+      this.config.security.authMethod = process.env.YAKSHA_AUTH_METHOD.toLowerCase();
+    }
+
+    // Logging
+    if (process.env.YAKSHA_LOG_LEVEL) {
+      this.config.logging.level = process.env.YAKSHA_LOG_LEVEL.toLowerCase();
+    }
+  }
+
+  /**
+   * Load configuration from file
+   */
+  loadFromFile(filePath) {
+    try {
+      const absolutePath = path.resolve(filePath);
+      const fileContent = fs.readFileSync(absolutePath, 'utf8');
+      const fileConfig = JSON.parse(fileContent);
+      this.config = this._merge(this.config, fileConfig);
+      return true;
+    } catch (error) {
+      throw new Error(`Failed to load config from ${filePath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get configuration value by path (e.g., 'server.port')
+   */
+  get(path) {
+    const keys = path.split('.');
+    let value = this.config;
+    for (const key of keys) {
+      if (value && typeof value === 'object' && key in value) {
+        value = value[key];
+      } else {
+        return undefined;
+      }
+    }
+    return value;
+  }
+
+  /**
+   * Set configuration value by path
+   */
+  set(path, value) {
+    const keys = path.split('.');
+    const lastKey = keys.pop();
+    let obj = this.config;
+    
+    for (const key of keys) {
+      if (!(key in obj)) {
+        obj[key] = {};
+      }
+      obj = obj[key];
+    }
+    
+    obj[lastKey] = value;
+  }
+
+  /**
+   * Get all configuration
+   */
+  getAll() {
+    return { ...this.config };
+  }
+
+  /**
+   * Validate configuration
+   */
+  validate() {
+    const errors = [];
+
+    // Validate security level
+    if (!['low', 'medium', 'high'].includes(this.config.security.level)) {
+      errors.push('Invalid security level. Must be: low, medium, or high');
+    }
+
+    // Validate auth method
+    if (!['password', 'token', 'certificate'].includes(this.config.security.authMethod)) {
+      errors.push('Invalid auth method. Must be: password, token, or certificate');
+    }
+
+    // Validate port
+    if (this.config.server.port < 1 || this.config.server.port > 65535) {
+      errors.push('Invalid port number. Must be between 1 and 65535');
+    }
+
+    // Validate log level
+    if (!['debug', 'info', 'warn', 'error', 'none'].includes(this.config.logging.level)) {
+      errors.push('Invalid log level. Must be: debug, info, warn, error, or none');
+    }
+
+    if (errors.length > 0) {
+      throw new Error(`Configuration validation failed:\n${errors.join('\n')}`);
+    }
+
+    return true;
+  }
+}
+
+module.exports = Config;
+module.exports.DEFAULT_CONFIG = DEFAULT_CONFIG;

package/src/utils/logger.js

@@ -0,0 +1,105 @@
+'use strict';
+
+/**
+ * Yaksha Logger - Performance-optimized logging utility
+ * Supports multiple log levels and async operation
+ */
+
+const LOG_LEVELS = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+  NONE: 4
+};
+
+class Logger {
+  constructor(options = {}) {
+    this.level = LOG_LEVELS[options.level] || LOG_LEVELS.INFO;
+    this.prefix = options.prefix || 'Yaksha';
+    this.timestamps = options.timestamps !== false;
+    this.colors = options.colors !== false && process.stdout.isTTY;
+  }
+
+  /**
+   * Format timestamp
+   */
+  _getTimestamp() {
+    if (!this.timestamps) return '';
+    const now = new Date();
+    return `[${now.toISOString()}] `;
+  }
+
+  /**
+   * Colorize output for terminal
+   */
+  _colorize(text, color) {
+    if (!this.colors) return text;
+    const colors = {
+      reset: '\x1b[0m',
+      red: '\x1b[31m',
+      yellow: '\x1b[33m',
+      blue: '\x1b[34m',
+      gray: '\x1b[90m'
+    };
+    return `${colors[color]}${text}${colors.reset}`;
+  }
+
+  /**
+   * Log debug message
+   */
+  debug(message, ...args) {
+    if (this.level <= LOG_LEVELS.DEBUG) {
+      const msg = `${this._getTimestamp()}${this._colorize('[DEBUG]', 'gray')} ${this.prefix}: ${message}`;
+      console.log(msg, ...args);
+    }
+  }
+
+  /**
+   * Log info message
+   */
+  info(message, ...args) {
+    if (this.level <= LOG_LEVELS.INFO) {
+      const msg = `${this._getTimestamp()}${this._colorize('[INFO]', 'blue')} ${this.prefix}: ${message}`;
+      console.log(msg, ...args);
+    }
+  }
+
+  /**
+   * Log warning message
+   */
+  warn(message, ...args) {
+    if (this.level <= LOG_LEVELS.WARN) {
+      const msg = `${this._getTimestamp()}${this._colorize('[WARN]', 'yellow')} ${this.prefix}: ${message}`;
+      console.warn(msg, ...args);
+    }
+  }
+
+  /**
+   * Log error message
+   */
+  error(message, ...args) {
+    if (this.level <= LOG_LEVELS.ERROR) {
+      const msg = `${this._getTimestamp()}${this._colorize('[ERROR]', 'red')} ${this.prefix}: ${message}`;
+      console.error(msg, ...args);
+    }
+  }
+
+  /**
+   * Set log level
+   */
+  setLevel(level) {
+    if (typeof level === 'string') {
+      this.level = LOG_LEVELS[level.toUpperCase()] || LOG_LEVELS.INFO;
+    } else {
+      this.level = level;
+    }
+  }
+}
+
+// Default logger instance
+const defaultLogger = new Logger();
+
+module.exports = Logger;
+module.exports.LOG_LEVELS = LOG_LEVELS;
+module.exports.default = defaultLogger;