Build Scripts

The scripts/build/ directory contains all build pipelines and supporting code generators.

Overview

build/
├── all.sh              Full build (server + ariadne)
├── server.sh           Server build pipeline
├── bug-collector.sh    Bug collector x64 build + deploy
├── keryx-status.sh     keryx-status x64 build + deploy (notify host)
├── rtls-relay.sh       rtls-relay x64 build + deploy (update host, RTLS field test)
├── ariadne.sh          Ariadne build pipeline
├── generators/
│   ├── embeds.ts          Static file and migration embed generator
│   ├── installer.ts       CLI bundler and installer generator
│   ├── vm-tests.ts        VM test bundler
│   └── offline-bundle.ts  Offline artifact bundle packer
└── templates/
    ├── installer.sh    Installer shell script template
    └── vm.sh           VM test shell script template

Full Build (all.sh)

Runs the complete build pipeline for both server and Ariadne:

bun build
# or directly: bash scripts/build/all.sh

Steps:

1. Run server tests (bun test in server/)
2. Run contract tests (bun scripts/test/contracts.ts)
3. Build server binaries via server.sh --server-only
4. Build Ariadne via ariadne.sh

Server Build (server.sh)

Builds the web frontend, generates embeds, compiles Linux binaries, runs smoke tests, and optionally uploads.

bun build:server
# or directly: bash scripts/build/server.sh

Flags:

• --server-only — skip the upload step (used by all.sh)
• --skip-upload — skip the upload step
• --vm-test — run the VM test suite on the local VirtualBox VM against the offline bundle before anything is uploaded (passed by bun commit --vm)

Steps:

1. Build web frontend (bun build.ts --release in web/)
2. Generate static embeds (generators/embeds.ts)
3. Generate installer script (generators/installer.ts)
4. Generate VM test script (generators/vm-tests.ts)
5. Compile Linux binaries (arm64 + x64) with bun build --compile
6. Generate offline tarball bundle (generators/offline-bundle.ts)
7. Run binary smoke tests (scripts/test/binary.sh)
8. Test and compile rtls-relay (rtls-relay.sh --skip-upload), so a failing relay test stops the release before anything ships (unless upload skipped)
9. With --vm-test: run the VM test suite on VirtualBox against the offline bundle; a failure stops the build before the docs, website and binaries are uploaded
10. Upload binaries and installer artifacts to the deploy server (unless skipped)
11. Deploy bug-collector x64 via bug-collector.sh (unless upload skipped)
12. Deploy keryx-status x64 via keryx-status.sh to the notify host (unless upload skipped)
13. Deploy rtls-relay x64 via rtls-relay.sh --upload-only when rtls-relay.service exists on the update host; a failure only warns (unless upload skipped)

Placement Planner DWG imports use system-installed conversion tools on the target server. The build pipeline does not package LibreDWG, rsvg-convert, or any DWG converter vendor archive.

Bug Collector Build (bug-collector.sh)

Compiles the Linux x64 bug-collector binary, uploads it to mnew.ssh, and restarts bug-collector.service.

bash scripts/build/bug-collector.sh
bash scripts/build/bug-collector.sh --skip-upload

See Bug Collector for systemd / sudoers setup.

keryx-status Build (keryx-status.sh)

Compiles the Linux x64 keryx-status binary, uploads it to mnew.ssh, and restarts keryx-status.service.

bash scripts/build/keryx-status.sh
bash scripts/build/keryx-status.sh --skip-upload

See keryx-status for systemd / sudoers / nginx setup. --server-only / --skip-upload on server.sh skips this deploy.

rtls-relay Build (rtls-relay.sh)

Tests and compiles the Linux x64 relay of the Theseus RTLS field test, uploads it to mnew.ssh, and restarts rtls-relay.service.

bash scripts/build/rtls-relay.sh                # test, compile, upload, restart
bash scripts/build/rtls-relay.sh --skip-upload  # test + compile only
bash scripts/build/rtls-relay.sh --upload-only  # upload the binary built before + restart

See RTLS relay for systemd / sudoers / nginx setup. --server-only / --skip-upload on server.sh skips both relay steps.

Ariadne Build (ariadne.sh)

Builds the Flutter app for both platforms.

bun build:ariadne
# or directly: bash scripts/build/ariadne.sh

Steps:

1. Fetch Flutter dependencies
2. Run Flutter analyze
3. Build Android App Bundle (AAB)
4. Build iOS IPA (macOS only, requires Xcode signing)
5. Copy artifacts to releases/

Keryx Build

bun run build:keryx and bun run build:keryx-ipa (via scripts/release/keryx-shared.ts) copy signed artifacts to releases/keryx.aab and releases/Keryx.ipa. Prefer bun keryx or bun run release:keryx for a full analyze/test/verify pass.

Generators

generators/embeds.ts

Generates two files that embed assets into the compiled server binary:

• server/src/static_embeds.ts — maps URL paths to web frontend files using import ... with { type: "file" }
• server/src/migration_embeds.ts — bundles database migration code for runtime execution

This runs automatically as part of server.sh, but can also be run standalone:

bun scripts/build/generators/embeds.ts

generators/installer.ts

Bundles the CLI TypeScript code (from scripts/cli/) into a single self-contained installer shell script:

1. Uses Bun.build() to bundle cli/main.ts with all dependencies
2. Reads the template from templates/installer.sh
3. Replaces ###version###, ###util.sh###, and ###util.ts### placeholders
4. Writes the final releases/installer.sh

generators/offline-bundle.ts

Packages release artifacts into a transferable offline bundle:

1. Reads version and active brand metadata
2. Collects installer.sh, test-vm.sh, and architecture binaries
3. Writes offline-manifest.json with checksums and size metadata
4. Produces releases/<brand>-offline-<version>.tar.gz

See Offline Installation for deployment workflow.

Templates

templates/installer.sh

Shell script template with placeholder markers that generators/installer.ts fills in at build time. Contains the installer logic for downloading and setting up SafeCall on a production server.