@feardread/fear 1.0.1

package/FEARServer.js

@@ -0,0 +1,280 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const express = require('express');
+require("dotenv").config();
+
+const FearServer = (function () {
+  // Private constants
+  const DEFAULT_PATHS = {
+    root: path.resolve(),
+    app: '/backend/dashboard/build',
+    build: 'backend/dashboard/build'
+  };
+
+  const DEFAULT_PORT = 4000;
+  const SHUTDOWN_TIMEOUT = 10000; // 10 seconds
+
+  // Constructor
+  function FearServer() {
+    this.fear = null;
+    this.server = null;
+    this.Router = null;
+    this.isShuttingDown = false;
+    this.rootDir = path.resolve();
+  }
+
+  FearServer.prototype = {
+    constructor: FearServer,
+
+    /**
+     * Configure static file serving for React SPA
+     * @param {string} root - Root directory path
+     * @param {string} app - App directory path
+     * @param {string} build - Build directory path
+     * @param {string} basePath - Base path for the app (e.g., '/fear/sites/ghap')
+     */
+    setupStaticFiles(root, app, build, basePath = '') {
+      this.rootDir = root || path.resolve();
+      const buildPath = path.join(this.rootDir, app);
+      const indexPath = path.resolve(this.rootDir, build, "index.html");
+
+      const normalizedBasePath = basePath
+        ? `/${basePath.replace(/^\/+|\/+$/g, '')}`
+        : '';
+
+        
+      this.fear.getLogger().info(`Serving static files from: ${buildPath}`);
+      this.fear.getLogger().info(`Base URL path: ${normalizedBasePath || '/'}`);
+
+      this.fear.getApp().use(
+        normalizedBasePath,
+        express.static(buildPath, {
+          index: false,
+          fallthrough: true 
+        })
+      );
+
+      this.fear.getApp().get(`${normalizedBasePath}/*`, (req, res) => {
+        res.sendFile(indexPath, (err) => {
+          if (err) {
+            this.fear.getLogger().error('Error serving index.html:', err);
+            res.status(500).send('Internal Server Error');
+          }
+        });
+      });
+    },
+
+    /**
+     * Setup process event handlers for graceful shutdown
+     */
+    setupProcessHandlers() {
+      // Handle unhandled promise rejections
+      process.on("unhandledRejection", (reason, promise) => {
+        console.log('Unhandled Rejection at:', promise, 'reason:', reason);
+        this.fear.getLogger().error('Unhandled Rejection at:', promise, 'reason:', reason);
+        //this.gracefulShutdown('unhandledRejection');
+      });
+
+      // Handle uncaught exceptions
+      process.on("uncaughtException", (err) => {
+        this.fear.getLogger().error('Uncaught Exception:', err);
+        this.gracefulShutdown('uncaughtException');
+      });
+
+      // Handle termination signals
+      process.on('SIGTERM', () => {
+        this.fear.getLogger().info('SIGTERM received, starting graceful shutdown');
+        this.gracefulShutdown('SIGTERM');
+      });
+
+      process.on('SIGINT', () => {
+        this.fear.getLogger().info('SIGINT received, starting graceful shutdown');
+        this.gracefulShutdown('SIGINT');
+      });
+    },
+
+    /**
+     * Initialize database connection
+     */
+    initializeDatabase() {
+      return new Promise((resolve, reject) => {
+        try {
+          this.fear.getDatabase().connect(this.fear.getEnvironment(), (err) => {
+            if (err) {
+              this.fear.getLogger().error('Database initialization failed:', err);
+              return reject(err);
+            }
+
+            this.fear.getLogger().info('Database initialized successfully');
+            resolve();
+          });
+        } catch (error) {
+          this.fear.getLogger().error('Database setup error:', error);
+          reject(error);
+        }
+      });
+    },
+
+    /**
+     * Start HTTP server on specified port
+     */
+    startHttpServer(port) {
+      return new Promise((resolve, reject) => {
+        const server = this.fear.getApp().listen(port, (err) => {
+          if (err) {
+            this.fear.getLogger().error(`Failed to start server on port ${port}:`, err);
+            return reject(err);
+          }
+          resolve(server);
+        });
+
+        server.on('error', (err) => {
+          if (err.code === 'EADDRINUSE') {
+            this.fear.getLogger().error(`Port ${port} is already in use`);
+          } else {
+            this.fear.getLogger().error('Server error:', err);
+          }
+          reject(err);
+        });
+      });
+    },
+
+    /**
+     * Perform graceful shutdown
+     */
+    gracefulShutdown(signal) {
+      if (this.isShuttingDown) {
+        this.fear.getLogger().warn('Shutdown already in progress...');
+        return Promise.resolve();
+      }
+
+      this.isShuttingDown = true;
+      this.fear.getLogger().info(`Graceful shutdown initiated by: ${signal}`);
+
+      // Force shutdown after timeout
+      const forceShutdownTimeout = setTimeout(() => {
+        this.fear.getLogger().error('Forced shutdown after timeout');
+        process.exit(1);
+      }, SHUTDOWN_TIMEOUT);
+
+      // Close server connections
+      const closeServerPromise = this.server
+        ? new Promise((resolve) => this.server.close(resolve))
+        : Promise.resolve();
+
+      return closeServerPromise
+        .then(() => {
+          // Shutdown FEAR application
+          if (this.fear && typeof this.fear.shutdown === 'function') {
+            return this.fear.shutdown();
+          }
+        })
+        .then(() => {
+          clearTimeout(forceShutdownTimeout);
+          this.fear.getLogger().info('Graceful shutdown completed');
+          process.exit(0);
+        })
+        .catch((error) => {
+          this.fear.getLogger().error('Error during shutdown:', error);
+          process.exit(1);
+        });
+    },
+
+    /**
+     * Initialize FEAR application
+     */
+    initialize(paths = DEFAULT_PATHS) {
+      try {
+        // Import FEAR after dotenv is configured
+        const FearFactory = require("./FEAR");
+        this.fear = new FearFactory();
+        this.Router = this.fear.Router;
+
+        this.setupStaticFiles(paths.root, paths.app, paths.build, paths.basePath);
+        this.setupProcessHandlers();
+
+        return Promise.resolve(this.fear);
+      } catch (error) {
+        console.error('Failed to initialize FEAR application:', error);
+        process.exit(1);
+      }
+    },
+
+    /**
+     * Start the server
+     */
+    startServer() {
+      const port = this.fear.getApp().get("PORT") || DEFAULT_PORT;
+      const logger = this.fear.getLogger();
+
+      // Display logo
+      if (this.fear.logo) {
+        logger.warn(this.fear.logo);
+      }
+
+      // Initialize database connection
+      return this.initializeDatabase()
+        .then(() => {
+          // Start the HTTP server
+          return this.startHttpServer(port);
+        })
+        .then((server) => {
+          this.server = server;
+          logger.info(`FEAR API Initialized :: Port ${port}`);
+          return server;
+        })
+        .catch((error) => {
+          logger.error('Failed to start server:', error);
+          throw error;
+        });
+    },
+
+    /**
+     * Get logger instance
+     */
+    getLogger() {
+      return this.fear ? this.fear.getLogger() : null;
+    },
+
+    /**
+     * Get FEAR instance
+     */
+    getFear() {
+      return this.fear;
+    },
+
+    /**
+     * Get HTTP server instance
+     */
+    getServer() {
+      return this.server;
+    },
+
+    /**
+     * Get Router instance
+     */
+    getRouter() {
+      return this.Router;
+    },
+
+    /**
+     * Check if server is shutting down
+     */
+    getIsShuttingDown() {
+      return this.isShuttingDown;
+    },
+
+    /**
+     * Get root directory path
+     */
+    getRootDir() {
+      return this.rootDir;
+    }
+  };
+
+  return FearServer;
+
+})();
+
+module.exports = FearServer;

