blackcoffee2 2.1.0 → 2.1.2

package/test-aplicacion.con-logisession/utils/dbAdapter.js

@@ -1,88 +0,0 @@
-/**
- * Módulo de adaptador centralizado para la base de datos
- * dbAdapter.js
- *
- * Proporciona una instancia singleton del adaptador MariaDB
- * para ser utilizada por todos los modelos del sistema
- */
-
-const { MariaDBAdapter } = require('insitu-js');
-
-// Variable para almacenar la instancia única del adaptador
-let sharedAdapterInstance = null;
-
-/**
- * Obtiene la instancia del adaptador de base de datos
- * Si no existe una instancia activa, crea una nueva
- * @returns {Object} - Instancia del adaptador de base de datos
- */
-function getSharedAdapter() {
-  if (!sharedAdapterInstance) {
-    // Configuración de la conexión desde variables de entorno
-    const dbConfig = {
-      host: process.env.DB_HOST || 'localhost',
-      user: process.env.DB_USER || 'root',
-      password: process.env.DB_PASSWORD || '',
-      database: process.env.DB_NAME || 'BlackCoffee_db',
-      connectionLimit: parseInt(process.env.DB_CONNECTION_LIMIT) || 10,
-      acquireTimeout: 10000, // Reducido para evitar cuelgues
-      timeout: 10000,        // Reducido para evitar cuelgues
-      // Opciones adicionales para mejorar la estabilidad
-      connectTimeout: 10000, // Reducido para evitar cuelgues
-      allowLocalInfiles: true,
-      initSql: 'SET SESSION sql_mode = "TRADITIONAL"',
-      extraFiles: [],
-      insertIdAsNumber: false,
-      bigIntAsNumber: false,
-      dateStrings: false
-    };
-
-    // Crear una nueva instancia del adaptador MariaDB
-    sharedAdapterInstance = new MariaDBAdapter(dbConfig);
-
-    // Guardar la función original de query
-    const originalQuery = sharedAdapterInstance.query;
-
-    // Reemplazar el método query con uno que maneje la desconexión
-    sharedAdapterInstance.query = async function(query, params = []) {
-      try {
-        // Intentar la consulta directamente
-        return await originalQuery.call(this, query, params);
-      } catch (error) {
-        // Si hay un error de conexión, lanzar un error más específico
-        if (error.errno || error.code === 'ECONNREFUSED' ||
-            error.code === 'ENOTFOUND' || error.code === 'PROTOCOL_CONNECTION_LOST') {
-          console.error('[DB_ADAPTER] Error de conexión a la base de datos:', error.message);
-          throw new Error('No hay conexión disponible a la base de datos. Por favor, verifique que el servidor de base de datos esté activo.');
-        }
-        // Si es otro tipo de error, lanzarlo tal cual
-        throw error;
-      }
-    };
-
-    console.log('[DB_ADAPTER] Adaptador centralizado creado exitosamente');
-  }
-
-  return sharedAdapterInstance;
-}
-
-/**
- * Cierra la conexión del adaptador centralizado
- */
-async function closeSharedAdapter() {
-  if (sharedAdapterInstance && sharedAdapterInstance.pool) {
-    try {
-      await sharedAdapterInstance.pool.end();
-      console.log('[DB_ADAPTER] Adaptador centralizado cerrado exitosamente');
-      sharedAdapterInstance = null;
-    } catch (error) {
-      console.error('[DB_ADAPTER] Error cerrando el adaptador centralizado:', error.message);
-      throw error;
-    }
-  }
-}
-
-module.exports = {
-  getSharedAdapter,
-  closeSharedAdapter
-};

package/test-aplicacion.con-logisession/utils/qbWrapper.js

@@ -1,4 +0,0 @@
-// Wrapper para usar qbuilderjs sin conflictos con insitu-js
-const { QueryBuilder } = require('qbuilderjs');
-
-module.exports = { QueryBuilder };

package/test-aplicacion.con-logisession/utils/queueProcessor.js

