jerkjs 2.5.6 → 2.6.1

package/lib/admin/AdminExtension.js

@@ -0,0 +1,491 @@
+/**
+ * Extensión de Administración para JERK Framework
+ * Implementación del componente admin/AdminExtension.js
+ */
+
+const net = require('net');
+const fs = require('fs');
+const path = require('path');
+
+class AdminExtension {
+  /**
+   * Constructor de la extensión de administración
+   * @param {Object} options - Opciones de configuración
+   * @param {number} options.port - Puerto para el servidor de administración
+   * @param {string} options.host - Host para el servidor de administración
+   */
+  constructor(options = {}) {
+    this.port = options.port || 9999;
+    this.host = options.host || '127.0.0.1'; // Solo localhost
+    this.server = null;
+    this.clients = new Set();
+    this.frameworkVersion = this.getFrameworkVersion();
+    this.activeRoutes = new Map(); // Para rastrear rutas activas
+    this.registeredRoutes = []; // Para almacenar rutas registradas
+    this.modules = new Map(); // Para almacenar módulos de administración
+    this.hooks = null; // Referencia al sistema de hooks
+  }
+
+  /**
+   * Obtiene la versión del framework desde package.json
+   * @returns {string} - Versión del framework
+   */
+  getFrameworkVersion() {
+    try {
+      const packagePath = path.join(__dirname, '../../package.json');
+      const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+      return packageJson.version || 'unknown';
+    } catch (error) {
+      console.error('Error leyendo la versión del framework:', error.message);
+      return 'unknown';
+    }
+  }
+
+  /**
+   * Inicializa la extensión y el servidor de administración
+   * @param {Object} frameworkInstance - Instancia del framework JERK
+   */
+  initialize(frameworkInstance) {
+    this.frameworkInstance = frameworkInstance;
+
+    // Obtener referencia al sistema de hooks
+    if (frameworkInstance && frameworkInstance.hooks) {
+      this.hooks = frameworkInstance.hooks;
+    } else {
+      // Si no se proporciona, crear uno nuevo
+      const { hooks } = require('../../index.js');
+      this.hooks = hooks;
+    }
+
+    // Registrar hooks para rastrear rutas
+    this.registerHooks();
+
+    // Registrar módulos
+    this.registerModules();
+
+    // Cargar módulos personalizados
+    this.loadCustomModules();
+
+    // Cargar rutas existentes si el servidor ya tiene rutas registradas
+    this.loadExistingRoutes();
+
+    // Iniciar servidor de administración
+    this.startAdminServer();
+  }
+
+  /**
+   * Carga módulos personalizados
+   */
+  loadCustomModules() {
+    try {
+      const ModuleLoader = require('./ModuleLoader');
+      const moduleLoader = new ModuleLoader(this);
+      
+      // Cargar módulos desde el directorio de módulos
+      moduleLoader.loadModulesFromDirectory('./modules');
+    } catch (error) {
+      console.error('Error cargando módulos personalizados:', error.message);
+    }
+  }
+
+  /**
+   * Carga las rutas existentes en el servidor
+   */
+  loadExistingRoutes() {
+    if (this.frameworkInstance && this.frameworkInstance.routes) {
+      // Copiar las rutas existentes al registro de rutas registradas
+      for (const route of this.frameworkInstance.routes) {
+        this.registeredRoutes.push({
+          method: route.method,
+          path: route.path,
+          handler: route.handler,
+          isStatic: route.isStatic
+        });
+      }
+    }
+  }
+
+  /**
+   * Registra los hooks necesarios para rastrear rutas
+   */
+  registerHooks() {
+    if (this.hooks) {
+      // Hook para rastrear rutas registradas
+      this.hooks.addAction('route_registered', (route) => {
+        this.registeredRoutes.push(route);
+      });
+
+      // Hook para rastrear rutas activas
+      this.hooks.addAction('request_received', (req, res) => {
+        const routeInfo = {
+          method: req.method,
+          url: req.url,
+          timestamp: new Date().toISOString(),
+          remoteAddress: req.connection.remoteAddress
+        };
+
+        // Usar la URL como clave y almacenar la última solicitud
+        this.activeRoutes.set(req.url, routeInfo);
+
+        // Disparar hook específico para módulos de administración
+        this.hooks.doAction('admin_route_active', routeInfo);
+      });
+
+      // Hook para cuando se cierra el servidor
+      this.hooks.addAction('server_stopped', () => {
+        this.close();
+      });
+    }
+  }
+
+  /**
+   * Registra los módulos de administración
+   */
+  registerModules() {
+    // Módulo de rutas - el primer módulo
+    this.modules.set('routes', {
+      name: 'Routes Module',
+      description: 'Módulo para ver rutas registradas y activas',
+      commands: ['routes', 'active'],
+      handler: this.handleRoutesCommand.bind(this)
+    });
+
+    // Módulo de sistema - para comandos generales
+    this.modules.set('system', {
+      name: 'System Module',
+      description: 'Módulo para información del sistema',
+      commands: ['version', 'status', 'help'],
+      handler: this.handleSystemCommand.bind(this)
+    });
+
+    // Cargar módulos personalizados
+    this.loadCustomModules();
+  }
+
+  /**
+   * Carga módulos personalizados desde el directorio de módulos
+   */
+  loadCustomModules() {
+    const fs = require('fs');
+    const path = require('path');
+
+    try {
+      const modulesDir = path.join(__dirname, 'modules');
+
+      if (fs.existsSync(modulesDir)) {
+        const files = fs.readdirSync(modulesDir);
+
+        for (const file of files) {
+          if (file.endsWith('.js') && file !== 'index.js') {
+            try {
+              const moduleName = file.replace('.js', '');
+              
+              const ModuleClass = require(path.join(modulesDir, file));
+
+              if (typeof ModuleClass === 'function') {
+                const moduleInstance = new ModuleClass(this);
+
+                this.modules.set(moduleName.toLowerCase(), {
+                  name: moduleInstance.name,
+                  description: moduleInstance.description,
+                  commands: moduleInstance.commands,
+                  handler: (command, socket) => moduleInstance.handleCommand(command, socket),
+                  instance: moduleInstance  // Mantener referencia a la instancia para manejo interactivo
+                });
+
+                console.log(`Módulo '${moduleName}' cargado exitosamente.`);
+              }
+            } catch (moduleError) {
+              console.error(`Error cargando módulo ${file}:`, moduleError.message);
+            }
+          }
+        }
+      }
+    } catch (error) {
+      console.error('Error general al cargar módulos personalizados:', error.message);
+    }
+  }
+
+  /**
+   * Manejador para el módulo de rutas
+   */
+  handleRoutesCommand(command, socket) {
+    switch (command) {
+      case 'routes':
+        this.sendRegisteredRoutes(socket);
+        break;
+      case 'active':
+        this.sendActiveRoutes(socket);
+        break;
+      default:
+        socket.write(`Comando desconocido para el módulo de rutas: ${command}\n`);
+        socket.write(`Comandos disponibles: routes, active\n\n`);
+        socket.write(`> `);
+    }
+  }
+
+  /**
+   * Manejador para el módulo de sistema
+   */
+  handleSystemCommand(command, socket) {
+    switch (command) {
+      case 'version':
+        socket.write(`\nVersión del framework: ${this.frameworkVersion}\n\n`);
+        socket.write(`> `);
+        break;
+      case 'status':
+        socket.write(`\nEstado del servidor:\n`);
+        socket.write(`- Puerto del servidor de administración: ${this.port}\n`);
+        socket.write(`- Host del servidor de administración: ${this.host}\n`);
+        
+        // Mostrar información del servidor principal si está disponible
+        if (this.frameworkInstance) {
+          socket.write(`- Puerto del servidor principal: ${this.frameworkInstance.port || 'desconocido'}\n`);
+          socket.write(`- Host del servidor principal: ${this.frameworkInstance.host || 'desconocido'}\n`);
+        } else {
+          socket.write(`- Puerto del servidor principal: desconocido\n`);
+          socket.write(`- Host del servidor principal: desconocido\n`);
+        }
+        
+        socket.write(`- Clientes conectados: ${this.clients.size}\n`);
+        socket.write(`- Rutas registradas: ${this.registeredRoutes.length}\n`);
+        socket.write(`- Rutas activas: ${this.activeRoutes.size}\n\n`);
+        socket.write(`> `);
+        break;
+      case 'help':
+        this.sendHelp(socket);
+        break;
+      default:
+        socket.write(`Comando desconocido para el módulo de sistema: ${command}\n`);
+        socket.write(`Comandos disponibles: version, status, help\n\n`);
+        socket.write(`> `);
+    }
+  }
+
+  /**
+   * Inicia el servidor de administración
+   */
+  startAdminServer() {
+    this.server = net.createServer((socket) => {
+      this.clients.add(socket);
+      
+      // Enviar mensaje de bienvenida
+      socket.write(`Bienvenido al Servidor de Administración de JERK Framework\n`);
+      socket.write(`Versión: ${this.frameworkVersion}\n`);
+      socket.write(`Puerto: ${this.port}\n`);
+      socket.write(`Fecha: ${new Date().toISOString()}\n\n`);
+      
+      socket.write(`Módulos disponibles:\n`);
+      for (const [name, module] of this.modules) {
+        socket.write(`  ${name}: ${module.description}\n`);
+      }
+      socket.write(`\n`);
+      
+      socket.write(`Comandos disponibles:\n`);
+      for (const [name, module] of this.modules) {
+        socket.write(`  \x1b[32m${module.commands.join(', ')}\x1b[0m - ${module.description}\n`);
+      }
+      socket.write(`  \x1b[32mhelp, ?\x1b[0m - Mostrar esta ayuda\n`);
+      socket.write(`  \x1b[32mquit\x1b[0m - Cerrar conexión\n\n`);
+      
+      socket.write(`> `);
+
+      socket.on('data', (data) => {
+        const input = data.toString();
+        // Dividir la entrada en líneas y procesar cada una
+        const lines = input.split('\n').filter(line => line.trim() !== '');
+
+        for (const line of lines) {
+          // Verificar si hay un proceso interactivo activo para este socket
+          const controllerGenModule = this.modules.get('controllergeneratormodule');
+          if (controllerGenModule && controllerGenModule.instance && controllerGenModule.instance.currentProcess) {
+            const sessionId = controllerGenModule.instance.getSessionId(socket);
+            if (controllerGenModule.instance.currentProcess.has(sessionId)) {
+              // Si hay un proceso interactivo activo, delegar el manejo de la entrada
+              controllerGenModule.instance.processInput(socket, line.trim());
+              continue; // Saltar el procesamiento normal
+            }
+          }
+          
+          // Verificar si hay un proceso interactivo activo para el módulo de gestión de rutas
+          const routeManagerModule = this.modules.get('routemanagermodule');
+          if (routeManagerModule && routeManagerModule.instance && routeManagerModule.instance.currentProcess) {
+            const sessionId = routeManagerModule.instance.getSessionId(socket);
+            if (routeManagerModule.instance.currentProcess.has(sessionId)) {
+              // Si hay un proceso interactivo activo, delegar el manejo de la entrada
+              routeManagerModule.instance.processInput(socket, line.trim());
+              continue; // Saltar el procesamiento normal
+            }
+          }
+
+          // Verificar si hay un proceso interactivo activo para el módulo de WAF
+          const wafModule = this.modules.get('wafmodule');
+          if (wafModule && wafModule.instance && wafModule.instance.currentProcess) {
+            const sessionId = wafModule.instance.getSessionId(socket);
+            if (wafModule.instance.currentProcess.has(sessionId)) {
+              // Si hay un proceso interactivo activo, delegar el manejo de la entrada
+              wafModule.instance.processInput(socket, line.trim());
+              continue; // Saltar el procesamiento normal
+            }
+          }
+
+          // Verificar si hay un proceso interactivo activo para el módulo de gestión de colas
+          const queueModule = this.modules.get('queuemanagementmodule');
+          if (queueModule && queueModule.instance && queueModule.instance.inputState && 
+              queueModule.instance.inputState.has(socket)) {
+            // Si hay un proceso interactivo activo, delegar el manejo de la entrada
+            queueModule.instance.processQueueAction(socket, queueModule.instance.inputState.get(socket).action, line.trim());
+            continue; // Saltar el procesamiento normal
+          }
+
+          const command = line.trim().toLowerCase();
+          console.log(`DEBUG: Comando recibido: "${command}"`); // Mensaje de depuración
+
+          // Verificar si es un comando de sistema
+          if (['help', 'quit', 'exit', '?'].includes(command)) {
+            console.log(`DEBUG: Comando de sistema encontrado: ${command}`); // Mensaje de depuración
+            switch (command) {
+              case 'help':
+              case '?':
+                this.sendHelp(socket);
+                break;
+              case 'quit':
+              case 'exit':
+                socket.write('Cerrando conexión...\n');
+                socket.end();
+                return;
+              default:
+                socket.write(`> `);
+            }
+            continue; // Continuar con la siguiente línea
+          }
+
+          // Buscar el módulo que maneje este comando
+          let handled = false;
+          console.log(`DEBUG: Buscando módulo para el comando "${command}"`); // Mensaje de depuración
+          console.log(`DEBUG: Módulos disponibles:`, Array.from(this.modules.keys())); // Mensaje de depuración
+
+          for (const [moduleName, module] of this.modules) {
+            console.log(`DEBUG: Revisando módulo "${moduleName}", comandos:`, module.commands); // Mensaje de depuración
+            if (module.commands.includes(command)) {
+              console.log(`DEBUG: Módulo encontrado para el comando "${command}", llamando handler`); // Mensaje de depuración
+              module.handler(command, socket);
+              handled = true;
+              break;
+            }
+          }
+
+          if (!handled) {
+            console.log(`DEBUG: Comando no encontrado: "${command}"`); // Mensaje de depuración
+            socket.write(`Comando desconocido: ${command}\n`);
+            socket.write(`Escribe 'help' para ver los comandos disponibles.\n\n`);
+            socket.write(`> `);
+          }
+        }
+      });
+
+      socket.on('close', () => {
+        this.clients.delete(socket);
+      });
+
+      socket.on('error', (err) => {
+        console.error('Error en el socket de administración:', err);
+      });
+    });
+
+    this.server.listen(this.port, this.host, () => {
+      console.log(`Servidor de administración JERK iniciado en ${this.host}:${this.port}`);
+      console.log(`Versión del framework: ${this.frameworkVersion}`);
+      
+      // Disparar hook cuando se inicia el servidor de administración
+      if (this.hooks) {
+        this.hooks.doAction('admin_server_started', this.port, this.host);
+      }
+    });
+
+    this.server.on('error', (err) => {
+      console.error('Error en el servidor de administración:', err);
+      
+      // Disparar hook cuando hay un error en el servidor de administración
+      if (this.hooks) {
+        this.hooks.doAction('admin_server_error', err);
+      }
+    });
+  }
+
+  /**
+   * Envía la lista de rutas registradas al cliente
+   * @param {Object} socket - Socket del cliente
+   */
+  sendRegisteredRoutes(socket) {
+    socket.write('\n=== Rutas Registradas ===\n');
+    
+    if (this.registeredRoutes.length === 0) {
+      socket.write('No hay rutas registradas.\n');
+    } else {
+      this.registeredRoutes.forEach((route, index) => {
+        socket.write(`${index + 1}. ${route.method} ${route.path}\n`);
+      });
+    }
+    
+    socket.write('\n> ');
+  }
+
+  /**
+   * Envía la lista de rutas activas al cliente
+   * @param {Object} socket - Socket del cliente
+   */
+  sendActiveRoutes(socket) {
+    socket.write('\n=== Rutas Activas (Últimas Solicitudes) ===\n');
+    
+    if (this.activeRoutes.size === 0) {
+      socket.write('No hay rutas activas registradas.\n');
+    } else {
+      for (const [url, info] of this.activeRoutes) {
+        socket.write(`${info.method} ${url} - ${info.timestamp} (${info.remoteAddress})\n`);
+      }
+    }
+    
+    socket.write('\n> ');
+  }
+
+  /**
+   * Envía la ayuda al cliente
+   * @param {Object} socket - Socket del cliente
+   */
+  sendHelp(socket) {
+    socket.write('\n=== Ayuda del Servidor de Administración ===\n');
+    socket.write(`Módulos disponibles:\n`);
+    for (const [name, module] of this.modules) {
+      socket.write(`  ${name}: ${module.description}\n`);
+      socket.write(`    Comandos: \x1b[32m${module.commands.join(', ')}\x1b[0m\n`);
+    }
+    socket.write(`\nComandos generales:\n`);
+    socket.write(`  \x1b[32mhelp, ?\x1b[0m - Mostrar esta ayuda\n`);
+    socket.write(`  \x1b[32mquit\x1b[0m - Cerrar conexión\n\n`);
+    socket.write(`> `);
+  }
+
+  /**
+   * Cierra el servidor de administración
+   */
+  close() {
+    if (this.server) {
+      // Cerrar todas las conexiones de clientes
+      for (const client of this.clients) {
+        client.end();
+      }
+      
+      this.server.close(() => {
+        console.log('Servidor de administración cerrado');
+        
+        // Disparar hook cuando se cierra el servidor de administración
+        if (this.hooks) {
+          this.hooks.doAction('admin_server_closed');
+        }
+      });
+    }
+  }
+}
+
+module.exports = AdminExtension;

