@decido/kernel-bridge 1.0.0 → 4.0.2

package/src/kernel.ts

@@ -1,376 +0,0 @@
-import { io, Socket } from 'socket.io-client';
-import { inferenceRouter, TaskType, InferenceBackend } from './ai/services/InferenceRouter';
-import { createSafeEvent } from '@decido/sdk';
-
-// Tauri modules are loaded dynamically to avoid breaking browser-only hosts
-// (e.g. theme-playground) where @tauri-apps/* is stubbed out by Vite.
-async function getTauriCore() { return import('@tauri-apps/api/core'); }
-async function getTauriEvent() { return import('@tauri-apps/api/event'); }
-
-export interface LogEntry {
-    id: string;
-    timestamp: number;
-    type: 'ipc_out' | 'ipc_in' | 'info' | 'error';
-    channel: string;
-    payload?: any;
-    duration?: number;
-}
-
-// -----------------------------------------------------
-// TRANSPORT ADAPTERS (Tauri vs WebSocket)
-// -----------------------------------------------------
-export interface KernelTransport {
-    name: string;
-    isConnectedToCloud: boolean;
-    connectToSwarm(tenantId: string, url: string, token?: string): void;
-    execute<T>(tenantId: string, cmd: string, args?: Record<string, unknown>): Promise<T>;
-    notify(title: string, body: string): Promise<void>;
-    vibrate(pattern: any): Promise<void>;
-    getEventHistory(tenantId: string, limit: number): Promise<any[]>;
-    listenEvents(onEvent: (payload: { type: string, channel: string, payload: any }) => void): () => void;
-}
-
-class TauriTransport implements KernelTransport {
-    name = "Anillo 0/1 (Tauri IPC)";
-    isConnectedToCloud = false;
-    private unlistenFns: (() => void)[] = [];
-
-    connectToSwarm(tenantId: string, url: string, token?: string) {
-        // En Anillo 0, Tauri (Rust) se encarga de la conexión WebSocket en background
-        // Podríamos enviar un invoke('connect_swarm') aquí si fuera necesario
-        console.log(`[Kernel/Tauri] Conexión nativa delegada a Core-Rust para tenant: ${tenantId}`);
-    }
-
-    async execute<T>(tenantId: string, cmd: string, args?: Record<string, unknown>): Promise<T> {
-        const { invoke } = await getTauriCore();
-        return invoke<T>(cmd, { tenantId, ...args });
-    }
-
-    async notify(title: string, body: string): Promise<void> {
-        try {
-            const { sendNotification } = await import('@tauri-apps/plugin-notification');
-            await sendNotification({ title, body });
-        } catch (e) {
-            console.log('[Kernel/Tauri] Notification plugin not available.');
-        }
-    }
-
-    async vibrate(pattern: any): Promise<void> {
-        try {
-            const { vibrate: nativeVibrate } = await import('@tauri-apps/plugin-haptics');
-            await nativeVibrate(pattern);
-        } catch (e) {
-            console.log('[Kernel/Tauri] Haptics not available on this platform.');
-        }
-    }
-
-    async getEventHistory(tenantId: string, limit: number): Promise<any[]> {
-        return this.execute<any[]>(tenantId, 'get_stream_history', { limit });
-    }
-
-    listenEvents(onEvent: (payload: { type: string, channel: string, payload: any }) => void): () => void {
-        let unlistenFn: (() => void) | null = null;
-        getTauriEvent().then(({ listen }) => {
-            listen('orchestrator-event', (event: any) => {
-                onEvent({ type: 'ipc_in', channel: 'orchestrator-event', payload: event.payload });
-            }).then(fn => {
-                unlistenFn = fn;
-                this.unlistenFns.push(fn);
-            });
-        });
-
-        return () => {
-            if (unlistenFn) {
-                unlistenFn();
-                this.unlistenFns = this.unlistenFns.filter(f => f !== unlistenFn);
-            }
-        };
-    }
-}
-
-class WebSocketTransport implements KernelTransport {
-    name = "Satélite Web (WebSocket)";
-    isConnectedToCloud = false;
-    private sockets: Record<string, Socket> = {};
-    private eventListeners: Set<(payload: { type: string, channel: string, payload: any }) => void> = new Set();
-
-    connectToSwarm(tenantId: string, url: string, token?: string) {
-        if (this.sockets[tenantId]) return;
-        const socket = io(url, { auth: token ? { token } : undefined });
-
-        socket.on('connect', () => {
-            this.isConnectedToCloud = true;
-            console.log(`✅ [Kernel/WS] Satélite conectado al Enjambre del Tenant: ${tenantId}`);
-        });
-
-        socket.on('orchestrator-event', (eventPayload) => {
-            this.eventListeners.forEach(cb => cb({ type: 'ipc_in', channel: 'orchestrator-event', payload: { tenantId, ...eventPayload } }));
-        });
-
-        socket.on('rpc_broadcast', (eventPayload) => {
-            console.log(`[Kernel] 🌐 Broadcast Recibido [${tenantId}]:`, eventPayload);
-            this.eventListeners.forEach(cb => cb({ type: 'ipc_in', channel: 'rpc_broadcast', payload: { tenantId, ...eventPayload } }));
-        });
-
-        this.sockets[tenantId] = socket;
-    }
-
-    async execute<T>(tenantId: string, cmd: string, args?: Record<string, unknown>): Promise<T> {
-        const socket = this.sockets[tenantId];
-        if (socket) {
-            return new Promise((resolve, reject) => {
-                socket.emit('rpc_call', { cmd, args }, (response: any) => {
-                    if (response.error) reject(new Error(response.error));
-                    else resolve(response.data as T);
-                });
-            });
-        }
-        console.warn(`[Kernel Mock] Executing ${cmd} for tenant ${tenantId}`, args);
-        return {} as T;
-    }
-
-    async notify(title: string, body: string): Promise<void> {
-        console.log(`[Notification Mock] ${title}: ${body}`);
-    }
-
-    async vibrate(pattern: any): Promise<void> {
-        if (typeof navigator !== 'undefined' && navigator.vibrate) {
-            navigator.vibrate(pattern === 'heavy' ? 200 : 50);
-        }
-    }
-
-    async getEventHistory(tenantId: string, limit: number): Promise<any[]> {
-        console.warn('[Kernel Mock] Cannot fetch stream history in Web Sandbox.');
-        return [];
-    }
-
-    listenEvents(onEvent: (payload: { type: string, channel: string, payload: any }) => void): () => void {
-        this.eventListeners.add(onEvent);
-        return () => this.eventListeners.delete(onEvent);
-    }
-}
-
-// -----------------------------------------------------
-// HIGH LEVEL KERNEL API
-// -----------------------------------------------------
-class DecidoKernel {
-    private logs: LogEntry[] = [];
-    private logListeners: Set<(logs: LogEntry[]) => void> = new Set();
-    private universalListeners: Set<(event: unknown) => void> = new Set();
-
-    private transport: KernelTransport;
-    private rateLimits: Map<string, { calls: number, resetAt: number }> = new Map();
-
-    private checkRateLimit(cmd: string): boolean {
-        const now = Date.now();
-        const limitWin = 1000; // 1 second window
-        const maxCalls = 50;   // 50 calls per second per command
-
-        let tracker = this.rateLimits.get(cmd);
-        if (!tracker || tracker.resetAt < now) {
-            tracker = { calls: 0, resetAt: now + limitWin };
-            this.rateLimits.set(cmd, tracker);
-        }
-
-        tracker.calls++;
-        if (tracker.calls > maxCalls) {
-            console.warn(`[Kernel Throttle] 🚨 Command ${cmd} blocked (Rate limit: >50 calls/sec). Possible plugin infinite loop.`);
-            return false;
-        }
-        return true;
-    }
-
-    constructor() {
-        // Factory detect
-        const isTauri = typeof window !== 'undefined' && '__TAURI_INTERNALS__' in window;
-        this.transport = isTauri ? new TauriTransport() : new WebSocketTransport();
-
-        console.log(`[Kernel] Entorno Detectado. Operando en Modo ${this.transport.name}.`);
-
-        // Global Event Hook
-        this.transport.listenEvents((event) => {
-            if (event.type === 'ipc_in') {
-                this.addLog({ type: 'ipc_in', channel: event.channel, payload: event.payload });
-                this.notifyUniversalListeners(event.payload.payload || event.payload);
-            }
-        });
-    }
-
-    public get isConnectedToCloud() {
-        return this.transport.isConnectedToCloud;
-    }
-
-    public connectToSwarm(tenantId: string, url: string, token?: string) {
-        this.transport.connectToSwarm(tenantId, url, token);
-    }
-
-    // Validador Zod y Notificador Universal
-    private notifyUniversalListeners(rawPayload: unknown) {
-        const parsed = createSafeEvent(rawPayload);
-
-        if (!parsed.success) {
-            console.error('[Kernel] 🚨 Inbound Mesh Event Failed Contract Validation:', parsed.error.format());
-            this.universalListeners.forEach(cb => cb({
-                type: 'system_alert',
-                source: 'kernel-bridge',
-                payload: {
-                    level: 'error',
-                    title: 'Contract Violation',
-                    message: 'A received event did not match the strict schema. Ignored.'
-                }
-            }));
-            return;
-        }
-        this.universalListeners.forEach(cb => cb(parsed.data));
-    }
-
-    injectEvent(payload: unknown) {
-        this.notifyUniversalListeners(payload);
-    }
-
-    private addLog(entry: Omit<LogEntry, 'id' | 'timestamp'>) {
-        const log: LogEntry = {
-            id: typeof crypto !== 'undefined' && crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36).substring(2, 9),
-            timestamp: Date.now(),
-            ...entry
-        };
-        this.logs = [log, ...this.logs].slice(0, 500);
-        this.logListeners.forEach(listener => listener(this.logs));
-    }
-
-    onLogsChange(callback: (logs: LogEntry[]) => void): () => void {
-        this.logListeners.add(callback);
-        callback(this.logs);
-        return () => this.logListeners.delete(callback);
-    }
-
-    async execute<T>(tenantIdOrCmd: string, cmdOrArgs?: string | Record<string, unknown>, argsOpts?: Record<string, unknown>): Promise<T> {
-        let tenantId = 'system';
-        let cmd = tenantIdOrCmd;
-        let args = cmdOrArgs as Record<string, unknown> | undefined;
-
-        if (typeof cmdOrArgs === 'string') {
-            tenantId = tenantIdOrCmd;
-            cmd = cmdOrArgs;
-            args = argsOpts;
-        }
-
-        if (!this.checkRateLimit(cmd)) {
-            throw new Error(`[Kernel Throttle] Request dropped for ${cmd} (Rate limit exceeded)`);
-        }
-
-        const start = performance.now();
-        try {
-            const result = await this.transport.execute<T>(tenantId, cmd, args);
-            this.addLog({ type: 'ipc_out', channel: cmd, payload: { tenantId, ...args }, duration: performance.now() - start });
-            return result;
-        } catch (error) {
-            this.addLog({ type: 'error', channel: cmd, payload: { tenantId, args, error }, duration: performance.now() - start });
-            throw error;
-        }
-    }
-
-    async notify(title: string, body: string): Promise<void> {
-        return this.transport.notify(title, body);
-    }
-
-    async vibrate(pattern: 'light' | 'medium' | 'heavy' | 'selection' | 'success' | 'warning' | 'error' = 'medium'): Promise<void> {
-        return this.transport.vibrate(pattern);
-    }
-
-    async captureScreen(tenantId: string = 'system'): Promise<string> {
-        return this.execute<string>(tenantId, 'capture_screen');
-    }
-
-    async getMachineId(tenantId: string = 'system'): Promise<string> {
-        return this.execute<string>(tenantId, 'get_machine_id');
-    }
-
-    async initiateSingularity(tenantId: string = 'system'): Promise<any[]> {
-        return this.execute<any[]>(tenantId, 'initiate_singularity');
-    }
-
-    async broadcastMessage(tenantId: string, message: string): Promise<number> {
-        return this.execute<number>(tenantId, 'broadcast_message', { message });
-    }
-
-    async fetchMemories(tenantId: string = 'system', query: string, limit: number = 20): Promise<any[]> {
-        return this.execute<any[]>(tenantId, 'fetch_memories', { query, limit });
-    }
-
-    async storeMemory(tenantId: string = 'system', text: string, metadata: Record<string, unknown> = {}): Promise<void> {
-        return this.execute<void>(tenantId, 'store_memory', { text, metadata });
-    }
-
-    async deleteMemory(tenantId: string = 'system', id: string): Promise<void> {
-        return this.execute<void>(tenantId, 'delete_memory', { id });
-    }
-
-    async reasonWithMLX(base64Image: string, prompt: string, previousError?: string): Promise<any> {
-        let finalPrompt = prompt;
-        if (previousError) {
-            finalPrompt += `\n\nWARNING: Your previous response failed to parse as JSON with the following error: ${previousError}. Fix the JSON syntax and return ONLY a valid JSON object.`;
-        }
-        try {
-            const response = await fetch('http://127.0.0.1:8080/v1/chat/completions', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    model: 'llava',
-                    messages: [{
-                        role: 'user',
-                        content: [
-                            { type: 'text', text: finalPrompt },
-                            { type: 'image_url', image_url: { url: base64Image } }
-                        ]
-                    }],
-                    max_tokens: 150, temperature: 0.1
-                })
-            });
-            const data = await response.json();
-            let content = data.choices[0].message.content.trim();
-            if (content.startsWith('```json')) content = content.replace(/```json\n?/, '').replace(/```$/, '').trim();
-            else if (content.startsWith('```')) content = content.replace(/```\n?/, '').replace(/```$/, '').trim();
-            return JSON.parse(content);
-        } catch (e: any) {
-            console.error('[MLX Bridge] Reasoning failed:', e);
-            throw e;
-        }
-    }
-
-    async executeAction(tenantId: string = 'system', action: any): Promise<any> {
-        return this.execute(tenantId, 'execute_action', { action });
-    }
-
-    async runAutonomousStep(tenantId: string = 'system', objective: string): Promise<void> {
-        const image = await this.captureScreen(tenantId);
-        let decision = null, retries = 0, lastError = null;
-        const instruction = `You are an AI OS agent. Based on the screen image, what action should be taken to achieve: "${objective}"? Return ONLY a strict JSON object of the action, no markdown. E.g. {"type": "mouseClick", "x": 100, "y": 200, "button": "left", "count": 1}`;
-        while (retries <= 2 && !decision) {
-            try {
-                decision = await this.reasonWithMLX(image, instruction, lastError || undefined);
-            } catch (error: any) {
-                lastError = error.message || String(error);
-                retries++;
-            }
-        }
-        if (!decision) return;
-        await this.executeAction(tenantId, decision);
-    }
-
-    async askAI(prompt: string, taskType: TaskType = 'reasoning' as any, forceProvider?: InferenceBackend): Promise<string> {
-        const result = await inferenceRouter.route(prompt, { preferredBackend: forceProvider || 'auto' });
-        return result.text;
-    }
-
-    onEvent(callback: (eventData: any) => void): () => void {
-        this.universalListeners.add(callback);
-        return () => this.universalListeners.delete(callback);
-    }
-
-    async getEventHistory(tenantId: string, limit: number = 50): Promise<any[]> {
-        return this.transport.getEventHistory(tenantId, limit);
-    }
-}
-
-export const kernel = new DecidoKernel();

