Arquitectura del producto

Arquitectura del producto

TraceWall Desktop V3 AI es una aplicación Electron (main + renderer) con procesos auxiliares para sensor, ARGUS y integraciones. Todo se ejecuta en la estación de trabajo del operador.

Diagrama de alto nivel

graph TB
    subgraph Electron["Electron App (Proceso Principal)"]
        Main[Main Process<br/>- Ventana<br/>- IPC<br/>- Cycle de vida]
        Preload[Preload Script<br/>- Context Bridge<br/>- APIs expuestas]
    end

    subgraph Renderer["Renderer Process (UI)"]
        UI[React UI<br/>- Command Center<br/>- Módulos<br/>- Settings]
    end

    subgraph Auxiliares["Procesos Auxiliares"]
        Sensor[Local Sensor<br/>- Interfaces, ARP, Rutas<br/>- Procesos, Servicios<br/>- Puertos, DNS]
        ArgusEngine[ARGUS Engine<br/>- llama.cpp server<br/>- Loopback 127.0.0.1]
        ArgusModel[Modelo GGUF<br/>- Cuantizado 4-8 GB<br/>- Carga en RAM/VRAM]
        Integrations[Integraciones<br/>- FortiGate, Palo Alto<br/>- Wazuh, Zabbix<br/>- SNMP, Syslog]
    end

    subgraph Storage["Almacenamiento Local"]
        SQLite[(SQLite<br/>tracewall.db<br/>Telemetría, Eventos, Activos)]
        Config[config.json<br/>Ajustes usuario]
        Logs[logs/ <br/>Rotating files]
        Models[models/ <br/>GGUF cache]
    end

    Main --> Preload
    Preload --> UI
    UI <--> Main
    Main <--> Sensor
    Main <--> ArgusEngine
    Main <--> Integrations
    Sensor --> SQLite
    Integrations --> SQLite
    Main --> SQLite
    Main --> Config
    Main --> Logs
    ArgusEngine --> Models
    ArgusEngine <--> Main

Procesos y responsabilidades

Proceso	Responsabilidad	Comunicación
Main (Electron)	Ventana, ciclo de vida, IPC, registro de servicios, actualizaciones	↔ Renderer (IPC), ↔ Auxiliares (child_process + IPC)
Preload	Puente seguro (contextBridge), expone APIs limitadas al renderer	↔ Main (IPC), → Renderer (window.api)
Renderer (UI)	Interfaz de usuario, módulos, visualizaciones	→ Main (IPC invoke/send)
Local Sensor	Recolección: interfaces, ARP, rutas, procesos, servicios, puertos, DNS	→ Main (eventos), → SQLite (persistencia)
ARGUS Engine	Servidor llama.cpp en loopback, gestión modelo, health check	↔ Main (IPC + HTTP loopback), → Modelos (archivos)
Integraciones	Polling/push configurado: FortiGate, Palo Alto, Wazuh, Zabbix, SNMP, Syslog	→ Main (eventos normalizados), → SQLite
Updater	Verificación, descarga, aplicación de actualizaciones	↔ Main, red saliente (opcional)

Límites de confianza

┌─────────────────────────────────────────────────────────────┐
│                    ESTACIÓN DE TRABAJO                      │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────┐  │
│  │   Renderer   │  │    Main      │  │   Auxiliares     │  │
│  │   (UI)       │  │  (Orquestador)│  │  (Sensor, ARGUS, │  │
│  │  Sin node    │  │  Node enabled│  │   Integrations)  │  │
│  └──────┬───────┘  └──────┬───────┘  └────────┬─────────┘  │
│         │                 │                   │            │
│         └─────────────────┼───────────────────┘            │
│                           ▼                                │
│              ┌───────────────────────┐                    │
│              │   Almacenamiento      │                    │
│              │   Local (SQLite, FS)  │                    │
│              └───────────┬───────────┘                    │
│                          │                                 │
└──────────────────────────┼────────────────────────────────┘
                           │
              ┌────────────┴────────────┐
              ▼                         ▼
       ┌─────────────┐           ┌─────────────┐
       │  Integraciones        │  ARGUS Model  │
       │  (Red LAN)    │           │  (Archivo    │
       │               │           │   local)    │
       └─────────────┘           └─────────────┘

• Renderer: sin nodeIntegration, contextIsolation: true. Solo APIs expuestas vía preload.
• Main: acceso completo a Node.js, sistema de archivos, procesos hijos.
• Auxiliares: procesos hijos independientes (child_process.fork / spawn), comunicación por IPC estructurado + HTTP loopback (ARGUS).
• Red saliente: solo integraciones configuradas, detección IP pública, descarga modelo ARGUS (primera vez), verificación actualizaciones.
• Red loopback: ARGUS Engine ↔ Main (puerto efímero aleatorio, solo 127.0.0.1).

Datos que cruzan límites

Origen → Destino	Tipo	Serialización
Renderer → Main	IPC invoke/send	Structured Clone / JSON
Main → Sensor	IPC + stdout	JSON lines
Main → Integrations	IPC + stdout	JSON
Main ↔ ARGUS Engine	IPC + HTTP loopback	JSON (IPC), JSON-RPC (HTTP)
Sensor → SQLite	Directo (better-sqlite3)	Binario SQLite
Integrations → SQLite	Directo	Binario SQLite

Persistencia

• SQLite (tracewall.db): telemetría sensor, eventos, activos, topología, hallazgos exposición, briefs ARGUS, logs auditoría.
• config.json: preferencias UI, credenciales integraciones (cifradas DPAPI/libsecret), ajustes sensor, ARGUS, retención.
• logs/: rotación diaria, 7 días por defecto, 50 MB máx.
• models/: archivos GGUF descargados o colocados manualmente.

Páginas relacionadas

• Flujo de datos — Detalle de recolección, transformación, almacenamiento
• Alcance y limitaciones
• Privacidad y conexiones
• Seguridad: Modelo de seguridad