Compilar desde el código fuente

Esta página explica cómo compilar y ejecutar Antimatter desde su código fuente, ya sea para trabajar en él o para crear tus propias compilaciones. Cubre el servidor y las interfaces web, que se encuentran en un solo repositorio, y luego la imagen de Docker y las aplicaciones.

Requisitos

Ir, a la versión en server/go.mod (1.26.7 en el momento de la redacción).
Node.js y npm, en las versiones indicadas en .nvmrc y webapp/package.json (Node 24.11.1 con npm 11.6.2). Con mise, el archivo mise.toml del repositorio instala la versión correcta de Node.
Docker con Compose: la configuración de desarrollo ejecuta PostgreSQL y otros servicios en contenedores.
make, git y una máquina con Linux o macOS.
Memoria: la compilación de las interfaces web es la parte más exigente. Planifica con 16 GB de RAM; consulta Compilaciones y memoria.

git clone https://github.com/AntimatterChat/antimatter.git
cd antimatter

El repositorio contiene el servidor en server/, las interfaces web en webapp/ (Fusion en webapp/fusion, la clásica en webapp/channels y los paquetes compartidos en webapp/platform), y las pruebas de extremo a extremo en e2e-tests/.

Ejecutar un servidor de desarrollo

cd server
make run

make run inicia los contenedores de desarrollo (PostgreSQL, Redis, un captor de correo y herramientas de supervisión), vincula las compilaciones de la aplicación web en su lugar, inicia el servidor en segundo plano con go run y arranca el observador de la aplicación web, que recompila la interfaz clásica a medida que la editas. Abre http://localhost:8065 y crea una cuenta: la primera se convierte en el administrador del sistema.

Comando (en `server/`)	Qué hace
`make run-server`, `make run-client`	Iniciar solo el servidor o solo el observador de la aplicación web.
`make restart-server`	Reiniciar el servidor después de modificar el código Go.
`make stop`	Detener el servidor, el observador y los contenedores.
`make debug-server`	Ejecutar el servidor bajo el depurador Delve.
`make run-cli ARGS="-version"`	Ejecutar un comando del servidor.
`make config-reset`	Restablecer `config/config.json` a los valores predeterminados.
`make clean`, `make nuke`	Eliminar archivos de compilación; `nuke` también elimina los datos de desarrollo.

La base de datos de desarrollo es postgres://mmuser:mostest_password@localhost/mattermost_test, la fuente de datos predeterminada del servidor. Elige qué contenedores se inician con ENABLED_DOCKER_SERVICES, en un archivo server/config.override.mk o en tu entorno (consulta server/config.mk).

Las interfaces web

En webapp/:

npm install      # also builds the shared packages
npm run build    # the classic interface, then Fusion

Las compilaciones se generan en webapp/channels/dist (clásico) y webapp/fusion/dist (Fusion). make client en server/ los vincula como server/client y server/client-fusion, desde donde el servidor los sirve: el clásico bajo /static/ y Fusion bajo /static/fusion/.

npm run run (o make run en webapp/) supervisa y recompila la interfaz clásica. Añade WATCH_FUSION=true para recompilar también Fusion.
npm run dev-server (make dev) ejecuta el servidor de desarrollo de webpack: el clásico en el puerto 9005 y Fusion en el puerto 9006.
Para ver una u otra interfaz en el navegador, añade ?webui=fusion o ?webui=classic a la dirección de cualquier página.

Pruebas y comprobaciones

Comando	Dónde	Qué hace
`make test-server`	`server/`	La suite de pruebas del servidor, contra los contenedores de desarrollo. Tarda mucho tiempo.
`make test-server-quick`	`server/`	Solo las pruebas cortas.
`go test ./channels/app/... -run TestName`	`server/`	Un paquete o prueba, con los contenedores en ejecución (`make start-docker`).
`make check-style`	`server/`	go vet, golangci-lint y las demás comprobaciones de Go.
`make test`	`webapp/`	Las pruebas unitarias de la aplicación web (Jest), en todos los paquetes.
`npm run test -- <pattern>`	`webapp/fusion`	Algunas de las pruebas de Fusion.
`make check-style`, `make check-types`	`webapp/`	ESLint y TypeScript.
`make i18n-extract`	`server/` y `webapp/`	Actualiza los archivos de cadenas en inglés después de añadir o modificar cadenas (véase Traducciones).

Ejecuta make modules-tidy en lugar de go mod tidy en server/.

Archivos de liberación

cd webapp && npm run build && cd ..
cd server
make build-linux       # the antimatter and amctl binaries
make package-linux     # dist/antimatter-linux-amd64.tar.gz and -arm64

make build compila las interfaces web y los binarios para Linux en un solo paso. El archivo contiene bin/antimatter, bin/amctl, un config/config.json predeterminado con un README.md sobre cómo cambiar la configuración, ambas interfaces web, las plantillas, las fuentes y las traducciones. Para otras plataformas: make package-osx, make package-windows, make package-freebsd.

Aplicaciones incluidas

Un simple make package-linux genera un archivo sin aplicaciones. Para incluirlas, como hacen las versiones publicadas, descarga primero los paquetes de aplicaciones firmados y pasa su carpeta:

