hyperhive/docs/4-implementation/swarm/matrix-provisioning.md

Matrix homeserver: account provisioning

How the swarm's appservice creates accounts on the homeserver, where its tokens live, and the settings the homeserver starts with. The operator's view is the matrix page.

Provisioning flow (appservice)

Registration is closed. The swarm's appservice creates accounts: agents never see an appservice token, and an agent only ever receives its own access_token.

The appservice has no URL (url: null in its registration), so the homeserver never calls out to it and there is no service to run. What the registration buys is an identity the homeserver recognises — which is why no secret has to be equal on both sides of the wire, and why account creation doesn't depend on registration being open to anyone who learns a token.

1. swarm-matrix-ctl appservice render, inside the hive-matrix container and before tuwunel starts, fetches the as_token and spec-required hs_token from the store and renders the registration to /run/swarm-matrix-appservice/swarm.yaml (mode 0600 root:root) on the container's tmpfs, so no token sits on disk. It mints a pair only when the store answers and holds none. While the store doesn't answer, render fails and retries, and tuwunel stays down.
2. systemd LoadCredential= copies the registration into /run/credentials/tuwunel.service/swarm-appservice.yaml, owned by tuwunel's dynamic user with mode 0400, at service start. The source file stays root:root 0600 — no chown :tuwunel / chmod 0640 / GID-pin gymnastics required. Keeps DynamicUser = true + PrivateUsers = true intact.
3. tuwunel's appservice_dir points at the credentials directory. It reads only .yaml/.yml entries from there, so the sibling credentials are invisible to it. The .yaml suffix on the credential id is what makes this work.
4. hive-c0re holds no appservice token, creates no account and does not talk to matrix.
5. swarm-controller creates every account: each agent's, with its token stored at swarm/agents/<agent>/matrix/main for the agent's hive-matrix-daemon to read as the agent itself, and each hive's sender account (below).

A homeserver whose swarm-matrix-ctl has no store identity (services.hyperhive.deploy.matrix.ctlBaoClientCertFile) loads no registration, and nothing creates accounts on it.

On the store's host ctlBaoClientCertFile / ctlBaoClientKeyFile default to the leaf glue-bao-tls.nix mints there. A homeserver host without the store gets no default, even when it holds the hive's own reader deploy.bao.clientCertFile: issue a leaf whose subject is deploy.bao.matrixCtlCommonName, place it, and name it in both options. Until you do, swarm-bao-matrix-oidc fails naming both.

The swarm's appservice, and its admin sender

The registration's id is swarm, its sender @swarm, and its user namespace non-exclusive. It's the swarm's identity on the homeserver: swarm-controller creates every agent's account and every hive's sender account with it.

The swarm secret store holds the registration's tokens, at swarm/controller/swarm-controller/matrix/appservice-registration. swarm-matrix-ctl appservice render fetches them and renders the registration tuwunel loads as a credential onto the hive-matrix container's tmpfs, before tuwunel starts. A render that can't reach the store fails and retries, and tuwunel, which fails to start without the registration, retries until one has landed. appservice sync runs beside tuwunel on a timer. The store's tokens win: when they differ from the rendered copy, it rewrites it. It restarts tuwunel whenever the registration is newer than tuwunel's last start, so the next run retries one that failed after writing, and starts one that failed because render couldn't reach the store. A store that holds none takes the tokens an earlier version kept in /var/lib/swarm-matrix-appservice with a create-only write, so a running swarm keeps its value; the files stay, unused. A host with neither files nor stored tokens mints a pair. sync then writes the as_token to swarm/controller/swarm-controller/matrix/appservice-token. No hive's policy reaches either path: only matrix-ctl (which holds create and read on the registration, and writes the token) and swarm-controller (which reads only the token) hold a grant.

@swarm is the one account the homeserver promotes to admin at boot (admin_execute). Only those two principals read its token, which is the difference from the hive sender below: every hive reads its own sender's token. swarm is a reserved name, so nothing can create an agent as this account.