package/lib/admin/ModuleLoader.js

@@ -0,0 +1,77 @@
+/**
+ * Sistema de Carga de Módulos Personalizados para la Extensión de Administración
+ * Permite cargar módulos externos como submódulos de la extensión
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class ModuleLoader {
+  /**
+   * Constructor del cargador de módulos
+   * @param {Object} adminExtension - Instancia de la extensión de administración
+   */
+  constructor(adminExtension) {
+    this.adminExtension = adminExtension;
+    this.modules = new Map();
+  }
+
+  /**
+   * Carga un módulo personalizado
+   * @param {string} moduleName - Nombre del módulo
+   * @param {Object} moduleClass - Clase del módulo
+   */
+  loadModule(moduleName, moduleClass) {
+    const moduleInstance = new moduleClass(this.adminExtension);
+    this.modules.set(moduleName, moduleInstance);
+    
+    // Registrar el módulo en la extensión de administración
+    this.adminExtension.modules.set(moduleName, {
+      name: moduleInstance.name,
+      description: moduleInstance.description,
+      commands: moduleInstance.commands,
+      handler: moduleInstance.handleCommand.bind(moduleInstance)
+    });
+    
+    console.log(`Módulo '${moduleName}' cargado exitosamente.`);
+  }
+
+  /**
+   * Carga módulos desde un directorio
+   * @param {string} directoryPath - Ruta del directorio de módulos
+   */
+  loadModulesFromDirectory(directoryPath) {
+    const modulesDir = path.resolve(__dirname, directoryPath);
+    
+    if (!fs.existsSync(modulesDir)) {
+      console.log(`Directorio de módulos no encontrado: ${modulesDir}`);
+      return;
+    }
+
+    const files = fs.readdirSync(modulesDir);
+    
+    for (const file of files) {
+      if (file.endsWith('.js') && file !== 'index.js') {
+        const moduleName = file.replace('.js', '');
+        const modulePath = path.join(modulesDir, file);
+        
+        try {
+          const ModuleClass = require(modulePath);
+          this.loadModule(moduleName.toLowerCase(), ModuleClass);
+        } catch (error) {
+          console.error(`Error cargando módulo ${file}:`, error.message);
+        }
+      }
+    }
+  }
+
+  /**
+   * Obtiene todos los módulos cargados
+   * @returns {Map} - Mapa de módulos cargados
+   */
+  getLoadedModules() {
+    return this.modules;
+  }
+}
+
+module.exports = ModuleLoader;

package/lib/admin/config.js

@@ -0,0 +1,21 @@
+/**
+ * Configuración de la extensión de administración para JERK Framework
+ */
+
+module.exports = {
+  adminExtension: {
+    enabled: true,
+    port: 9999,
+    host: '127.0.0.1', // Solo localhost
+    modules: {
+      routes: {
+        enabled: true,
+        options: {}
+      },
+      system: {
+        enabled: true,
+        options: {}
+      }
+    }
+  }
+};