Pagbuo mula sa source

Inaakda ng pahinang ito kung paano mag-build at mag-run ng Antimatter mula sa kanyang source code, para sa pagtrabaho dito o para gumawa ng sariling build. Tinatalakay nito ang server at ang mga web interface, na nasa iisang repository, at ang Docker image at mga app.

Ang mga kailangan mo

Go, sa bersyon na nakasa sa server/go.mod (1.26.7 noong panahong ito).
Node.js at npm, sa mga bersyon na nakasa sa .nvmrc at webapp/package.json (Node 24.11.1 kasama ang npm 11.6.2). Gamit ang mise, ang mise.toml ng repository ang nag-i-install ng tamang Node.
Docker na may Compose: ang setup para sa development ay nagpapatakbo ng PostgreSQL at ilang ibang serbisyo sa mga container.
make, git, at isang makina na Linux o macOS.
Memory: ang pagbuo ng mga web interface ang pinakamabigat na bahagi. Magplano ng 16 GB ng RAM; tingnan ang Mga Build at Memory.

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

Nasa server/ ang server, nasa webapp/ ang mga web interface (Fusion sa webapp/fusion, classic sa webapp/channels, at mga shared package sa webapp/platform), at nasa e2e-tests/ ang mga end-to-end test.

Pagpapatakbo ng development server

cd server
make run

Ang make run ay nagpapa-start ng mga development container (PostgreSQL, Redis, mail catcher, at mga monitoring tool), nag-uugnay ng mga build ng web app sa tamang lugar, nagpapa-start ng server sa background gamit ang go run, at nagpapa-start ng watcher ng web app, na nagre-rebuild ng classic interface habang inu-edit ito. Buksan ang http://localhost:8065 at gumawa ng account: ang unang account ang maging system admin.

Command (sa `server/`)	Ginagawa nito
`make run-server`, `make run-client`	Pumunta sa server lang, o sa watcher ng web app lang.
`make restart-server`	I-restart ang server pagkatapos magbago ng Go code.
`make stop`	I-stop ang server, ang watcher, at ang mga container.
`make debug-server`	Pumunta sa server gamit ang Delve debugger.
`make run-cli ARGS="-version"`	Pumunta sa command ng server.
`make config-reset`	I-reset ang `config/config.json` sa mga default.
`make clean`, `make nuke`	Alisin ang mga build file; ang `nuke` ay pinaputol din ang mga development data.

Ang development database ay postgres://mmuser:mostest_password@localhost/mattermost_test, ang default na data source ng server. Piliin kung alin sa mga container ang magsisimula gamit ang ENABLED_DOCKER_SERVICES, sa isang server/config.override.mk file o sa iyong environment (tingnan ang server/config.mk).

Ang mga web interface

Sa webapp/:

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

Ang mga build ay nakalagay sa webapp/channels/dist (classic) at webapp/fusion/dist (Fusion). Ang make client sa server/ ay nag-uugnay sa kanila bilang server/client at server/client-fusion, kung saan ipinapasa ng server ang mga ito: ang classic ay nasa /static/, at ang Fusion ay nasa /static/fusion/.

Ang npm run run (o make run sa webapp/) ay nagbabantay at nagre-rebuild ng classic interface. Idagdag ang WATCH_FUSION=true upang ma-rebuild din ang Fusion.
Ang npm run dev-server (make dev) ay nagpapatakbo ng development server ng webpack sa halip: ang classic ay nasa port 9005, at ang Fusion ay nasa port 9006.
Upang makita ang isa sa mga interface sa browser, idagdag ang ?webui=fusion o ?webui=classic sa address ng anumang pahina.

Mga test at pagsusuri

Command	Saan	Ginagawa nito
`make test-server`	`server/`	Ang test suite ng server, laban sa mga development container. Matagal itong gagawin.
`make test-server-quick`	`server/`	Ang maikling mga test lamang.
`go test ./channels/app/... -run TestName`	`server/`	Isang package o test, habang tumatakbo ang mga container (`make start-docker`).
`make check-style`	`server/`	Ang go vet, golangci-lint, at ang ibang Go checks.
`make test`	`webapp/`	Ang mga unit test ng web app (Jest), sa bawat package.
`npm run test -- <pattern>`	`webapp/fusion`	Ilang test ng Fusion.
`make check-style`, `make check-types`	`webapp/`	Ang ESLint at TypeScript.
`make i18n-extract`	`server/` at `webapp/`	Pinapa-update ang mga English string files pagkatapos mong magdagdag o magbago ng mga string (tingnan ang Mga Pagsasalin).

Paggamit ng make modules-tidy sa halip ng go mod tidy sa server/.

Mga release archive

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

Ang make build ay nagbu-build ng mga web interface at Linux binary sa isang beses. Ang archive ay naglalaman ng bin/antimatter, bin/amctl, isang default na config/config.json na may README.md tungkol sa pagbabago ng mga setting, ang parehong web interface, ang mga template, ang mga font, at ang mga pagsasalin. Iba pang platform: make package-osx, make package-windows, make package-freebsd.

Mga app na kasama sa Antimatter

Ang simpleng make package-linux ay nagbu-build ng archive na walang mga app. Upang isama ang mga ito, gaya ng ginagawa ng mga published na release, kunin muna ang mga signed na app bundle at ipasa ang kanilang folder:

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

