@decido/shell 1.0.0

package/src/store/engine.ts

@@ -0,0 +1,392 @@
+import { create } from 'zustand';
+import { MaciaPlugin, MaciaWidget, WidgetRenderMode } from '@decido/plugin-engine';
+import { kernel } from '@decido/kernel-bridge';
+
+// Transient Overlays definitions
+export type ShellMode = 'workbench' | 'canvas' | 'landing' | 'ghost';
+
+export interface TransientOverlay {
+    id: string;
+    widgetId: string;
+    position: { x: number; y: number; width?: number; height?: number };
+    props?: Record<string, any>;
+}
+
+export type LayoutNode = {
+    id: string;
+    type: 'split-vertical' | 'split-horizontal' | 'tabs' | 'widget';
+    children?: LayoutNode[];
+    widgetId?: string;
+    size?: number; // flex basis/flex grow ratio
+};
+
+export interface Workspace {
+    id: string;
+    name: string;
+    icon?: any; // React.ReactNode equivalent but avoiding cyclic typings issue if any, or just import React
+    layout: LayoutNode;
+}
+
+interface ShellState {
+    plugins: Map<string, MaciaPlugin>;
+    widgets: Map<string, MaciaWidget>;
+
+    // Layout Management
+    activeShellMode: ShellMode;
+    setShellMode: (mode: ShellMode) => void;
+
+    rootLayout: LayoutNode | null;
+    activeWidgetId: string | null;
+
+    // Workspaces (Tabs mapping to rootLayouts)
+    workspaces: Workspace[];
+    activeWorkspaceId: string | null;
+
+    // Transient UI Layer
+    transientOverlays: TransientOverlay[];
+    isCommandPaletteOpen: boolean;
+    isForgeTerminalOpen: boolean;
+    isGodModePanelOpen: boolean;
+    isMarketplaceOpen: boolean;
+    isShortcutSettingsOpen: boolean;
+
+
+    // Actions
+    registerPlugin: (plugin: MaciaPlugin) => void;
+    unregisterPlugin: (pluginId: string) => void;
+
+    openTransientOverlay: (overlay: Omit<TransientOverlay, 'id'>) => string;
+    closeTransientOverlay: (id: string) => void;
+
+    setCommandPaletteOpen: (open: boolean) => void;
+    setForgeTerminalOpen: (open: boolean) => void;
+    setGodModePanelOpen: (open: boolean) => void;
+    setMarketplaceOpen: (open: boolean) => void;
+    setShortcutSettingsOpen: (open: boolean) => void;
+
+    setLayout: (layout: LayoutNode) => void;
+
+    // Workspace actions
+    addWorkspace: (workspace: Workspace) => void;
+    setActiveWorkspace: (id: string) => void;
+
+    // Scene / Layout Persistence
+    savedScenes: Record<string, LayoutNode>;
+    saveScene: (sceneName: string) => void;
+    loadScene: (sceneName: string) => void;
+
+    // Phase 9: Intent-Based Registry & Morphological Interfaces
+    requestCapability: (capability: string) => MaciaWidget[];
+    openWidgetByCapability: (capability: string, options?: { renderMode?: WidgetRenderMode; data?: any }) => boolean;
+
+    // Phase 16: Live Data Context
+    widgetDataBus: Record<string, any>;
+    setWidgetData: (widgetId: string, data: any) => void;
+
+    // Phase 18: Thin Client Mobile Support
+    isThinClient: boolean;
+    initializeEnvironment: () => Promise<void>;
+}
+
+import { sentinelMiddleware } from '@decido/sentinel-browser';
+
+export const useShellStore = create<ShellState>()(
+    sentinelMiddleware('shell_store', (set) => ({
+        plugins: new Map(),
+        widgets: new Map(),
+
+        activeShellMode: 'workbench', // Default to Workbench given it's the ERP standard
+        setShellMode: (mode) => set({ activeShellMode: mode }),
+
+        rootLayout: null,
+        activeWidgetId: null,
+
+        workspaces: [],
+        activeWorkspaceId: null,
+
+        transientOverlays: [],
+        isCommandPaletteOpen: false,
+        isForgeTerminalOpen: false,
+        isGodModePanelOpen: false,
+        isMarketplaceOpen: false,
+        isShortcutSettingsOpen: false,
+
+        // MCP servers moved to dedicated McpStore.ts
+
+        savedScenes: {},
+
+        widgetDataBus: {},
+
+        setWidgetData: (widgetId: string, data: any) => set((state: ShellState) => ({
+            widgetDataBus: { ...state.widgetDataBus, [widgetId]: data }
+        })),
+
+        isThinClient: false,
+        initializeEnvironment: async () => {
+            try {
+                const isTauri = typeof window !== 'undefined' && '__TAURI_INTERNALS__' in window;
+                if (!isTauri) {
+                    console.log('[OS] Web Environment Detected (No Tauri). Running in standard browser mode.');
+                    set({ isThinClient: false });
+                    return;
+                }
+
+                const osPlugin = await import('@tauri-apps/plugin-os');
+                const osType = await osPlugin.type();
+                const mobile = osType === 'android' || osType === 'ios';
+                set({ isThinClient: mobile });
+                console.log(`[OS] Entorno detectado: ${mobile ? 'Móvil (Thin Client)' : 'Desktop (Node)'}`);
+
+                if (mobile) {
+                    kernel.execute('broadcast_message', {
+                        intent: "node_announcement",
+                        payload: JSON.stringify({
+                            tier: "Satellite",
+                            capabilities: ["voice", "display"]
+                        })
+                    });
+                }
+
+                // Registrar listener global para notificaciones inter-nodales
+                kernel.onEvent(async (payload: any) => {
+                    if (payload.event_type === 'broadcast_event' && payload.data?.intent === 'push_notification') {
+                        const { title, body, urgency } = payload.data.payload;
+
+                        try {
+                            const notification = await import('@tauri-apps/plugin-notification');
+                            let permission = await notification.isPermissionGranted();
+                            if (!permission) {
+                                permission = await notification.requestPermission() === 'granted';
+                            }
+
+                            if (permission) {
+                                notification.sendNotification({
+                                    title,
+                                    body,
+                                    icon: 'notification_icon',
+                                    sound: urgency === 'critical' ? 'alarm' : 'default'
+                                });
+                                console.log(`[Satellite] 🔔 Alerta recibida de ${payload.agent_id}: ${title}`);
+                            }
+                        } catch (e) {
+                            console.warn('Failed to send tauri notification', e);
+                        }
+                    }
+                });
+
+            } catch (e) {
+                console.warn('[OS] No se pudo detectar el entorno Tauri, asumiendo Desktop', e);
+            }
+        },
+
+        registerPlugin: (plugin: MaciaPlugin) => set((state: ShellState) => {
+            const pluginId = plugin.id || plugin.manifest?.id;
+            if (!pluginId) return state; // Ignore invalid plugins
+
+            const newPlugins = new Map(state.plugins);
+            newPlugins.set(pluginId, plugin);
+
+            const newWidgets = new Map(state.widgets);
+            const widgets = plugin.widgets || plugin.manifest?.widgets || [];
+            widgets.forEach(w => {
+                const boundWidget: MaciaWidget = { ...w, pluginId: pluginId };
+                newWidgets.set(boundWidget.id, boundWidget);
+            });
+
+            // Add explicit cast to `state` as any to bypass `intentsCache` errors locally, or just omit it because intents are scanned dynamically via AIDirector now!
+            // We'll just execute standard state properties 
+
+            if (plugin.onRegister) {
+                try {
+                    Promise.resolve(plugin.onRegister()).catch(e => console.error(`[OS] Failed to async-register plugin ${pluginId}:`, e));
+                } catch (e) {
+                    console.error(`[OS] Failed to sync-register plugin ${pluginId}:`, e);
+                }
+            }
+
+            // --- Phase 24: SDK Zero-Trust Mount ---
+            if (plugin.mount && plugin.manifest && typeof window !== 'undefined') {
+                try {
+                    plugin.mount({} as any);
+                } catch (e) {
+                    console.error(`[OS] Failed to mount plugin ${pluginId}`, e);
+                }
+            }
+
+            return { plugins: newPlugins, widgets: newWidgets } as any; // Typecast because of store variations
+        }),
+
+        unregisterPlugin: (pluginId: string) => set((state: ShellState) => {
+            const newPlugins = new Map(state.plugins);
+            const plugin = newPlugins.get(pluginId) as any;
+
+            if (plugin) {
+                const newWidgets = new Map(state.widgets);
+                const widgets = plugin.widgets || plugin.manifest?.widgets || [];
+                widgets.forEach((w: MaciaWidget) => newWidgets.delete(w.id));
+
+                if (plugin.onUnregister) {
+                    try {
+                        Promise.resolve(plugin.onUnregister()).catch(e => console.error(`[OS] Failed to async-unregister plugin ${pluginId}:`, e));
+                    } catch (e) {
+                        console.error(`[OS] Failed to sync-unregister plugin ${pluginId}:`, e);
+                    }
+                }
+
+                newPlugins.delete(pluginId);
+                return { plugins: newPlugins, widgets: newWidgets } as any;
+            }
+            return state;
+        }),
+
+        openTransientOverlay: (overlay) => {
+            const id = typeof crypto !== 'undefined' && crypto.randomUUID ? crypto.randomUUID() : Date.now().toString() + Math.random().toString(36).substring(2);
+            set((state: ShellState) => ({
+                transientOverlays: [...state.transientOverlays, { ...overlay, id }]
+            }));
+            return id;
+        },
+
+        closeTransientOverlay: (id) => {
+            set((state: ShellState) => ({
+                transientOverlays: state.transientOverlays.filter(o => o.id !== id)
+            }));
+        },
+
+        setCommandPaletteOpen: (open) => {
+            set({ isCommandPaletteOpen: open });
+        },
+
+        setForgeTerminalOpen: (open) => {
+            set({ isForgeTerminalOpen: open });
+        },
+
+        setGodModePanelOpen: (open) => {
+            set({ isGodModePanelOpen: open });
+        },
+
+        setMarketplaceOpen: (open) => {
+            set({ isMarketplaceOpen: open });
+        },
+
+        setShortcutSettingsOpen: (open) => {
+            set({ isShortcutSettingsOpen: open });
+        },
+
+        setLayout: (layout) => {
+            // Wrap in View Transitions API to implement transmutations as per architectural rules
+            if (typeof document !== 'undefined' && 'startViewTransition' in document) {
+                const transition = (document as any).startViewTransition(() => {
+                    set({ rootLayout: layout });
+                });
+                // Suppress the AbortError from unhandled promise rejections if transitions rapidly overlap
+                if (transition.ready) transition.ready.catch(() => { });
+                if (transition.finished) transition.finished.catch(() => { });
+                if (transition.updateCallbackDone) transition.updateCallbackDone.catch(() => { });
+            } else {
+                set({ rootLayout: layout });
+            }
+        },
+
+        addWorkspace: (workspace) => {
+            set((state: ShellState) => {
+                const exists = state.workspaces.find(w => w.id === workspace.id);
+                if (exists) return state;
+                return { workspaces: [...state.workspaces, workspace] };
+            });
+        },
+
+        setActiveWorkspace: (id) => {
+            // Actually Zustand set takes a function. Let's do carefully.
+            set((state: ShellState) => {
+                const ws = state.workspaces.find(w => w.id === id);
+                if (!ws) return state;
+
+                // Apply View Transition natively inside the state setter wrapping logic, 
+                // but since startViewTransition is async, we do it carefully:
+                if (typeof document !== 'undefined' && 'startViewTransition' in document) {
+                    const transition = (document as any).startViewTransition(() => {
+                        set({ rootLayout: ws.layout, activeWorkspaceId: id });
+                    });
+                    if (transition.ready) transition.ready.catch(() => { });
+                    if (transition.finished) transition.finished.catch(() => { });
+                    if (transition.updateCallbackDone) transition.updateCallbackDone.catch(() => { });
+                    return state; // We already called set() async inside the transition
+                } else {
+                    return { rootLayout: ws.layout, activeWorkspaceId: id };
+                }
+            });
+        },
+
+        saveScene: (sceneName: string) => {
+            set((state: ShellState) => {
+                if (!state.rootLayout) return state;
+                // Native structured cloning or deep copy of the layout tree to avoid proxy mutations
+                const layoutSnapshot = JSON.parse(JSON.stringify(state.rootLayout));
+                return {
+                    savedScenes: {
+                        ...state.savedScenes,
+                        [sceneName]: layoutSnapshot
+                    }
+                };
+            });
+        },
+
+        loadScene: (sceneName: string) => {
+            set((state: ShellState) => {
+                const scene = state.savedScenes[sceneName];
+                if (!scene) return state;
+
+                // Implement view transition for the layout swap
+                if (typeof document !== 'undefined' && 'startViewTransition' in document) {
+                    const transition = (document as any).startViewTransition(() => {
+                        set({ rootLayout: JSON.parse(JSON.stringify(scene)) });
+                    });
+                    if (transition.ready) transition.ready.catch(() => { });
+                    if (transition.finished) transition.finished.catch(() => { });
+                    if (transition.updateCallbackDone) transition.updateCallbackDone.catch(() => { });
+                    return state;
+                } else {
+                    return { rootLayout: JSON.parse(JSON.stringify(scene)) };
+                }
+            });
+        },
+
+        requestCapability: (capability: string) => {
+            const matchingWidgets: MaciaWidget[] = [];
+            useShellStore.getState().widgets.forEach(w => {
+                if (w.capabilities?.includes(capability)) {
+                    matchingWidgets.push(w);
+                }
+            });
+            return matchingWidgets;
+        },
+
+        openWidgetByCapability: (capability: string, options) => {
+            const state = useShellStore.getState();
+            const widgets = state.requestCapability(capability);
+            if (widgets.length === 0) return false;
+
+            const widget = widgets[0]; // Take best match (first for now)
+            const zone = widget.layoutConfig?.preferredZone || 'overlay';
+
+            // For morphological generic overlays
+            if (zone === 'overlay') {
+                state.openTransientOverlay({
+                    widgetId: widget.id,
+                    position: {
+                        x: typeof window !== 'undefined' ? window.innerWidth / 2 - 200 : 100,
+                        y: typeof window !== 'undefined' ? window.innerHeight / 2 - 150 : 100,
+                        width: widget.layoutConfig?.initialSize?.w || 400,
+                        height: widget.layoutConfig?.initialSize?.h || 300
+                    },
+                    props: { context: { renderMode: options?.renderMode || 'expanded', data: options?.data } }
+                });
+                return true;
+            }
+
+            // Feature expansion point: handle rendering into 'main-canvas' or 'dock'
+            console.warn(`[Shell OS] Morphological view requested for capability ${capability} in zone ${zone}, but only 'overlay' is currently implemented for Intent-Based Registry.`);
+            return false;
+        }
+    })));

