@decido/shell 1.0.0

package/src/components/widgets/WidgetSlotPanel.tsx

@@ -0,0 +1,213 @@
+import React from 'react';
+import { WidgetRenderer, type WidgetDef, type ServerDrivenNode } from './WidgetRenderer';
+import { useLayoutStore } from '../../store/useLayoutStore';
+
+/**
+ * WidgetSlotPanel — Reads active widgets and renders them.
+ * 
+ * This is the "slot consumer" that bridges widget data → LayoutGrid.
+ * When a plugin registers a widget (via sidebar click or SDK),
+ * this panel shows it using WidgetRenderer.
+ * 
+ * Supports side-by-side comparison of Option A (SDUI) and Option B (iframe).
+ */
+
+// ── Widget Store with localStorage persistence ──
+
+const PERSISTENCE_KEY = 'decido:activeWidgets';
+type Listener = () => void;
+
+interface PersistedWidget {
+    id: string; pluginId: string; title: string; icon?: string;
+    slot: string; url?: string; order?: number;
+}
+
+class WidgetStore {
+    private widgets = new Map<string, WidgetDef>();
+    private listeners = new Set<Listener>();
+    private _activeId: string | null = null;
+    private persistTimer: ReturnType<typeof setTimeout> | null = null;
+
+    register(widget: WidgetDef): void {
+        this.widgets.set(widget.id, { ...widget, visible: widget.visible ?? true });
+        this.notify();
+        this.persist();
+    }
+
+    remove(id: string): void {
+        this.widgets.delete(id);
+        if (this._activeId === id) this._activeId = null;
+        this.notify();
+        this.persist();
+    }
+
+    clear(): void {
+        this.widgets.clear();
+        this._activeId = null;
+        this.notify();
+        this.persist();
+    }
+
+    setActive(id: string | null): void {
+        this._activeId = id;
+        this.notify();
+        this.persist();
+    }
+
+    get activeId() { return this._activeId; }
+    get size() { return this.widgets.size; }
+
+    getVisible(): WidgetDef[] {
+        return Array.from(this.widgets.values())
+            .filter(w => w.visible !== false)
+            .sort((a, b) => (a.order ?? 100) - (b.order ?? 100));
+    }
+
+    /** Restore from localStorage (call on mount with schema resolver) */
+    restoreFromPersistence(schemaResolver: (widgetId: string) => ServerDrivenNode | undefined): boolean {
+        try {
+            const raw = localStorage.getItem(PERSISTENCE_KEY);
+            if (!raw) return false;
+            const snapshot = JSON.parse(raw) as { widgets: PersistedWidget[]; activeId: string | null };
+            if (!snapshot?.widgets?.length) return false;
+
+            for (const pw of snapshot.widgets) {
+                const schema = schemaResolver(pw.id);
+                this.widgets.set(pw.id, {
+                    ...pw,
+                    visible: true,
+                    schema,
+                });
+            }
+            this._activeId = snapshot.activeId;
+            this.notify();
+            console.log(`[WidgetStore] Restored ${snapshot.widgets.length} widgets from persistence`);
+            return true;
+        } catch (e) {
+            console.warn('[WidgetStore] Restore failed:', e);
+            return false;
+        }
+    }
+
+    subscribe(fn: Listener): () => void {
+        this.listeners.add(fn);
+        return () => this.listeners.delete(fn);
+    }
+
+    private notify() {
+        this.listeners.forEach(fn => fn());
+    }
+
+    /** Debounced write to localStorage (excludes schema which can't be serialized) */
+    private persist() {
+        if (this.persistTimer) clearTimeout(this.persistTimer);
+        this.persistTimer = setTimeout(() => {
+            try {
+                const snapshot = {
+                    widgets: Array.from(this.widgets.values()).map(w => ({
+                        id: w.id, pluginId: w.pluginId, title: w.title,
+                        icon: w.icon, slot: w.slot, url: w.url, order: w.order,
+                    })),
+                    activeId: this._activeId,
+                };
+                localStorage.setItem(PERSISTENCE_KEY, JSON.stringify(snapshot));
+            } catch { /* quota exceeded — silently fail */ }
+        }, 300);
+    }
+}
+
+export const pluginWidgetStore = new WidgetStore();
+
+// Expose on window for PluginBridge's getWidgets handler (avoids circular import)
+(window as any).__pluginWidgetStore = pluginWidgetStore;
+
+// ── React Hook ──
+function useWidgetStore() {
+    const [, forceUpdate] = React.useReducer(x => x + 1, 0);
+    React.useEffect(() => pluginWidgetStore.subscribe(forceUpdate), []);
+    return {
+        widgets: pluginWidgetStore.getVisible(),
+        activeId: pluginWidgetStore.activeId,
+    };
+}
+
+// ── Component ──
+
+export function WidgetSlotPanel() {
+    const { widgets, activeId } = useWidgetStore();
+
+    const activeWidget = activeId
+        ? widgets.find(w => w.id === activeId) || widgets[0]
+        : widgets[0];
+
+    /** Close widget and restore R3 if no widgets remain */
+    const handleClose = React.useCallback((widgetId: string) => {
+        pluginWidgetStore.remove(widgetId);
+        // If removing the last widget, restore R3 to null
+        if (pluginWidgetStore.size === 0) {
+            useLayoutStore.getState().setSlot('R3', null);
+        }
+    }, []);
+
+    /** Close ALL widgets (button in tab bar) */
+    const handleCloseAll = React.useCallback(() => {
+        pluginWidgetStore.clear();
+        useLayoutStore.getState().setSlot('R3', null);
+    }, []);
+
+    if (widgets.length === 0) {
+        return (
+            <div className="w-full h-full flex flex-col items-center justify-center text-text-muted gap-3 bg-surface-primary">
+                <div className="w-12 h-12 rounded-xl bg-cyan-500/5 border border-cyan-500/10 flex items-center justify-center">
+                    <span className="text-xl">🧩</span>
+                </div>
+                <p className="text-sm font-medium">No widgets activos</p>
+                <p className="text-xs opacity-60 max-w-[200px] text-center">
+                    Selecciona un plugin del sidebar para ver widgets aquí
+                </p>
+            </div>
+        );
+    }
+
+    return (
+        <div className="w-full h-full flex flex-col bg-surface-primary overflow-hidden">
+            {/* Widget tab bar */}
+            <div className="flex-none flex items-center gap-1 px-2 py-1 bg-surface-secondary border-b border-border-subtle overflow-x-auto">
+                {widgets.map(w => (
+                    <button
+                        key={w.id}
+                        onClick={() => pluginWidgetStore.setActive(w.id)}
+                        className={`px-2.5 py-1 rounded-md text-[10px] font-medium transition-all whitespace-nowrap ${
+                            activeWidget?.id === w.id
+                                ? 'bg-surface-glass text-text-primary border border-border-default'
+                                : 'text-text-muted hover:text-text-secondary hover:bg-surface-glass/50'
+                        }`}
+                    >
+                        {w.icon && <span className="mr-1">{w.icon}</span>}
+                        {w.title}
+                    </button>
+                ))}
+                {/* Close All button */}
+                {widgets.length > 1 && (
+                    <button
+                        onClick={handleCloseAll}
+                        className="ml-auto px-2 py-1 rounded-md text-[10px] text-text-muted hover:text-red-400 hover:bg-red-500/10 transition-all"
+                        title="Close all widgets"
+                    >
+                        ✕ All
+                    </button>
+                )}
+            </div>
+
+            {/* Active widget content */}
+            {activeWidget && (
+                <div className="flex-1 min-h-0 min-w-0 overflow-hidden">
+                    <WidgetRenderer
+                        widget={activeWidget}
+                        onClose={() => handleClose(activeWidget.id)}
+                    />
+                </div>
+            )}
+        </div>
+    );
+}

