blackcoffee2 2.1.0

package/includes/404-hooks.js

@@ -0,0 +1,423 @@
+/**
+ * Hooks para manejo de errores 404 en BlackCoffee
+ * Utiliza el sistema de hooks de Insitu Framework
+ * 
+ * Maneja dos tipos de errores 404:
+ *   1. Ruta no encontrada (endpoints)
+ *   2. Archivo estático no encontrado
+ * 
+ * Sirve un template HTML personalizado desde public/templates/404.html
+ * 
+ * Uso:
+ *   const hooks404 = require('./includes/404-hooks.js');
+ *   hooks404.register(server.hooks);
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Cache del template 404
+let cached404Template = null;
+
+/**
+ * Carga el template 404 desde el archivo
+ * @returns {string} - Contenido del template HTML
+ */
+function load404Template() {
+  if (cached404Template) {
+    return cached404Template;
+  }
+
+  const templatePath = path.join(__dirname, '../public/templates/404.html');
+  
+  try {
+    cached404Template = fs.readFileSync(templatePath, 'utf8');
+    console.log('✅ Template 404 cargado en caché');
+    return cached404Template;
+  } catch (error) {
+    console.warn('⚠️ No se pudo cargar el template 404:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Registra los hooks para manejo de errores 404
+ * @param {Object} hooks - Sistema de hooks de Insitu
+ */
+function register(hooks) {
+  if (!hooks) {
+    console.warn('⚠️ No se proporcionó el sistema de hooks');
+    return;
+  }
+
+  console.log('🔗 Registrando hooks para manejo 404...');
+
+  // Cargar template 404
+  load404Template();
+
+  // ============================================
+  // FILTROS (Filters) - Permiten modificar datos
+  // ============================================
+
+  /**
+   * Filtro: custom_404_message
+   * Permite personalizar el mensaje de error 404
+   * Este es el filtro principal para modificar la respuesta
+   */
+  hooks.addFilter('custom_404_message', (errorData, req, res, type) => {
+    if (type === 'file') {
+      errorData.message = 'Archivo no encontrado';
+      errorData.hint = 'Verifica la ruta del archivo estático';
+    } else {
+      errorData.message = 'Endpoint no encontrado';
+      errorData.hint = 'Verifica la URL e intenta nuevamente';
+    }
+    
+    errorData.timestamp = new Date().toISOString();
+    errorData.blackcoffee = 'BlackCoffee v1.1.0';
+    
+    return errorData;
+  }, 10);
+
+  /**
+   * Filtro: pre_route_not_found
+   * Se ejecuta antes de devolver un 404 de ruta
+   */
+  hooks.addFilter('pre_route_not_found', (data, req, res) => {
+    return data;
+  }, 10);
+
+  /**
+   * Filtro: customize_404_response
+   * Filtro PRINCIPAL para servir template HTML 404
+   * Si shouldSendDefaultResponse = false, evita la respuesta JSON por defecto
+   * y sirve el template HTML personalizado
+   */
+  hooks.addFilter('customize_404_response', (data, pathname, req, res) => {
+    const template = load404Template();
+    
+    if (template && req && res) {
+      // Preparar datos del error
+      const errorData = {
+        type: 'route',
+        path: pathname,
+        method: req.method,
+        timestamp: new Date().toISOString()
+      };
+
+      // Reemplazar placeholders en el template
+      let html = template;
+      html = html.replace(
+        "window.errorData = {};",
+        `window.errorData = ${JSON.stringify(errorData)};`
+      );
+
+      // Enviar respuesta HTML
+      res.writeHead(404, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end(html);
+
+      // Evitar respuesta por defecto
+      data.shouldSendDefaultResponse = false;
+    }
+    
+    return data;
+  }, 5); // Prioridad alta para que se ejecute primero
+
+  /**
+   * Filtro: customize_static_404_response
+   * Filtro para servir template HTML 404 para archivos estáticos
+   * Si shouldSendDefaultResponse = false, evita la respuesta JSON por defecto
+   * y sirve el template HTML personalizado
+   */
+  hooks.addFilter('customize_static_404_response', (data, filePath, req, res) => {
+    const template = load404Template();
+    
+    // Usar filePath de data si el directo es undefined
+    const actualFilePath = filePath || data?.filePath;
+    const actualReq = req || data?.req;
+    const actualRes = res || data?.res;
+    
+    if (template && actualReq && actualRes && actualFilePath) {
+      // Preparar datos del error para archivo estático
+      const errorData = {
+        type: 'file',
+        path: actualFilePath,
+        method: actualReq.method || 'GET',
+        url: actualReq.url || actualFilePath,
+        timestamp: new Date().toISOString()
+      };
+
+      // Reemplazar placeholders en el template
+      let html = template;
+      html = html.replace(
+        "window.errorData = {};",
+        `window.errorData = ${JSON.stringify(errorData)};`
+      );
+
+      // Enviar respuesta HTML
+      actualRes.writeHead(404, { 'Content-Type': 'text/html; charset=utf-8' });
+      actualRes.end(html);
+
+      // Evitar respuesta por defecto
+      data.shouldSendDefaultResponse = false;
+    }
+    
+    return data;
+  }, 5); // Prioridad alta para que se ejecute primero
+
+  /**
+   * Filtro: route_not_found_response
+   * Permite modificar la respuesta 404 antes de enviarla
+   */
+  hooks.addFilter('route_not_found_response', (response, req, res, path) => {
+    const customResponse = hooks.applyFilters(
+      'custom_404_message',
+      response,
+      req,
+      res,
+      'route'
+    );
+    
+    return customResponse;
+  }, 10);
+
+  /**
+   * Filtro: static_file_not_found_response
+   * Permite modificar la respuesta 404 para archivos estáticos
+   * NOTA: Este hook se ejecuta DESPUÉS de sendNotFoundResponse,
+   * por lo que no podemos evitar la respuesta JSON.
+   * Se usa solo para logging/métricas.
+   */
+  hooks.addFilter('static_file_not_found_response', (response, req, res, filePath) => {
+    const customResponse = hooks.applyFilters(
+      'custom_404_message',
+      response,
+      req,
+      res,
+      'file'
+    );
+    
+    customResponse.requestedFile = filePath;
+    
+    return customResponse;
+  }, 10);
+
+  // ============================================
+  // FUNCIONES AUXILIARES
+  // ============================================
+
+  /**
+   * Obtiene la IP del cliente de forma segura
+   */
+  function getIP(req) {
+    if (!req) return 'N/A';
+    return req.connection?.remoteAddress || 
+           req.socket?.remoteAddress || 
+           req.headers?.['x-forwarded-for'] || 
+           'N/A';
+  }
+
+  // ============================================
+  // ACCIONES (Actions) - Efectos secundarios
+  // ============================================
+
+  /**
+   * Acción: route_not_found
+   * Se ejecuta cuando no se encuentra una ruta (endpoint)
+   * Muestra mensaje por stdout
+   * Firma del hook: (pathname, req, res)
+   */
+  hooks.addAction('route_not_found', (pathname, req, res) => {
+    const ip = getIP(req);
+    const method = req?.method || 'N/A';
+    const userAgent = req?.headers?.['user-agent'] || 'unknown';
+    
+    console.log(`\n❌ [404 - ROUTE] Ruta no encontrada:`);
+    console.log(`   Método: ${method}`);
+    console.log(`   Path: ${pathname}`);
+    console.log(`   IP: ${ip}`);
+    console.log(`   User-Agent: ${userAgent}`);
+    console.log(`   Timestamp: ${new Date().toISOString()}\n`);
+    
+    // Registrar en métricas
+    trackPath(pathname, 'route');
+  }, 10);
+
+  /**
+   * Acción: post_route_not_found
+   * Se ejecuta después de enviar la respuesta 404 de ruta
+   */
+  hooks.addAction('post_route_not_found', (pathname, req, res) => {
+    console.log(`📤 [404 - ROUTE] Respuesta enviada para: ${pathname}`);
+  }, 10);
+
+  /**
+   * Acción: static_file_not_found
+   * Se ejecuta cuando no se encuentra un archivo estático
+   * Muestra mensaje por stdout
+   * Firma del hook: (filePath, req, res)
+   */
+  hooks.addAction('static_file_not_found', (filePath, req, res) => {
+    const ip = getIP(req);
+    const method = req?.method || 'N/A';
+    const url = req?.url || 'N/A';
+    
+    console.log(`\n❌ [404 - FILE] Archivo no encontrado:`);
+    console.log(`   Método: ${method}`);
+    console.log(`   Path solicitado: ${url}`);
+    console.log(`   Archivo físico: ${filePath}`);
+    console.log(`   IP: ${ip}`);
+    console.log(`   Timestamp: ${new Date().toISOString()}\n`);
+    
+    // Registrar en métricas
+    trackPath(filePath, 'file');
+  }, 10);
+
+  /**
+   * Acción: static_file_access_denied
+   * Se ejecuta cuando se deniega acceso a un archivo
+   * Firma del hook: (req, res, normalizedPath)
+   */
+  hooks.addAction('static_file_access_denied', (req, res, normalizedPath) => {
+    console.log(`\n❌ [403 - FILE] Acceso denegado:`);
+    console.log(`   Archivo: ${normalizedPath}`);
+    console.log(`   Razón: Path traversal detectado`);
+    console.log(`   IP: ${req?.connection?.remoteAddress || req?.socket?.remoteAddress || 'N/A'}`);
+    console.log(`   Timestamp: ${new Date().toISOString()}\n`);
+  }, 10);
+
+  /**
+   * Acción: post_static_file_not_found
+   * Se ejecuta después de enviar la respuesta 404 de archivo
+   */
+  hooks.addAction('post_static_file_not_found', (filePath, req, res) => {
+    console.log(`📤 [404 - FILE] Respuesta enviada para: ${filePath}`);
+  }, 10);
+
+  console.log('✅ Hooks 404 registrados exitosamente');
+  console.log('   Filtros:');
+  console.log('     • custom_404_message (personalizar mensaje)');
+  console.log('     • customize_404_response (template HTML para rutas)');
+  console.log('     • customize_static_404_response (template HTML para archivos)');
+  console.log('     • pre_route_not_found');
+  console.log('     • route_not_found_response');
+  console.log('     • static_file_not_found_response');
+  console.log('   Acciones:');
+  console.log('     • route_not_found (stdout)');
+  console.log('     • post_route_not_found');
+  console.log('     • static_file_not_found (stdout)');
+  console.log('     • static_file_access_denied (stdout)');
+  console.log('     • post_static_file_not_found\n');
+}
+
+// ============================================
+// MÉTRICAS
+// ============================================
+
+/**
+ * Inicializa el sistema de métricas 404
+ */
+function initMetrics() {
+  global.metrics404 = {
+    count: 0,
+    routes: 0,
+    files: 0,
+    lastPath: null,
+    lastType: null,
+    lastTime: null,
+    paths: new Map() // Contador por path
+  };
+
+  console.log('📊 Métricas 404 inicializadas');
+}
+
+/**
+ * Registra un path en las métricas
+ * @param {string} path - Ruta o archivo solicitado
+ * @param {string} type - Tipo: 'route' o 'file'
+ */
+function trackPath(path, type = 'route') {
+  if (!global.metrics404) {
+    initMetrics();
+  }
+
+  global.metrics404.count++;
+  
+  if (type === 'file') {
+    global.metrics404.files++;
+  } else {
+    global.metrics404.routes++;
+  }
+  
+  global.metrics404.lastPath = path;
+  global.metrics404.lastType = type;
+  global.metrics404.lastTime = new Date().toISOString();
+
+  const count = global.metrics404.paths.get(path) || 0;
+  global.metrics404.paths.set(path, count + 1);
+}
+
+/**
+ * Obtiene las métricas de errores 404
+ * @returns {Object} - Métricas de errores 404
+ */
+function getMetrics() {
+  return global.metrics404 || {
+    count: 0,
+    routes: 0,
+    files: 0,
+    lastPath: null,
+    lastType: null,
+    lastTime: null,
+    paths: new Map()
+  };
+}
+
+/**
+ * Limpia las métricas de errores 404
+ */
+function clearMetrics() {
+  global.metrics404 = {
+    count: 0,
+    routes: 0,
+    files: 0,
+    lastPath: null,
+    lastType: null,
+    lastTime: null,
+    paths: new Map()
+  };
+  console.log('🧹 Métricas 404 limpiadas');
+}
+
+/**
+ * Imprime las métricas por stdout
+ */
+function printMetrics() {
+  const metrics = getMetrics();
+  console.log('\n📊 === Métricas 404 ===');
+  console.log(`   Total: ${metrics.count}`);
+  console.log(`   Rutas: ${metrics.routes}`);
+  console.log(`   Archivos: ${metrics.files}`);
+  console.log(`   Último: ${metrics.lastPath} (${metrics.lastType})`);
+  console.log(`   Hora: ${metrics.lastTime || 'N/A'}`);
+  
+  if (metrics.paths.size > 0) {
+    console.log('   Paths más solicitados:');
+    const sorted = Array.from(metrics.paths.entries())
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 5);
+    sorted.forEach(([path, count]) => {
+      console.log(`     - ${path}: ${count}`);
+    });
+  }
+  console.log('========================\n');
+}
+
+module.exports = {
+  register,
+  initMetrics,
+  getMetrics,
+  trackPath,
+  clearMetrics,
+  printMetrics
+};

package/includes/adminAuth.js

@@ -0,0 +1,214 @@
+/**
+ * Módulo de Autenticación y Rutas de Administración para BlackCoffee
+ * Maneja SessionManager, hooks de autenticación y rutas del dashboard
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { SessionManager } = require('insitu-js');
+const { hooks } = require('insitu-js');
+const { initDatabase } = require('./initAdminDb');
+
+/**
+ * Middleware de autenticación para proteger rutas admin
+ */
+function authMiddleware() {
+  return (req, res, next) => {
+    const requestPath = req.url?.split('?')[0];
+
+    if (!requestPath) {
+      return next();
+    }
+
+    // Excepción: recursos estáticos del admin (CSS, JS) - NO requieren autenticación
+    if (requestPath.startsWith('/admin/css') || requestPath.startsWith('/admin/js')) {
+      return next();
+    }
+
+    // Excepción: página de login web - NO requiere autenticación
+    if (requestPath === '/admin/login') {
+      return next();
+    }
+
+    // Excepción: rutas de autenticación (API) - NO requieren autenticación
+    if (requestPath.startsWith('/api/admin/auth')) {
+      return next();
+    }
+
+    // Rutas que requieren autenticación (API y Web)
+    const protectedPaths = [
+      '/api/admin/apps',
+      '/api/admin/stats',
+      '/api/admin/config',
+      '/api/admin/db',
+      '/api/admin/database',
+      '/admin',  // Dashboard web (ahora es dinámica)
+      '/admin/database'  // Database Pools web (ahora es dinámica)
+    ];
+
+    // Verificar si la ruta está protegida
+    let isProtected = false;
+    for (const p of protectedPaths) {
+      if (p === requestPath) {
+        isProtected = true;
+        break;
+      }
+      if (requestPath.startsWith(p + '/')) {
+        isProtected = true;
+        break;
+      }
+    }
+
+    if (isProtected) {
+      // Verificar sesión
+      const isAuthenticated = req.session && req.session.data && req.session.data.authenticated;
+      
+      if (!isAuthenticated) {
+        // Para peticiones API, devolver JSON
+        if (requestPath.startsWith('/api/')) {
+          res.writeHead(401, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({
+            success: false,
+            error: 'No autenticado',
+            redirect: '/admin/login'
+          }));
+          return;
+        }
+
+        // Para peticiones web, redirigir al login
+        res.writeHead(302, { 'Location': '/admin/login' });
+        res.end();
+        return;
+      }
+
+      // Usuario autenticado, añadir información a la request
+      req.currentUser = {
+        userId: req.session.data.userId,
+        username: req.session.data.username,
+        role: req.session.data.role
+      };
+    }
+
+    next();
+  };
+}
+
+/**
+ * Inicializar el sistema de autenticación y rutas admin
+ * @param {Object} server - Instancia del servidor APIServer
+ */
+async function initAdminAuth(server) {
+  const config = {
+    cookieName: 'blackcoffee_admin_session',
+    secret: process.env.SESSION_SECRET || 'blackcoffee-session-secret-change-in-production',
+    timeout: 3600000, // 1 hora
+    secure: false, // Cambiar a true en producción con HTTPS
+    httpOnly: true,
+    sameSite: 'lax'
+  };
+
+  // ============================================
+  // Session Manager para autenticación
+  // ============================================
+  const sessionManager = new SessionManager(config);
+  
+  // Registrar middleware de sesión PRIMERO
+  server.use(sessionManager.middleware());
+  
+  server.sessionManager = sessionManager;
+  console.log('🔐 Session Manager inicializado\n');
+
+  // ============================================
+  // Rutas estáticas para CSS y JS (ANTES del middleware de auth)
+  // ============================================
+  console.log('🎨 Cargando recursos estáticos del admin...\n');
+  
+  server.addRoute('GET', '/admin/css', {
+    static: {
+      dir: path.join(__dirname, '..', 'public', 'admin', 'css'),
+      cacheControl: 'public, max-age=31536000'
+    }
+  });
+
+  server.addRoute('GET', '/admin/js', {
+    static: {
+      dir: path.join(__dirname, '..', 'public', 'admin', 'js'),
+      cacheControl: 'public, max-age=31536000'
+    }
+  });
+  
+  console.log('   ✅ Recursos estáticos cargados\n');
+
+  // ============================================
+  // Middleware de autenticación (DESPUÉS de las estáticas)
+  // ============================================
+  server.use(authMiddleware());
+  console.log('🔒 Middleware de autenticación registrado\n');
+
+  // ============================================
+  // Inicializar base de datos de administración
+  // ============================================
+  try {
+    await initDatabase();
+    console.log('🗄️  Base de datos admin inicializada\n');
+  } catch (error) {
+    console.error('❌ Error inicializando DB admin:', error.message);
+  }
+
+  // ============================================
+  // Rutas de autenticación (API)
+  // ============================================
+  const authRoutesPath = path.join(__dirname, '..', 'routes', 'auth.json');
+  if (fs.existsSync(authRoutesPath)) {
+    const RouteLoader = require('insitu-js/lib/loader/routeLoader');
+    const routeLoader = new RouteLoader();
+
+    try {
+      const authRoutes = fs.readFileSync(authRoutesPath, 'utf8');
+      const routes = JSON.parse(authRoutes);
+
+      for (const route of routes) {
+        const controllerPath = path.resolve(__dirname, '..', route.controller);
+        const routeCopy = { ...route, controller: controllerPath };
+        await routeLoader.loadSingleRoute(server, routeCopy);
+        console.log(`   ✅ ${route.method} ${route.path}`);
+      }
+
+      console.log('   ✅ Rutas de autenticación cargadas\n');
+    } catch (error) {
+      console.error(`   ❌ Error cargando rutas auth: ${error.message}\n`);
+    }
+  }
+
+  // ============================================
+  // Rutas de la UI de administración (Web) - DINÁMICAS con controlador
+  // ============================================
+  console.log('🎨 Cargando UI de administración...\n');
+
+  const adminViewsRoutesPath = path.join(__dirname, '..', 'routes', 'admin-views.json');
+  if (fs.existsSync(adminViewsRoutesPath)) {
+    const RouteLoader = require('insitu-js/lib/loader/routeLoader');
+    const routeLoader = new RouteLoader();
+
+    try {
+      const adminViewsRoutes = fs.readFileSync(adminViewsRoutesPath, 'utf8');
+      const routes = JSON.parse(adminViewsRoutes);
+
+      for (const route of routes) {
+        const controllerPath = path.resolve(__dirname, '..', route.controller);
+        const routeCopy = { ...route, controller: controllerPath };
+        await routeLoader.loadSingleRoute(server, routeCopy);
+        console.log(`   ✅ ${route.method} ${route.path}`);
+      }
+
+      console.log('   ✅ Rutas de administración cargadas\n');
+    } catch (error) {
+      console.error(`   ❌ Error cargando rutas admin views: ${error.message}\n`);
+    }
+  }
+
+  // Exponer sessionManager globalmente para acceso desde controladores
+  global.sessionManager = sessionManager;
+}
+
+module.exports = { initAdminAuth };

package/includes/adminExtension.js

@@ -0,0 +1,53 @@
+/**
+ * Extensión administrativa de BlackCoffee
+ * Habilita la consola TCP de administración de Insitu
+ * 
+ * Uso:
+ *   const adminExtension = require('./includes/adminExtension');
+ *   adminExtension.init(server, config);
+ */
+
+/**
+ * Inicializa la consola administrativa
+ * @param {Object} server - Instancia del servidor APIServer
+ * @param {Object} config - Configuración del servidor
+ */
+function init(server, config = {}) {
+  const adminPort = config.adminPort || parseInt(process.env.ADMIN_PORT, 10) || 9999;
+  const adminHost = config.adminHost || process.env.ADMIN_HOST || '127.0.0.1';
+
+  try {
+    console.log(`🔧 Inicializando consola administrativa...`);
+    
+    server.initializeAdminExtension({
+      port: adminPort,
+      host: adminHost
+    });
+
+    console.log(`✅ Consola administrativa iniciada en ${adminHost}:${adminPort}`);
+    console.log(`   Conéctate con: telnet ${adminHost} ${adminPort}`);
+    console.log(`   O usa: nc ${adminHost} ${adminPort}\n`);
+    
+    return true;
+  } catch (error) {
+    console.error(`❌ Error inicializando consola administrativa: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Obtiene información sobre la consola administrativa
+ * @returns {Object} - Información de la consola
+ */
+function getInfo() {
+  return {
+    port: parseInt(process.env.ADMIN_PORT, 10) || 9999,
+    host: process.env.ADMIN_HOST || '127.0.0.1',
+    connectCommand: `telnet ${process.env.ADMIN_HOST || '127.0.0.1'} ${process.env.ADMIN_PORT || 9999}`
+  };
+}
+
+module.exports = {
+  init,
+  getInfo
+};