swarm-controller mints each agent's account with the device id hyperhive-<agent>, and a login on that device replaces its token. The controller therefore reads the stored token back with whoami every five minutes and re-mints only when it's missing, unknown to the homeserver, or someone else's. An agent's daemon picks a re-minted token up on its next start, and a timer restarts it while it's down.

A hive's sender account, and why it isn't an admin

@hive-<hive>:<server_name> is the account a hive acts as. swarm-controller creates it with the swarm's appservice token, for every hive in its directory. It's an ordinary account: nothing promotes it; the homeserver's admin_execute promotes only @swarm.

One account per hive. The localpart carries the hive's name, so a swarm whose hives share a homeserver gives each of them its own identity: the homeserver attributes an action to the hive that took it, and revoking one hive's standing leaves the others alone.

Its access token is the sender token. swarm-controller, its only minter, mints it for every hive with the swarm's appservice token and publishes it to swarm/hives/<hive>/matrix/sender-token, inside the hive's own read grant (swarm/hives/<hive>/*). Nothing on the hive uses it any more: hive-c0re used to present it for its Space and invite calls and no longer makes any. The name says what it authenticates as — an account the swarm's appservice creates — rather than any privilege level, because it carries none.

Promoting a user to homeserver admin and resetting a password both need an admin sender: !admin … messages into #admins:<server_name>, and tuwunel only treats a message as a command when its sender is already an admin. Of the swarm's own accounts only @swarm is a homeserver admin (operators are too, see Operators are homeserver admins), so both are swarm-level operations.

Appservice identity

swarm-matrix-ctl appservice render renders the registration from the store's copy of the appservice tokens before tuwunel starts, so every boot has both halves. With the store down or sealed, tuwunel waits for it.

• Access tokens live on the device that minted them. login_with_password stays on, so the password fallback works too.
• The homeserver's admin_execute promotes only @swarm at boot (above); a hive's sender account is never promoted.
• The value that matters lives at swarm/controller/swarm-controller/matrix/appservice-token. appservice sync writes it there whenever the store's differs from the registration's as_token, and swarm-controller reads it from there.

Rollout settings

• allow_federation = true at the protocol level so swarms can be wired up later by extending trustedServers without a homeserver restart. trusted_servers = [] keeps it effectively closed until you list peers.
• allow_registration = false. tuwunel checks this flag only for requests that arrive without an appservice token, so the swarm's appservice still creates accounts and tuwunel refuses everyone else. With no registration token configured, allow_registration = true makes tuwunel refuse to start unless yes_i_am_very_very_sure_…_open_registration_… is also set.
• allow_encryption — server-side E2EE switch, sourced from services.hyperhive.deploy.matrix.allowEncryption (default false, opt-in). Off by default because on the swarm's own homeserver the operator already controls the transport; turn it on for encrypted rooms on external / federated homeservers or to keep contents opaque to the homeserver admin. The agent matrix client always supports decryption regardless of this flag — it uses the e2e-encryption feature of matrix-sdk so it can read encrypted rooms it's invited to even when this homeserver doesn't permit room encryption. matrix-sdk stores crypto keys in the per-agent sqlite store under the state dir; they persist across restarts. read_room decrypts via room.messages() — UTD events surface as event_type = "m.room.encrypted" with body = "[unable to decrypt]". The daemon bootstraps cross-signing on the bearer token alone, which works where the homeserver skips re-auth for a first key upload (MSC3967, as tuwunel does).
• Key backup. swarm-controller mints a random recovery passphrase for every matrix account an agent has, at swarm/agents/<agent>/matrix-recovery/<account> in the swarm secret store, and never replaces it. When hive-matrix-daemon brings an account up it reads that passphrase: with no backup on the account's homeserver it turns on server-side key backup and secret storage (log line matrix recovery enabled), unless the account already has secret storage, which it never replaces (a WARN instead). With a backup there it recovers from it (recovered from the server-side key backup), which downloads the room keys and signs the new device with the account's existing cross-signing identity. A crypto store lost to --purge or to a primary-token reset therefore comes back with its history. With no passphrase stored yet the account comes up without backup and picks it up on the next daemon start. A failure is a WARN and never stops the daemon.

The module's retired hive-side code, its evaluation assertions and the fluffychat-web build fixes are in the implementation notes.