jerkjs 2.5.6 → 2.6.1

package/jerk-admin-client.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+
+/**
+ * Cliente CLI para interactuar con el servidor de administración de JERK Framework
+ * Permite reutilizar comandos y tiene autocompletado
+ */
+
+const net = require('net');
+const readline = require('readline');
+const fs = require('fs');
+const path = require('path');
+
+// Configuración por defecto
+const DEFAULT_HOST = 'localhost';
+const DEFAULT_PORT = 9999;
+
+// Historial de comandos
+let commandHistory = [];
+const HISTORY_FILE = path.join(require('os').homedir(), '.jerk_admin_history');
+
+// Cargar historial de comandos si existe
+if (fs.existsSync(HISTORY_FILE)) {
+  try {
+    const historyData = fs.readFileSync(HISTORY_FILE, 'utf8');
+    commandHistory = JSON.parse(historyData);
+  } catch (error) {
+    console.error('Error al cargar el historial:', error.message);
+  }
+}
+
+// Comandos conocidos para autocompletado
+const knownCommands = [
+  'help',
+  'stats',
+  'statistics', 
+  'requests',
+  'endpoints',
+  'routes',
+  'active',
+  'version',
+  'status',
+  'cache',
+  'cache-stats',
+  'cache-clear',
+  'cache-info',
+  'sysinfo',
+  'system',
+  'resources',
+  'time',
+  'date',
+  'quit',
+  'exit'
+];
+
+// Función para guardar el historial
+function saveHistory() {
+  try {
+    fs.writeFileSync(HISTORY_FILE, JSON.stringify(commandHistory, null, 2));
+  } catch (error) {
+    console.error('Error al guardar el historial:', error.message);
+  }
+}
+
+// Función para autocompletar comandos
+function completer(line) {
+  const hits = knownCommands.filter(cmd => cmd.startsWith(line));
+  return [hits.length ? hits : knownCommands, line];
+}
+
+// Función para crear el cliente
+function createClient(host = DEFAULT_HOST, port = DEFAULT_PORT) {
+  const client = new net.Socket();
+  
+  // Conectar al servidor de administración
+  client.connect(port, host, () => {
+    console.log(`Conectado al servidor de administración en ${host}:${port}`);
+    console.log('Escribe "help" para ver los comandos disponibles o "quit" para salir\n');
+    
+    // Configurar readline con autocompletado
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      completer: completer,
+      history: commandHistory
+    });
+    
+    // Mostrar historial de comandos recientes
+    if (commandHistory.length > 0) {
+      console.log(`Comandos recientes: ${commandHistory.slice(-5).join(', ')}\n`);
+    }
+    
+    // Función para manejar la entrada del usuario
+    function handleInput() {
+      rl.question('> ', (input) => {
+        const command = input.trim();
+        
+        if (command.toLowerCase() === 'quit' || command.toLowerCase() === 'exit') {
+          console.log('Desconectando del servidor...');
+          client.end();
+          rl.close();
+          saveHistory();
+          return;
+        }
+        
+        if (command.toLowerCase() === 'history') {
+          console.log('Historial de comandos:');
+          commandHistory.forEach((cmd, index) => {
+            console.log(`${index + 1}. ${cmd}`);
+          });
+          handleInput();
+          return;
+        }
+        
+        if (command.toLowerCase() === 'clear') {
+          console.clear();
+          handleInput();
+          return;
+        }
+        
+        if (command.toLowerCase() === 'help-cli') {
+          console.log('\n--- Comandos del Cliente CLI ---');
+          console.log('help-cli - Muestra esta ayuda');
+          console.log('history - Muestra el historial de comandos');
+          console.log('clear - Limpia la pantalla');
+          console.log('re <número> - Reutiliza el comando número n del historial');
+          console.log('re <texto> - Reutiliza el último comando que contiene el texto');
+          console.log('-----------------------------\n');
+          handleInput();
+          return;
+        }
+        
+        // Comando para reutilizar comandos del historial
+        if (command.toLowerCase().startsWith('re ')) {
+          const arg = command.substring(3).trim();
+          
+          if (/^\d+$/.test(arg)) {
+            // Reutilizar por número
+            const index = parseInt(arg) - 1;
+            if (index >= 0 && index < commandHistory.length) {
+              const reusedCmd = commandHistory[index];
+              console.log(`Reutilizando comando: ${reusedCmd}`);
+              client.write(reusedCmd + '\n');
+              if (!commandHistory.includes(reusedCmd)) {
+                commandHistory.push(reusedCmd);
+              }
+            } else {
+              console.log(`Número de comando inválido: ${arg}`);
+              handleInput();
+            }
+          } else {
+            // Reutilizar por texto
+            const matchingCmd = commandHistory.reverse().find(cmd => cmd.includes(arg));
+            commandHistory.reverse(); // Restaurar orden original
+            
+            if (matchingCmd) {
+              console.log(`Reutilizando comando: ${matchingCmd}`);
+              client.write(matchingCmd + '\n');
+            } else {
+              console.log(`No se encontró comando que contenga: ${arg}`);
+              handleInput();
+            }
+          }
+        } else if (command) {
+          // Enviar comando al servidor
+          client.write(command + '\n');
+          
+          // Agregar al historial si no está repetido
+          if (!commandHistory.includes(command)) {
+            commandHistory.push(command);
+            // Mantener solo los últimos 100 comandos
+            if (commandHistory.length > 100) {
+              commandHistory = commandHistory.slice(-100);
+            }
+          }
+        }
+        
+        handleInput();
+      });
+    }
+    
+    // Iniciar la interacción
+    handleInput();
+  });
+  
+  // Manejar datos recibidos del servidor
+  client.on('data', (data) => {
+    const output = data.toString();
+    process.stdout.write(output);
+    
+    // Si la salida termina con el prompt, significa que el comando terminó
+    if (output.endsWith('> ')) {
+      // No hacer nada, dejar que readline continúe
+    }
+  });
+  
+  // Manejar errores
+  client.on('error', (error) => {
+    console.error(`Error de conexión: ${error.message}`);
+    process.exit(1);
+  });
+  
+  // Manejar cierre de conexión
+  client.on('close', () => {
+    console.log('\nConexión cerrada');
+    process.exit(0);
+  });
+}
+
+// Mostrar ayuda
+function showHelp() {
+  console.log(`
+Cliente CLI para JERK Framework Administration Server
+
+Uso: node jerk-admin-client.js [opciones]
+
+Opciones:
+  -h, --host HOST     Host del servidor (por defecto: ${DEFAULT_HOST})
+  -p, --port PORT     Puerto del servidor (por defecto: ${DEFAULT_PORT})
+  --help              Mostrar esta ayuda
+
+Comandos especiales del cliente:
+  history             Mostrar historial de comandos
+  clear               Limpiar la pantalla
+  re <número>         Reutilizar comando por número
+  re <texto>          Reutilizar último comando que contiene texto
+  help-cli            Mostrar ayuda del cliente
+
+Ejemplos:
+  node jerk-admin-client.js
+  node jerk-admin-client.js --host 127.0.0.1 --port 9999
+  `);
+}
+
+// Parsear argumentos
+const args = process.argv.slice(2);
+let host = DEFAULT_HOST;
+let port = DEFAULT_PORT;
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--help' || args[i] === '-h') {
+    showHelp();
+    process.exit(0);
+  } else if (args[i] === '--host' || args[i] === '-h') {
+    host = args[++i];
+  } else if (args[i] === '--port' || args[i] === '-p') {
+    port = parseInt(args[++i]);
+  }
+}
+
+// Validar puerto
+if (isNaN(port) || port <= 0 || port > 65535) {
+  console.error(`Puerto inválido: ${port}`);
+  process.exit(1);
+}
+
+// Iniciar el cliente
+createClient(host, port);