package/src/rehydration.ts

@@ -1,52 +0,0 @@
-import { kernel } from './kernel';
-import { decryptEvent } from './crypto';
-// Import store if needed, or rely on kernel dispatch. 
-// We will broadcast locally to avoid tight coupling if we don't have direct access to the shell store here.
-
-export const StateRehydrationManager = {
-    async rehydrate(swarmKey: string) {
-        console.log("[Rehydration] 🔄 Iniciando recuperación de estado...");
-
-        try {
-            // Pedimos los últimos 100 eventos del stream persistente
-            const history = await kernel.execute('get_stream_history', { limit: 100 });
-
-            if (!Array.isArray(history)) {
-                console.warn("[Rehydration] El historial devuelto no es un array válido.");
-                return;
-            }
-
-            // Procesamos cronológicamente (de más viejo a más nuevo)
-            const events = history.reverse();
-
-            for (const rawEvent of events) {
-                let event = rawEvent;
-
-                // Si el evento viene cifrado (formato Secure Stream), lo desciframos
-                if (typeof rawEvent === 'string') {
-                    try {
-                        event = await decryptEvent(rawEvent, swarmKey);
-                    } catch (e) {
-                        console.warn("[Rehydration] No se pudo descifrar un evento, saltando...");
-                        continue;
-                    }
-                }
-
-                // Distribuimos el evento a los sistemas interesados
-                this.replayEvent(event);
-            }
-
-            console.log(`[Rehydration] ✅ Memoria restaurada: ${events.length} eventos procesados.`);
-        } catch (error) {
-            console.error("[Rehydration] Fallo crítico en la rehidratación:", error);
-        }
-    },
-
-    replayEvent(event: any) {
-        try {
-            kernel.injectEvent({ ...event, is_rehydration: true });
-        } catch (e) {
-            console.warn("[Rehydration] Error inyectando evento de historial", e);
-        }
-    }
-};

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-    "extends": "../../tsconfig.base.json",
-    "compilerOptions": {
-        "strict": true,
-        "baseUrl": ".",
-        "paths": {
-            "~/*": [
-                "./src/*"
-            ],
-            "@decido/contracts": [
-                "../contracts/src"
-            ]
-        }
-    },
-    "include": [
-        "src"
-    ]
-}