onbuzz 3.3.0

package/src/utilities/logger.js

@@ -0,0 +1,436 @@
+/**
+ * Logger - Centralized logging system for the Loxia AI Agents System
+ * 
+ * Purpose:
+ * - Structured logging with different levels
+ * - Agent activity logging
+ * - Tool execution logging
+ * - System event logging
+ * - Log output management (console, file)
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+import {
+  SYSTEM_VERSION
+} from './constants.js';
+
+class Logger {
+  constructor(config = {}) {
+    this.config = config;
+    
+    // Log levels in order of severity
+    this.levels = {
+      error: 0,
+      warn: 1,
+      info: 2,
+      debug: 3
+    };
+    
+    this.currentLevel = this.levels[config.level || 'info'];
+    this.outputs = config.outputs || ['console'];
+    this.logFile = config.logFile || null;
+    this.maxFileSize = config.maxFileSize || 10 * 1024 * 1024; // 10MB
+    this.maxFiles = config.maxFiles || 5;
+    
+    // Log formatting
+    this.enableColors = config.colors !== false;
+    this.includeTimestamp = config.timestamp !== false;
+    this.includeLevel = config.includeLevel !== false;
+    
+    // Color codes for console output
+    this.colors = {
+      error: '\x1b[31m', // Red
+      warn: '\x1b[33m',  // Yellow
+      info: '\x1b[36m',  // Cyan
+      debug: '\x1b[90m', // Gray
+      reset: '\x1b[0m'
+    };
+    
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize logger
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    if (this.initialized) return;
+    
+    try {
+      // Create log directory if file output is enabled
+      if (this.outputs.includes('file') && this.logFile) {
+        const logDir = path.dirname(this.logFile);
+        await fs.mkdir(logDir, { recursive: true });
+      }
+      
+      this.initialized = true;
+      this.info('Logger initialized', {
+        level: Object.keys(this.levels)[this.currentLevel],
+        outputs: this.outputs,
+        logFile: this.logFile
+      });
+      
+    } catch (error) {
+      console.error('Logger initialization failed:', error.message);
+    }
+  }
+
+  /**
+   * Log error message
+   * @param {string} message - Log message
+   * @param {Object} meta - Additional metadata
+   */
+  error(message, meta = {}) {
+    this.log('error', message, meta);
+  }
+
+  /**
+   * Log warning message
+   * @param {string} message - Log message
+   * @param {Object} meta - Additional metadata
+   */
+  warn(message, meta = {}) {
+    this.log('warn', message, meta);
+  }
+
+  /**
+   * Log info message
+   * @param {string} message - Log message
+   * @param {Object} meta - Additional metadata
+   */
+  info(message, meta = {}) {
+    this.log('info', message, meta);
+  }
+
+  /**
+   * Log debug message
+   * @param {string} message - Log message
+   * @param {Object} meta - Additional metadata
+   */
+  debug(message, meta = {}) {
+    this.log('debug', message, meta);
+  }
+
+  /**
+   * Log agent activity
+   * @param {string} agentId - Agent identifier
+   * @param {string} action - Action performed
+   * @param {Object} details - Action details
+   */
+  logAgentActivity(agentId, action, details = {}) {
+    this.info(`[AGENT:${agentId}] ${action}`, {
+      category: 'agent-activity',
+      agentId,
+      action,
+      ...details
+    });
+  }
+
+  /**
+   * Log tool execution
+   * @param {string} toolId - Tool identifier
+   * @param {string} operationId - Operation identifier
+   * @param {string} status - Execution status
+   * @param {number} duration - Execution duration in ms
+   * @param {Object} details - Additional details
+   */
+  logToolExecution(toolId, operationId, status, duration, details = {}) {
+    const level = status === 'failed' ? 'error' : 'info';
+    this[level](`[TOOL:${toolId}] Operation ${operationId} ${status} (${duration}ms)`, {
+      category: 'tool-execution',
+      toolId,
+      operationId,
+      status,
+      duration,
+      ...details
+    });
+  }
+
+  /**
+   * Log system event
+   * @param {string} event - Event name
+   * @param {Object} context - Event context
+   */
+  logSystemEvent(event, context = {}) {
+    this.info(`[SYSTEM] ${event}`, {
+      category: 'system-event',
+      event,
+      ...context
+    });
+  }
+
+  /**
+   * Log API request/response
+   * @param {string} method - HTTP method
+   * @param {string} url - Request URL
+   * @param {number} status - Response status
+   * @param {number} duration - Request duration in ms
+   * @param {Object} details - Additional details
+   */
+  logApiRequest(method, url, status, duration, details = {}) {
+    const level = status >= 400 ? 'error' : 'info';
+    this[level](`[API] ${method} ${url} ${status} (${duration}ms)`, {
+      category: 'api-request',
+      method,
+      url,
+      status,
+      duration,
+      ...details
+    });
+  }
+
+  /**
+   * Log with specified level
+   * @param {string} level - Log level
+   * @param {string} message - Log message
+   * @param {Object} meta - Additional metadata
+   */
+  log(level, message, meta = {}) {
+    // Check if level is enabled
+    if (this.levels[level] > this.currentLevel) {
+      return;
+    }
+    
+    const logEntry = this.createLogEntry(level, message, meta);
+    
+    // Output to configured destinations
+    for (const output of this.outputs) {
+      switch (output) {
+        case 'console':
+          this.outputToConsole(logEntry);
+          break;
+        case 'file':
+          this.outputToFile(logEntry);
+          break;
+      }
+    }
+  }
+
+  /**
+   * Create structured log entry
+   * @private
+   */
+  createLogEntry(level, message, meta) {
+    const entry = {
+      timestamp: new Date().toISOString(),
+      level: level.toUpperCase(),
+      message,
+      version: SYSTEM_VERSION,
+      ...meta
+    };
+    
+    // Add process information
+    entry.pid = process.pid;
+    
+    // Add memory usage for debug level
+    if (level === 'debug') {
+      const memUsage = process.memoryUsage();
+      entry.memory = {
+        rss: Math.round(memUsage.rss / 1024 / 1024),
+        heapUsed: Math.round(memUsage.heapUsed / 1024 / 1024),
+        heapTotal: Math.round(memUsage.heapTotal / 1024 / 1024)
+      };
+    }
+    
+    return entry;
+  }
+
+  /**
+   * Output log entry to console
+   * @private
+   */
+  outputToConsole(entry) {
+    let output = '';
+    
+    // Add timestamp
+    if (this.includeTimestamp) {
+      const timestamp = new Date(entry.timestamp).toLocaleTimeString();
+      output += `[${timestamp}] `;
+    }
+    
+    // Add level with color
+    if (this.includeLevel) {
+      const levelStr = entry.level.padEnd(5);
+      if (this.enableColors && process.stdout.isTTY) {
+        const color = this.colors[entry.level.toLowerCase()] || '';
+        output += `${color}${levelStr}${this.colors.reset} `;
+      } else {
+        output += `${levelStr} `;
+      }
+    }
+    
+    // Add message
+    output += entry.message;
+    
+    // Add metadata if present
+    const { timestamp, level, message, version, pid, ...metadata } = entry;
+    if (Object.keys(metadata).length > 0) {
+      output += ` ${JSON.stringify(metadata)}`;
+    }
+    
+    // Output based on level
+    if (entry.level === 'ERROR') {
+      console.error(output);
+    } else {
+      console.log(output);
+    }
+  }
+
+  /**
+   * Output log entry to file
+   * @private
+   */
+  async outputToFile(entry) {
+    if (!this.logFile) return;
+    
+    try {
+      // Check file size and rotate if needed
+      await this.rotateLogFileIfNeeded();
+      
+      const logLine = JSON.stringify(entry) + '\n';
+      await fs.appendFile(this.logFile, logLine, 'utf8');
+      
+    } catch (error) {
+      console.error('Failed to write to log file:', error.message);
+    }
+  }
+
+  /**
+   * Rotate log file if it exceeds max size
+   * @private
+   */
+  async rotateLogFileIfNeeded() {
+    try {
+      const stats = await fs.stat(this.logFile);
+      
+      if (stats.size >= this.maxFileSize) {
+        await this.rotateLogFiles();
+      }
+      
+    } catch (error) {
+      // File doesn't exist yet, that's ok
+      if (error.code !== 'ENOENT') {
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Rotate log files
+   * @private
+   */
+  async rotateLogFiles() {
+    const dir = path.dirname(this.logFile);
+    const basename = path.basename(this.logFile, path.extname(this.logFile));
+    const ext = path.extname(this.logFile);
+    
+    // Rotate existing files
+    for (let i = this.maxFiles - 1; i >= 1; i--) {
+      const oldFile = path.join(dir, `${basename}.${i}${ext}`);
+      const newFile = path.join(dir, `${basename}.${i + 1}${ext}`);
+      
+      try {
+        await fs.rename(oldFile, newFile);
+      } catch (error) {
+        // File doesn't exist, continue
+        if (error.code !== 'ENOENT') {
+          console.error(`Failed to rotate log file ${oldFile}:`, error.message);
+        }
+      }
+    }
+    
+    // Move current file to .1
+    const rotatedFile = path.join(dir, `${basename}.1${ext}`);
+    try {
+      await fs.rename(this.logFile, rotatedFile);
+    } catch (error) {
+      console.error(`Failed to rotate current log file:`, error.message);
+    }
+  }
+
+  /**
+   * Set log level
+   * @param {string} level - New log level
+   */
+  setLevel(level) {
+    if (level in this.levels) {
+      this.currentLevel = this.levels[level];
+      this.info(`Log level changed to: ${level}`);
+    } else {
+      this.warn(`Invalid log level: ${level}. Valid levels: ${Object.keys(this.levels).join(', ')}`);
+    }
+  }
+
+  /**
+   * Add output destination
+   * @param {string} output - Output destination ('console' or 'file')
+   */
+  addOutput(output) {
+    if (!this.outputs.includes(output)) {
+      this.outputs.push(output);
+      this.info(`Added log output: ${output}`);
+    }
+  }
+
+  /**
+   * Remove output destination
+   * @param {string} output - Output destination to remove
+   */
+  removeOutput(output) {
+    const index = this.outputs.indexOf(output);
+    if (index > -1) {
+      this.outputs.splice(index, 1);
+      this.info(`Removed log output: ${output}`);
+    }
+  }
+
+  /**
+   * Create child logger with additional context
+   * @param {Object} context - Additional context to include in all logs
+   * @returns {Logger} Child logger instance
+   */
+  child(context) {
+    const childLogger = Object.create(this);
+    childLogger.childContext = { ...this.childContext, ...context };
+    return childLogger;
+  }
+
+  /**
+   * Flush any pending log entries
+   * @returns {Promise<void>}
+   */
+  async flush() {
+    // File system writes are typically immediate, but this provides
+    // a hook for more complex logging backends
+    return Promise.resolve();
+  }
+
+  /**
+   * Close logger and cleanup resources
+   * @returns {Promise<void>}
+   */
+  async close() {
+    await this.flush();
+    this.info('Logger closed');
+  }
+}
+
+/**
+ * Create a logger instance with specified configuration
+ * @param {Object} config - Logger configuration
+ * @returns {Logger} Logger instance
+ */
+function createLogger(config = {}) {
+  const logger = new Logger(config);
+  
+  // Auto-initialize if not explicitly disabled
+  if (config.autoInit !== false) {
+    setImmediate(() => logger.initialize());
+  }
+  
+  return logger;
+}
+
+export { Logger, createLogger };

package/src/utilities/platformUtils.js

@@ -0,0 +1,255 @@
+/**
+ * Platform Utilities Module
+ *
+ * Centralized platform abstraction for cross-platform compatibility.
+ * Provides functions for detecting platform, shell, paths, and other
+ * platform-specific configurations.
+ *
+ * @module platformUtils
+ */
+
+import os from 'os';
+import path from 'path';
+
+/**
+ * Platform constants
+ */
+export const PLATFORMS = {
+  MACOS: 'darwin',
+  WINDOWS: 'win32',
+  LINUX: 'linux'
+};
+
+/**
+ * Get the current platform
+ * @returns {string} Platform identifier (darwin, win32, linux)
+ */
+export function getPlatform() {
+  return process.platform;
+}
+
+/**
+ * Check if running on macOS
+ * @returns {boolean}
+ */
+export function isMacOS() {
+  return process.platform === 'darwin';
+}
+
+/**
+ * Check if running on Windows
+ * @returns {boolean}
+ */
+export function isWindows() {
+  return process.platform === 'win32';
+}
+
+/**
+ * Check if running on Linux
+ * @returns {boolean}
+ */
+export function isLinux() {
+  return process.platform === 'linux';
+}
+
+/**
+ * Detect the user's shell
+ * @returns {string} Shell type (zsh, bash, fish, powershell, cmd)
+ */
+export function getUserShell() {
+  if (isWindows()) {
+    // Windows: Check for PowerShell or CMD
+    if (process.env.PSModulePath) {
+      return 'powershell';
+    }
+    // Check if running in WSL or Git Bash
+    if (process.env.SHELL && process.env.SHELL.includes('bash')) {
+      return 'bash';
+    }
+    return 'cmd';
+  }
+
+  // Unix-like systems (macOS, Linux)
+  // macOS Catalina (10.15) and later default to zsh
+  const defaultShell = isMacOS() ? '/bin/zsh' : '/bin/bash';
+  const shell = process.env.SHELL || defaultShell;
+
+  if (shell.includes('zsh')) return 'zsh';
+  if (shell.includes('fish')) return 'fish';
+  if (shell.includes('bash')) return 'bash';
+
+  return 'bash'; // Fallback
+}
+
+/**
+ * Get the shell executable path
+ * @returns {string} Path to shell executable
+ */
+export function getShellPath() {
+  if (isWindows()) {
+    const shell = getUserShell();
+    if (shell === 'powershell') return 'powershell';
+    return 'cmd';
+  }
+
+  return process.env.SHELL || (isMacOS() ? '/bin/zsh' : '/bin/bash');
+}
+
+/**
+ * Get system restricted paths for the current platform
+ * These paths should be protected from unauthorized access
+ * @returns {string[]} Array of restricted paths
+ */
+export function getSystemRestrictedPaths() {
+  const common = [
+    '/etc',
+    '/var',
+    '/usr',
+    '/bin',
+    '/sbin',
+    '/boot',
+    '/dev',
+    '/proc',
+    '/sys'
+  ];
+
+  if (isMacOS()) {
+    return [
+      ...common,
+      '/System',
+      '/Library',
+      '/Applications',
+      '/private',
+      '/cores',
+      '/Volumes',
+      path.join(os.homedir(), 'Library')
+    ];
+  }
+
+  if (isWindows()) {
+    // Use environment variables for Windows paths (handles different drive letters)
+    const winDir = process.env.WINDIR || 'C:\\Windows';
+    const programFiles = process.env.ProgramFiles || 'C:\\Program Files';
+    const programFilesX86 = process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)';
+    return [winDir, programFiles, programFilesX86];
+  }
+
+  // Linux
+  return common;
+}
+
+/**
+ * Get platform-specific blocked file extensions
+ * Only blocks executables/installers for the current platform
+ * @returns {string[]} Array of blocked extensions
+ */
+export function getPlatformBlockedExtensions() {
+  // Universal - blocked on all platforms
+  const universal = ['.jar', '.apk'];
+
+  // Platform-specific executables and installers
+  const platformSpecific = {
+    darwin: ['.app', '.dmg', '.pkg', '.dylib'],
+    win32: ['.exe', '.dll', '.bat', '.cmd', '.ps1', '.msi'],
+    linux: ['.so', '.deb', '.rpm']
+  };
+
+  return [...universal, ...(platformSpecific[process.platform] || [])];
+}
+
+/**
+ * Normalize a path for comparison
+ * Handles case-insensitivity on macOS and Windows
+ * @param {string} p - Path to normalize
+ * @returns {string} Normalized path
+ */
+export function normalizePath(p) {
+  let normalized = path.normalize(p);
+
+  // macOS (APFS/HFS+) and Windows (NTFS) are case-insensitive
+  if (isMacOS() || isWindows()) {
+    normalized = normalized.toLowerCase();
+  }
+
+  return normalized;
+}
+
+/**
+ * Compare two paths for equality (case-aware based on platform)
+ * @param {string} path1 - First path
+ * @param {string} path2 - Second path
+ * @returns {boolean} True if paths are equal
+ */
+export function pathsEqual(path1, path2) {
+  return normalizePath(path1) === normalizePath(path2);
+}
+
+/**
+ * Check if targetPath starts with basePath (case-aware)
+ * @param {string} targetPath - Path to check
+ * @param {string} basePath - Base path to compare against
+ * @returns {boolean} True if targetPath starts with basePath
+ */
+export function pathStartsWith(targetPath, basePath) {
+  const normalizedTarget = normalizePath(targetPath);
+  const normalizedBase = normalizePath(basePath);
+  return normalizedTarget.startsWith(normalizedBase);
+}
+
+/**
+ * Get platform-appropriate default user agent for browser automation
+ * @returns {string} User agent string
+ */
+export function getDefaultUserAgent() {
+  if (isMacOS()) {
+    return 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+  }
+  if (isWindows()) {
+    return 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+  }
+  // Linux
+  return 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+}
+
+/**
+ * Get common Python executable locations for macOS
+ * Includes Homebrew and pyenv paths
+ * @returns {string[]} Array of Python paths to try
+ */
+export function getMacOSPythonPaths() {
+  if (!isMacOS()) return [];
+
+  const homeDir = os.homedir();
+  return [
+    '/opt/homebrew/bin/python3',           // Homebrew (Apple Silicon)
+    '/usr/local/bin/python3',               // Homebrew (Intel Mac)
+    `${homeDir}/.pyenv/shims/python3`,      // pyenv
+    `${homeDir}/.pyenv/shims/python`
+  ];
+}
+
+/**
+ * Check if a Python command is from Homebrew installation
+ * @param {string} pythonPath - Path to Python executable
+ * @returns {boolean} True if Homebrew Python
+ */
+export function isHomebrewPython(pythonPath) {
+  if (!pythonPath) return false;
+  return pythonPath.includes('/opt/homebrew') || pythonPath.includes('/usr/local/Cellar');
+}
+
+/**
+ * Get platform info object for logging/debugging
+ * @returns {object} Platform information
+ */
+export function getPlatformInfo() {
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    shell: getUserShell(),
+    shellPath: getShellPath(),
+    homeDir: os.homedir(),
+    tmpDir: os.tmpdir(),
+    nodeVersion: process.version
+  };
+}