@decido/shell 1.0.0

package/src/lib/networkInterceptor.ts

@@ -0,0 +1,100 @@
+/**
+ * networkInterceptor — Monkey-patches window.fetch to capture all network requests.
+ * Sprint AP: All captured requests are stored in a global array accessible by NetworkTab.
+ */
+
+export interface NetworkEntry {
+    id: number;
+    timestamp: string;
+    method: string;
+    url: string;
+    status: number;
+    duration: number; // ms
+    requestBody?: string;
+    responseBody?: string;
+    size: number; // bytes approx
+    error?: string;
+}
+
+let _networkId = 0;
+const MAX_ENTRIES = 200;
+const _entries: NetworkEntry[] = [];
+const _listeners = new Set<() => void>();
+
+function _getTimestamp(): string {
+    const now = new Date();
+    return `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`;
+}
+
+function _addEntry(entry: NetworkEntry) {
+    _entries.push(entry);
+    if (_entries.length > MAX_ENTRIES) _entries.shift();
+    _listeners.forEach(fn => fn());
+}
+
+export function getNetworkEntries(): NetworkEntry[] {
+    return _entries;
+}
+
+export function clearNetworkEntries() {
+    _entries.length = 0;
+    _listeners.forEach(fn => fn());
+}
+
+export function subscribeNetwork(cb: () => void): () => void {
+    _listeners.add(cb);
+    return () => _listeners.delete(cb);
+}
+
+let _installed = false;
+
+export function installNetworkInterceptor() {
+    if (_installed) return;
+    _installed = true;
+
+    const _origFetch = window.fetch;
+
+    window.fetch = async function (input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+        const method = init?.method?.toUpperCase() || 'GET';
+        const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : (input as Request).url;
+        const id = ++_networkId;
+        const t0 = performance.now();
+
+        let requestBody: string | undefined;
+        try {
+            if (init?.body) {
+                requestBody = typeof init.body === 'string' ? init.body.slice(0, 2048) : '[binary]';
+            }
+        } catch { /* ignore */ }
+
+        try {
+            const res = await _origFetch.call(window, input, init);
+            const duration = Math.round(performance.now() - t0);
+
+            // Clone response to read body without consuming
+            let responseBody: string | undefined;
+            let size = 0;
+            try {
+                const clone = res.clone();
+                const text = await clone.text();
+                size = text.length;
+                responseBody = text.slice(0, 2048);
+            } catch { /* ignore */ }
+
+            _addEntry({
+                id, timestamp: _getTimestamp(), method, url,
+                status: res.status, duration, requestBody, responseBody, size,
+            });
+
+            return res;
+        } catch (err: any) {
+            const duration = Math.round(performance.now() - t0);
+            _addEntry({
+                id, timestamp: _getTimestamp(), method, url,
+                status: 0, duration, requestBody, size: 0,
+                error: err.message,
+            });
+            throw err;
+        }
+    };
+}

package/src/mocks/decido.tsx

@@ -0,0 +1,41 @@
+export const kernel = {
+  askAI: async (prompt: string, type: string, mode: string) => {
+      // Stub, logic moved
+      return JSON.stringify({
+        duration: 20,
+        keyframes: [
+          { t: 0, state: 'idle', canvas: false, speech: 'Modo sin servidor activo.' }
+        ]
+      });
+  },
+  onEvent: (cb: any) => {
+    return () => { };
+  }
+};
+
+export type UserRole = 'user' | 'admin' | 'developer';
+export type LicenseTarget = { id: string, name: string, type: string };
+
+export const useAuthStore = Object.assign(
+  (selector: any) => {
+    const state = {
+      availableLicenses: [
+        { id: '1', name: 'Decido Personal', type: 'personal' },
+        { id: '2', name: 'Kúspide Corp', type: 'enterprise' },
+        { id: '3', name: 'Madefront Ind', type: 'enterprise' }
+      ]
+    };
+    return selector ? selector(state) : state;
+  },
+  {
+    getState: () => ({
+      availableLicenses: [
+        { id: '1', name: 'Decido Personal', type: 'personal' },
+        { id: '2', name: 'Kúspide Corp', type: 'enterprise' },
+        { id: '3', name: 'Madefront Ind', type: 'enterprise' }
+      ],
+      login: (role?: string, context?: string, licenses?: any) => { },
+      setActiveContext: (id?: string) => { }
+    })
+  }
+);

package/src/plugins/pluginAPI.ts