package/src/store/index.ts

@@ -0,0 +1,4 @@
+export * from './engine';
+export * from "@decido/shell-auth";
+export * from '@decido/plugin-engine';
+export * from './McpStore';

package/src/store/layoutPresets.ts

@@ -0,0 +1,66 @@
+/**
+ * Layout types and built-in presets.
+ * Extracted from useLayoutStore for reuse across components.
+ */
+
+/** Slot component identifiers — maps to real React components */
+export type SlotComponentId =
+    | 'workspace-chat' | 'debug' | 'graph-editor' | 'timeline-editor'
+    | 'canvas' | 'terminal' | 'app-sidebar' | 'widget-panel' | null;
+
+/** The 6 content regions from the grid */
+export type RegionId = 'R1' | 'R2' | 'R3' | 'R4' | 'R5' | 'R6';
+
+/** Morph stage types */
+export type MorphStageType = '2d' | '3d' | 'workbench' | 'liquid' | 'artifact' | 'custom';
+
+export interface MorphStage {
+    type: MorphStageType;
+    label?: string;
+    data?: any;
+    componentId?: string;
+    sourceNodeId?: string;
+}
+
+/** Tab in the T2 Tab Bar */
+export interface LayoutTab {
+    id: string;
+    label: string;
+    icon?: string;
+    componentId: string;
+    closeable?: boolean;
+    data?: any;
+}
+
+/** Saved layout preset */
+export interface LayoutPreset {
+    id: string;
+    name: string;
+    slots: Record<RegionId, SlotComponentId>;
+    createdAt: number;
+}
+
+// ── Built-in Presets ──
+
+const PRESET_CREATOR: Record<RegionId, SlotComponentId> = {
+    R1: 'workspace-chat', R2: null, R3: 'graph-editor', R4: 'debug', R5: null, R6: null,
+};
+
+const PRESET_PLAYER: Record<RegionId, SlotComponentId> = {
+    R1: 'workspace-chat', R2: null, R3: null, R4: null, R5: null, R6: null,
+};
+
+const PRESET_MINIMAL: Record<RegionId, SlotComponentId> = {
+    R1: null, R2: null, R3: null, R4: null, R5: null, R6: null,
+};
+
+const PRESET_STUDIO: Record<RegionId, SlotComponentId> = {
+    R1: 'app-sidebar', R2: null, R3: 'graph-editor', R4: 'terminal', R5: null, R6: null,
+};
+
+export const BUILT_IN_PRESETS: Record<string, Record<RegionId, SlotComponentId>> = {
+    creator: PRESET_CREATOR,
+    player: PRESET_PLAYER,
+    minimal: PRESET_MINIMAL,
+    studio: PRESET_STUDIO,
+};