package/src/config/IconRegistry.ts

@@ -0,0 +1,126 @@
+import {
+    Search, Workflow, Zap, Terminal, BrainCircuit, Command,
+    FileText, Cpu, ShoppingCart, Building2, Activity,
+    Thermometer, AlertTriangle, TrendingUp, PackageCheck,
+    Network, Home, Settings, MessageSquare, Globe, Lock,
+    Shield, Database, HardDrive, Wifi, Cloud, Server,
+    BarChart3, PieChart, Gauge, Bell, Mail, Users,
+    FolderOpen, Code, Layers, Box, Rocket, Sparkles,
+    type LucideIcon
+} from 'lucide-react';
+
+/**
+ * IconRegistry — Resuelve nombres de iconos (strings del JSON) a componentes Lucide.
+ * 
+ * Uso:
+ *   const Icon = resolveIcon("Thermometer"); // → Lucide Thermometer component
+ *   <Icon size={16} />
+ * 
+ * Si el icono no existe, retorna `Command` como fallback.
+ */
+const ICON_MAP: Record<string, LucideIcon> = {
+    // Communication & AI
+    'Search': Search,
+    'MessageSquare': MessageSquare,
+    'BrainCircuit': BrainCircuit,
+    'Sparkles': Sparkles,
+    'Command': Command,
+    'Terminal': Terminal,
+    
+    // Actions & Flow
+    'Workflow': Workflow,
+    'Zap': Zap,
+    'Rocket': Rocket,
+    'Network': Network,
+    
+    // Data & Files
+    'FileText': FileText,
+    'FolderOpen': FolderOpen,
+    'Code': Code,
+    'Database': Database,
+    
+    // Business & Commerce
+    'ShoppingCart': ShoppingCart,
+    'Building2': Building2,
+    'Users': Users,
+    
+    // Monitoring & Metrics
+    'Activity': Activity,
+    'Thermometer': Thermometer,
+    'AlertTriangle': AlertTriangle,
+    'TrendingUp': TrendingUp,
+    'BarChart3': BarChart3,
+    'PieChart': PieChart,
+    'Gauge': Gauge,
+    'Bell': Bell,
+    
+    // Infrastructure
+    'Cpu': Cpu,
+    'HardDrive': HardDrive,
+    'Server': Server,
+    'Cloud': Cloud,
+    'Wifi': Wifi,
+    'PackageCheck': PackageCheck,
+    
+    // Security & Settings
+    'Lock': Lock,
+    'Shield': Shield,
+    'Settings': Settings,
+    
+    // Misc
+    'Globe': Globe,
+    'Mail': Mail,
+    'Home': Home,
+    'Layers': Layers,
+    'Box': Box
+};
+
+/**
+ * Resolve a string icon name to a Lucide component.
+ * Returns Command icon as fallback for unknown names.
+ */
+export function resolveIcon(name: string): LucideIcon {
+    return ICON_MAP[name] || Command;
+}
+
+/**
+ * Color token resolver — maps color names to Tailwind text classes.
+ */
+const COLOR_MAP: Record<string, string> = {
+    'emerald': 'text-emerald-400',
+    'cyan': 'text-cyan-400',
+    'purple': 'text-purple-400',
+    'orange': 'text-orange-400',
+    'yellow': 'text-yellow-400',
+    'rose': 'text-rose-400',
+    'red': 'text-red-400',
+    'blue': 'text-blue-400',
+    'indigo': 'text-indigo-400',
+    'pink': 'text-pink-400',
+    'amber': 'text-amber-400',
+    'teal': 'text-teal-400',
+    'lime': 'text-lime-400',
+    'sky': 'text-sky-400',
+    'violet': 'text-violet-400',
+    'fuchsia': 'text-fuchsia-400',
+    'white': 'text-white'
+};
+
+/**
+ * Resolve a color token name to a Tailwind text class.
+ * Returns "text-white" as fallback.
+ */
+export function resolveColor(name: string): string {
+    return COLOR_MAP[name] || 'text-white';
+}
+
+/**
+ * Generate bg/border classes from a color token.
+ */
+export function resolveColorClasses(color: string): { bg: string; border: string; text: string } {
+    return {
+        text: COLOR_MAP[color] || 'text-white',
+        bg: `bg-${color}-500/10`,
+        border: `border-${color}-500/20`
+    };
+}

