@decido/kernel-bridge

v4.1.0

Published

8 days ago

Tauri v2 IPC Bridge for Decido OS

0High
0Medium
0Low

🚀 @decido/kernel-bridge (v4.1.0)

Puente del Kernel Maestro de Decido OS: Infraestructura transversal e isomórfica de comunicación nativa (Tauri IPC Anillo 0) y satélite (WebSocket enjambre Anillo 1), gobernanza con validación de contratos Zod, blindaje criptográfico y orquestación distribuida de Inteligencia Artificial.

🏛️ Arquitectura de Transporte Dual e Isomorfismo

El paquete @decido/kernel-bridge actúa como el sistema nervioso central y la frontera de seguridad de Decido OS. Abstrae por completo las capas de red y el entorno de ejecución, permitiendo que cualquier micro-frontend (MFE) o plugin del ecosistema interactúe de forma unificada con el hardware nativo o redes distribuidas.

flowchart TB
    subgraph MFE["Capa de Aplicación (Micro-Frontends / Plugins)"]
        UI[Interfaces React / Vue]
        Plugins[Componentes Dinámicos]
    end

    subgraph Bridge["@decido/kernel-bridge (Anillo de Frontera)"]
        Kernel[DecidoKernel Singleton]
        ZodValidator{Validación Zod\ncreateSafeEvent}
        Throttle{Preventive Throttle\n50 llamadas/seg}
    end

    subgraph Transports["Capa de Transporte Isomórfico"]
        TauriT[TauriTransport]
        WST[WebSocketTransport]
    end

    subgraph Native["Anillo 0 (Nativo Host)"]
        TauriIPC[Tauri IPC / invoke]
        RustCore[Core-Rust Watchdog]
        Citadel[Citadel Local Axum Daemon]
    end

    subgraph Web["Anillo 1 (Nube / Satélite)"]
        WSSwarm[WebSocket Mesh Swarm]
        SSEEvents[SSE Api Server]
    end

    %% Flujos de Conexión
    UI -->|execute / onEvent| Kernel
    Plugins -->|execute / onEvent| Kernel
    Kernel --> Throttle
    Throttle -->|Comando Permitido| ZodValidator
    ZodValidator -->|Detección Automática __TAURI_INTERNALS__| TauriT
    ZodValidator -->|Navegador Convencional Fallback| WST

    TauriT -->|Bajo Latencia Directa| TauriIPC
    TauriT -.->|Eventos en Desarrollo| Citadel
    WST -->|RPC Mesh Call| WSSwarm
    WST -.->|Eventos en Web| SSEEvents

    TauriIPC --> RustCore

📦 Instalación

Para integrar este paquete en cualquier módulo o paquete dentro del monorepo:

# Instalación a través del gestor del monorepo
pnpm add @decido/kernel-bridge

🔑 Módulos Principales y Capas de Ingeniería

1. Capa Central: Kernel Maestro e Isomorfismo

Detección Dinámica de Runtime: Identifica de forma automática la presencia de __TAURI_INTERNALS__ o __TAURI_IPC__ en el objeto global window para activar el transporte nativo de Tauri o degradar de forma segura a WebSockets.
Gobernanza y Contratos Estrictos: Utiliza @decido/sdk y createSafeEvent en la frontera de entrada del kernel. Todo evento del bus de datos que no satisfaga el contrato de Zod (SafeEvent) es preventivamente rechazado, inyectando un evento transversal de alerta (system_alert) y notificando al sistema de auditoría.
Rate Limiting Preventivo: Incorpora un limitador de flujo a nivel de comando (50 llamadas por segundo). Esto previene de forma activa bloqueos de interfaz por bucles infinitos de plugins o llamadas descontroladas.

2. Capa Criptográfica y Rehidratación

Cifrado AES-256-GCM: Algoritmo criptográfico de nivel industrial implementado para cifrar y descifrar cargas útiles en memoria o disco.
Resiliencia Base64: Cuenta con mecanismos de saneamiento con autopadding (safeAtob) para evitar corrupción al procesar volcados binarios provenientes de Redis o buses asíncronos.
Rehidratación de Streams: Reconstruye flujos históricos de eventos ordenados de forma cronológica inversa, inyectando metadatos estructurales de estado e ignorando con tolerancia fallos de descifrado individuales.

3. Capa de Servicios de IA y Orquestación Colectiva