package/src/store/playgroundTypes.ts

@@ -0,0 +1,98 @@
+/**
+ * Playground shared types.
+ * Extracted from usePlaygroundStore for reuse in components and hooks.
+ */
+
+export type StepType = 'chat' | 'profile' | 'action';
+
+export interface PlaygroundLog {
+    time: string;
+    msg: string;
+    type: string;
+}
+
+export type ChatMessageType = 'text' | 'alert' | 'card' | 'canvas' | 'workflow' | 'ui-artifact' | 'tool' | 'error';
+export type ChatMessageSender = 'user' | 'agent' | 'system' | 'tool';
+
+// ── Thinking (Chain of Thought) ──
+export interface ThinkingData {
+    content: string;
+    duration?: number;
+    isStreaming?: boolean;
+}
+
+// ── Tool Calls (inline in message) ──
+export interface ToolCallInfo {
+    id: string;
+    name: string;
+    args?: unknown;
+    result?: unknown;
+    status: 'running' | 'success' | 'error';
+    startTime: number;
+    endTime?: number;
+}
+
+// ── Execution Timeline Steps ──
+export interface ExecutionStep {
+    type: 'thinking' | 'tool_call' | 'text_delta' | 'text_complete' | 'error';
+    label: string;
+    startTime: number;
+    endTime?: number;
+}
+
+// ── Code Blocks with Apply capability ──
+export interface CodeBlockData {
+    code: string;
+    language?: string;
+    filePath?: string;
+    applyMode?: 'write' | 'search_replace' | 'insert_at' | 'append';
+    searchText?: string;
+    insertLine?: number;
+}
+
+export interface ChatMessage {
+    id: string;
+    type: ChatMessageType;
+    sender: ChatMessageSender;
+    text: string;
+    payload?: any;
+    timestamp: number;
+    actorId?: string;
+    actorName?: string;
+    uiSchema?: string;
+    // ── V2 Rich Content ──
+    thinking?: ThinkingData;
+    toolCalls?: ToolCallInfo[];
+    executionSteps?: ExecutionStep[];
+    codeBlocks?: CodeBlockData[];
+    // ── Intent metadata ──
+    detectedIntent?: {
+        type: string;
+        confidence: number;
+        matchedTokens?: string[];
+        resolvedAt: 'regex' | 'llm' | 'fallback';
+    };
+    morphInstanceId?: string;
+}
+
+export interface SavedSequence {
+    id: string;
+    prompt: string;
+    brand: string;
+    duration: number;
+    keyframes: any[];
+}
+
+export interface ChatInstance {
+    id: string;
+    title: string;
+    createdAt: number;
+    updatedAt: number;
+    preview?: string;
+    // ── V2: Identity & Context ──
+    shellType?: string;       // Shell de salida asociada
+    icon?: string;            // Emoji identificador
+    color?: string;           // Color hex (#10b981)
+    model?: string;           // Modelo Gemini usado
+    messageCount?: number;    // Contador para preview
+}