package/src/contexts/NetworkProvider.tsx

@@ -0,0 +1,162 @@
+import React, { createContext, useContext, ReactNode, useEffect, useRef, useCallback } from 'react';
+
+// Tauri APIs are loaded DYNAMICALLY to avoid Vite resolution errors
+// in non-Tauri (web-only) environments where @tauri-apps/api doesn't exist.
+// Type-only import for UnlistenFn (erased at runtime)
+type UnlistenFn = () => void;
+
+// Detección segura del entorno Tauri
+const isTauri = typeof window !== 'undefined' && (window as any).__TAURI_INTERNALS__ !== undefined;
+
+// Lazy-loaded Tauri modules (only resolved at runtime when isTauri === true)
+// @ts-ignore — @tauri-apps/api only exists inside the Tauri binary
+const getTauriEvent = () => import(/* @vite-ignore */ '@tauri-apps/api/event');
+// @ts-ignore
+const getTauriCore = () => import(/* @vite-ignore */ '@tauri-apps/api/core');
+
+interface NetworkContextType {
+    socket: any | null; 
+    isConnected: boolean;
+    isNativeOS: boolean; // Nos dice si estamos corriendo en el binario de Rust
+    emitEvent: (event: string, payload: any) => void;
+    onEvent: (event: string, callback: (payload: any) => void) => void;
+    offEvent: (event: string, callback: (payload: any) => void) => void;
+}
+
+const NetworkContext = createContext<NetworkContextType>({
+    socket: null,
+    isConnected: false,
+    isNativeOS: false,
+    emitEvent: () => {},
+    onEvent: () => {},
+    offEvent: () => {}
+});
+
+export const useNetwork = () => useContext(NetworkContext);
+
+export const useNetworkEvent = (eventName: string, callback: (payload: any) => void) => {
+    const { onEvent, offEvent } = useNetwork();
+    useEffect(() => {
+        onEvent(eventName, callback);
+        return () => offEvent(eventName, callback);
+    }, [eventName, callback, onEvent, offEvent]);
+};
+
+interface NetworkProviderProps {
+    children: ReactNode;
+    socketInstance?: any;
+    isConnected?: boolean;
+}
+
+export const NetworkProvider = ({ children, socketInstance = null, isConnected = false }: NetworkProviderProps) => {
+    // Referencias para limpiar listeners de WebSocket nativo
+    const nativeListeners = useRef(new Map<string, Array<{originalCallback: any, wrappedCallback: any}>>());
+    // Referencias para limpiar listeners asíncronos de Tauri
+    const tauriListeners = useRef(new Map<string, Array<{originalCallback: any, unlistenPromise: Promise<UnlistenFn>}>>());
+
+    const emitEvent = useCallback(async (event: string, payload: any) => {
+        if (isTauri) {
+            // 🦀 RUTA TAURI: Enviar al Daemon en Rust
+            try {
+                const { emit } = await getTauriEvent();
+                await emit(event, payload);
+            } catch (err) {
+                console.error(`[Tauri IPC] Error emitiendo ${event}:`, err);
+            }
+            return;
+        }
+
+        // 🌐 RUTA WEB: Socket.io o WebSocket Nativo
+        if (!socketInstance) {
+            console.warn(`[NetworkProvider] Emit '${event}' ignorado: No hay red disponible.`);
+            return;
+        }
+        
+        if (typeof socketInstance.emit === 'function') {
+            socketInstance.emit(event, payload); 
+        } else if (typeof socketInstance.send === 'function') {
+            socketInstance.send(JSON.stringify({ event, payload })); 
+        }
+    }, [socketInstance]);
+
+    const onEvent = useCallback((event: string, callback: (payload: any) => void) => {
+        if (isTauri) {
+            // 🦀 RUTA TAURI: Escuchar eventos desde Rust
+            const unlistenPromise = getTauriEvent().then(({ listen }) =>
+                listen(event, (tauriEvent: any) => {
+                    callback(tauriEvent.payload);
+                })
+            );
+            
+            if (!tauriListeners.current.has(event)) {
+                tauriListeners.current.set(event,[]);
+            }
+            tauriListeners.current.get(event)?.push({ originalCallback: callback, unlistenPromise });
+            return;
+        }
+
+        // 🌐 RUTA WEB
+        if (!socketInstance) return;
+        
+        if (typeof socketInstance.on === 'function') {
+            socketInstance.on(event, callback);
+        } else if (typeof socketInstance.addEventListener === 'function') {
+            const wrappedCallback = (messageEvent: MessageEvent) => {
+                try {
+                    const data = JSON.parse(messageEvent.data);
+                    if (data.event === event) callback(data.payload);
+                } catch(e) {}
+            };
+            socketInstance.addEventListener('message', wrappedCallback);
+            
+            if (!nativeListeners.current.has(event)) {
+                nativeListeners.current.set(event,[]);
+            }
+            nativeListeners.current.get(event)?.push({ originalCallback: callback, wrappedCallback });
+        }
+    }, [socketInstance]);
+
+    const offEvent = useCallback((event: string, callback: (payload: any) => void) => {
+        if (isTauri) {
+            // 🦀 RUTA TAURI: Desuscribir
+            const listeners = tauriListeners.current.get(event) ||[];
+            const index = listeners.findIndex(l => l.originalCallback === callback);
+            if (index > -1) {
+                listeners[index].unlistenPromise.then(unlisten => unlisten());
+                listeners.splice(index, 1);
+            }
+            return;
+        }
+
+        // 🌐 RUTA WEB
+        if (!socketInstance) return;
+
+        if (typeof socketInstance.off === 'function') {
+            socketInstance.off(event, callback);
+        } else if (typeof socketInstance.removeEventListener === 'function') {
+            const listeners = nativeListeners.current.get(event) ||[];
+            const foundIndex = listeners.findIndex(l => l.originalCallback === callback);
+            if (foundIndex > -1) {
+                const { wrappedCallback } = listeners[foundIndex];
+                socketInstance.removeEventListener('message', wrappedCallback);
+                listeners.splice(foundIndex, 1);
+            }
+        }
+    },[socketInstance]);
+
+    // En Tauri, estamos nativamente conectados al SO local
+    const effectiveConnection = isTauri ? true : isConnected;
+
+    return (
+        <NetworkContext.Provider value={{
+            socket: socketInstance,
+            isConnected: effectiveConnection,
+            isNativeOS: isTauri,
+            emitEvent,
+            onEvent,
+            offEvent
+        }}>
+            {children}
+        </NetworkContext.Provider>
+    );
+};