@@ -1,305 +0,0 @@
-const QueueJobModel = require('../models/QueueJobModel');
-const { hooks } = require('insitu-js');
-
-class QueueProcessor {
-  constructor() {
-    this.jobModel = QueueJobModel;
-    this.isRunning = false;
-    this.processingDelay = 1000; // Milisegundos entre procesamientos
-    this.workers = new Map(); // Mapa de workers por cola
-  }
-
-  // Iniciar el procesador de colas
-  start() {
-    if (this.isRunning) {
-      console.log('El procesador de colas ya está en ejecución');
-      return;
-    }
-
-    // Disparar hook antes de iniciar el procesador
-    hooks.doAction('queue_processor_started');
-
-    this.isRunning = true;
-    console.log('Iniciando procesador de colas...');
-    this.run();
-  }
-
-  // Detener el procesador de colas
-  stop() {
-    // Disparar hook antes de detener el procesador
-    hooks.doAction('queue_processor_stopped');
-
-    this.isRunning = false;
-    console.log('Deteniendo procesador de colas...');
-  }
-
-  // Ejecutar el bucle principal del procesador
-  async run() {
-    if (!this.isRunning) return;
-
-    try {
-      // Disparar hook al comienzo de cada iteración del bucle principal
-      await hooks.doActionAsync('queue_processor_iteration_start');
-
-      // Filtrar las colas que se van a procesar
-      const queuesToProcess = await hooks.applyFiltersAsync('filter_queue_names_to_process', Array.from(this.jobModel.queues.keys()));
-
-      // Procesar trabajos de todas las colas
-      for (const queueName of queuesToProcess) {
-        await this.processQueue(queueName);
-      }
-
-      // Disparar hook al final de cada iteración del bucle principal
-      await hooks.doActionAsync('queue_processor_iteration_end');
-    } catch (error) {
-      console.error('Error en el procesador de colas:', error);
-    }
-
-    // Continuar ejecutando después de un delay
-    setTimeout(() => this.run(), this.processingDelay);
-  }
-
-  // Procesar una cola específica
-  async processQueue(queueName) {
-    // Disparar hook antes de procesar una cola específica
-    await hooks.doActionAsync('queue_before_process_specific', queueName);
-
-    // Obtener el siguiente trabajo pendiente
-    const job = await this.jobModel.getNextPendingJob(queueName);
-
-    if (job) {
-      // Disparar hook antes de marcar como en proceso
-      await hooks.doActionAsync('queue_job_mark_processing_before', job);
-
-      // Marcar como en proceso
-      await this.jobModel.markJobAsProcessing(job.id);
-
-      // Disparar hook después de marcar como en proceso
-      await hooks.doActionAsync('queue_job_mark_processing_after', job);
-
-      // Ejecutar el trabajo
-      await this.executeJob(job);
-    }
-
-    // Disparar hook después de procesar una cola específica
-    await hooks.doActionAsync('queue_after_process_specific', queueName);
-  }
-
-  // Ejecutar un trabajo específico
-  async executeJob(job) {
-    try {
-      // Disparar hook antes de ejecutar un trabajo específico
-      await hooks.doActionAsync('queue_job_execute_start', job);
-
-      // Simular un delay para dar tiempo a otros procesos
-      await this.delay(100);
-
-      // Obtener el manejador de trabajo para esta cola
-      const handler = this.getHandlerForQueue(job.queue);
-
-      if (handler) {
-        // Filtrar el payload antes de ejecutarlo
-        const filteredPayload = await hooks.applyFiltersAsync('filter_job_payload_before_execution', job.payload, job);
-
-        // Ejecutar el manejador con los datos del trabajo
-        const result = await handler(filteredPayload);
-
-        // Filtrar el resultado antes de guardarlo
-        const filteredResult = await hooks.applyFiltersAsync('filter_job_result_before_save', result, job);
-
-        // Marcar como completado
-        await this.jobModel.markJobAsCompleted(job.id, filteredResult);
-        console.log(`Trabajo ${job.id} completado exitosamente`);
-
-        // Disparar hook después de completar un trabajo exitosamente
-        await hooks.doActionAsync('queue_job_execute_end', job, filteredResult, 'success');
-      } else {
-        // Si no hay manejador, marcar como fallido
-        const error = `No se encontró un manejador para la cola: ${job.queue}`;
-        await this.jobModel.markJobAsFailed(job.id, error);
-        console.error(error);
-
-        // Disparar hook después de completar un trabajo con error
-        await hooks.doActionAsync('queue_job_execute_end', job, error, 'failure');
-      }
-    } catch (error) {
-      // Disparar hook cuando ocurre un error durante la ejecución de un trabajo
-      await hooks.doActionAsync('queue_job_error_occurred', job, error);
-
-      // Manejar error en la ejecución del trabajo
-      console.error(`Error ejecutando el trabajo ${job.id}:`, error);
-
-      // Verificar si se debe reintentar
-      if (await this.jobModel.shouldRetryJob(job.id, error.message)) {
-        // Disparar hook antes de reintentar un trabajo
-        await hooks.doActionAsync('queue_job_retry', job, error);
-
-        // Si se debe reintentar, volver a poner en cola pendiente
-        const originalJob = this.jobModel.jobs.get(job.id);
-        if (originalJob) {
-          originalJob.status = 'pending';
-          originalJob.updated_at = new Date().toISOString();
-
-          // Añadir de nuevo a la cola
-          const queue = this.jobModel.queues.get(originalJob.queue);
-          if (queue) {
-            queue.push(originalJob);
-
-            // Reordenar la cola
-            queue.sort((a, b) => {
-              if (b.priority !== a.priority) {
-                return b.priority - a.priority;
-              }
-              return new Date(a.created_at) - new Date(b.created_at);
-            });
-          }
-        }
-      } else {
-        // Si no se debe reintentar, marcar como fallido permanentemente
-        await this.jobModel.markJobAsFailed(job.id, error.message);
-      }
-    }
-  }
-
-  // Obtener el manejador de trabajo para una cola específica
-  getHandlerForQueue(queueName) {
-    // Disparar hook antes de seleccionar un manejador
-    hooks.doAction('queue_job_handler_selected_before', queueName);
-
-    // Manejadores predeterminados para colas comunes
-    const defaultHandlers = {
-      'default': this.defaultHandler.bind(this),
-      'analytics': this.analyticsHandler.bind(this),
-      'email': this.emailHandler.bind(this),
-      'notifications': this.notificationsHandler.bind(this),
-      'qwen': this.qwenHandler.bind(this)
-    };
-
-    // Obtener el manejador
-    const handler = defaultHandlers[queueName] || defaultHandlers['default'];
-
-    // Disparar hook después de seleccionar un manejador
-    hooks.doAction('queue_job_handler_selected', queueName, handler);
-
-    // Devolver el manejador específico o el predeterminado
-    return handler;
-  }
-
-  // Manejador predeterminado
-  async defaultHandler(payload) {
-    console.log('Ejecutando trabajo predeterminado con payload:', payload);
-    // Simular trabajo
-    await this.delay(500);
-    return { success: true, message: 'Trabajo predeterminado completado', payload };
-  }
-
-  // Manejador para trabajos de analytics
-  async analyticsHandler(payload) {
-    console.log('Ejecutando trabajo de analytics con payload:', payload);
-    // Simular análisis de datos
-    await this.delay(1000);
-    return { success: true, message: 'Análisis completado', payload };
-  }
-
-  // Manejador para trabajos de correo electrónico
-  async emailHandler(payload) {
-    console.log('Ejecutando trabajo de email con payload:', payload);
-    // Simular envío de correo
-    await this.delay(800);
-    return { success: true, message: 'Correo enviado', payload };
-  }
-
-  // Manejador para trabajos de notificaciones
-  async notificationsHandler(payload) {
-    console.log('Ejecutando trabajo de notificaciones con payload:', payload);
-    // Simular envío de notificación
-    await this.delay(300);
-    return { success: true, message: 'Notificación enviada', payload };
-  }
-
-  // Manejador para trabajos de Qwen
-  async qwenHandler(payload) {
-    console.log('Ejecutando trabajo de Qwen con payload:', payload);
-
-    // Disparar hook antes de la verificación de seguridad
-    await hooks.doActionAsync('qwen_queue_before_security_check', payload);
-
-    try {
-      // Importar el servicio de reglas
-      const { qwenRulesService } = require('../utils/qwenRulesService');
-
-      // Verificar si el prompt original es seguro ANTES de aplicar reglas
-      if (!qwenRulesService.isPromptSafe(payload.prompt)) {
-        // Si el prompt es inseguro, lanzar un error específico que no se reintente
-        throw new Error('SECURITY_ERROR: El prompt contiene patrones no seguros según las reglas de seguridad');
-      }
-
-      // Disparar hook después de la verificación de seguridad
-      await hooks.doActionAsync('qwen_queue_after_security_check', payload);
-
-      // Aplicar reglas al prompt
-      const securedPrompt = qwenRulesService.applyRulesToPrompt(payload.prompt, payload.data);
-
-      // Disparar hook antes de ejecutar el comando Qwen
-      await hooks.doActionAsync('qwen_queue_before_command_execution', securedPrompt, payload);
-
-      // Importar exec aquí para evitar problemas de dependencias
-      const { exec } = require('child_process');
-      const util = require('util');
-      const execAsync = util.promisify(exec);
-
-      // Preparar el comando para Qwen con el prompt modificado
-      const dataString = JSON.stringify(payload.data).replace(/"/g, '\\"');
-      const qwenCommand = `qwen -p "${securedPrompt} ${dataString}"`;
-
-      // Ejecutar el comando de Qwen
-      const result = await execAsync(qwenCommand);
-
-      // Disparar hook después de ejecutar el comando Qwen
-      await hooks.doActionAsync('qwen_queue_after_command_execution', result, qwenCommand);
-
-      // Validar la respuesta según las reglas
-      const validatedResponse = qwenRulesService.validateResponse(result.stdout);
-
-      // Disparar hook después de validar la respuesta
-      await hooks.doActionAsync('qwen_queue_response_validated', validatedResponse, payload);
-
-      return {
-        success: true,
-        response: validatedResponse,
-        command: qwenCommand,
-        userId: payload.userId,
-        requestId: payload.requestId
-      };
-    } catch (error) {
-      console.error('Error executing Qwen command:', error);
-      throw new Error(`Qwen execution failed: ${error.message}`);
-    }
-  }
-
-  // Método para registrar un manejador personalizado
-  registerHandler(queueName, handlerFunction) {
-    if (typeof handlerFunction !== 'function') {
-      throw new Error('El manejador debe ser una función');
-    }
-
-    // Disparar hook antes de registrar un manejador
-    hooks.doAction('queue_handler_registered_before', queueName, handlerFunction);
-
-    // Añadir el manejador al mapa de workers
-    this.workers.set(queueName, handlerFunction);
-
-    // Disparar hook después de registrar un manejador
-    hooks.doAction('queue_handler_registered', queueName, handlerFunction);
-  }
-
-  // Método de utilidad para crear un delay
-  delay(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-}
-
-// Instancia global del procesador de colas
-const queueProcessor = new QueueProcessor();
-
-module.exports = { QueueProcessor, queueProcessor };

package/test-aplicacion.con-logisession/utils/qwenRulesService.js

@@ -1,131 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-class QwenRulesService {
-  constructor(configPath = './config/qwen-rules.json') {
-    // Construir la ruta absoluta desde la raíz del proyecto
-    this.configPath = path.join(__dirname, '..', 'config', 'qwen-rules.json');
-    this.rulesConfig = this.loadConfig();
-  }
-
-  // Cargar la configuración de reglas
-  loadConfig() {
-    try {
-      const configData = fs.readFileSync(this.configPath, 'utf8');
-      return JSON.parse(configData);
-    } catch (error) {
-      console.error('Error loading Qwen rules configuration:', error.message);
-      // Devolver configuración por defecto si hay error
-      return {
-        qwenRules: {
-          restrictSystemInfo: true,
-          preventDataLeakage: true,
-          allowExternalContext: false,
-          maxResponseTokens: 2000,
-          prohibitedTopics: [
-            "sistema de archivos",
-            "estructura de directorios",
-            "archivos del sistema",
-            "información interna",
-            "código fuente del sistema",
-            "configuración interna"
-          ],
-          customInstructions: [
-            "Solo responde sobre los datos que se te proporcionan explícitamente",
-            "No hagas suposiciones sobre la estructura interna del sistema",
-            "Si se te pregunta sobre archivos o estructura del sistema, redirige a los datos proporcionados"
-          ]
-        },
-        queueSettings: {
-          defaultPriority: 0,
-          maxRetries: 3,
-          processingTimeout: 60000,
-          maxPayloadSize: 1048576
-        },
-        security: {
-          sanitizeInputs: true,
-          validateOutputs: true,
-          blockSuspiciousPatterns: true
-        }
-      };
-    }
-  }
-
-  // Aplicar reglas al prompt antes de enviarlo a Qwen
-  applyRulesToPrompt(prompt, data) {
-    const { qwenRules } = this.rulesConfig;
-    let enhancedPrompt = prompt;
-
-    // Añadir instrucciones personalizadas al principio del prompt
-    if (qwenRules.customInstructions && qwenRules.customInstructions.length > 0) {
-      const instructions = qwenRules.customInstructions.join('\n');
-      enhancedPrompt = `Instrucciones de seguridad:\n${instructions}\n\nPrompt original: ${enhancedPrompt}`;
-    }
-
-    // Añadir restricciones si están habilitadas
-    if (qwenRules.restrictSystemInfo) {
-      enhancedPrompt += "\n\nImportante: No proporciones información sobre el sistema, archivos o estructura interna. Responde solo basándote en los datos proporcionados.";
-    }
-
-    return enhancedPrompt;
-  }
-
-  // Validar la respuesta de Qwen según las reglas
-  validateResponse(response) {
-    const { qwenRules } = this.rulesConfig;
-    
-    // Verificar si la respuesta contiene temas prohibidos
-    if (qwenRules.prohibitedTopics) {
-      for (const topic of qwenRules.prohibitedTopics) {
-        if (response.toLowerCase().includes(topic.toLowerCase())) {
-          throw new Error(`La respuesta contiene información prohibida sobre: ${topic}`);
-        }
-      }
-    }
-
-    return response;
-  }
-
-  // Verificar si un prompt es seguro para procesar
-  isPromptSafe(prompt) {
-    const { qwenRules } = this.rulesConfig;
-
-    if (!qwenRules || !qwenRules.preventDataLeakage) {
-      return true;
-    }
-
-    // Verificar si el prompt solicita información sensible
-    const unsafePatterns = [
-      /archivo.*sistema/i,
-      /estructura.*interna/i,
-      /configuraci.n.*interna/i,
-      /c.digo.*fuente/i,
-      /sistema.*archivo/i,
-      /directorio.*interno/i,
-      /informaci.n.*interna/i
-    ];
-
-    for (const pattern of unsafePatterns) {
-      if (pattern.test(prompt)) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  // Obtener configuración de cola
-  getQueueSettings() {
-    return this.rulesConfig.queueSettings || {};
-  }
-
-  // Obtener configuración de seguridad
-  getSecuritySettings() {
-    return this.rulesConfig.security || {};
-  }
-}
-
-// Instancia global del servicio de reglas
-const qwenRulesService = new QwenRulesService();
-
-module.exports = { QwenRulesService, qwenRulesService };

package/test-aplicacion.con-logisession/utils/tokenHelper.js

@@ -1,22 +0,0 @@
-/**
- * Helper para la validación de tokens en el framework JERK
- * tokenHelper.js
- */
-
-const TokenModel = require('../models/tracking/TokenModel');
-
-// Instancia del modelo de tokens
-const tokenModel = new TokenModel();
-
-/**
- * Valida un token contra la base de datos
- * @param {string} token - Token a validar
- * @returns {Promise<boolean>} - True si el token es válido, false en caso contrario
- */
-async function validateToken(token) {
-  return await tokenModel.validateToken(token);
-}
-
-module.exports = {
-  validateToken
-};