Ang fetch-apps.sh ay nagda-download ng pinakabagong GitHub release ng bawat app na nakalista sa plugins.json ng antimatter-docker, kasama ang kanyang signature, at tinutukoy ang signature laban sa plugin key ng Antimatter. Sa default, kinukuha nito ang Whiteboard, Voice channels, Calls, Agents, Todo, Polls, Notes, GIFs, at Memes; ang AM_BUNDLED_APPS (mga pangalan ng repository, hiwalay sa espasyo) ang nagbabago ng listahan. Ang mga app na walang release, o walang signature, ay nilalaktaw na may babala. Ang mga bundle ay nakakalat sa prepackaged_plugins/ ng archive.

Mga .deb at .rpm package

Ang build/package/build-packages.sh <archive> <amd64|arm64> <version> <out-dir> ay nagbu-build ng all-in-one .deb at .rpm package mula sa isang release archive, gamit ang nfpm. Inilalarawan ng admin guide kung ano ang nilalaman ng mga ito: tingnan ang Pag-install ng .deb o .rpm package.

Ang release workflow

Ang antimatter-release.yml workflow ng repository ng server ang nagpapatupad ng lahat ng ito sa GitHub: sa v* tag, nagbu-build ito ng mga archive at package para sa amd64 at arm64, kasama ang SHA256SUMS, at inilalathala ang mga ito bilang GitHub release ng tag (prerelease para sa bersyon na may -). Kapag ginagawa nang manu-man, inuunahan nito ang build bilang 0.9.0-dev.<run> at pinapanatili ang mga file bilang workflow artifacts. Bawat repository ng app ay may release.yml workflow na naglathala ng kanyang signed bundle sa paraan na iyon.

Ang Docker image

Ang antimatter-docker repository ay nagbu-build ng mga published image, ang server kasama ang mga app, buong-buo sa loob ng 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

Kailangan nito ng Docker na may buildx, Python 3, git, at gpg, tungkol sa 16 GB ng RAM at 30 GB ng disk. Ang resulta ay niluload bilang ghcr.io/antimatterchat/antimatter:dev; subukan ito gamit ang ANTIMATTER_IMAGE=ghcr.io/antimatterchat/antimatter:dev docker compose -f compose.local.yml up -d. Ang plugins.json ay naglilista ng mga app at bersyon na nabu-build, at ang README ng repository ay nagpapaliwanag ng mga variant.

Ang build-all.sh ay nagpapa-sign ng mga kasamang app gamit ang Antimatter signing key, at ang image build ay tumatanggi sa mga app na walang sign. Kung wala ang private key na iyon, na mayroon lamang ang mga maintainer, patakbuhin ang mga unang hakbang nang mag-isa: scripts/fetch-sources.sh, scripts/build-plugins.sh (mga app bundle sa out/plugins/) at scripts/build-server.sh (mga server archive sa out/server/).

Mga build at memory

Ang mga web interface ay malalaking webpack build, at ang pagkaubos ng memory ang pinakakaraniwang dahilan ng pagkabigo ng build.

Ang npm run build ay nagbu-build ng classic interface at Fusion nang isa-isa, hindi sabay-sabay, upang mabawasan ang peak. Huwag nilang sabay-sabay na patakbuhin.
Ang minifier ay nagpapa-start ng isang worker bawat processor. Sa isang makina na maraming core ngunit kaunting memory, limitahan ang mga processor na nakikita ng build: taskset -c 0-5 npm run build.
Kung ang Node ay nagkaubos ng heap, itaas ang limit nito: NODE_OPTIONS=--max-old-space-size=6144. Ginagamit ng Docker build ang halong ito (BUILD_NODE_OPTIONS sa build.env).
Iwasan ang sabay-sabay na pagtaas ng buong test suite ng server, isang web build, at isang Docker build sa isang maliit na makina.

Mga App

Bawat app (plugin) ay may sariling repository at Makefile; ang make dist ay nagbu-build ng bundle nito. Tingnan ang Build, install at debug.

Desktop app

Ang desktop app ay isang Electron app. Gamit ang Node.js 24 o higit pa:

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)

Nasa src/common/config/buildConfig.ts ang mga setting sa panahon ng pagbuo, tulad ng mga server na gagawing preconfigure. Kung wala kang Apple certificate, ilagay ang AM_MAC_ADHOC_SIGN=true upang i-sign ad hoc ang macOS app, nang walang notarisation: tinatanggi ng mga Apple silicon Mac ang unsigned code. Ang release.yml workflow ng repository ay nagbu-buo ng mga unsigned package para sa Linux, Windows, at macOS sa bawat v* tag.

Mobile app

Ang mobile app ay isang React Native app; nakatala sa kanyang README ang mga command (npm run ios, npm run android). Upang magbuo ng sarili mong kopya, kailangan mo rin ng sarili mong signing keys, isang Firebase project para sa Android notifications, isang APNs key para sa iOS, at isang push proxy na naglalaman ng mga credentials na iyon. Ang release.yml workflow ng repository ay nagbu-buo ng Android APK at AAB, at isang unsigned iOS .ipa sa bawat v* tag, nang walang store accounts; nakatala sa kanyang README ang mga secret na nagse-sign ng Android build at nagse-setup ng Firebase.