package/controllers/agent.js

@@ -0,0 +1,438 @@
+const SecurityAgent = require('../libs/agent');
+
+class AgentController {
+  constructor() {
+    this.agentInstance = null;
+    this.isInitialized = false;
+  }
+
+  /**
+   * Get or create agent instance (singleton pattern)
+   */
+  getInstance() {
+    if (!this.agentInstance) {
+      this.agentInstance = new SecurityAgent();
+      this.isInitialized = false;
+    }
+    return this.agentInstance;
+  }
+
+  /**
+   * Initialize the security agent
+   */
+  async initialize(req, res, handler, logger) {
+    try {
+      const agent = this.getInstance();
+      
+      if (this.isInitialized) {
+        return res.status(200).json({
+          success: true,
+          message: 'Agent already initialized',
+          initialized: true
+        });
+      }
+
+      // Agent auto-loads modules in constructor
+      this.isInitialized = true;
+
+      logger.info('Agent initialized via API');
+      
+      return handler.success(res, {
+        success: true,
+        message: 'Agent initialized successfully',
+        initialized: true,
+        modulesLoaded: Object.keys(agent.modules).length,
+        commandsRegistered: Object.keys(agent.commands).length
+      });
+
+    } catch (error) {
+      logger.error('Agent initialization error:', error);
+      return new handler.error(res, error.message || 'Failed to initialize agent', 500);
+    }
+  }
+
+  /**
+   * Execute a single command
+   */
+  async executeCommand(req, res, handler, logger) {
+    try {
+      const { command, args } = req.body;
+
+      if (!command) {
+        return handler.error(res, 'Command is required', 400);
+      }
+
+      const agent = this.getInstance();
+      
+      if (!this.isInitialized) {
+        this.isInitialized = true;
+      }
+
+      // Check if command exists
+      if (!agent.commands[command]) {
+        return handler.error(res, `Unknown command: ${command}`, 400);
+      }
+
+      // Parse args
+      const parsedArgs = Array.isArray(args) ? args : (args ? [args] : []);
+
+      // Execute command and capture output
+      const output = await this.captureCommandOutput(
+        () => agent.commands[command](parsedArgs)
+      );
+
+      logger.info(`Agent command executed: ${command}`);
+      
+      return handler.success(res, {
+        success: true,
+        command,
+        output,
+        executedAt: new Date().toISOString()
+      });
+
+    } catch (error) {
+      logger.error('Agent command execution error:', error);
+      return new handler.error(res, error.message || 'Command execution failed', 500);
+    }
+  }
+
+  /**
+   * Execute multiple commands in sequence
+   */
+  async executeBatch(req, res, handler, logger) {
+    try {
+      const { commands } = req.body;
+
+      if (!Array.isArray(commands) || commands.length === 0) {
+        return handler.error(res, 'Commands array is required', 400);
+      }
+
+      const agent = this.getInstance();
+      
+      if (!this.isInitialized) {
+        this.isInitialized = true;
+      }
+
+      const results = [];
+
+      for (const cmdConfig of commands) {
+        const { command, args } = cmdConfig;
+        
+        if (!command) {
+          results.push({
+            success: false,
+            error: 'Command name is required'
+          });
+          continue;
+        }
+
+        if (!agent.commands[command]) {
+          results.push({
+            success: false,
+            command,
+            error: `Unknown command: ${command}`
+          });
+          continue;
+        }
+
+        try {
+          const parsedArgs = Array.isArray(args) ? args : (args ? [args] : []);
+          const output = await this.captureCommandOutput(
+            () => agent.commands[command](parsedArgs)
+          );
+
+          results.push({
+            success: true,
+            command,
+            output
+          });
+        } catch (error) {
+          results.push({
+            success: false,
+            command,
+            error: error.message
+          });
+        }
+      }
+
+      logger.info(`Agent batch execution: ${commands.length} commands`);
+      
+      return handler.success(res, {
+        success: true,
+        totalCommands: commands.length,
+        results,
+        executedAt: new Date().toISOString()
+      });
+
+    } catch (error) {
+      logger.error('Agent batch execution error:', error);
+      return handler.error(res, error.message || 'Batch execution failed', 500);
+    }
+  }
+
+  /**
+   * Get all available commands
+   */
+  async getCommands(req, res, handler, logger) {
+    try {
+      const agent = this.getInstance();
+      
+      if (!this.isInitialized) {
+        this.isInitialized = true;
+      }
+
+      const commands = {};
+      
+      // Build command list with descriptions
+      Object.entries(agent.mappings).forEach(([cmd, config]) => {
+        commands[cmd] = {
+          description: config.description,
+          module: config.module,
+          method: config.method
+        };
+      });
+
+      // Add built-in commands
+      const builtInCommands = {
+        'help': { description: 'Show help information', module: 'core', method: 'showHelp' },
+        'status': { description: 'Show system status', module: 'core', method: 'showStatus' },
+        'history': { description: 'Show command history', module: 'core', method: 'showHistory' },
+        'clear': { description: 'Clear screen', module: 'core', method: 'clearScreen' },
+        'banner': { description: 'Show banner', module: 'core', method: 'showBanner' },
+        'version': { description: 'Show version info', module: 'core', method: 'showVersion' },
+        'tips': { description: 'Show tips and tricks', module: 'core', method: 'showTips' },
+        'exit': { description: 'Exit agent', module: 'core', method: 'exit' }
+      };
+
+      Object.assign(commands, builtInCommands);
+
+      return handler.success(res, {
+        success: true,
+        totalCommands: Object.keys(commands).length,
+        commands
+      });
+
+    } catch (error) {
+      logger.error('Error fetching commands:', error);
+      return handler.error(res, 'Failed to fetch commands', 500);
+    }
+  }
+
+  /**
+   * Check if a specific command exists
+   */
+  async checkCommand(req, res, handler, logger) {
+    try {
+      const { command } = req.params;
+      const agent = this.getInstance();
+      
+      if (!this.isInitialized) {
+        this.isInitialized = true;
+      }
+
+      const exists = !!agent.commands[command];
+      const config = agent.mappings[command];
+
+      return handler.success(res, {
+        success: true,
+        command,
+        exists,
+        details: config || null
+      });
+
+    } catch (error) {
+      logger.error('Error checking command:', error);
+      return handler.error(res, 'Failed to check command', 500);
+    }
+  }
+
+  /**
+   * Get agent and module status
+   */
+  async getStatus(req, res, handler, logger) {
+    try {
+      const agent = this.getInstance();
+      
+      if (!this.isInitialized) {
+        return handler.success(res, {
+          success: true,
+          initialized: false,
+          message: 'Agent not initialized'
+        });
+      }
+
+      // Get module status
+      const modules = {};
+      agent.definitions.forEach(moduleDef => {
+        const module = agent.modules[moduleDef.name];
+        modules[moduleDef.name] = {
+          displayName: moduleDef.displayName,
+          loaded: !!module,
+          status: module ? 'ready' : 'unavailable'
+        };
+
+        // Special handling for AI modules
+        if (moduleDef.name === 'aiAnalyzer' && module) {
+          modules[moduleDef.name].configured = module.isConfigured ? module.isConfigured() : false;
+          modules[moduleDef.name].provider = module.getProviderName ? module.getProviderName() : null;
+        }
+        if (moduleDef.name === 'aiChat' && module) {
+          modules[moduleDef.name].configured = module.isConfigured ? module.isConfigured() : false;
+        }
+      });
+
+      // Get background services status
+      const services = {};
+      agent.backgroundServices.forEach((service, name) => {
+        services[name] = agent.serviceStatus.get(name) || 'stopped';
+      });
+
+      const version = this.getVersionInfo(agent);
+
+      return handler.success(res, {
+        success: true,
+        initialized: true,
+        version,
+        modules,
+        services,
+        stats: {
+          modulesLoaded: Object.keys(agent.modules).length,
+          commandsAvailable: Object.keys(agent.commands).length,
+          servicesRunning: Array.from(agent.serviceStatus.values()).filter(s => s === 'running').length,
+          commandHistory: agent.commandHistory.length
+        }
+      });
+
+    } catch (error) {
+      logger.error('Error fetching agent status:', error);
+      return handler.error(res, 'Failed to fetch status', 500);
+    }
+  }
+
+  /**
+   * Get command history
+   */
+  async getHistory(req, res, handler, logger) {
+    try {
+      const { limit } = req.query;
+      const agent = this.getInstance();
+      
+      if (!this.isInitialized) {
+        return handler.success(res, {
+          success: true,
+          history: [],
+          message: 'Agent not initialized'
+        });
+      }
+
+      const limitNum = limit ? parseInt(limit) : 20;
+      const history = agent.commandHistory.slice(-limitNum);
+
+      return handler.success(res, {
+        success: true,
+        total: agent.commandHistory.length,
+        limit: limitNum,
+        history
+      });
+
+    } catch (error) {
+      logger.error('Error fetching history:', error);
+      return handler.error(res, 'Failed to fetch history', 500);
+    }
+  }
+
+  /**
+   * Get agent version information
+   */
+  async getVersion(req, res, handler, logger) {
+    try {
+      const agent = this.getInstance();
+      const version = this.getVersionInfo(agent);
+
+      return handler.success(res, {
+        success: true,
+        ...version
+      });
+
+    } catch (error) {
+      logger.error('Error fetching version:', error);
+      return handler.error(res, 'Failed to fetch version', 500);
+    }
+  }
+
+  /**
+   * Shutdown the agent
+   */
+  async shutdown(req, res, handler, logger) {
+    try {
+      const agent = this.getInstance();
+
+      // Stop all background services
+      const stoppedServices = [];
+      agent.backgroundServices.forEach((service, name) => {
+        if (agent.serviceStatus.get(name) === 'running') {
+          agent.stopService(name);
+          stoppedServices.push(name);
+        }
+      });
+
+      // Cleanup modules
+      if (agent.modules.trafficMonitor && agent.modules.trafficMonitor.stopMonitoring) {
+        agent.modules.trafficMonitor.stopMonitoring();
+      }
+
+      this.isInitialized = false;
+      this.agentInstance = null;
+
+      logger.info('Agent shutdown via API');
+      
+      return handler.success(res, {
+        success: true,
+        message: 'Agent shutdown successfully',
+        servicesStopped: stoppedServices
+      });
+
+    } catch (error) {
+      logger.error('Agent shutdown error:', error);
+      return handler.error(res, 'Failed to shutdown agent', 500);
+    }
+  }
+
+  /**
+   * Helper: Capture command output
+   */
+  async captureCommandOutput(commandFn) {
+    const originalLog = console.log;
+    const output = [];
+
+    console.log = (...args) => {
+      output.push(args.map(arg => 
+        typeof arg === 'string' ? arg : JSON.stringify(arg)
+      ).join(' '));
+    };
+
+    try {
+      await commandFn();
+      return output.join('\n');
+    } finally {
+      console.log = originalLog;
+    }
+  }
+
+  /**
+   * Helper: Get version info
+   */
+  getVersionInfo(agent) {
+    return {
+      version: '2.4.0',
+      nodeVersion: process.version,
+      platform: process.platform,
+      architecture: process.arch,
+      modulesLoaded: Object.keys(agent.modules).length,
+      commandsAvailable: Object.keys(agent.commands).length
+    };
+  }
+}
+
+// Export singleton instance
+module.exports = new AgentController();