build/package/fetch-apps.sh "$HOME/release-apps"   # needs gh, python3 and gpg
make package-linux PREPACKAGED_PLUGINS_DIR="$HOME/release-apps"

fetch-apps.sh descarga la última versión de GitHub de cada aplicación listada en el plugins.json de antimatter-docker, junto con su firma, y verifica la firma con la clave de complementos de Antimatter. De forma predeterminada, incluye Whiteboard, Canales de voz, Llamadas, Chat de IA (Agentes), Por hacer, Encuestas, Notas, GIFs y Memes; AM_BUNDLED_APPS (nombres de repositorios, separados por espacios) cambia la lista. Las aplicaciones sin versión publicada o sin firma se omiten con una advertencia. Los paquetes se colocan en prepackaged_plugins/ del archivo.

Paquetes .deb y .rpm

build/package/build-packages.sh <archive> <amd64|arm64> <version> <out-dir> convierte un archivo de versión en paquetes .deb y .rpm todo en uno, con nfpm. La guía de administración describe qué instalan: consulta Instalar el paquete .deb o .rpm.

El flujo de trabajo de publicación

El flujo de trabajo antimatter-release.yml del repositorio del servidor realiza todo esto en GitHub: con una etiqueta v*, compila los archivos y paquetes para amd64 y arm64, con SHA256SUMS, y los publica como la versión de GitHub de la etiqueta (una versión preliminar si la versión contiene un -). Si se ejecuta manualmente, numera la compilación como 0.9.0-dev.<run> y mantiene los archivos como artefactos del flujo de trabajo. Cada repositorio de aplicación tiene un flujo de trabajo release.yml que publica su paquete firmado de la misma manera.

La imagen de Docker

El repositorio antimatter-docker compila las imágenes publicadas, el servidor con sus aplicaciones, por completo dentro de Docker:

git clone https://github.com/AntimatterChat/antimatter-docker.git
cd antimatter-docker
scripts/build-all.sh                     # from the main branches on GitHub
SOURCES=local scripts/build-all.sh       # from your checkouts next to this folder
VARIANT=next scripts/build-all.sh        # the "next" image, with every Antimatter app

Requiere Docker con buildx, Python 3, git y gpg, unos 16 GB de RAM y 30 GB de disco. El resultado se carga como ghcr.io/antimatterchat/antimatter:dev; pruébalo con ANTIMATTER_IMAGE=ghcr.io/antimatterchat/antimatter:dev docker compose -f compose.local.yml up -d. plugins.json lista las aplicaciones y las versiones compiladas, y el README del repositorio explica las variantes.

build-all.sh firma las aplicaciones incluidas con la clave de firma de Antimatter, y la compilación de la imagen rechaza las aplicaciones sin firmar. Sin esa clave privada, que solo tienen los mantenedores, ejecuta los primeros pasos por separado: scripts/fetch-sources.sh, scripts/build-plugins.sh (paquetes de aplicaciones en out/plugins/) y scripts/build-server.sh (archivos del servidor en out/server/).

Compilación y memoria

Las interfaces web son compilaciones grandes de webpack, y agotar la memoria es el fallo de compilación más común.

npm run build compila la interfaz clásica y Fusion una tras otra, no a la vez, para mantener el pico más bajo. No las ejecutes en paralelo tú mismo.
El minimizador inicia un trabajador por procesador. En una máquina con muchos núcleos y poca memoria, limita los procesadores que ve la compilación: taskset -c 0-5 npm run build.
Si Node se queda sin memoria en la pila, aumenta su límite: NODE_OPTIONS=--max-old-space-size=6144. La compilación de Docker usa este valor (BUILD_NODE_OPTIONS en build.env).
Evita ejecutar la suite de pruebas completa del servidor, una compilación web y una compilación de Docker al mismo tiempo en una máquina pequeña.

Las aplicaciones

Cada aplicación (plugin) tiene su propio repositorio y Makefile; make dist compila su paquete. Consulta Compilar, instalar y depurar.

Aplicación de escritorio

La aplicación de escritorio es una aplicación de Electron. Con Node.js 24 o posterior:

npm install --allow-git=all
npm run build          # development build, into dist/
npm start              # run it
npm run package:linux  # packages into release/ (also package:windows, package:mac)

La configuración de tiempo de compilación, como los servidores para preconfigurar, se encuentra en src/common/config/buildConfig.ts. Sin un certificado de Apple, establece AM_MAC_ADHOC_SIGN=true para firmar la aplicación de macOS de forma ad hoc, sin notarización: los Mac con Apple Silicon rechazan el código no firmado. El flujo de trabajo release.yml del repositorio compila paquetes sin firmar para Linux, Windows y macOS en una etiqueta v*.

Aplicación móvil

La aplicación móvil es una aplicación React Native; su README enumera los comandos (npm run ios, npm run android). Para compilar tu propia copia, también necesitas tus propias claves de firma, un proyecto de Firebase para las notificaciones de Android, una clave APNs para iOS y un proxy de notificaciones push que contenga esas credenciales. El flujo de trabajo release.yml del repositorio compila el APK y el AAB de Android y un archivo .ipa de iOS sin firmar en una etiqueta v*, sin cuentas de tienda; su README enumera los secretos que firman la compilación de Android y configuran Firebase.