Compilazione dal codice sorgente

Questa pagina spiega come compilare ed eseguire Antimatter dal suo codice sorgente, per lavorarci o per creare le proprie build. Copre il server e le interfacce web, che si trovano in un unico repository, seguiti dall'immagine Docker e dalle app.

Requisiti

Vai, alla versione in server/go.mod (1.26.7 al momento della stesura).
Node.js e npm, alle versioni indicate in .nvmrc e webapp/package.json (Node 24.11.1 con npm 11.6.2). Con mise, il file mise.toml del repository installa la versione corretta di Node.
Docker con Compose: l'ambiente di sviluppo esegue PostgreSQL e altri servizi in container.
make, git e un sistema operativo Linux o macOS.
Memoria: la compilazione delle interfacce web è la parte più pesante. Prevedi 16 GB di RAM; consulta Compilazioni e memoria.

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

Il repository contiene il server in server/, le interfacce web in webapp/ (Fusion in webapp/fusion, classic in webapp/channels, pacchetti condivisi in webapp/platform) e i test end-to-end in e2e-tests/.

Avvio di un server di sviluppo

cd server
make run

make run avvia i container di sviluppo (PostgreSQL, Redis, un catturatore di email e strumenti di monitoraggio), collega le build dell'app web, avvia il server in background con go run e avvia il watcher dell'app web, che ricompila l'interfaccia classic durante la modifica. Apri http://localhost:8065 e crea un account: il primo diventa l'amministratore di sistema.

Comando (in `server/`)	Funzione
`make run-server`, `make run-client`	Avvia solo il server o solo il watcher dell'app web.
`make restart-server`	Riavvia il server dopo aver modificato il codice Go.
`make stop`	Arresta il server, il watcher e i container.
`make debug-server`	Esegui il server sotto il debugger Delve.
`make run-cli ARGS="-version"`	Esegui un comando del server.
`make config-reset`	Ripristina `config/config.json` ai valori predefiniti.
`make clean`, `make nuke`	Rimuovi i file di compilazione; `nuke` elimina anche i dati di sviluppo.

Il database di sviluppo è postgres://mmuser:mostest_password@localhost/mattermost_test, la fonte dati predefinita del server. Scegli quali container avviare con ENABLED_DOCKER_SERVICES, in un file server/config.override.mk o nell'ambiente (vedi server/config.mk).

Le interfacce web

In webapp/:

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

Le build vengono generate in webapp/channels/dist (classico) e webapp/fusion/dist (Fusion). make client in server/ le collega come server/client e server/client-fusion, da cui il server le serve: il classico sotto /static/, Fusion sotto /static/fusion/.

npm run run (o make run in webapp/) monitora e ricostruisce l'interfaccia classica. Aggiungi WATCH_FUSION=true per ricostruire anche Fusion.
npm run dev-server (make dev) avvia invece il server di sviluppo di webpack: il classico sulla porta 9005, Fusion sulla porta 9006.
Per visualizzare nel browser una delle due interfacce, aggiungi ?webui=fusion o ?webui=classic all'indirizzo di qualsiasi pagina.

Test e verifiche

Comando	Dove	Funzione
`make test-server`	`server/`	La suite di test del server, contro i contenitori di sviluppo. Richiede molto tempo.
`make test-server-quick`	`server/`	Solo i test brevi.
`go test ./channels/app/... -run TestName`	`server/`	Un singolo pacchetto o test, con i contenitori in esecuzione (`make start-docker`).
`make check-style`	`server/`	go vet, golangci-lint e le altre verifiche Go.
`make test`	`webapp/`	I test unitari dell'app web (Jest), in tutti i pacchetti.
`npm run test -- <pattern>`	`webapp/fusion`	Alcuni dei test di Fusion.
`make check-style`, `make check-types`	`webapp/`	ESLint e TypeScript.
`make i18n-extract`	`server/` e `webapp/`	Aggiorna i file delle stringhe in inglese dopo aver aggiunto o modificato le stringhe (vedi Traduzioni).

Esegui make modules-tidy invece di go mod tidy in server/.

Archivi di rilascio

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 le interfacce web e i binari per Linux in un'unica operazione. L'archivio contiene bin/antimatter, bin/amctl, un config/config.json predefinito con un README.md sulla modifica delle impostazioni, entrambe le interfacce web, i modelli, i font e le traduzioni. Per altre piattaforme: make package-osx, make package-windows, make package-freebsd.

App integrate

