⚡ NovaCore-Engine

El backend definitivo para tu launcher de Minecraft

Servidor HTTP + WebSocket · Descarga de assets/libs/java · Lanzamiento de Minecraft ·
Soporte de modloaders · Multi-instancia · Eventos en tiempo real · SDK para TypeScript · 150+ opciones de configuración

📋 Tabla de Contenidos

¿Qué es NovaCore-Engine?
Características
Arquitectura
Primeros pasos
Configuración vía entorno
API REST completa
Ciclo de vida del juego
Configuración avanzada
- Categorías de AdvancedConfig
- Usar advanced desde la API
Modloaders soportados
SDK para TypeScript
Estructura del proyecto
Testing
Construir para distribución
Licencia

¿Qué es NovaCore-Engine?

NovaCore-Engine es un motor backend headless escrito en Go que convierte cualquier launcher de Minecraft en una aplicación profesional. En lugar de tener que implementar tú mismo todo el caos de descargar versiones, resolver dependencias de modloaders, construir classpaths, extraer nativos, gestionar procesos Java y detectar crashes — NovaCore-Engine lo hace todo por ti.

Se ejecuta como un único binario autónomo que levanta un servidor HTTP + WebSocket. Tu launcher (web, electron, Tauri, o el que sea) solo tiene que hablar con su API REST y escuchar los eventos en tiempo real.

Características

Característica	Detalle
🎮 Lanzamiento de Minecraft	Construye argumentos JVM y del juego, substitución de variables, classpath, extracción de nativos, classpath de modloaders
📦 Descarga inteligente	Version manifests, client jars, librerías, assets (con índices virtuales), runtimes de Java — todo con caché y reintentos
🔧 Soporte de modloaders	Fabric, Quilt, LegacyFabric, Forge y NeoForge — detección automática, descarga e instalación
📂 Multi-instancia	Crea, clona, configura, verifica y elimina instancias con configuraciones independientes
⚡ Eventos en tiempo real	WebSocket con broadcast de progreso de descargas, logs del juego, logs del motor y eventos del ciclo de vida
💀 Detección de crashes	Análisis de código de salida, marker de cierre limpio, escaneo de crash-reports, detección de hs_err_pid, matching de patrones en el log (OOM, JVM fatal, access violation, etc.)
🔌 Configuración avanzada	Más de 150 opciones para control absoluto: memoria, GC, GPU, JPMS, proxy, hooks pre/post lanzamiento, flags JVM, variables de entorno, etc.
🌐 API REST completa	Todos los endpoints documentados, respuestas JSON, IDs para seguimiento
📡 SDK TypeScript	Paquete npm `@novastepstudio/novacore-engine-go` con API tipada, eventos y manejo de descargas
🪟 Multiplataforma	Windows y Linux, en sus arquitecturas de 64 bits

Arquitectura