@@ -0,0 +1,190 @@
+/**
+ * Plugin API — Public API for plugins to register shells, nodes, and extend Decido OS.
+ * 
+ * Usage:
+ *   import { registerNodeType, registerShell, getNodeTypes } from '@decido/studio';
+ *   
+ *   registerNodeType({ type: 'my-node', component: MyNode, category: 'custom' });
+ *   registerShell('my-canvas', MyCanvasComponent);
+ */
+import type { ComponentType } from 'react';
+
+// ═══════════════════════════════════════════
+// Node Type Registry
+// ═══════════════════════════════════════════
+
+export interface NodeTypeRegistration {
+    /** Unique node type identifier */
+    type: string;
+    /** Display label */
+    label: string;
+    /** Category for grouping in context menu */
+    category: 'automation' | 'logic' | 'ui' | 'data' | 'integration' | 'custom';
+    /** React component to render the node */
+    component: ComponentType<any>;
+    /** Which canvas types this node is compatible with */
+    compatibleWith?: ('flow-canvas' | 'dsd-editor' | 'all')[];
+    /** Default node data */
+    defaultData?: Record<string, any>;
+    /** Handle definitions */
+    handles?: {
+        inputs?: string[];
+        outputs?: string[];
+    };
+    /** Plugin ID that registered this node */
+    pluginId?: string;
+    /** Icon component or emoji */
+    icon?: ComponentType<{ size?: number }> | string;
+}
+
+// In-memory registry
+const nodeTypeRegistry = new Map<string, NodeTypeRegistration>();
+
+/**
+ * Register a custom node type that can be used in any compatible canvas.
+ */
+export function registerNodeType(registration: NodeTypeRegistration): void {
+    if (nodeTypeRegistry.has(registration.type)) {
+        console.warn(`[PluginAPI] Node type "${registration.type}" already registered, overwriting.`);
+    }
+    nodeTypeRegistry.set(registration.type, {
+        compatibleWith: ['all'],
+        defaultData: {},
+        handles: { inputs: ['default'], outputs: ['success'] },
+        ...registration,
+    });
+    console.log(`[PluginAPI] 🧩 Node type registered: ${registration.type} (${registration.category})`);
+}
+
+/**
+ * Get all registered node types, optionally filtered by canvas compatibility.
+ */
+export function getRegisteredNodeTypes(
+    canvasFilter?: 'flow-canvas' | 'dsd-editor' | 'all'
+): NodeTypeRegistration[] {
+    const all = Array.from(nodeTypeRegistry.values());
+    if (!canvasFilter) return all;
+    return all.filter(
+        (n) => n.compatibleWith?.includes('all') || n.compatibleWith?.includes(canvasFilter)
+    );
+}
+
+/**
+ * Get React Flow nodeTypes map for a specific canvas type.
+ * Merges built-in types with plugin-registered types.
+ */
+export function getNodeTypesMap(
+    canvasFilter?: 'flow-canvas' | 'dsd-editor' | 'all'
+): Record<string, ComponentType<any>> {
+    const filtered = getRegisteredNodeTypes(canvasFilter);
+    const map: Record<string, ComponentType<any>> = {};
+    for (const reg of filtered) {
+        map[reg.type] = reg.component;
+    }
+    return map;
+}
+
+/**
+ * Get context menu entries for registered node types.
+ */
+export function getNodeTypeMenuEntries(
+    canvasFilter?: 'flow-canvas' | 'dsd-editor' | 'all'
+): Array<{ type: string; label: string; category: string; icon?: any }> {
+    return getRegisteredNodeTypes(canvasFilter).map((reg) => ({
+        type: reg.type,
+        label: reg.label,
+        category: reg.category,
+        icon: reg.icon,
+    }));
+}
+
+/**
+ * Remove a registered node type.
+ */
+export function unregisterNodeType(type: string): boolean {
+    return nodeTypeRegistry.delete(type);
+}
+
+// ═══════════════════════════════════════════
+// Plugin Manifest
+// ═══════════════════════════════════════════
+
+export interface PluginManifest {
+    /** Unique plugin ID */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Version */
+    version: string;
+    /** Shells to register */
+    shells?: Array<{
+        type: string;
+        component: ComponentType<any>;
+    }>;
+    /** Node types to register */
+    nodeTypes?: NodeTypeRegistration[];
+    /** Called when plugin is loaded */
+    onLoad?: () => void;
+    /** Called when plugin is unloaded */
+    onUnload?: () => void;
+}
+
+// Plugin registry
+const pluginRegistry = new Map<string, PluginManifest>();
+
+/**
+ * Load a plugin manifest — registers all shells and node types.
+ */
+export async function loadPlugin(manifest: PluginManifest): Promise<void> {
+    // Avoid re-loading
+    if (pluginRegistry.has(manifest.id)) {
+        console.warn(`[PluginAPI] Plugin "${manifest.id}" already loaded.`);
+        return;
+    }
+
+    // Register shells
+    if (manifest.shells) {
+        const { registerShell } = await import('../store/useShellRegistry');
+        for (const shell of manifest.shells) {
+            registerShell(shell.type, shell.component);
+        }
+    }
+
+    // Register node types
+    if (manifest.nodeTypes) {
+        for (const nodeType of manifest.nodeTypes) {
+            registerNodeType({ ...nodeType, pluginId: manifest.id });
+        }
+    }
+
+    // Lifecycle
+    manifest.onLoad?.();
+    pluginRegistry.set(manifest.id, manifest);
+    console.log(`[PluginAPI] 📦 Plugin loaded: ${manifest.name} v${manifest.version}`);
+}
+
+/**
+ * Unload a plugin — removes its shells and node types.
+ */
+export function unloadPlugin(pluginId: string): void {
+    const manifest = pluginRegistry.get(pluginId);
+    if (!manifest) return;
+
+    // Remove node types
+    if (manifest.nodeTypes) {
+        for (const nt of manifest.nodeTypes) {
+            unregisterNodeType(nt.type);
+        }
+    }
+
+    manifest.onUnload?.();
+    pluginRegistry.delete(pluginId);
+    console.log(`[PluginAPI] 📦 Plugin unloaded: ${manifest.name}`);
+}
+
+/**
+ * Get all loaded plugins.
+ */
+export function getLoadedPlugins(): PluginManifest[] {
+    return Array.from(pluginRegistry.values());
+}

