wu-framework 1.1.11 → 1.1.13

package/src/core/wu-loader.js

@@ -3,12 +3,14 @@
  * Carga aplicaciones y componentes sin depender del framework
  */
 
+import { logger } from './wu-logger.js';
+
 export class WuLoader {
   constructor() {
     this.cache = new Map();
     this.loadingPromises = new Map();
 
-    console.log('[WuLoader] 📦 Dynamic loader initialized');
+    logger.debug('[WuLoader] 📦 Dynamic loader initialized');
   }
 
   /**
@@ -21,18 +23,18 @@ export class WuLoader {
     const entryFile = manifest?.entry || 'index.js';
     const fullUrl = `${appUrl}/${entryFile}`;
 
-    console.log(`[WuLoader] 📥 Loading app from: ${fullUrl}`);
+    logger.debug(`[WuLoader] 📥 Loading app from: ${fullUrl}`);
 
     try {
       // Verificar cache
       if (this.cache.has(fullUrl)) {
-        console.log(`[WuLoader] ⚡ Cache hit for: ${fullUrl}`);
+        logger.debug(`[WuLoader] ⚡ Cache hit for: ${fullUrl}`);
         return this.cache.get(fullUrl);
       }
 
       // Verificar si ya está cargando
       if (this.loadingPromises.has(fullUrl)) {
-        console.log(`[WuLoader] ⏳ Loading in progress for: ${fullUrl}`);
+        logger.debug(`[WuLoader] ⏳ Loading in progress for: ${fullUrl}`);
         return await this.loadingPromises.get(fullUrl);
       }
 
@@ -46,7 +48,7 @@ export class WuLoader {
       this.loadingPromises.delete(fullUrl);
       this.cache.set(fullUrl, code);
 
-      console.log(`[WuLoader] ✅ App loaded successfully: ${fullUrl}`);
+      logger.debug(`[WuLoader] ✅ App loaded successfully: ${fullUrl}`);
       return code;
 
     } catch (error) {
@@ -74,7 +76,7 @@ export class WuLoader {
 
     const fullUrl = `${appUrl}/${normalizedPath}`;
 
-    console.log(`[WuLoader] 🧩 Loading component from: ${fullUrl}`);
+    logger.debug(`[WuLoader] 🧩 Loading component from: ${fullUrl}`);
 
     try {
       // Cargar código del componente
@@ -91,13 +93,13 @@ export class WuLoader {
       // Ejecutar y obtener el componente
       const fakeModule = { exports: {} };
       const fakeRequire = (name) => {
-        console.warn(`[WuLoader] Component ${componentPath} requires ${name} - not supported yet`);
+        logger.warn(`[WuLoader] Component ${componentPath} requires ${name} - not supported yet`);
         return {};
       };
 
       const component = componentFunction(fakeRequire, fakeModule, fakeModule.exports);
 
-      console.log(`[WuLoader] ✅ Component loaded: ${componentPath}`);
+      logger.debug(`[WuLoader] ✅ Component loaded: ${componentPath}`);
       return component;
 
     } catch (error) {
@@ -168,19 +170,19 @@ export class WuLoader {
    * @param {Array} appConfigs - Configuraciones de aplicaciones
    */
   async preload(appConfigs) {
-    console.log(`[WuLoader] 🚀 Preloading ${appConfigs.length} apps...`);
+    logger.debug(`[WuLoader] 🚀 Preloading ${appConfigs.length} apps...`);
 
     const preloadPromises = appConfigs.map(async (config) => {
       try {
         await this.loadApp(config.url, config.manifest);
-        console.log(`[WuLoader] ✅ Preloaded: ${config.name}`);
+        logger.debug(`[WuLoader] ✅ Preloaded: ${config.name}`);
       } catch (error) {
-        console.warn(`[WuLoader] ⚠️ Failed to preload ${config.name}:`, error.message);
+        logger.warn(`[WuLoader] ⚠️ Failed to preload ${config.name}:`, error.message);
       }
     });
 
     await Promise.allSettled(preloadPromises);
-    console.log(`[WuLoader] 🎉 Preload completed`);
+    logger.debug(`[WuLoader] 🎉 Preload completed`);
   }
 
   /**
@@ -209,13 +211,13 @@ export class WuLoader {
       const [appName, componentName] = importPath.split('.');
 
       if (!appName || !componentName) {
-        console.warn(`[WuLoader] Invalid import format: ${importPath}`);
+        logger.warn(`[WuLoader] Invalid import format: ${importPath}`);
         continue;
       }
 
       const app = availableApps.get(appName);
       if (!app) {
-        console.warn(`[WuLoader] Import app not found: ${appName}`);
+        logger.warn(`[WuLoader] Import app not found: ${appName}`);
         continue;
       }
 
@@ -223,14 +225,14 @@ export class WuLoader {
       const exportPath = manifest?.wu?.exports?.[componentName];
 
       if (!exportPath) {
-        console.warn(`[WuLoader] Export not found: ${importPath}`);
+        logger.warn(`[WuLoader] Export not found: ${importPath}`);
         continue;
       }
 
       try {
         const component = await this.loadComponent(app.url, exportPath);
         resolved.set(importPath, component);
-        console.log(`[WuLoader] ✅ Resolved dependency: ${importPath}`);
+        logger.debug(`[WuLoader] ✅ Resolved dependency: ${importPath}`);
       } catch (error) {
         console.error(`[WuLoader] ❌ Failed to resolve: ${importPath}`, error);
       }
@@ -249,12 +251,12 @@ export class WuLoader {
       for (const [url] of this.cache) {
         if (regex.test(url)) {
           this.cache.delete(url);
-          console.log(`[WuLoader] 🗑️ Cleared cache for: ${url}`);
+          logger.debug(`[WuLoader] 🗑️ Cleared cache for: ${url}`);
         }
       }
     } else {
       this.cache.clear();
-      console.log(`[WuLoader] 🗑️ Cache cleared completely`);
+      logger.debug(`[WuLoader] 🗑️ Cache cleared completely`);
     }
   }
 

package/src/core/wu-manifest.js

@@ -3,6 +3,8 @@
  * Validación estricta de wu.json para seguridad
  */
 
+import { logger } from './wu-logger.js';
+
 export class WuManifest {
   constructor() {
     this.cache = new Map();
@@ -62,12 +64,12 @@ export class WuManifest {
   async load(appUrl) {
     const manifestUrl = `${appUrl}/wu.json`;
 
-    console.log(`[WuManifest] 📥 Loading manifest: ${manifestUrl}`);
+    logger.debug(`[WuManifest] 📥 Loading manifest: ${manifestUrl}`);
 
     try {
       // Verificar cache
       if (this.cache.has(manifestUrl)) {
-        console.log(`[WuManifest] ⚡ Cache hit: ${manifestUrl}`);
+        logger.debug(`[WuManifest] ⚡ Cache hit: ${manifestUrl}`);
         return this.cache.get(manifestUrl);
       }
 
@@ -82,7 +84,7 @@ export class WuManifest {
       if (!response.ok) {
         // Si no hay manifest, crear uno básico
         if (response.status === 404) {
-          console.log(`[WuManifest] 📄 No manifest found, creating default for: ${appUrl}`);
+          logger.debug(`[WuManifest] 📄 No manifest found, creating default for: ${appUrl}`);
           return this.createDefaultManifest(appUrl);
         }
 
@@ -110,7 +112,7 @@ export class WuManifest {
       // Cachear resultado
       this.cache.set(manifestUrl, validatedManifest);
 
-      console.log(`[WuManifest] ✅ Manifest loaded: ${manifest.name}`);
+      logger.debug(`[WuManifest] ✅ Manifest loaded: ${manifest.name}`);
       return validatedManifest;
 
     } catch (error) {
@@ -145,7 +147,7 @@ export class WuManifest {
       }
     };
 
-    console.log(`[WuManifest] 🔧 Created default manifest for: ${appName}`);
+    logger.debug(`[WuManifest] 🔧 Created default manifest for: ${appName}`);
     return defaultManifest;
   }
 
@@ -344,7 +346,7 @@ export class WuManifest {
     // Validar imports
     normalized.wu.imports = normalized.wu.imports.filter(imp => {
       if (typeof imp !== 'string' || !imp.includes('.')) {
-        console.warn(`[WuManifest] Invalid import format: ${imp}`);
+        logger.warn(`[WuManifest] Invalid import format: ${imp}`);
         return false;
       }
       return true;
@@ -486,12 +488,12 @@ export class WuManifest {
       for (const [url] of this.cache) {
         if (regex.test(url)) {
           this.cache.delete(url);
-          console.log(`[WuManifest] 🗑️ Cleared cache for: ${url}`);
+          logger.debug(`[WuManifest] 🗑️ Cleared cache for: ${url}`);
         }
       }
     } else {
       this.cache.clear();
-      console.log(`[WuManifest] 🗑️ Manifest cache cleared completely`);
+      logger.debug(`[WuManifest] 🗑️ Manifest cache cleared completely`);
     }
   }
 

package/src/core/wu-mcp-bridge.js

@@ -30,6 +30,7 @@ import {
   getFilteredNetwork,
   getFilteredConsole,
 } from '../ai/wu-ai-browser-primitives.js';
+import { logger } from './wu-logger.js';
 
 /**
  * Create the MCP bridge for a Wu instance.
@@ -280,7 +281,7 @@ export function createMcpBridge(wu) {
 
   function connect(url = 'ws://localhost:19100', options = {}) {
     if (ws && ws.readyState <= 1) {
-      console.warn('[wu-mcp-bridge] Already connected or connecting');
+      logger.warn('[wu-mcp-bridge] Already connected or connecting');
       return;
     }
 
@@ -291,7 +292,7 @@ export function createMcpBridge(wu) {
       ws = new WebSocket(url);
 
       ws.onopen = () => {
-        console.log('[wu-mcp-bridge] Connected to wu-mcp-server');
+        logger.debug('[wu-mcp-bridge] Connected to wu-mcp-server');
         reconnectAttempts = 0;
 
         // Send auth handshake if token provided
@@ -314,7 +315,7 @@ export function createMcpBridge(wu) {
               console.error('[wu-mcp-bridge] Authentication failed:', msg.reason || 'Invalid token');
               disconnect();
             } else {
-              console.log('[wu-mcp-bridge] Authenticated successfully');
+              logger.debug('[wu-mcp-bridge] Authenticated successfully');
             }
             return;
           }
@@ -330,7 +331,7 @@ export function createMcpBridge(wu) {
           const { id, command, params } = msg;
 
           if (!id || !command) {
-            console.warn('[wu-mcp-bridge] Invalid message:', msg);
+            logger.warn('[wu-mcp-bridge] Invalid message:', msg);
             return;
           }
 
@@ -352,7 +353,7 @@ export function createMcpBridge(wu) {
       };
 
       ws.onclose = () => {
-        console.log('[wu-mcp-bridge] Disconnected');
+        logger.debug('[wu-mcp-bridge] Disconnected');
         ws = null;
         authenticated = false;
         _scheduleReconnect(url, options);

package/src/core/wu-performance.js

@@ -7,6 +7,8 @@
  * - Estadísticas por app
  */
 
+import { logger } from './wu-logger.js';
+
 export class WuPerformance {
   constructor() {
     this.metrics = new Map(); // appName -> metrics
@@ -24,7 +26,7 @@ export class WuPerformance {
       load: 5000 // ms
     };
 
-    console.log('[WuPerformance] ⚡ Framework performance monitoring initialized');
+    logger.debug('[WuPerformance] ⚡ Framework performance monitoring initialized');
   }
 
   /**
@@ -36,7 +38,7 @@ export class WuPerformance {
     const markName = `${appName}:${name}:start`;
     this.marks.set(markName, performance.now());
 
-    console.log(`[WuPerformance] 📊 Measure started: ${markName}`);
+    logger.debug(`[WuPerformance] 📊 Measure started: ${markName}`);
   }
 
   /**
@@ -68,10 +70,10 @@ export class WuPerformance {
 
     // Verificar threshold
     if (this.checkThreshold(name, duration)) {
-      console.warn(`[WuPerformance] ⚠️ Threshold exceeded for ${name}: ${duration.toFixed(2)}ms`);
+      logger.warn(`[WuPerformance] ⚠️ Threshold exceeded for ${name}: ${duration.toFixed(2)}ms`);
     }
 
-    console.log(`[WuPerformance] ⏹️ Measure ended: ${markName} (${duration.toFixed(2)}ms)`);
+    logger.debug(`[WuPerformance] ⏹️ Measure ended: ${markName} (${duration.toFixed(2)}ms)`);
     return duration;
   }
 
@@ -203,7 +205,7 @@ export class WuPerformance {
       this.measurements = [];
     }
 
-    console.log(`[WuPerformance] 🧹 Metrics cleared${appName ? ` for ${appName}` : ''}`);
+    logger.debug(`[WuPerformance] 🧹 Metrics cleared${appName ? ` for ${appName}` : ''}`);
   }
 
   /**

package/src/core/wu-plugin.js

@@ -7,6 +7,8 @@
  * - Permission system
  * - Timeout protection
  */
+import { logger } from './wu-logger.js';
+
 
 export class WuPluginSystem {
   constructor(core) {
@@ -101,7 +103,7 @@ export class WuPluginSystem {
     // 🚨 Acceso completo solo con permiso 'unsafe'
     if (permissions.includes('unsafe')) {
       api._unsafeCore = this._core;
-      console.warn('[WuPlugin] ⚠️ Plugin has unsafe access to core!');
+      logger.warn('[WuPlugin] ⚠️ Plugin has unsafe access to core!');
     }
 
     // Congelar API para evitar modificaciones
@@ -166,7 +168,7 @@ export class WuPluginSystem {
 
     // Verificar si ya está instalado
     if (this.plugins.has(plugin.name)) {
-      console.warn(`[WuPlugin] Plugin "${plugin.name}" already installed`);
+      logger.warn(`[WuPlugin] Plugin "${plugin.name}" already installed`);
       return;
     }
 
@@ -204,7 +206,7 @@ export class WuPluginSystem {
       installedAt: Date.now()
     });
 
-    console.log(`[WuPlugin] ✅ Plugin "${plugin.name}" installed (permissions: ${permissions.join(', ')})`);
+    logger.debug(`[WuPlugin] ✅ Plugin "${plugin.name}" installed (permissions: ${permissions.join(', ')})`);
   }
 
   /**
@@ -237,7 +239,7 @@ export class WuPluginSystem {
    */
   registerHook(hookName, callback) {
     if (!this.hooks.has(hookName)) {
-      console.warn(`[WuPlugin] Unknown hook: ${hookName}`);
+      logger.warn(`[WuPlugin] Unknown hook: ${hookName}`);
       return;
     }
     this.hooks.get(hookName).push(callback);
@@ -269,7 +271,7 @@ export class WuPluginSystem {
   uninstall(pluginName) {
     const pluginData = this.plugins.get(pluginName);
     if (!pluginData) {
-      console.warn(`[WuPlugin] Plugin "${pluginName}" not found`);
+      logger.warn(`[WuPlugin] Plugin "${pluginName}" not found`);
       return;
     }
 
@@ -284,7 +286,7 @@ export class WuPluginSystem {
     }
 
     this.plugins.delete(pluginName);
-    console.log(`[WuPlugin] ✅ Plugin "${pluginName}" uninstalled`);
+    logger.debug(`[WuPlugin] ✅ Plugin "${pluginName}" uninstalled`);
   }
 
   /**

package/src/core/wu-strategies.js

@@ -8,6 +8,8 @@
  * - Idle: Carga cuando el navegador está idle
  */
 
+import { logger } from './wu-logger.js';
+
 export class WuLoadingStrategy {
   constructor(core) {
     this.core = core;
@@ -18,7 +20,7 @@ export class WuLoadingStrategy {
     this.registerDefaultStrategies();
     this.setupIdleCallback();
 
-    console.log('[WuStrategies] 🎯 Loading strategies initialized');
+    logger.debug('[WuStrategies] 🎯 Loading strategies initialized');
   }
 
   /**
@@ -29,7 +31,7 @@ export class WuLoadingStrategy {
     this.register('lazy', {
       shouldPreload: false,
       load: async (appName, config) => {
-        console.log(`[Strategy:Lazy] Loading ${appName} on demand (no preload)`);
+        logger.debug(`[Strategy:Lazy] Loading ${appName} on demand (no preload)`);
         // No hace nada, la app se carga cuando se monta
         return;
       }
@@ -40,14 +42,14 @@ export class WuLoadingStrategy {
       shouldPreload: true,
       priority: 'high',
       load: async (appName, config) => {
-        console.log(`[Strategy:Eager] Preloading ${appName} immediately`);
+        logger.debug(`[Strategy:Eager] Preloading ${appName} immediately`);
 
         // Cargar el módulo de la app
         const app = this.core.apps.get(appName);
         if (app) {
           const moduleUrl = await this.core.resolveModulePath(app);
           await import(/* @vite-ignore */ moduleUrl);
-          console.log(`[Strategy:Eager] ✅ ${appName} preloaded`);
+          logger.debug(`[Strategy:Eager] ✅ ${appName} preloaded`);
         }
       }
     });
@@ -57,7 +59,7 @@ export class WuLoadingStrategy {
       shouldPreload: true,
       priority: 'medium',
       load: async (appName, config) => {
-        console.log(`[Strategy:Preload] Using resource hints for ${appName}`);
+        logger.debug(`[Strategy:Preload] Using resource hints for ${appName}`);
 
         // Crear <link rel="prefetch">
         const app = this.core.apps.get(appName);
@@ -70,7 +72,7 @@ export class WuLoadingStrategy {
           link.as = 'script';
           document.head.appendChild(link);
 
-          console.log(`[Strategy:Preload] ✅ Resource hint added for ${appName}`);
+          logger.debug(`[Strategy:Preload] ✅ Resource hint added for ${appName}`);
         }
       }
     });
@@ -92,7 +94,7 @@ export class WuLoadingStrategy {
     this.register('idle', {
       shouldPreload: false,
       load: async (appName, config) => {
-        console.log(`[Strategy:Idle] Queueing ${appName} for idle loading`);
+        logger.debug(`[Strategy:Idle] Queueing ${appName} for idle loading`);
 
         return new Promise((resolve) => {
           this.loadingQueue.push({
@@ -127,7 +129,7 @@ export class WuLoadingStrategy {
       load: strategy.load
     });
 
-    console.log(`[WuStrategies] Strategy "${name}" registered`);
+    logger.debug(`[WuStrategies] Strategy "${name}" registered`);
   }
 
   /**
@@ -141,7 +143,7 @@ export class WuLoadingStrategy {
     const strategy = this.strategies.get(strategyName);
 
     if (!strategy) {
-      console.warn(`[WuStrategies] Strategy "${strategyName}" not found, using lazy`);
+      logger.warn(`[WuStrategies] Strategy "${strategyName}" not found, using lazy`);
       return await this.strategies.get('lazy').load(appName, config);
     }
 
@@ -166,7 +168,7 @@ export class WuLoadingStrategy {
       return priorityOrder[aPriority] - priorityOrder[bPriority];
     });
 
-    console.log(`[WuStrategies] Preloading ${toPreload.length} apps`);
+    logger.debug(`[WuStrategies] Preloading ${toPreload.length} apps`);
 
     // Precargar en orden
     for (const app of toPreload) {
@@ -219,7 +221,7 @@ export class WuLoadingStrategy {
         if (app) {
           const moduleUrl = await this.core.resolveModulePath(app);
           await import(/* @vite-ignore */ moduleUrl);
-          console.log(`[Strategy:Idle] ✅ ${item.appName} loaded during idle time`);
+          logger.debug(`[Strategy:Idle] ✅ ${item.appName} loaded during idle time`);
           item.resolve(true);
         } else {
           item.resolve(null);
@@ -249,6 +251,6 @@ export class WuLoadingStrategy {
    */
   cleanup() {
     this.loadingQueue = [];
-    console.log('[WuStrategies] 🧹 Strategies cleaned up');
+    logger.debug('[WuStrategies] 🧹 Strategies cleaned up');
   }
 }

package/src/utils/dependency-resolver.js

@@ -3,12 +3,14 @@
  * Maneja imports/exports entre micro-apps
  */
 
+import { logger } from '../core/wu-logger.js';
+
 export class WuDependencyResolver {
   constructor() {
     this.resolvedComponents = new Map();
     this.pendingResolutions = new Map();
 
-    console.log('[WuDependencyResolver] 🔗 Dependency resolver initialized');
+    logger.debug('[WuDependencyResolver] 🔗 Dependency resolver initialized');
   }
 
   /**
@@ -18,7 +20,7 @@ export class WuDependencyResolver {
    * @returns {Map} Componentes resueltos
    */
   async resolveAll(imports, availableApps) {
-    console.log(`[WuDependencyResolver] 🔍 Resolving ${imports.length} dependencies...`);
+    logger.debug(`[WuDependencyResolver] 🔍 Resolving ${imports.length} dependencies...`);
 
     const resolved = new Map();
     const errors = [];
@@ -27,18 +29,18 @@ export class WuDependencyResolver {
       try {
         const component = await this.resolve(importPath, availableApps);
         resolved.set(importPath, component);
-        console.log(`[WuDependencyResolver] ✅ Resolved: ${importPath}`);
+        logger.debug(`[WuDependencyResolver] ✅ Resolved: ${importPath}`);
       } catch (error) {
         errors.push({ import: importPath, error: error.message });
-        console.warn(`[WuDependencyResolver] ❌ Failed to resolve: ${importPath}`, error);
+        logger.warn(`[WuDependencyResolver] ❌ Failed to resolve: ${importPath}`, error);
       }
     }
 
     if (errors.length > 0) {
-      console.warn(`[WuDependencyResolver] ⚠️ ${errors.length} dependencies failed to resolve:`, errors);
+      logger.warn(`[WuDependencyResolver] ⚠️ ${errors.length} dependencies failed to resolve:`, errors);
     }
 
-    console.log(`[WuDependencyResolver] 🎉 Resolved ${resolved.size}/${imports.length} dependencies`);
+    logger.debug(`[WuDependencyResolver] 🎉 Resolved ${resolved.size}/${imports.length} dependencies`);
     return resolved;
   }
 
@@ -51,13 +53,13 @@ export class WuDependencyResolver {
   async resolve(importPath, availableApps) {
     // Verificar cache
     if (this.resolvedComponents.has(importPath)) {
-      console.log(`[WuDependencyResolver] ⚡ Cache hit: ${importPath}`);
+      logger.debug(`[WuDependencyResolver] ⚡ Cache hit: ${importPath}`);
       return this.resolvedComponents.get(importPath);
     }
 
     // Verificar si ya está resolviendo
     if (this.pendingResolutions.has(importPath)) {
-      console.log(`[WuDependencyResolver] ⏳ Waiting for pending resolution: ${importPath}`);
+      logger.debug(`[WuDependencyResolver] ⏳ Waiting for pending resolution: ${importPath}`);
       return await this.pendingResolutions.get(importPath);
     }
 
@@ -269,7 +271,7 @@ export class WuDependencyResolver {
    */
   createComponentWrapper(component, importPath) {
     return function WuSharedComponent(props) {
-      console.log(`[WuDependencyResolver] 🧩 Rendering shared component: ${importPath}`);
+      logger.debug(`[WuDependencyResolver] 🧩 Rendering shared component: ${importPath}`);
 
       try {
         return component(props);
@@ -304,12 +306,12 @@ export class WuDependencyResolver {
       for (const [importPath] of this.resolvedComponents) {
         if (regex.test(importPath)) {
           this.resolvedComponents.delete(importPath);
-          console.log(`[WuDependencyResolver] 🗑️ Cleared cache for: ${importPath}`);
+          logger.debug(`[WuDependencyResolver] 🗑️ Cleared cache for: ${importPath}`);
         }
       }
     } else {
       this.resolvedComponents.clear();
-      console.log(`[WuDependencyResolver] 🗑️ Dependency cache cleared completely`);
+      logger.debug(`[WuDependencyResolver] 🗑️ Dependency cache cleared completely`);
     }
   }