Compilation à partir du code source

Cette page explique comment compiler et exécuter Antimatter à partir de son code source, que ce soit pour y travailler ou pour créer vos propres versions. Elle couvre le serveur et les interfaces web, qui se trouvent dans un même dépôt, puis l'image Docker et les applications.

Prérequis

Aller à, à la version dans server/go.mod (1.26.7 à la date de rédaction).
Node.js et npm, aux versions indiquées dans .nvmrc et webapp/package.json (Node 24.11.1 avec npm 11.6.2). Avec mise, le fichier mise.toml du dépôt installe la bonne version de Node.
Docker avec Compose : l'environnement de développement exécute PostgreSQL et quelques autres services dans des conteneurs.
make, git, et une machine sous Linux ou macOS.
Mémoire : la compilation des interfaces web est la partie la plus gourmande. Prévoyez 16 Go de RAM ; voir Compilation et mémoire.

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

Le dépôt contient le serveur dans server/, les interfaces web dans webapp/ (Fusion dans webapp/fusion, l'interface classique dans webapp/channels, et les paquets partagés dans webapp/platform), ainsi que les tests de bout en bout dans e2e-tests/.

Exécuter un serveur de développement

cd server
make run

make run démarre les conteneurs de développement (PostgreSQL, Redis, un capteur d'e-mails et des outils de supervision), place les builds de l'application web, démarre le serveur en arrière-plan avec go run, et lance le surveillant de l'application web, qui recompile l'interface classique à chaque modification. Ouvrez http://localhost:8065 et créez un compte : le premier devient l'administrateur système.

Commande (dans `server/`)	Fonction
`make run-server`, `make run-client`	Démarrer uniquement le serveur, ou uniquement le surveillant de l'application web.
`make restart-server`	Redémarrer le serveur après avoir modifié le code Go.
`make stop`	Arrêter le serveur, le surveillant et les conteneurs.
`make debug-server`	Exécuter le serveur sous le débogueur Delve.
`make run-cli ARGS="-version"`	Exécuter une commande du serveur.
`make config-reset`	Réinitialiser `config/config.json` aux valeurs par défaut.
`make clean`, `make nuke`	Supprimer les fichiers de compilation ; `nuke` supprime également les données de développement.

La base de données de développement est postgres://mmuser:mostest_password@localhost/mattermost_test, la source de données par défaut du serveur. Choisissez quels conteneurs démarrer avec ENABLED_DOCKER_SERVICES, dans un fichier server/config.override.mk ou dans votre environnement (voir server/config.mk).

Les interfaces web

Dans webapp/ :

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

Les builds sont placés dans webapp/channels/dist (classique) et webapp/fusion/dist (Fusion). make client dans server/ les lie en tant que server/client et server/client-fusion, où le serveur les sert : classique sous /static/, Fusion sous /static/fusion/.

npm run run (ou make run dans webapp/) surveille et reconstruit l'interface classique. Ajoutez WATCH_FUSION=true pour reconstruire également Fusion.
npm run dev-server (make dev) exécute le serveur de développement de webpack à la place : classique sur le port 9005, Fusion sur le port 9006.
Pour afficher l'une ou l'autre interface dans le navigateur, ajoutez ?webui=fusion ou ?webui=classic à l'adresse de n'importe quelle page.

Tests et vérifications

Commande	Où	Fonction
`make test-server`	`server/`	La suite de tests du serveur, contre les conteneurs de développement. Elle prend beaucoup de temps.
`make test-server-quick`	`server/`	Uniquement les tests courts.
`go test ./channels/app/... -run TestName`	`server/`	Un paquet ou un test, avec les conteneurs en cours d'exécution (`make start-docker`).
`make check-style`	`server/`	go vet, golangci-lint et les autres vérifications Go.
`make test`	`webapp/`	Les tests unitaires de l'application web (Jest), dans tous les paquets.
`npm run test -- <pattern>`	`webapp/fusion`	Certains des tests de Fusion.
`make check-style`, `make check-types`	`webapp/`	ESLint et TypeScript.
`make i18n-extract`	`server/` et `webapp/`	Met à jour les fichiers de chaînes en anglais après avoir ajouté ou modifié des chaînes (voir Traductions).

Exécutez make modules-tidy plutôt que go mod tidy dans server/.

Archives de publication

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 compile les interfaces web et les binaires Linux en une seule commande. L'archive contient bin/antimatter, bin/amctl, un fichier config/config.json par défaut avec un README.md expliquant comment modifier les paramètres, les deux interfaces web, les modèles, les polices et les traductions. Pour les autres plateformes : make package-osx, make package-windows, make package-freebsd.

Applications intégrées

Une simple commande make package-linux crée une archive sans applications. Pour les inclure, comme le font les publications officielles, récupérez d'abord les paquets d'applications signés et indiquez leur dossier :

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 télécharge la dernière publication GitHub de chaque application listée dans plugins.json d'antimatter-docker, avec sa signature, et vérifie cette signature par rapport à la clé de plugins d'Antimatter. Par défaut, il prend Whiteboard, Voice channels, Calls, Agents, Todo, Polls, Notes, GIFs et Memes ; AM_BUNDLED_APPS (noms des dépôts, séparés par des espaces) modifie cette liste. Les applications sans publication ou sans signature sont ignorées avec un avertissement. Les paquets sont placés dans prepackaged_plugins/ de l'archive.

Paquets .deb et .rpm

build/package/build-packages.sh <archive> <amd64|arm64> <version> <out-dir> transforme une archive de publication en paquets .deb et .rpm tout-en-un, à l'aide de nfpm. Le guide d'administration décrit ce qu'ils installent : voir Installer le paquet .deb ou .rpm.

Le flux de publication

Le workflow antimatter-release.yml du dépôt serveur effectue toutes ces étapes sur GitHub : lorsqu'une étiquette v* est créée, il construit les archives et les paquets pour amd64 et arm64, avec SHA256SUMS, et les publie en tant que publication GitHub de l'étiquette (publication préliminaire pour une version contenant un -). Exécuté manuellement, il numérote la construction 0.9.0-dev.<run> et conserve les fichiers en tant qu'artefacts du workflow. Chaque dépôt d'application possède un workflow release.yml qui publie son paquet signé de la même manière.

L'image Docker

Le dépôt antimatter-docker construit les images publiées, le serveur avec ses applications, entièrement dans 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

Il nécessite Docker avec buildx, Python 3, git et gpg, environ 16 Go de RAM et 30 Go de disque. Le résultat est chargé en tant que ghcr.io/antimatterchat/antimatter:dev ; essayez-le avec ANTIMATTER_IMAGE=ghcr.io/antimatterchat/antimatter:dev docker compose -f compose.local.yml up -d. plugins.json liste les applications et les versions construites, et le README du dépôt explique les variantes.

build-all.sh signe les applications intégrées avec la clé de signature Antimatter, et la construction de l'image refuse les applications non signées. Sans cette clé privée, dont seuls les mainteneurs disposent, exécutez les premières étapes seules : scripts/fetch-sources.sh, scripts/build-plugins.sh (paquets d'applications dans out/plugins/) et scripts/build-server.sh (archives du serveur dans out/server/).

Compilation et mémoire

Les interfaces web sont de grandes compilations webpack, et le manque de mémoire est l'échec de compilation le plus courant.

npm run build compile l'interface classique puis Fusion l'une après l'autre, et non en même temps, afin de limiter le pic de consommation. Ne les exécutez pas en parallèle vous-même.
L'outil de minification démarre un travailleur par processeur. Sur une machine dotée de nombreux cœurs mais de peu de mémoire, limitez les processeurs visibles par la compilation : taskset -c 0-5 npm run build.
Si Node manque d'espace mémoire, augmentez sa limite : NODE_OPTIONS=--max-old-space-size=6144. La compilation Docker utilise cette valeur (BUILD_NODE_OPTIONS dans build.env).
Évitez d'exécuter simultanément la suite de tests complète du serveur, une compilation web et une compilation Docker sur une petite machine.

Les applications

Chaque application (plugin) possède son propre dépôt et son propre Makefile ; make dist compile son paquet. Consultez Compiler, installer et déboguer.

Application de bureau

L'application de bureau est une application Electron. Avec Node.js 24 ou ultérieur :

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)

Les paramètres de compilation, tels que les serveurs à préconfigurer, se trouvent dans src/common/config/buildConfig.ts. Sans certificat Apple, définissez AM_MAC_ADHOC_SIGN=true pour signer l'application macOS de manière ad hoc, sans notarisation : les Mac à puce Apple refusent le code non signé. Le workflow release.yml du dépôt génère des paquets non signés pour Linux, Windows et macOS sur une étiquette v*.

Application mobile

L'application mobile est une application React Native ; son README liste les commandes (npm run ios, npm run android). Pour construire votre propre copie, vous avez également besoin de vos propres clés de signature, d'un projet Firebase pour les notifications Android, d'une clé APNs pour iOS, et d'un proxy de notification qui détient ces identifiants. Le workflow release.yml du dépôt génère l'APK et l'AAB Android ainsi qu'un .ipa iOS non signé sur une étiquette v*, sans comptes de stores ; son README liste les secrets qui signent la compilation Android et configurent Firebase.