package/src/store/useActionTimelineStore.ts

@@ -0,0 +1,48 @@
+/**
+ * useActionTimelineStore — Records all store actions in chronological order.
+ * Sprint AR: Event-sourcing style timeline for debugging.
+ */
+
+import { create } from 'zustand';
+
+export interface TimelineEvent {
+    id: number;
+    timestamp: string;
+    storeName: string;
+    actionName: string;
+    data?: any;
+    level: 'info' | 'warn' | 'error';
+}
+
+const MAX_EVENTS = 200;
+let _evtId = 0;
+
+interface ActionTimelineState {
+    events: TimelineEvent[];
+    isPaused: boolean;
+    filter: string;
+
+    addEvent: (event: Omit<TimelineEvent, 'id'>) => void;
+    clear: () => void;
+    togglePause: () => void;
+    setFilter: (filter: string) => void;
+}
+
+export const useActionTimelineStore = create<ActionTimelineState>((set, get) => ({
+    events: [],
+    isPaused: false,
+    filter: '',
+
+    addEvent: (event) => {
+        if (get().isPaused) return;
+        const id = ++_evtId;
+        set(s => {
+            const events = [...s.events, { ...event, id }];
+            return { events: events.length > MAX_EVENTS ? events.slice(-MAX_EVENTS) : events };
+        });
+    },
+
+    clear: () => set({ events: [] }),
+    togglePause: () => set(s => ({ isPaused: !s.isPaused })),
+    setFilter: (filter) => set({ filter }),
+}));