wu-framework 1.0.0

package/src/core/wu-script-executor.js

@@ -0,0 +1,216 @@
+/**
+ * 📜 WU-SCRIPT-EXECUTOR: Sistema de ejecución segura de scripts
+ * Basado en video-code - Ejecuta scripts en contexto sandbox aislado
+ */
+
+export class WuScriptExecutor {
+  constructor() {
+    console.log('[WuScriptExecutor] 📜 Script execution system initialized');
+  }
+
+  /**
+   * Ejecutar script usando Function constructor (más seguro que eval)
+   * @param {string} script - Código JavaScript a ejecutar
+   * @param {string} appName - Nombre de la app
+   * @param {Proxy} globalProxy - Proxy sandbox como window
+   * @returns {*} Resultado de la ejecución
+   */
+  executeWithFunction(script, appName, globalProxy) {
+    console.log(`[WuScriptExecutor] 🚀 Executing script for ${appName} using Function`);
+
+    try {
+      // 🌟 Almacenar proxy globalmente de forma temporal
+      window.__WU_PROXY_TEMP__ = globalProxy;
+
+      // 🎯 Crear función que recibe window como parámetro
+      const scriptText = `
+        return ((window) => {
+          ${script}
+          return window['${appName}'];
+        })(window.__WU_PROXY_TEMP__);
+      `;
+
+      // 🚀 Ejecutar con Function (más seguro que eval)
+      const fn = new Function(scriptText);
+      const result = fn();
+
+      // 🧹 Limpiar proxy temporal
+      delete window.__WU_PROXY_TEMP__;
+
+      console.log(`[WuScriptExecutor] ✅ Script executed successfully for ${appName}`);
+      return result;
+
+    } catch (error) {
+      // 🧹 Limpiar en caso de error
+      delete window.__WU_PROXY_TEMP__;
+
+      console.error(`[WuScriptExecutor] ❌ Script execution failed for ${appName}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Ejecutar script usando eval (fallback)
+   * @param {string} script - Código JavaScript a ejecutar
+   * @param {string} appName - Nombre de la app
+   * @param {Proxy} globalProxy - Proxy sandbox como window
+   * @returns {*} Resultado de la ejecución
+   */
+  executeWithEval(script, appName, globalProxy) {
+    console.log(`[WuScriptExecutor] 🚀 Executing script for ${appName} using eval`);
+
+    try {
+      // 🌟 Almacenar proxy globalmente de forma temporal
+      window.__WU_PROXY_TEMP__ = globalProxy;
+
+      // 🎯 IIFE que recibe window como parámetro
+      const scriptText = `
+        ((window) => {
+          ${script}
+          return window['${appName}'];
+        })(window.__WU_PROXY_TEMP__);
+      `;
+
+      // ⚠️ Usar eval (menos seguro pero compatible)
+      const result = eval(scriptText);
+
+      // 🧹 Limpiar proxy temporal
+      delete window.__WU_PROXY_TEMP__;
+
+      console.log(`[WuScriptExecutor] ✅ Script executed successfully for ${appName}`);
+      return result;
+
+    } catch (error) {
+      // 🧹 Limpiar en caso de error
+      delete window.__WU_PROXY_TEMP__;
+
+      console.error(`[WuScriptExecutor] ❌ Script execution failed for ${appName}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Ejecutar script con estrategia automática (intenta Function primero, luego eval)
+   * @param {string} script - Código JavaScript a ejecutar
+   * @param {string} appName - Nombre de la app
+   * @param {Proxy} globalProxy - Proxy sandbox como window
+   * @param {string} strategy - 'function' | 'eval' | 'auto'
+   * @returns {*} Resultado de la ejecución
+   */
+  execute(script, appName, globalProxy, strategy = 'function') {
+    if (strategy === 'eval') {
+      return this.executeWithEval(script, appName, globalProxy);
+    }
+
+    if (strategy === 'function' || strategy === 'auto') {
+      try {
+        return this.executeWithFunction(script, appName, globalProxy);
+      } catch (error) {
+        if (strategy === 'auto') {
+          console.warn(`[WuScriptExecutor] ⚠️ Function failed, falling back to eval`);
+          return this.executeWithEval(script, appName, globalProxy);
+        }
+        throw error;
+      }
+    }
+
+    throw new Error(`Unknown execution strategy: ${strategy}`);
+  }
+
+  /**
+   * Ejecutar múltiples scripts en secuencia
+   * @param {Array<string>} scripts - Array de scripts
+   * @param {string} appName - Nombre de la app
+   * @param {Proxy} globalProxy - Proxy sandbox
+   * @param {string} strategy - Estrategia de ejecución
+   * @returns {Array<*>} Resultados de ejecución
+   */
+  async executeMultiple(scripts, appName, globalProxy, strategy = 'function') {
+    console.log(`[WuScriptExecutor] 📚 Executing ${scripts.length} scripts for ${appName}`);
+
+    const results = [];
+
+    for (let i = 0; i < scripts.length; i++) {
+      const script = scripts[i];
+      console.log(`[WuScriptExecutor] 📜 Executing script ${i + 1}/${scripts.length}`);
+
+      try {
+        const result = this.execute(script, appName, globalProxy, strategy);
+        results.push({ success: true, result });
+      } catch (error) {
+        console.error(`[WuScriptExecutor] ❌ Script ${i + 1} failed:`, error);
+        results.push({ success: false, error });
+      }
+    }
+
+    const successCount = results.filter(r => r.success).length;
+    console.log(`[WuScriptExecutor] ✅ Executed ${successCount}/${scripts.length} scripts successfully`);
+
+    return results;
+  }
+
+  /**
+   * Validar script antes de ejecutar
+   * @param {string} script - Código a validar
+   * @returns {boolean} True si el script parece válido
+   */
+  validateScript(script) {
+    if (!script || typeof script !== 'string') {
+      return false;
+    }
+
+    if (script.trim().length === 0) {
+      return false;
+    }
+
+    // Detectar código potencialmente peligroso
+    const dangerousPatterns = [
+      /__proto__/,
+      /constructor.*prototype/,
+      /document\.write/,
+      /eval\(/,
+      /new\s+Function\(/
+    ];
+
+    for (const pattern of dangerousPatterns) {
+      if (pattern.test(script)) {
+        console.warn(`[WuScriptExecutor] ⚠️ Potentially dangerous code detected`);
+        // No bloquear, solo advertir
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Obtener estadísticas del executor
+   */
+  getStats() {
+    return {
+      executor: 'WuScriptExecutor',
+      capabilities: ['function', 'eval', 'auto'],
+      defaultStrategy: 'function',
+      validation: true
+    };
+  }
+}
+
+/**
+ * 🎯 EXPORTS DE CONVENIENCIA
+ */
+
+/**
+ * Ejecutar script de forma segura
+ */
+export function executeScript(script, appName, globalProxy, strategy = 'function') {
+  const executor = new WuScriptExecutor();
+  return executor.execute(script, appName, globalProxy, strategy);
+}
+
+/**
+ * Ejecutar múltiples scripts
+ */
+export async function executeScripts(scripts, appName, globalProxy, strategy = 'function') {
+  const executor = new WuScriptExecutor();
+  return await executor.executeMultiple(scripts, appName, globalProxy, strategy);
+}

package/src/core/wu-snapshot-sandbox.js

@@ -0,0 +1,184 @@
+/**
+ * 🛡️ WU-SNAPSHOT-SANDBOX: JavaScript Isolation con Snapshots
+ * Basado en video-code - Fallback para navegadores sin Proxy
+ *
+ * Este sandbox toma "fotos" del estado de window antes de montar
+ * y restaura el estado original al desmontar
+ */
+
+export class WuSnapshotSandbox {
+  constructor(appName) {
+    this.appName = appName;
+    this.proxy = window; // En snapshot mode, proxy es window directamente
+    this.snapshot = new Map();
+    this.modifiedKeys = new Set();
+    this.active = false;
+
+    console.log(`[WuSnapshotSandbox] 📸 Creating snapshot sandbox for: ${appName}`);
+  }
+
+  /**
+   * Activar sandbox - Captura snapshot del window
+   */
+  activate() {
+    if (this.active) {
+      console.warn(`[WuSnapshotSandbox] Sandbox already active for ${this.appName}`);
+      return this.proxy;
+    }
+
+    console.log(`[WuSnapshotSandbox] 📸 Taking window snapshot for ${this.appName}...`);
+
+    // 📸 Capturar estado actual de window
+    this.snapshot.clear();
+    this.modifiedKeys.clear();
+
+    // Iterar sobre todas las propiedades de window
+    for (const key in window) {
+      try {
+        // Guardar el valor actual
+        this.snapshot.set(key, window[key]);
+      } catch (error) {
+        // Algunas propiedades pueden ser inaccesibles
+        console.warn(`[WuSnapshotSandbox] ⚠️ Could not snapshot property: ${key}`);
+      }
+    }
+
+    this.active = true;
+    console.log(`[WuSnapshotSandbox] ✅ Snapshot captured with ${this.snapshot.size} properties`);
+
+    return this.proxy;
+  }
+
+  /**
+   * Desactivar sandbox - Restaura el snapshot original
+   */
+  deactivate() {
+    if (!this.active) {
+      console.warn(`[WuSnapshotSandbox] Sandbox not active for ${this.appName}`);
+      return;
+    }
+
+    console.log(`[WuSnapshotSandbox] 🔄 Restoring window snapshot for ${this.appName}...`);
+
+    let restoredCount = 0;
+    let deletedCount = 0;
+
+    // 🔄 Detectar y restaurar cambios
+    for (const key in window) {
+      try {
+        const currentValue = window[key];
+        const originalValue = this.snapshot.get(key);
+
+        // Si la propiedad cambió, restaurarla
+        if (currentValue !== originalValue) {
+          if (this.snapshot.has(key)) {
+            window[key] = originalValue;
+            restoredCount++;
+          } else {
+            // Nueva propiedad agregada por la app, eliminarla
+            try {
+              delete window[key];
+              deletedCount++;
+            } catch (error) {
+              // Algunas propiedades no se pueden eliminar
+              console.warn(`[WuSnapshotSandbox] ⚠️ Could not delete: ${key}`);
+            }
+          }
+        }
+      } catch (error) {
+        console.warn(`[WuSnapshotSandbox] ⚠️ Could not restore property: ${key}`);
+      }
+    }
+
+    // 🧹 Limpiar estado
+    this.snapshot.clear();
+    this.modifiedKeys.clear();
+    this.active = false;
+
+    console.log(`[WuSnapshotSandbox] ✅ Snapshot restored - ${restoredCount} restored, ${deletedCount} deleted`);
+  }
+
+  /**
+   * Obtener el proxy (en este caso, window)
+   */
+  getProxy() {
+    return this.active ? this.proxy : null;
+  }
+
+  /**
+   * Verificar si el sandbox está activo
+   */
+  isActive() {
+    return this.active;
+  }
+
+  /**
+   * Obtener estadísticas del sandbox
+   */
+  getStats() {
+    const modifiedProps = [];
+
+    if (this.active) {
+      // Detectar qué propiedades han cambiado
+      for (const key in window) {
+        try {
+          const currentValue = window[key];
+          const originalValue = this.snapshot.get(key);
+
+          if (currentValue !== originalValue) {
+            modifiedProps.push(key);
+          }
+        } catch (error) {
+          // Ignorar errores de acceso
+        }
+      }
+    }
+
+    return {
+      appName: this.appName,
+      active: this.active,
+      snapshotSize: this.snapshot.size,
+      modifiedProperties: modifiedProps,
+      modifiedCount: modifiedProps.length
+    };
+  }
+
+  /**
+   * Verificar si una propiedad fue modificada
+   */
+  isPropertyModified(prop) {
+    if (!this.active) return false;
+
+    try {
+      const currentValue = window[prop];
+      const originalValue = this.snapshot.get(prop);
+      return currentValue !== originalValue;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Obtener todas las propiedades modificadas
+   */
+  getModifiedProperties() {
+    const modified = {};
+
+    if (this.active) {
+      for (const key in window) {
+        try {
+          if (this.isPropertyModified(key)) {
+            modified[key] = {
+              original: this.snapshot.get(key),
+              current: window[key]
+            };
+          }
+        } catch (error) {
+          // Ignorar errores de acceso
+        }
+      }
+    }
+
+    return modified;
+  }
+}

package/src/core/wu-store.js

@@ -0,0 +1,297 @@
+/**
+ * 🚀 WU-STORE: Ultra-High Performance State Management
+ *
+ * Basado en patrones de Disruptor y Vert.x
+ * - Ring Buffer para zero-allocation
+ * - Lock-free operations
+ * - Event Bus para pub/sub
+ * - API minimalista: get(), set(), on()
+ */
+
+export class WuStore {
+  constructor(bufferSize = 256) {
+    // Ring Buffer configuration
+    this.bufferSize = this.nextPowerOfTwo(bufferSize);
+    this.mask = this.bufferSize - 1;
+    this.buffer = new Array(this.bufferSize);
+    this.cursor = 0;
+
+    // State storage
+    this.state = {};
+
+    // Event listeners map: path -> Set of callbacks
+    this.listeners = new Map();
+
+    // Pattern listeners for wildcards
+    this.patternListeners = new Map();
+
+    // Performance metrics
+    this.metrics = {
+      reads: 0,
+      writes: 0,
+      notifications: 0
+    };
+
+    // Initialize ring buffer slots
+    for (let i = 0; i < this.bufferSize; i++) {
+      this.buffer[i] = { path: null, value: null, timestamp: 0 };
+    }
+
+    // No global pollution - proper library architecture
+  }
+
+  /**
+   * Get value from store
+   * @param {string} path - Dot notation path (e.g., 'user.name')
+   * @returns {*} Value at path or entire state if no path
+   */
+  get(path) {
+    this.metrics.reads++;
+
+    if (!path) return this.state;
+
+    // Fast path resolution with reduce
+    return path.split('.').reduce((obj, key) => obj?.[key], this.state);
+  }
+
+  /**
+   * Set value in store with Ring Buffer
+   * @param {string} path - Dot notation path
+   * @param {*} value - Value to set
+   * @returns {number} Sequence number
+   */
+  set(path, value) {
+    this.metrics.writes++;
+
+    // Write to ring buffer (lock-free)
+    const sequence = this.cursor++;
+    const index = sequence & this.mask;
+
+    // Reuse buffer slot (zero allocation)
+    const event = this.buffer[index];
+    event.path = path;
+    event.value = value;
+    event.timestamp = performance.now();
+
+    // Update state synchronously
+    this.updateState(path, value);
+
+    // Schedule async notifications (non-blocking)
+    queueMicrotask(() => {
+      this.notify(path, value);
+      this.notifyPatterns(path, value);
+    });
+
+    return sequence;
+  }
+
+  /**
+   * Subscribe to state changes
+   * @param {string} pattern - Path or pattern (supports * wildcard)
+   * @param {Function} callback - Callback function
+   * @returns {Function} Unsubscribe function
+   */
+  on(pattern, callback) {
+    // Check if pattern contains wildcards
+    if (pattern.includes('*')) {
+      // Pattern subscription
+      if (!this.patternListeners.has(pattern)) {
+        this.patternListeners.set(pattern, new Set());
+      }
+      this.patternListeners.get(pattern).add(callback);
+
+      // Return unsubscribe function
+      return () => {
+        const listeners = this.patternListeners.get(pattern);
+        if (listeners) {
+          listeners.delete(callback);
+          if (listeners.size === 0) {
+            this.patternListeners.delete(pattern);
+          }
+        }
+      };
+    } else {
+      // Direct path subscription
+      if (!this.listeners.has(pattern)) {
+        this.listeners.set(pattern, new Set());
+      }
+      this.listeners.get(pattern).add(callback);
+
+      // Return unsubscribe function
+      return () => {
+        const listeners = this.listeners.get(pattern);
+        if (listeners) {
+          listeners.delete(callback);
+          if (listeners.size === 0) {
+            this.listeners.delete(pattern);
+          }
+        }
+      };
+    }
+  }
+
+  /**
+   * Batch set multiple values
+   * @param {Object} updates - Object with path:value pairs
+   */
+  batch(updates) {
+    const sequences = [];
+
+    for (const [path, value] of Object.entries(updates)) {
+      sequences.push(this.set(path, value));
+    }
+
+    return sequences;
+  }
+
+  /**
+   * Get current metrics
+   * @returns {Object} Performance metrics
+   */
+  getMetrics() {
+    return {
+      ...this.metrics,
+      bufferUtilization: (this.cursor % this.bufferSize) / this.bufferSize,
+      listenerCount: this.listeners.size + this.patternListeners.size
+    };
+  }
+
+  // Private methods
+
+  nextPowerOfTwo(n) {
+    return Math.pow(2, Math.ceil(Math.log2(n)));
+  }
+
+  updateState(path, value) {
+    if (!path) {
+      this.state = value;
+      return;
+    }
+
+    const keys = path.split('.');
+    const last = keys.pop();
+
+    // Create nested structure if needed
+    let target = this.state;
+    for (const key of keys) {
+      if (!(key in target) || typeof target[key] !== 'object') {
+        target[key] = {};
+      }
+      target = target[key];
+    }
+
+    target[last] = value;
+  }
+
+  notify(path, value) {
+    this.metrics.notifications++;
+
+    // Notify exact path listeners
+    const exactListeners = this.listeners.get(path);
+    if (exactListeners) {
+      exactListeners.forEach(callback => {
+        try {
+          callback(value, path);
+        } catch (error) {
+          console.error('[WuStore] Listener error:', error);
+        }
+      });
+    }
+
+    // Notify parent path listeners
+    const parts = path.split('.');
+    for (let i = parts.length - 1; i > 0; i--) {
+      const parentPath = parts.slice(0, i).join('.');
+      const parentListeners = this.listeners.get(parentPath);
+      if (parentListeners) {
+        const parentValue = this.get(parentPath);
+        parentListeners.forEach(callback => {
+          try {
+            callback(parentValue, parentPath);
+          } catch (error) {
+            console.error('[WuStore] Parent listener error:', error);
+          }
+        });
+      }
+    }
+  }
+
+  notifyPatterns(path, value) {
+    // Check all pattern listeners
+    for (const [pattern, listeners] of this.patternListeners) {
+      if (this.matchesPattern(path, pattern)) {
+        listeners.forEach(callback => {
+          try {
+            callback({ path, value });
+          } catch (error) {
+            console.error('[WuStore] Pattern listener error:', error);
+          }
+        });
+      }
+    }
+  }
+
+  matchesPattern(path, pattern) {
+    // Convert pattern to regex
+    // user.* matches user.name, user.email, etc.
+    // *.name matches user.name, post.name, etc.
+    // * matches everything
+
+    if (pattern === '*') return true;
+
+    const regexPattern = pattern
+      .split('.')
+      .map(part => part === '*' ? '[^.]+' : part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+      .join('\\.');
+
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(path);
+  }
+
+  /**
+   * Clear all state and listeners
+   */
+  clear() {
+    this.state = {};
+    this.listeners.clear();
+    this.patternListeners.clear();
+    this.cursor = 0;
+
+    // Clear buffer
+    for (let i = 0; i < this.bufferSize; i++) {
+      this.buffer[i].path = null;
+      this.buffer[i].value = null;
+      this.buffer[i].timestamp = 0;
+    }
+  }
+
+  /**
+   * Get recent events from ring buffer
+   * @param {number} count - Number of recent events
+   * @returns {Array} Recent events
+   */
+  getRecentEvents(count = 10) {
+    const events = [];
+    const start = Math.max(0, this.cursor - count);
+
+    for (let i = start; i < this.cursor && events.length < count; i++) {
+      const index = i & this.mask;
+      const event = this.buffer[index];
+      if (event.path) {
+        events.push({
+          path: event.path,
+          value: event.value,
+          timestamp: event.timestamp
+        });
+      }
+    }
+
+    return events.reverse();
+  }
+}
+
+// Create singleton instance
+const store = new WuStore();
+
+// Export both class and instance
+export default store;