┌─────────────────────────────────────────────────────────────┐
│                         main.go                             │
│                                                             │
│  Config → Logger → WSHub (WebSocket)                       │
│       ↓                                                     │
│  ┌──────────────┐   ┌───────────┐   ┌──────────────────┐   │
│  │ DownloadMgr   │   │ LaunchMgr │   │ InstanceManager  │   │
│  │ (assets/libs  │   │ (game     │   │ (CRUD,           │   │
│  │  /java/rts)   │   │  process  │   │  version mgmt)   │   │
│  └──────┬───────┘   │  mgmt)    │   └────────┬─────────┘   │
│         │           └─────┬─────┘            │             │
│         │                 │                  │             │
│         ▼                 ▼                  ▼             │
│  ┌──────────────────────────────────────────────────┐      │
│  │           ModLoader Orchestrator                  │      │
│  │   Fabric / Quilt / LegacyFabric / Forge / NeoForge│      │
│  └──────────────────────────────────────────────────┘      │
│         │                                                   │
│         ▼                                                   │
│  ┌──────────────────────────────────────────────────┐      │
│  │            HTTP + WebSocket Server                │      │
│  │  /health /versions /download/* /launch /games    │      │
│  │  /instance/* /modloaders/* /ws                    │      │
│  └──────────────────────────────────────────────────┘      │
│         │                                                   │
│         ▼ (proceso hijo)                                    │
│  ┌──────────────────────────────────────────────────┐      │
│  │          Java process (Minecraft client)          │      │
│  └──────────────────────────────────────────────────┘      │
└─────────────────────────────────────────────────────────────┘

Flujo de datos

[Tu UI/Launcher] ←→ HTTP API ←→ NovaCore-Engine ←→ Java (Minecraft)
                         ↕
                    WebSocket (eventos en tiempo real)

Tu launcher envía una petición POST /launch con la configuración deseada
NovaCore-Engine construye los argumentos, classpath, extrae nativos, resuelve el Java runtime
Ejecuta el hook preLaunchCommand si existe
Lanza el proceso Java como proceso hijo separado (DETACHED_PROCESS en Windows, new process group en Linux)
Comienza a transmitir logs del juego y eventos de ciclo de vida por WebSocket
Cuando el juego termina, analiza la salida, detecta crashes, guarda el contexto y ejecuta el hook postLaunchCommand

Primeros pasos

Construir el binario

# Windows — build.bat genera ambos (windows + linux) 64 bits
.\build.bat

# Manual
cd src
go build -ldflags="-s -w" -o "../build/NovaCore-Engine.exe" .

# Linux
cd src
GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o "../build/NovaCore-Engine" .

Ejecutar el motor

# Mínimo — usa valores por defecto
.\NovaCore-Engine.exe

# Con configuración vía entorno
set NOVA_PORT=9090
set NOVA_WORK_DIR=D:\minecraft
set NOVA_MAX_RAM=4096
.\NovaCore-Engine.exe

El motor imprime NOVA_PORT=<puerto> en stdout para que el proceso padre pueda detectar el puerto asignado automáticamente.

Consumir la API

# Verificar que el motor está vivo
curl http://localhost:8080/health

# Listar versiones de Minecraft disponibles
curl http://localhost:8080/versions/release

# Descargar Minecraft 1.21 (client + librerías + assets + java)
curl -X POST http://localhost:8080/download/1.21

# Lanzar Minecraft
curl -X POST http://localhost:8080/launch \
  -H "Content-Type: application/json" \
  -d '{
    "version": "1.21",
    "username": "Steve",
    "accessToken": "tu-access-token",
    "maxRam": 4096
  }'

# Listar juegos en ejecución
curl http://localhost:8080/games

# Obtener estado de un juego específico
curl http://localhost:8080/game/game-1

# Detener un juego
curl -X POST http://localhost:8080/game/game-1/stop

Configuración vía entorno

Variable	Descripción	Valor por defecto
`NOVA_PORT`	Puerto del servidor HTTP	`8080`
`NOVA_WORK_DIR`	Directorio de trabajo (contiene .minecraft)	`{cwd}/.minecraft`
`NOVA_LOG_DIR`	Directorio de logs del motor	`{workDir}/logs`
`NOVA_CACHE_DIR`	Directorio de caché de descargas	`{workDir}/cache`
`NOVA_MAX_CORES`	Límite de CPUs para Go	CPUs totales - 1
`NOVA_MAX_RAM`	RAM máxima recomendada (MB)	`2048`
`NOVA_LAUNCHER_NAME`	Marca del launcher enviada a Minecraft	`NovaCore-Engine`
`NOVA_LAUNCHER_VERSION`	Versión del launcher enviada a Minecraft	`3.2.0`
`NOVA_INSTANCES_DIR`	Subdirectorio de instancias	`instances`
`NOVA_SHARED_DIR`	Subdirectorio compartido (assets/libs)	`shared`
`NOVA_PORT_FILE`	Ruta de archivo donde se escribe el puerto	—
`NOVA_DEVELOPER_MODE`	Modo desarrollador (web desde directorio externo)	`false`

El motor detecta automáticamente si el puerto está ocupado y prueba los siguientes 10 puertos. Si todos fallan, asigna uno aleatorio.

API REST completa

Health & Versions

Método	Ruta	Descripción
`GET`	`/health`	Estado del motor + versión
`GET`	`/versions/{type}`	Lista versiones de Minecraft (`release`, `snapshot`, `old_beta`, `old_alpha`)

Descargas

Método	Ruta	Descripción
`POST`	`/download/{version}`	Descarga todo (client + librerías + nativos + assets + java)
`POST`	`/download/start`	Inicia descarga con filtro personalizado
`GET`	`/download/{id}/status`	Progreso de descarga
`POST`	`/download/{id}/pause`	Pausa descarga
`POST`	`/download/{id}/resume`	Reanuda descarga
`POST`	`/download/{id}/cancel`	Cancela descarga

Las descargas transmiten progreso en tiempo real vía WebSocket con eventos tipo download_progress, download_state, download_log y download_error.

Lanzamiento del juego

Método	Ruta	Descripción
`POST`	`/launch`	Lanza Minecraft con la configuración deseada
`GET`	`/games`	Lista juegos en ejecución
`GET`	`/game/{id}`	Estado detallado de un juego
`POST`	`/game/{id}/stop`	Detiene un juego (mata el proceso)

El endpoint POST /launch acepta un objeto advanced con todos los campos de AdvancedConfig (ver sección más abajo). Los campos planos tradicionales se mantienen para retrocompatibilidad.

Respuesta de POST /launch:

{
  "id": "game-1",
  "pid": 12345,
  "version": "1.21",
  "status": "starting",
  "logPath": "logs/game/game-1.log"
}

Respuesta de GET /game/{id}:

{
  "id": "game-1",
  "pid": 12345,
  "version": "1.21",
  "status": "crashed",
  "startTime": "2026-06-29 14:30:00",
  "exitCode": 1,
  "logPath": "logs/game/game-1.log",
  "crashLog": "crash-reports/crash-2026-06-29_14.31.02-client.txt",
  "crashReason": "generic_error",
  "crashCategory": "game_error"
}

Modloaders

Método	Ruta	Descripción
`GET`	`/modloaders`	Lista modloaders disponibles
`GET`	`/modloaders/versions/{loader}/{mcVersion}`	Versiones disponibles para un loader + MC
`POST`	`/modloaders/install`	Instala un modloader
`GET`	`/modloaders/state`	Estado de la instalación actual
`DELETE`	`/modloaders/state`	Elimina el estado del modloader instalado

Instancias

Método	Ruta	Descripción
`POST`	`/instance/create`	Crea una nueva instancia
`GET`	`/instance/list`	Lista todas las instancias
`GET`	`/instance/{name}`	Obtiene metadatos de una instancia
`DELETE`	`/instance/{name}`	Elimina una instancia
`PUT`	`/instance/{name}/metadata`	Actualiza metadatos (título, descripción, icono, etc.)
`PUT`	`/instance/{name}/config`	Actualiza configuración de lanzamiento
`POST`	`/instance/{name}/version/add`	Agrega una versión a la instancia
`GET`	`/instance/{name}/versions`	Lista versiones descargadas
`DELETE`	`/instance/{name}/version/{version}`	Elimina una versión
`GET`	`/instance/{name}/verify`	Verifica integridad de la instancia
`POST`	`/instance/{name}/clone`	Clona una instancia
`POST`	`/instance/{name}/launch`	Lanza la instancia

WebSocket

Ruta	Descripción
`ws://host:port/ws`	Canal bidireccional de eventos en tiempo real

Tipos de eventos que recibirás:

Tipo	Descripción
`engine_log`	Logs internos del motor
`game_log`	Líneas del log de Minecraft
`download_progress`	Progreso de descarga
`download_state`	Cambio de estado de descarga
`download_log`	Mensajes de la descarga
`download_error`	Errores de descarga
`game_starting`	Juego iniciando
`game_started`	Juego lanzado exitosamente
`game_exited`	Juego terminó limpiamente
`game_crashed`	Juego crasheó
`game_stopped`	Juego detenido por el usuario

Los mensajes del engine y los eventos de juego tienen replay — cuando un cliente WebSocket se conecta tarde, recibe los últimos eventos almacenados en buffer.

Ciclo de vida del juego

Eventos

Cada juego pasa por una secuencia de eventos que se transmiten vía WebSocket y se almacenan para replay:

[POST /launch]
    │
    ▼
┌─────────────┐    ┌─────────────┐
│ game_starting│───▶│ game_started│  ← JVM spawn exitoso
└─────────────┘    └──────┬──────┘
                          │
            ┌─────────────┼─────────────┐
            ▼             ▼             ▼
    ┌───────────┐  ┌───────────┐  ┌───────────┐
    │game_exited│  │game_crashed│  │game_stopped│
    │ (código 0 │  │ (código ≠0│  │ (killed)  │
    │  o marker │  │  y sin    │  │           │
    │  limpio)  │  │  marker)  │  │           │
    └───────────┘  └───────────┘  └───────────┘

Cada evento incluye este payload:

{
  "type": "game_crashed",
  "data": {
    "id": "game-1",
    "pid": 12345,
    "version": "1.21",
    "status": "crashed",
    "exitCode": 1,
    "crashLog": "crash-reports/crash-...txt",
    "crashReason": "generic_error",
    "crashCategory": "game_error",
    "uptimeMs": 123456,
    "timestamp": "2026-06-29T14:31:02Z"
  }
}

Sistema de detección de crashes

Cuando el proceso Java termina, NovaCore-Engine ejecuta esta pipeline para determinar si fue un crash y por qué:

   ┌─ ¿Código de salida?
   │    ├── 0 → Éxito (game_exited)
   │    └── ≠0 → Posible crash
   │
   ├─ ¿Marker de cierre limpio?
   │    ├── "Stopping!" en el log → Mojang cerró correctamente
   │    └── Sin marker → Crash confirmado
   │
   ├─ ¿Archivos de crash?
   │    ├── crash-reports/*.txt → Crash report de Minecraft
   │    └── hs_err_pid*.log, *.mdmp → Crash report de la JVM
   │
   └─ ¿Patrones en el log?
        ├── "OutOfMemoryError" → OOM
        ├── "# A fatal error has been detected" → JVM fatal
        ├── "EXCEPTION_ACCESS_VIOLATION" → Access violation
        ├── "EXCEPTION_STACK_OVERFLOW" → Stack overflow
        ├── "Internal Error" → Error interno de JVM
        ├── "Unhandled exception" → Excepción no capturada
        └── (14 patrones en total)

Además, se guardan en CrashLog las últimas 25 líneas del buffer de log para dar contexto inmediato.

Categorías de crash

Categoría	Significado
`clean`	Salida normal (código 0)
`oom`	OutOfMemoryError detectado en el log
`oom_or_killed`	Código de salida -1 (típicamente muerte por OOM killer del SO o kill -9)
`java_vm_crash`	Error fatal de la JVM (SIGSEGV 139, SIGABRT 134, SIGILL 132, SIGBUS 6)
`game_error`	Error a nivel de juego (código 1, unhandled exception, "Exiting with error")
`killed`	SIGTERM (código 143)
`interrupted`	SIGINT (código 130, Ctrl+C)
`signal`	Otra señal (código > 128)
`unknown`	Código de salida no reconocido

Configuración avanzada

El objeto AdvancedConfig expone más de 150 campos para tener control total sobre todos los aspectos del lanzamiento. Puedes usarlo tanto en el endpoint POST /launch como en la configuración de cada instancia, y también desde el SDK de TypeScript.

Categorías de AdvancedConfig

🧠 Memoria y GC — Control total de la JVM

Campo	Tipo	Descripción
`minRam`	`int`	RAM inicial (`-Xms`) en MB
`maxRam`	`int`	RAM máxima (`-Xmx`) en MB
`maxMetaspaceSize`	`int`	`-XX:MaxMetaspaceSize` en MB
`metaspaceSize`	`int`	`-XX:MetaspaceSize` inicial en MB
`stackSize`	`int`	`-Xss` en KB
`directMemorySize`	`int`	`-XX:MaxDirectMemorySize` en MB
`reservedCodeCache`	`int`	`-XX:ReservedCodeCacheSize` en MB
`gcPreset`	`string`	`g1gc_basic`, `g1gc_optimized`, `zgc`, `shenandoah`

🎮 GPU y Video — Aceleración y preferencia gráfica

Campo	Tipo	Descripción
`gpuPreference`	`string`	`auto`, `dgpu` (dedicada), `igpu` (integrada)
`hardwareAcceleration`	`bool`	Habilita/deshabilita HW acceleration
`framerateLimit`	`int`	`--framerateLimit <fps>`
`renderer`	`string`	`--renderer <name>` (ej: `opengl`)
`fullscreen`	`bool`	Inicia en pantalla completa
`customResolution`	`bool`	Habilita resolución personalizada
`resWidth` / `resHeight`	`int`	Resolución personalizada

📁 Rutas — Directorios personalizados

Campo	Descripción
`gameDir`	Directorio del juego (saves, screenshots, resourcepacks)
`assetsDir`	Objetos de assets + índices
`librariesDir`	Librerías .jar
`versionsDir`	Versions JSON + client .jar
`nativesDir`	Directorio de nativos extraídos
`nativesBaseDir`	Base para generar directorio de nativos por versión
`runtimeDir`	Runtimes Java (Mojang JREs)
`cacheDir`	Caché de descargas
`workingDir`	Directorio raíz de trabajo

🔧 JPMS (Java 9+) — Módulos, exports y opens

Campo	Descripción
`javaModulePath`	`--module-path`
`javaAddModules`	`--add-modules` (lista)
`javaAddExports`	`--add-exports` (lista)
`javaAddOpens`	`--add-opens` (lista)

🌐 Red y Proxy

Campo	Descripción
`proxyHost` / `proxyPort`	Host y puerto del proxy HTTP
`proxyUser` / `proxyPass`	Credenciales del proxy
`libraryCustomRepo`	Repositorio Maven personalizado
`assetCustomUrl`	URL base personalizada para assets
`downloadConcurrency`	Gorutinas concurrentes de descarga (default: 4)
`maxRetries`	Reintentos por descarga fallida (default: 3)
`connectionTimeout`	Timeout HTTP en segundos (default: 30)

🎯 Server Join & QuickPlay

Campo	Descripción
`serverAddress`	Servidor para unirse automáticamente (`--server`)
`serverPort`	Puerto del servidor (`--port`, default: 25565)
`quickPlayPath`	`--quickPlayPath <path>`
`minecraftLogConfig`	`--log-config <file>`
`logLevel`	`--log-level`

🧪 Hooks pre/post lanzamiento

Campo	Descripción
`preLaunchCommand`	Comando shell ejecutado ANTES de lanzar Minecraft
`postLaunchCommand`	Comando shell ejecutado DESPUÉS de que Minecraft termine

🚩 Flags de salto

Campo	Descripción
`skipLibraryCheck`	Salta verificación de librerías existentes
`skipAssetCheck`	Salta verificación de assets existentes
`skipNativeExtract`	Salta extracción de nativos
`skipVersionDownload`	Salta descarga del client .jar
`disableLibraries`	Desactiva todo procesamiento de librerías
`disableAssets`	Desactiva todo procesamiento de assets

📝 Logs y Retención

Campo	Descripción
`gameLogLines`	Tamaño del buffer circular en memoria (100-10000, default: 1500)
`logKeepDays`	Días de retención de logs (0 = guardar siempre)
`logMaxFiles`	Máximo de archivos de log a retener (0 = sin límite)
`windowTitle`	Título de la ventana (`-Dminecraft.window.title`)
`userType`	Tipo de usuario (default: `mojang`)

🛠 Varios

Campo	Descripción
`javaExec`	Ruta al ejecutable de Java
`useOfficialJava`	Usar runtime oficial de Mojang
`useSystemJava`	Usar Java del sistema
`javaArgs`	Argumentos JVM adicionales
`gameArgs`	Argumentos del juego adicionales
`environmentVars`	Variables de entorno para el proceso hijo
`jvmFlags`	Banderas JVM crudas
`libraryExcludePatterns`	Patrones para excluir librerías del classpath
`profileVersion`	Versión de perfil de modloader
`baseVersion`	Versión base vanilla para herencia
`allowServerList` / `allowMultiplayer` / `allowChat` / `allowRealms`	Mojang feature flags
`forceRedownload`	Forzar redescarga de todo
`assetIndexVirtual`	Layout virtual de assets
`forceReindex`	Forzar re-descarga del asset index
`cleanupDelay`	Delay antes de limpiar nativos después de salida limpia

Usar advanced desde la API

# POST /launch con el objeto advanced
curl -X POST http://localhost:8080/launch \
  -H "Content-Type: application/json" \
  -d '{
    "version": "1.21",
    "username": "Steve",
    "accessToken": "token",
    "advanced": {
      "minRam": 2048,
      "maxRam": 8192,
      "gcPreset": "zgc",
      "gpuPreference": "dgpu",
      "windowTitle": "Mi Launcher",
      "serverAddress": "mc.example.com",
      "preLaunchCommand": "echo empezando...",
      "javaArgs": ["-XX:+AlwaysPreTouch", "-XX:-UseBiasedLocking"],
      "allowMultiplayer": true,
      "environmentVars": {
        "MY_VAR": "valor"
      },
      "libraryExcludePatterns": ["*-debug.jar"]
    }
  }'

Los campos planos tradicionales (javaExec, minRam, maxRam, gameDir, etc.) siguen funcionando para no romper código existente. Si envías advanced, esos campos planos se ignoran.

Modloaders soportados

Loader	Provider	Estado
Fabric	`fabric`	✅ Estable
Quilt	`quilt`	✅ Estable
LegacyFabric	`legacyfabric`	✅ Estable
Forge	`forge`	✅ Estable
NeoForge	`neoforge`	✅ Estable

El proceso de instalación de un modloader:

Resolución — Obtiene las versiones disponibles del loader compatibles con la versión de MC
Descarga — Descarga el installer o los metadatos del loader
Instalación — Ejecuta la lógica específica del loader (Fabric/Quilt: procesamiento JSON; Forge/NeoForge: extracción de installer JAR y aplicación de parches)
Plan de ejecución — Genera un ExecutionPlan con la clase principal modificada, classpath adicional y argumentos extra del loader

Los modloaders se integran automáticamente con el sistema de instancias — una instancia detecta si tiene un modloader instalado y lo aplica al lanzar.

SDK para TypeScript

El paquete @novastepstudio/novacore-engine-go es un SDK liviano que envuelve el binario de NovaCore-Engine y proporciona una API tipada.

Instalación

npm install @novastepstudio/novacore-engine-go
# o
bun add @novastepstudio/novacore-engine-go

Uso básico

import { novaCore } from "@novastepstudio/novacore-engine-go"

// Inicializa: arranca el binario, espera a que esté listo
const engine = await novaCore({
  workDir: "./.minecraft",
  launcherName: "MiLauncher",
})

console.log(`Motor corriendo en puerto ${engine.port}, PID: ${engine.pid}`)

// Descargar Minecraft 1.21
const dl = await engine.download({ version: "1.21" })
dl.onProgress((p) => console.log(`Progreso: ${p.percent.toFixed(1)}%`))
await dl.wait() // opcional, esperar a que termine

// Lanzar el juego
const game = await engine.launch({
  version: "1.21",
  username: "Steve",
  accessToken: "token-real",
  maxRam: 4096,
})

// Consultar estado
const status = await engine.getGame(game.id)
console.log("Estado del juego:", status.status)

// Listar juegos activos
const juegos = await engine.listGames()
console.log(`Hay ${juegos.length} juego(s) corriendo`)

// Detener juego
await engine.stopGame(game.id)

// Detener el motor (envía POST /shutdown)
await engine.stop()

Eventos del juego desde el SDK

// Escuchar TODOS los eventos de juego
const unsub = engine.onGameEvent((event) => {
  console.log(`[${event.type}]`, event.data)
})

// O escuchar eventos específicos
engine.onGameStarted((e) => {
  console.log(`Juego lanzado! PID: ${e.data.pid}`)
})

engine.onGameExited((e) => {
  console.log(`Juego cerró limpiamente. Uptime: ${e.data.uptimeMs}ms`)
})

engine.onGameCrashed((e) => {
  console.log(`⚠️ CRASH: ${e.data.crashReason} (${e.data.crashCategory})`)
  console.log(`   Log: ${e.data.crashLog}`)
})

engine.onGameStopped((e) => {
  console.log("Juego detenido por el usuario")
})

// Cada una retorna una función para desuscribirse
unsub()

Configuración avanzada desde el SDK

const game = await engine.launch({
  version: "1.21",
  username: "Steve",
  accessToken: "token",
  advanced: {
    minRam: 2048,
    maxRam: 8192,
    gcPreset: "zgc",
    gpuPreference: "dgpu",
    windowTitle: "Mi Servidor",
    fullscreen: true,
    serverAddress: "mc.example.com",
    serverPort: 25565,
    preLaunchCommand: "echo Iniciando Minecraft...",
    javaArgs: ["-XX:+AlwaysPreTouch"],
    environmentVars: {
      "MY_VAR": "valor",
    },
    disableAssets: false,
    skipNativeExtract: false,
    allowServerList: true,
    allowMultiplayer: true,
  },
})

Estructura del proyecto

NovaCore-Engine/
│
├── build.bat                          # Script de compilación (Windows + Linux)
├── LICENSE                            # GNU General Public License v3.0
├── README.md                          # Este documento
│
├── src/                               # ★ Código fuente Go
│   ├── main.go                        # Punto de entrada, wiring de componentes
│   ├── go.mod / go.sum                # Dependencias (única: gorilla/websocket)
│   │
│   └── internal/
│       ├── config/                    # Configuración vía entorno + defaults
│       ├── logger/                    # Logger estructurado con broadcast
│       ├── platform/                  # Detección de SO (convenciones Mojang)
│       │
│       ├── server/                    # ★ Servidor HTTP + WebSocket
│       │   ├── server.go             # Inicio, listen con fallback de puerto
│       │   ├── ws.go                  # Hub WebSocket (pub/sub + replay buffer)
│       │   ├── middleware.go          # Auth, tracing, recovery
│       │   └── handlers/             # Manejadores de rutas
│       │       ├── health.go, versions.go, download.go
│       │       ├── launch.go          # POST /launch, GET /games, etc.
│       │       └── modloader.go       # Endpoints de modloaders
│       │
│       ├── launcher/                  # ★ Lanzamiento de Minecraft
│       │   ├── config.go             # LaunchConfig
│       │   ├── advconfig.go          # AdvancedConfig (150+ opciones)
│       │   ├── types.go              # GameInstance, GameStatus
│       │   ├── launcher.go           # Lógica de lanzamiento + waitForExit
│       │   ├── manager.go            # LaunchManager (tracking de juegos)
│       │   ├── events.go             # Sistema de eventos del juego
│       │   ├── helpers/
│       │   │   ├── java.go           # Resolución de Java (Mojang / sistema)
│       │   │   ├── args.go           # Construcción de args JVM + juego
│       │   │   ├── classpath.go      # Construcción de classpath
│       │   │   ├── natives.go        # Extracción de nativos
│       │   │   └── system.go         # RAM recomendada, flags GC, crash labels
│       │   ├── log/
│       │   │   └── game_log.go       # Log manager con ring buffer + rotación
│       │   └── utils/
│       │       ├── process.go         # LaunchProcess, KillTree, FindCrashReport
│       │       ├── process_windows.go # Windows process attributes
│       │       └── process_unix.go    # Unix process attributes
│       │
│       ├── downloader/               # ★ Descarga inteligente
│       │   ├── download.go           # HTTP download con reintentos
│       │   ├── manager.go            # State machine de descarga
│       │   ├── queue.go              # Cola con concurrencia limitada
│       │   ├── types/types.go        # Estructuras de datos Mojang
│       │   ├── tasks/tasks.go        # Construcción de tareas de descarga
│       │   ├── handlers/events.go    # Eventos broadcast (progreso, estado, error)
│       │   └── utils/
│       │       ├── cache.go          # Fetch JSON con caché
│       │       ├── extract.go        # Extracción de nativos
│       │       ├── helpers.go        # Cálculo de porcentajes
│       │       └── verify.go         # Verificación SHA-1
│       │
│       ├── instance/                 # ★ Gestión multi-instancia
│       │   ├── types.go             # InstanceMetadata, InstanceLaunchConfig
│       │   ├── manager.go           # CRUD + version management
│       │   ├── launch.go            # Lanzamiento desde instancia
│       │   ├── handlers.go          # Manejadores HTTP
│       │   ├── helpers.go           # File ops, locking, IDs
│       │   ├── download.go          # AddVersion con orchestrator
│       │   └── verify.go            # Verificación de integridad
│       │
│       └── modloader/               # ★ Instalación de modloaders
│           ├── types.go             # LoaderVersion, ExecutionPlan
│           ├── provider.go          # Interfaz ModLoaderProvider
│           ├── registry.go          # Registro de providers
│           ├── orchestrator.go      # Orquestador de instalación
│           ├── maven.go             # Parseo de coordenadas Maven
│           ├── events.go            # Eventos de instalación
│           ├── installer/
│           │   └── executor.go      # Ejecutor de installers Forge/NeoForge
│           ├── resolver/
│           │   └── neoforge.go      # Resolvedor de versiones NeoForge
│           └── provider/
│               ├── fabric.go, quilt.go, legacyfabric.go
│               ├── forge.go, neoforge.go
│
├── @novastepstudio/
│   └── novacore-engine-go/          # ★ SDK TypeScript
│       ├── package.json             # @novastepstudio/novacore-engine-go
│       ├── tsconfig.json
│       ├── src/
│       │   ├── engine.ts            # novaCore() — spawn + API client
│       │   ├── types.ts             # Interfaces TypeScript
│       │   └── downloader/          # Cliente de descarga con WS
│       └── dist/                    # JavaScript compilado
│
└── test/                            # ★ Tests de integración (Bun)
    ├── 00-webpanel.test.mjs
    ├── 01-connection.test.mjs
    ├── 02-health.test.mjs
    ├── 03-versions.test.mjs
    ├── 04-download.test.mjs
    ├── 05-launch.test.mts
    ├── 06-instance-create.test.mjs
    ├── 07-instance-launch.test.mjs
    ├── 08-modloader-versions.test.mjs
    ├── 09-modloader-install.test.mjs
    ├── 10-modloader-install-all.test.mjs
    ├── 11-modloader-baremetal.test.mjs
    ├── 12-launch-fabric.test.mjs
    ├── 12-modloader-launch-all.test.mjs
    └── dev.mjs

Testing

Los tests son de integración y están escritos en Bun (TypeScript). Cada test levanta el binario, se conecta vía HTTP y WebSocket, y prueba flujos completos.

cd test
bun install
bun test

Los tests cubren:

Health check y conectividad WebSocket
Listado de versiones
Descarga de Minecraft (todos los componentes)
Lanzamiento del juego (vanilla y con modloaders)
CRUD de instancias
Instalación de modloaders (Fabric, Quilt, LegacyFabric, Forge, NeoForge)
Lanzamiento de instancias con modloaders

Construir para distribución

.\build.bat

Esto genera:

Releases/
├── NovaCore-Engine-v3.2.0-windows-amd64/
│   ├── NovaCore-Engine-v3.2.0-windows-amd64.exe
│   └── LICENSE
└── NovaCore-Engine-v3.2.0-linux-amd64/
    ├── NovaCore-Engine-v3.2.0-linux-amd64
    └── LICENSE

Cada binario viene compilado con -ldflags="-s -w" para reducir tamaño (sin tabla de símbolos ni debug info). El web panel está embebido dentro del binario vía //go:embed, así que no necesitas archivos adicionales.

Licencia

NovaCore-Engine está licenciado bajo GNU General Public License v3.0.

Copyright (C) 2024  NovaStepStudio

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Ver el archivo LICENSE para más detalles.

NovaCore-Engine — Creado por NovaStepStudio

Name		Name	Last commit message	Last commit date
Latest commit History 3 Commits
.vscode		.vscode
@novastepstudio/novacore-engine-go		@novastepstudio/novacore-engine-go
src		src
test		test
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
build.bat		build.bat

Uh oh!

Folders and files

Latest commit

History

Repository files navigation