Un semplice make package-linux crea un archivio senza app. Per includerle, come fanno i rilasci pubblicati, scaricare prima i bundle delle app firmati e passare la relativa cartella:

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 scarica l'ultimo rilascio GitHub di ciascuna app elencata in plugins.json di antimatter-docker, insieme alla sua firma, e verifica la firma rispetto alla chiave plugin di Antimatter. Di default include Whiteboard, Canali vocali, Chiamate, Agenti, Da fare, Sondaggi, Note, GIF e Memes; AM_BUNDLED_APPS (nomi dei repository, separati da spazi) modifica l'elenco. Le app senza un rilascio, o senza una firma, vengono ignorate con un avviso. I bundle vengono inseriti nella cartella prepackaged_plugins/ dell'archivio.

Pacchetti .deb e .rpm

build/package/build-packages.sh <archive> <amd64|arm64> <version> <out-dir> trasforma un archivio di rilascio in pacchetti .deb e .rpm all-in-one, utilizzando nfpm. La guida per amministratori descrive cosa installano: consulta Installazione del pacchetto .deb o .rpm.

Il flusso di lavoro per i rilasci

Il flusso di lavoro antimatter-release.yml del repository del server esegue tutte queste operazioni su GitHub: su un tag v* compila gli archivi e i pacchetti per amd64 e arm64, con SHA256SUMS, e li pubblica come rilascio GitHub del tag (un rilascio pre-pubblicazione per una versione con -). Se eseguito manualmente, numera la build 0.9.0-dev.<run> e conserva i file come artefatti del flusso di lavoro. Ogni repository di app ha un flusso di lavoro release.yml che pubblica il suo bundle firmato nello stesso modo.

L'immagine Docker

Il repository antimatter-docker compila le immagini pubblicate, il server con le sue app, interamente all'interno di 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

Richiede Docker con buildx, Python 3, git e gpg, circa 16 GB di RAM e 30 GB di spazio su disco. Il risultato viene caricato come ghcr.io/antimatterchat/antimatter:dev; provalo con ANTIMATTER_IMAGE=ghcr.io/antimatterchat/antimatter:dev docker compose -f compose.local.yml up -d. plugins.json elenca le app e le versioni compilate, e il README del repository spiega le varianti.

build-all.sh firma le app incorporate con la chiave di firma di Antimatter e la costruzione dell'immagine rifiuta le app non firmate. Senza quella chiave privata, di cui dispongono solo i manutentori, esegui solo i primi passaggi: scripts/fetch-sources.sh, scripts/build-plugins.sh (pacchetti delle app in out/plugins/) e scripts/build-server.sh (archivi del server in out/server/).

Costruzione e memoria

Le interfacce web sono grandi build webpack e l'esaurimento della memoria è il guasto di costruzione più comune.

npm run build costruisce l'interfaccia classica e Fusion una dopo l'altra, non insieme, per mantenere il picco più basso. Non eseguirle in parallelo.
Il minificatore avvia un worker per processore. Su una macchina con molti core e poca memoria, limita i processori visibili alla costruzione: taskset -c 0-5 npm run build.
Se Node esaurisce la heap, aumenta il suo limite: NODE_OPTIONS=--max-old-space-size=6144. La costruzione Docker usa questo valore (BUILD_NODE_OPTIONS in build.env).
Evita di eseguire la suite di test completa del server, una build web e una build Docker contemporaneamente su una macchina piccola.

Le app

Ogni app (plugin) ha il proprio repository e Makefile; make dist costruisce il suo pacchetto. Consulta Costruzione, installazione e debug.

App desktop

L'app desktop è un'app Electron. Con Node.js 24 o successivo:

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)

Le impostazioni di build, come i server da preconfigurare, si trovano in src/common/config/buildConfig.ts. In assenza di un certificato Apple, impostare AM_MAC_ADHOC_SIGN=true per firmare l'app macOS in modo ad hoc, senza notarizzazione: i Mac con chip Apple rifiutano il codice non firmato. Il workflow release.yml del repository crea pacchetti non firmati per Linux, Windows e macOS al tag v*.

App mobile

L'app mobile è un'app React Native; il relativo README elenca i comandi (npm run ios, npm run android). Per creare una copia propria sono inoltre necessari le proprie chiavi di firma, un progetto Firebase per le notifiche Android, una chiave APNs per iOS e un proxy push che conservi tali credenziali. Il workflow release.yml del repository crea l'APK e l'AAB per Android e un .ipa iOS non firmato al tag v*, senza account per gli store; il relativo README elenca i segreti per firmare la build Android e configurare Firebase.