jerkjs 2.5.8 → 2.6.1

package/lib/admin/AdminExtension.js

@@ -168,29 +168,31 @@ class AdminExtension {
   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));
               
+              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)
+                  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) {
@@ -233,8 +235,18 @@ class AdminExtension {
         break;
       case 'status':
         socket.write(`\nEstado del servidor:\n`);
-        socket.write(`- Puerto: ${this.port}\n`);
-        socket.write(`- Host: ${this.host}\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`);
@@ -271,10 +283,10 @@ class AdminExtension {
       
       socket.write(`Comandos disponibles:\n`);
       for (const [name, module] of this.modules) {
-        socket.write(`  ${module.commands.join(', ')} - ${module.description}\n`);
+        socket.write(`  \x1b[32m${module.commands.join(', ')}\x1b[0m - ${module.description}\n`);
       }
-      socket.write(`  help - Mostrar esta ayuda\n`);
-      socket.write(`  quit - Cerrar conexión\n\n`);
+      socket.write(`  \x1b[32mhelp, ?\x1b[0m - Mostrar esta ayuda\n`);
+      socket.write(`  \x1b[32mquit\x1b[0m - Cerrar conexión\n\n`);
       
       socket.write(`> `);
 
@@ -282,16 +294,59 @@ class AdminExtension {
         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)) {
+          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':
@@ -309,7 +364,7 @@ class AdminExtension {
           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)) {
@@ -403,11 +458,11 @@ class AdminExtension {
     socket.write(`Módulos disponibles:\n`);
     for (const [name, module] of this.modules) {
       socket.write(`  ${name}: ${module.description}\n`);
-      socket.write(`    Comandos: ${module.commands.join(', ')}\n`);
+      socket.write(`    Comandos: \x1b[32m${module.commands.join(', ')}\x1b[0m\n`);
     }
     socket.write(`\nComandos generales:\n`);
-    socket.write(`  help - Mostrar esta ayuda\n`);
-    socket.write(`  quit - Cerrar conexión\n\n`);
+    socket.write(`  \x1b[32mhelp, ?\x1b[0m - Mostrar esta ayuda\n`);
+    socket.write(`  \x1b[32mquit\x1b[0m - Cerrar conexión\n\n`);
     socket.write(`> `);
   }
 

package/lib/admin/modules/ControllerGeneratorModule.js

@@ -0,0 +1,414 @@
+/**
+ * Módulo de Generación de Controladores para la Extensión de Administración de JERK Framework
+ * Módulo personalizado para crear controladores de manera interactiva
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class ControllerGeneratorModule {
+  /**
+   * Constructor del módulo de generación de controladores
+   * @param {Object} adminExtension - Instancia de la extensión de administración
+   */
+  constructor(adminExtension) {
+    this.adminExtension = adminExtension;
+    this.name = 'Controller Generator Module';
+    this.description = 'Módulo para crear controladores de manera interactiva';
+    this.commands = ['generate-controller', 'gen-ctrl', 'new-ctrl'];
+    
+    // Estado para el proceso interactivo
+    this.currentProcess = new Map(); // Almacena el estado de generación por socket
+  }
+
+  /**
+   * Manejador para los comandos del módulo de generación de controladores
+   * @param {string} command - Comando a ejecutar
+   * @param {Object} socket - Socket de la conexión
+   */
+  handleCommand(command, socket) {
+    switch (command) {
+      case 'generate-controller':
+      case 'gen-ctrl':
+      case 'new-ctrl':
+        this.startControllerGeneration(socket);
+        break;
+      default:
+        socket.write(`Comando desconocido para el módulo de generación de controladores: ${command}\n`);
+        socket.write(`Comandos disponibles: generate-controller, gen-ctrl, new-ctrl\n\n`);
+        socket.write(`> `);
+    }
+  }
+
+  /**
+   * Inicia el proceso interactivo de generación de controlador
+   * @param {Object} socket - Socket de la conexión
+   */
+  startControllerGeneration(socket) {
+    const sessionId = this.getSessionId(socket);
+    
+    // Inicializar el estado de la sesión
+    this.currentProcess.set(sessionId, {
+      step: 'name',
+      controllerData: {}
+    });
+    
+    socket.write('\n=== Generador de Controladores ===\n');
+    socket.write('Por favor, introduce el nombre del controlador (sin la palabra "Controller"):\n');
+    socket.write('(Ej: "User", "Product", "Home")\n');
+    socket.write('Para cancelar, escribe "cancel"\n');
+    socket.write('> ');
+  }
+
+  /**
+   * Obtiene un ID único para la sesión del socket
+   * @param {Object} socket - Socket de la conexión
+   * @returns {string} - ID de sesión
+   */
+  getSessionId(socket) {
+    // Usar la dirección remota y puerto como identificador único
+    return `${socket.remoteAddress}:${socket.remotePort}`;
+  }
+
+  /**
+   * Procesa la entrada del usuario durante el proceso interactivo
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} input - Entrada del usuario
+   */
+  processInput(socket, input) {
+    const sessionId = this.getSessionId(socket);
+    const processState = this.currentProcess.get(sessionId);
+    
+    if (!processState) {
+      socket.write('No hay proceso activo. Usa "generate-controller" para iniciar.\n> ');
+      return;
+    }
+    
+    const userInput = input.trim();
+    
+    if (userInput.toLowerCase() === 'cancel') {
+      this.cancelProcess(socket, sessionId);
+      return;
+    }
+    
+    switch (processState.step) {
+      case 'name':
+        this.handleControllerName(socket, sessionId, userInput);
+        break;
+      case 'methods':
+        this.handleMethodsSelection(socket, sessionId, userInput);
+        break;
+      case 'confirm':
+        this.handleConfirmation(socket, sessionId, userInput);
+        break;
+      case 'path':
+        this.handleControllerPath(socket, sessionId, userInput);
+        break;
+    }
+  }
+
+  /**
+   * Maneja la entrada del nombre del controlador
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} name - Nombre del controlador
+   */
+  handleControllerName(socket, sessionId, name) {
+    if (!name) {
+      socket.write('El nombre no puede estar vacío. Por favor, introduce un nombre válido:\n> ');
+      return;
+    }
+    
+    // Validar nombre (solo letras, números y guiones bajos)
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+      socket.write('Nombre inválido. Usa solo letras, números y guiones bajos, comenzando con una letra o guión bajo:\n> ');
+      return;
+    }
+    
+    const processState = this.currentProcess.get(sessionId);
+    processState.controllerData.name = name;
+    processState.step = 'methods';
+    
+    socket.write(`\nNombre del controlador: ${name}Controller\n`);
+    socket.write('\nSelecciona los métodos que deseas incluir (separados por comas):\n');
+    socket.write('Opciones disponibles:\n');
+    socket.write('  1. index - Método para mostrar lista de elementos\n');
+    socket.write('  2. show - Método para mostrar un elemento específico\n');
+    socket.write('  3. create - Método para crear un nuevo elemento\n');
+    socket.write('  4. update - Método para actualizar un elemento\n');
+    socket.write('  5. delete - Método para eliminar un elemento\n');
+    socket.write('  6. All - Todos los métodos anteriores\n');
+    socket.write('\nEjemplos: "1,2,3" o "index,show,create" o "All"\n> ');
+  }
+
+  /**
+   * Maneja la selección de métodos
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} selection - Selección de métodos
+   */
+  handleMethodsSelection(socket, sessionId, selection) {
+    const processState = this.currentProcess.get(sessionId);
+    const methodsMap = {
+      '1': 'index', '2': 'show', '3': 'create', '4': 'update', '5': 'delete'
+    };
+    
+    let selectedMethods = [];
+    
+    if (selection.toLowerCase() === 'all') {
+      selectedMethods = ['index', 'show', 'create', 'update', 'delete'];
+    } else {
+      // Separar por comas y procesar cada selección
+      const selections = selection.split(',').map(s => s.trim());
+      
+      for (const sel of selections) {
+        if (methodsMap[sel]) {
+          selectedMethods.push(methodsMap[sel]);
+        } else if (['index', 'show', 'create', 'update', 'delete'].includes(sel)) {
+          selectedMethods.push(sel);
+        } else {
+          socket.write(`Selección inválida: ${sel}. Por favor, selecciona métodos válidos:\n> `);
+          return;
+        }
+      }
+    }
+    
+    // Eliminar duplicados
+    selectedMethods = [...new Set(selectedMethods)];
+    
+    processState.controllerData.methods = selectedMethods;
+    processState.step = 'path';
+    
+    socket.write(`\nMétodos seleccionados: ${selectedMethods.join(', ')}\n`);
+    socket.write('\nIndica la ruta donde deseas crear el archivo del controlador:\n');
+    socket.write('(Ruta relativa desde la raíz del proyecto, ej: "./controllers/", "./src/controllers/")\n');
+    socket.write('Deja vacío para usar "./controllers/" por defecto:\n> ');
+  }
+
+  /**
+   * Maneja la selección de la ruta del controlador
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} pathInput - Ruta ingresada
+   */
+  handleControllerPath(socket, sessionId, pathInput) {
+    const processState = this.currentProcess.get(sessionId);
+    
+    // Usar la ruta por defecto si no se proporciona ninguna
+    const controllerPath = pathInput.trim() || './controllers/';
+    
+    // Asegurarse de que termine con '/'
+    const normalizedPath = controllerPath.endsWith('/') ? controllerPath : controllerPath + '/';
+    
+    processState.controllerData.path = normalizedPath;
+    processState.step = 'confirm';
+    
+    socket.write(`\nRuta del controlador: ${normalizedPath}\n`);
+    this.showControllerPreview(socket, processState.controllerData);
+  }
+
+  /**
+   * Muestra una vista previa del controlador que se va a generar
+   * @param {Object} socket - Socket de la conexión
+   * @param {Object} controllerData - Datos del controlador
+   */
+  showControllerPreview(socket, controllerData) {
+    socket.write('\n=== Vista Previa del Controlador ===\n');
+    socket.write(`Nombre del archivo: ${controllerData.name}Controller.js\n\n`);
+    
+    let preview = `const ControllerBase = require('../../index.js').ControllerBase;\n\n`;
+    preview += `class ${controllerData.name}Controller extends ControllerBase {\n`;
+    
+    for (const method of controllerData.methods) {
+      preview += this.generateMethodSkeleton(method, controllerData.name);
+    }
+    
+    preview += `}\n\n`;
+    preview += `module.exports = new ${controllerData.name}Controller();\n`;
+    
+    socket.write(preview);
+    socket.write('\n¿Deseas crear este controlador? (sí/no):\n> ');
+  }
+
+  /**
+   * Genera el esqueleto de un método
+   * @param {string} method - Nombre del método
+   * @param {string} controllerName - Nombre del controlador
+   * @returns {string} - Código del método
+   */
+  generateMethodSkeleton(method, controllerName) {
+    let skeleton = '';
+    
+    switch (method) {
+      case 'index':
+        skeleton += `  async index(req, res) {\n`;
+        skeleton += `    try {\n`;
+        skeleton += `      // Lógica para obtener y mostrar una lista de ${controllerName.toLowerCase()}s\n`;
+        skeleton += `      const items = await this.loadModel('${controllerName}Model').then(model => model.find({}));\n`;
+        skeleton += `      \n`;
+        skeleton += `      res.render('${controllerName.toLowerCase()}/index', { \n`;
+        skeleton += `        title: '${controllerName}s',\n`;
+        skeleton += `        items\n`;
+        skeleton += `      });\n`;
+        skeleton += `    } catch (error) {\n`;
+        skeleton += `      console.error('Error en el método index:', error);\n`;
+        skeleton += `      res.writeHead(500, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ error: 'Error interno del servidor' }));\n`;
+        skeleton += `    }\n`;
+        skeleton += `  }\n\n`;
+        break;
+        
+      case 'show':
+        skeleton += `  async show(req, res) {\n`;
+        skeleton += `    try {\n`;
+        skeleton += `      const id = req.params.id;\n`;
+        skeleton += `      // Lógica para obtener y mostrar un ${controllerName.toLowerCase()} específico\n`;
+        skeleton += `      const item = await this.loadModel('${controllerName}Model').then(model => model.findOne({ id: parseInt(id) }));\n`;
+        skeleton += `      \n`;
+        skeleton += `      if (!item) {\n`;
+        skeleton += `        res.writeHead(404, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `        res.end(JSON.stringify({ error: '${controllerName} no encontrado' }));\n`;
+        skeleton += `        return;\n`;
+        skeleton += `      }\n`;
+        skeleton += `      \n`;
+        skeleton += `      res.render('${controllerName.toLowerCase()}/show', { \n`;
+        skeleton += `        title: '${controllerName} #' + id,\n`;
+        skeleton += `        item\n`;
+        skeleton += `      });\n`;
+        skeleton += `    } catch (error) {\n`;
+        skeleton += `      console.error('Error en el método show:', error);\n`;
+        skeleton += `      res.writeHead(500, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ error: 'Error interno del servidor' }));\n`;
+        skeleton += `    }\n`;
+        skeleton += `  }\n\n`;
+        break;
+        
+      case 'create':
+        skeleton += `  async create(req, res) {\n`;
+        skeleton += `    try {\n`;
+        skeleton += `      // Lógica para crear un nuevo ${controllerName.toLowerCase()}\n`;
+        skeleton += `      const data = req.body;\n`;
+        skeleton += `      const newItem = await this.loadModel('${controllerName}Model').then(model => model.create(data));\n`;
+        skeleton += `      \n`;
+        skeleton += `      res.writeHead(201, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ success: true, data: newItem }));\n`;
+        skeleton += `    } catch (error) {\n`;
+        skeleton += `      console.error('Error en el método create:', error);\n`;
+        skeleton += `      res.writeHead(400, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ error: error.message }));\n`;
+        skeleton += `    }\n`;
+        skeleton += `  }\n\n`;
+        break;
+        
+      case 'update':
+        skeleton += `  async update(req, res) {\n`;
+        skeleton += `    try {\n`;
+        skeleton += `      const id = req.params.id;\n`;
+        skeleton += `      const data = req.body;\n`;
+        skeleton += `      // Lógica para actualizar un ${controllerName.toLowerCase()} existente\n`;
+        skeleton += `      const result = await this.loadModel('${controllerName}Model').then(model => model.update({ id: parseInt(id) }, data));\n`;
+        skeleton += `      \n`;
+        skeleton += `      res.writeHead(200, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ success: true, data: result }));\n`;
+        skeleton += `    } catch (error) {\n`;
+        skeleton += `      console.error('Error en el método update:', error);\n`;
+        skeleton += `      res.writeHead(400, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ error: error.message }));\n`;
+        skeleton += `    }\n`;
+        skeleton += `  }\n\n`;
+        break;
+        
+      case 'delete':
+        skeleton += `  async delete(req, res) {\n`;
+        skeleton += `    try {\n`;
+        skeleton += `      const id = req.params.id;\n`;
+        skeleton += `      // Lógica para eliminar un ${controllerName.toLowerCase()}\n`;
+        skeleton += `      const result = await this.loadModel('${controllerName}Model').then(model => model.delete({ id: parseInt(id) }));\n`;
+        skeleton += `      \n`;
+        skeleton += `      res.writeHead(200, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ success: true, message: '${controllerName} eliminado correctamente' }));\n`;
+        skeleton += `    } catch (error) {\n`;
+        skeleton += `      console.error('Error en el método delete:', error);\n`;
+        skeleton += `      res.writeHead(400, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ error: error.message }));\n`;
+        skeleton += `    }\n`;
+        skeleton += `  }\n\n`;
+        break;
+    }
+    
+    return skeleton;
+  }
+
+  /**
+   * Maneja la confirmación de creación del controlador
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} confirmation - Confirmación del usuario
+   */
+  handleConfirmation(socket, sessionId, confirmation) {
+    const processState = this.currentProcess.get(sessionId);
+    
+    if (confirmation.toLowerCase() === 'sí' || confirmation.toLowerCase() === 'si' || confirmation.toLowerCase() === 'yes') {
+      this.createControllerFile(socket, processState.controllerData);
+    } else {
+      socket.write('\nGeneración del controlador cancelada.\n> ');
+      this.currentProcess.delete(sessionId);
+    }
+  }
+
+  /**
+   * Crea el archivo del controlador
+   * @param {Object} socket - Socket de la conexión
+   * @param {Object} controllerData - Datos del controlador
+   */
+  createControllerFile(socket, controllerData) {
+    const { name, methods, path: controllerPath } = controllerData;
+    
+    // Crear el contenido del archivo
+    let content = `const ControllerBase = require('../../index.js').ControllerBase;\n\n`;
+    content += `class ${name}Controller extends ControllerBase {\n`;
+    
+    for (const method of methods) {
+      content += this.generateMethodSkeleton(method, name);
+    }
+    
+    content += `}\n\n`;
+    content += `module.exports = new ${name}Controller();\n`;
+    
+    // Crear directorio si no existe
+    const fullPath = path.join(process.cwd(), controllerPath);
+    if (!fs.existsSync(fullPath)) {
+      fs.mkdirSync(fullPath, { recursive: true });
+    }
+    
+    // Ruta completa del archivo
+    const filePath = path.join(fullPath, `${name}Controller.js`);
+    
+    try {
+      // Escribir el archivo
+      fs.writeFileSync(filePath, content);
+      
+      socket.write(`\n✅ Controlador "${name}Controller" creado exitosamente en:\n${filePath}\n`);
+      socket.write(`\nMétodos incluidos: ${methods.join(', ')}\n`);
+      socket.write('\n> ');
+    } catch (error) {
+      socket.write(`\n❌ Error al crear el archivo: ${error.message}\n> `);
+    }
+    
+    // Limpiar el estado
+    const sessionId = this.getSessionId(socket);
+    this.currentProcess.delete(sessionId);
+  }
+
+  /**
+   * Cancela el proceso de generación
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   */
+  cancelProcess(socket, sessionId) {
+    this.currentProcess.delete(sessionId);
+    socket.write('\nProceso cancelado.\n> ');
+  }
+}
+
+module.exports = ControllerGeneratorModule;