McpClient: Cliente isomórfico del protocolo de contexto de modelo (MCP) que permite al kernel registrar, exponer y ejecutar herramientas de Inteligencia Artificial locales y distribuidas.
LocalAgentResponder: Motor reactivo local que responde de forma inmediata a solicitudes de diagnóstico del sistema (CPU, memoria, latidos, menú de ayuda).
MLXBridge: Puente con servidores locales MLX/Ollama. Soporta visión artificial (llava), prompts con inyección de contextos de error anteriores, benchmarks de hardware y entrenamientos LoRA asíncronos en background con decaimiento de pérdida (loss).
PeerMesh: Red P2P robusta sobre WebSockets para la sincronización colaborativa multitenant, heartbeats de actividad y purga automática de peers muertos.

🔧 Tabla de APIs Públicas Exponentes

A continuación se detallan las clases principales expuestas por el paquete y sus métodos:

`DecidoKernel` (Singleton `kernel`)

`crypto` / `rehydration`

💡 Ejemplos de Consumo Práctico

1. Interacción Básica y Suscripción del Kernel en React MFE

import React, { useEffect, useState } from 'react';
import { kernel } from '@decido/kernel-bridge';

export const DecidoSystemMonitor = () => {
    const [status, setStatus] = useState('Desconectado');
    const [logs, setLogs] = useState<any[]>([]);

    useEffect(() => {
        // 1. Conectar al enjambre distributed del tenant
        kernel.connectToSwarm('company_tenant', 'ws://localhost:3000');

        // 2. Suscribirse a eventos normalizados y validados por Zod
        const unsubscribe = kernel.onEvent((event: any) => {
            if (event.type === 'agent.heartbeat') {
                setStatus(`Conectado - Agente: ${event.source}`);
            }
            setLogs(prev => [event, ...prev].slice(0, 50));
        });

        return () => unsubscribe();
    }, []);

    const triggerAction = async () => {
        try {
            // Ejecución preventiva con rate-limit de comandos
            const result = await kernel.execute('company_tenant', 'run_diagnostic', { level: 'deep' });
            kernel.notify('Éxito', 'Diagnóstico completado');
            await kernel.vibrate('success');
        } catch (err: any) {
            kernel.notify('Error', err.message);
            await kernel.vibrate('error');
        }
    };

    return (
        <div>
            <h2>Estado: {status}</h2>
            <button onClick={triggerAction}>Lanzar Diagnóstico</button>
        </div>
    );
};

2. Cifrado AES-256-GCM y Rehidratación Segura

import { encrypt, decrypt, rehydrateStream } from '@decido/kernel-bridge';

const SECRET_KEY = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"; // 256 bits hex

// Cifrar datos sensibles de configuración
const securePayload = { dbUser: "admin", dbPass: "secret123" };
const cipherText = encrypt(JSON.stringify(securePayload), SECRET_KEY);
console.log("Cifrado Hex:", cipherText);

// Descifrar datos
const decrypedText = decrypt(cipherText, SECRET_KEY);
const originalPayload = JSON.parse(decrypedText);
console.log("Datos Descifrados:", originalPayload);

// Rehidratar un stream de eventos cifrados de forma cronológica inversa
const encryptedEvents = [
    encrypt(JSON.stringify({ id: 1, type: "click", timestamp: 100 }), SECRET_KEY),
    encrypt(JSON.stringify({ id: 2, type: "keypress", timestamp: 105 }), SECRET_KEY),
    "EVENTO_CORRUPTO_QUE_NO_HARA_CAER_EL_SISTEMA"
];

const activeEvents = rehydrateStream(encryptedEvents, SECRET_KEY);
// Resultado ordenado de más reciente a más antiguo, ignorando el corrupto:
// [ { id: 2, type: "keypress" }, { id: 1, type: "click" } ]

3. Conexión de Enjambre P2P (`PeerMesh`)

import { PeerMesh } from '@decido/kernel-bridge';

const mesh = PeerMesh.getInstance();

// Unirse a la red de un tenant
mesh.joinMesh('tenant_engineering', 'ws://localhost:3000', 'p2p-client-a');

// Escuchar cambios de topología de la malla
mesh.onPeerStateChange((peers) => {
    console.log("Nodos Activos en la Malla P2P:", peers);
});

// Desconectar y liberar temporizadores de forma limpia
// Evita memory leaks de timers huérfanos
mesh.destroy();

🧪 Pruebas Unitarias y Cobertura Exigida

Este paquete está blindado bajo el estándar de alta ingeniería de Decido OS, garantizando una cobertura estricta del 100% de líneas de código de producción.

# Ejecutar todas las pruebas unitarias y generar reporte de cobertura
pnpm test:coverage

Resumen del Reporte Vitest / v8:

Statements: 98.51% (100% de la lógica ejecutable)
Branches: 89.62%
Functions: 95.55%
Lines: 100.00% absoluto en todos los archivos de producción

Módulo de Alta Ingeniería. Propiedad de Decido OS. Calidad Certificada.

Published

Vulnerabilities

Links

Maintainers

Keywords

Readme