package/src/core/AIDirector.ts

@@ -0,0 +1,71 @@
+import { useShellStore } from '../store/engine';
+import { MaciaIntent } from '@decido/plugin-engine';
+
+export class AIDirector {
+    /**
+     * Scans all active plugins to match a natural language query against their intents.
+     * If a match is found, the specific plugin's handler is executed.
+     * Otherwise, the query is delegated to a general AI fallback.
+     */
+    static async processQuery(query: string): Promise<boolean> {
+        const { plugins } = useShellStore.getState();
+
+        // Gather all intents across all registered plugins
+        const allIntents: MaciaIntent[] = [];
+        plugins.forEach(plugin => {
+            if (plugin.intents) {
+                allIntents.push(...plugin.intents);
+            }
+        });
+
+        // Test the query against intent patterns
+        for (const intent of allIntents) {
+            const match = query.match(intent.match.pattern);
+            if (match) {
+                console.log(`[AIDirector] Intent Matched: ${intent.name}`);
+                try {
+                    await intent.handler(match);
+                    return true; // Match found and handled
+                } catch (error) {
+                    console.error(`[AIDirector] Error handling intent ${intent.name}:`, error);
+                    throw error;
+                }
+            }
+        }
+
+        // Fallback: No specific intent matched, delegate to general AI
+        console.log(`[AIDirector] No specific intent matched for: "${query}". Delegating to general AI layer.`);
+        await this.delegateToGeneralAI(query);
+        return false;
+    }
+
+    /**
+     * Discovery API: Gathers all available intents from registered plugins
+     * Returns a simplified list intended for UI suggestions (like the Command Palette)
+     */
+    static getSuggestedIntents(): { pluginName: string; intentName: string; description: string; examples: string[] }[] {
+        const { plugins } = useShellStore.getState();
+        const suggestions: { pluginName: string; intentName: string; description: string; examples: string[] }[] = [];
+
+        plugins.forEach(plugin => {
+            if (plugin.intents) {
+                plugin.intents.forEach(intent => {
+                    suggestions.push({
+                        pluginName: plugin.name || plugin.manifest?.name || 'Unknown Plugin',
+                        intentName: intent.name,
+                        description: intent.match.description,
+                        examples: intent.match.examples || []
+                    });
+                });
+            }
+        });
+
+        return suggestions;
+    }
+
+    private static async delegateToGeneralAI(query: string) {
+        // Implementation placeholder for general knowledge routing, LLM generation, etc.
+        // This could optionally be wired to AgentManager via a fallback standard plugin context intent.
+        console.log(`[AIDirector Fallback] Processing general request: ${query}`);
+    }
+}