package/src/store/McpStore.ts

@@ -0,0 +1,69 @@
+import { create } from 'zustand';
+
+// ─── MCP Server Types ────────────────────────────────────────
+export interface McpServerConfig {
+    name: string;
+    command: string;
+    args: string;
+    isDefault: boolean;
+    isConnected: boolean;
+}
+
+interface McpState {
+    mcpServers: McpServerConfig[];
+    addMcpServer: (server: Omit<McpServerConfig, 'isConnected'>) => void;
+    removeMcpServer: (name: string) => void;
+    setMcpServerStatus: (name: string, isConnected: boolean) => void;
+}
+
+const STORAGE_KEY = 'macia_mcp_servers';
+
+/**
+ * Load MCP server configs from localStorage.
+ * No hardcoded server entries — defaults are injected by the host app
+ * via `useMcpStore.getState().addMcpServer(...)` during boot.
+ */
+const loadPersistedServers = (): McpServerConfig[] => {
+    try {
+        const stored = localStorage.getItem(STORAGE_KEY);
+        if (stored) {
+            const parsed = JSON.parse(stored);
+            if (Array.isArray(parsed)) return parsed;
+        }
+    } catch (e) {
+        console.error('[McpStore] Failed to parse persisted MCP servers', e);
+    }
+    return [];
+};
+
+const persistServers = (servers: McpServerConfig[]) => {
+    try {
+        localStorage.setItem(STORAGE_KEY, JSON.stringify(servers));
+    } catch (e) {
+        console.error('[McpStore] Failed to persist MCP servers', e);
+    }
+};
+
+// ─── Store ───────────────────────────────────────────────────
+export const useMcpStore = create<McpState>()((set) => ({
+    mcpServers: loadPersistedServers(),
+
+    addMcpServer: (server) => set((state) => {
+        const next = [
+            ...state.mcpServers.filter(s => s.name !== server.name),
+            { ...server, isConnected: false },
+        ];
+        persistServers(next);
+        return { mcpServers: next };
+    }),
+
+    removeMcpServer: (name) => set((state) => {
+        const next = state.mcpServers.filter(s => s.name !== name || s.isDefault);
+        persistServers(next);
+        return { mcpServers: next };
+    }),
+
+    setMcpServerStatus: (name, isConnected) => set((state) => ({
+        mcpServers: state.mcpServers.map(s => s.name === name ? { ...s, isConnected } : s),
+    })),
+}));

package/src/store/UpdaterStore.ts

@@ -0,0 +1,60 @@
+import { create } from 'zustand';
+
+export type UpdaterStatus = 'idle' | 'checking' | 'downloading' | 'installing' | 'rebooting' | 'error';
+
+interface UpdaterState {
+    isUpdating: boolean;
+    status: UpdaterStatus;
+    progress: number; // 0 to 100
+    downloadedBytes: number;
+    totalBytes: number;
+    version: string | null;
+    error: string | null;
+
+    // Actions
+    setChecking: () => void;
+    setDownloading: (version: string, totalBytes: number) => void;
+    updateProgress: (downloadedBytes: number) => void;
+    setInstalling: () => void;
+    setRebooting: () => void;
+    setError: (msg: string) => void;
+    reset: () => void;
+}
+
+export const useUpdaterStore = create<UpdaterState>((set, get) => ({
+    isUpdating: false,
+    status: 'idle',
+    progress: 0,
+    downloadedBytes: 0,
+    totalBytes: 0,
+    version: null,
+    error: null,
+
+    setChecking: () => set({ status: 'checking', error: null }),
+    setDownloading: (version, totalBytes) => set({
+        isUpdating: true,
+        status: 'downloading',
+        version,
+        totalBytes,
+        downloadedBytes: 0,
+        progress: 0
+    }),
+    updateProgress: (downloadedBytes) => {
+        const total = get().totalBytes;
+        const currentBytes = get().downloadedBytes + downloadedBytes;
+        const progress = total > 0 ? Math.min(Math.round((currentBytes / total) * 100), 100) : 0;
+        set({ downloadedBytes: currentBytes, progress });
+    },
+    setInstalling: () => set({ status: 'installing', progress: 100 }),
+    setRebooting: () => set({ status: 'rebooting' }),
+    setError: (msg) => set({ status: 'error', error: msg, isUpdating: false }),
+    reset: () => set({
+        isUpdating: false,
+        status: 'idle',
+        progress: 0,
+        downloadedBytes: 0,
+        totalBytes: 0,
+        version: null,
+        error: null
+    })
+}));