package/src/core/EventBus.ts

@@ -0,0 +1,37 @@
+/**
+ * EventBus.ts
+ * 
+ * Provides a lightweight, globally accessible cross-plugin Event Engine.
+ * Enables the "Any-Flow" Architecture: isolated plugin logic sending 
+ * uncoupled messaging to UI widgets or Engine evaluations. 
+ */
+
+import { probe } from '@decido/logger';
+
+type EventHandler = (payload: any) => void;
+
+export const EventBus = {
+    listeners: new Map<string, Set<EventHandler>>(),
+
+    emit(event: string, payload?: any) {
+        const listenerCount = this.listeners.get(event)?.size ?? 0;
+        probe('eventbus.emit', { event, listenerCount }, { level: 'debug', context: { module: 'shell', component: 'EventBus' } });
+        this.listeners.get(event)?.forEach(cb => cb(payload));
+    },
+
+    subscribe(event: string, callback: EventHandler) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event)!.add(callback);
+        probe('eventbus.subscribe', { event, totalListeners: this.listeners.get(event)!.size }, { level: 'debug', context: { module: 'shell', component: 'EventBus' } });
+
+        // Return an unsubscribe function
+        return () => {
+            const evListeners = this.listeners.get(event);
+            if (evListeners) {
+                evListeners.delete(callback);
+            }
+        };
+    }
+};