tajniak81andClaude Opus 5
d187ad0d17
Implements PLAN.md Phase 4: the read model. /sync, /messages and /context, the filters that narrow them, and the streams a response carries that are not room events — typing, receipts, presence and to-device messages. With this a client can be used against Warp, which is milestone M1. The one architectural choice is that the syncapi has no copy of the rooms: it reads them through the roomserver. Dendrite gives its syncapi its own tables and feeds them from the output stream, which is right for a design where the two can be separate processes, and Dendrite's could be. Warp is one process by decision, and there the copy buys nothing and costs the hardest class of bug a homeserver has — a read model that disagrees with the room, where a client is shown a message that was rejected and the only way to find out is to compare two tables. So the roomserver grew a read model (stream.go, roomsync.go, visibility.go) rather than exporting its store: reading an event means parsing it under its room's version, and a second copy of the version registry, the parser and the client projection would be a second place for them to disagree. syncapi: stream tokens naming a position in each of five independent streams, so a client that has seen receipt 7 but only event 4 can say so in one opaque string. A token with fewer positions than this build writes is accepted and the rest read as zero, which is what lets a token stored before a stream existed go on working. The PDU position comes from MAX(stream_ordering) and not from the counter row the other four use: the counter is advanced inside the writing transaction, so a token taken from it would name a position whose event no reader can see yet, and the event would be skipped for good once that transaction committed. Long polling goes through a notifier that wakes by room and by user rather than globally — an event wakes the listeners of its room, a membership event also wakes the user it names, so an invite reaches a client that is not in the room yet. A wake-up is only ever a hint: the listener re-reads the streams and decides for itself what changed, which is what makes it safe for the notifier to hold no state about what each client has seen. The listener registers before the read, so an event landing in between leaves the channel signalled and the sync reads again rather than blocking on a change it just missed. EventPersisted must not block, because it is called with the room's write lock still held. "Something happened" is not "a token moved". A stream can move without this user being concerned by it, and returning on every such move would turn a long poll back into a busy loop. The same trap caught presence twice over: a client says it is still online by syncing, so ?set_presence= makes every sync a presence write, and a stream that moved each time would wake every peer, which would sync, which would move it again. SetPresence therefore reports whether anything a peer would notice actually changed, and a write that only refreshes the last-active timestamp leaves the stream alone. Timeline windows are named by their two ends and a direction, Low exclusive and High inclusive in both directions, rather than by "from" and "to" as the wire format spells them. Each of those would otherwise be the low bound in one direction and the high bound in the other, which is exactly the off-by-one every pagination bug is made of; the handlers translate once and nothing below them thinks about it again. A sync's timeline is read backwards and reported forwards, because a client wants the newest events of the window it missed — a forward read with a limit hands it the oldest and then calls the rest a gap. visibility: history visibility is now a span rather than a yes or no, which is what Phase 3 deferred here. A user who has left a room is served the room as it was when they left — their state reads, their members and their timeline — instead of being refused, and is bounded above at their own membership event so a kicked client cannot go on streaming. Their span is found from their own member events, so a user who joined, left and rejoined sees their latest span. ?at= on /members is honoured for the same reason. What is left is that the span is computed from the room's current history_visibility where the spec judges each event by the one in force when it was sent; that is a state read per event and belongs with open question 1. Typing is held in memory and nowhere else: notifications expire in seconds, are worthless across a restart, and arrive one per keystroke-burst per room, so persisting them would be the busiest table in the database holding the least valuable data in it. Receipts only ever advance, compared on the position of the event acknowledged rather than on arrival, because two of a user's clients read at different speeds and the slower one must not drag the marker backwards. To-device queues are per device and drained by the next sync rather than by the one that delivered them, so a client that crashes in between gets the batch again — the right way round, since a lost key share leaves a message permanently undecryptable and a duplicate is ignored. A wildcard addressee is expanded when sent, not stored, because "every device" means the ones that existed then. Presence is off by default, which answers PLAN.md open question 3. It is the noisiest thing in Matrix and the one genuinely fan-out notification here; a private homeserver gains little from it. With it off the endpoints refuse rather than disappearing, because a client that gets a 404 from /presence concludes the server is too old to have it and stops asking. storage: one migration per driver adding the receipt, to-device, presence and filter tables with a counter row each, and a stream position on the existing account data table rather than a parallel one — there is exactly one current value per (user, room, type), and a second table would be a second thing to keep in step. Account data is reported in an event list but is not an event, so it gets its own response type: a room event with an empty sender and no timestamp would make a client decide what that meant. Deliberately missing, each named in docs/sync.md: notification counts (they need push rules, Phase 8), device lists (the keyserver, Phase 7), anything remote (Phase 5), threads (Phase 10). device_lists is sent as two empty lists because a client reads a missing one as malformed; the notification counts are left out entirely, because a zero there is a claim and an absent field is not. Tested through HTTP rather than against the builder, because what is worth pinning down is the response a client sees — which section a room lands in, whether a token handed back can be handed in again, whether paging terminates and loses nothing. The storage tests run against both SQL drivers; the notifier has its own tests for the concurrent case. A live server was driven end to end, which is what caught the two bugs the unit tests had missed: a backwards /messages page must be in reverse chronological order, and `start` must name where the page began rather than position zero when ?from= was omitted. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Warp
A Matrix homeserver written from scratch in Go, plus a family of first-party clients. Federation is optional and can be switched on and off at runtime.
The full design and roadmap live in PLAN.md. This README covers what exists today.
Status
Phase 4 — sync. Complete. Milestone M1. Warp is now a homeserver a
client can be used against. /sync is real: stream tokens across five
independent streams, long polling that wakes the moment something concerns
the client rather than when its timeout expires, incremental deltas, gappy
timelines with a prev_batch to close them, filters, and lazy-loaded
members. /messages pages a room's history and /context opens a
permalink. The streams that are not room events are here too: typing,
read receipts and read markers, to-device messaging for Phase 7's
encryption to build on, and presence behind a config switch that is off by
default. A user who has left a room is now served the room as it was when
they left rather than refused, and ?at= on /members is honoured. See
docs/sync.md.
Phase 3 — rooms, local only. Complete. A client can create a room at any
supported version, invite, join, leave, kick, ban, send messages and state,
redact, name a room with an alias and find one in the public directory. Every
event goes through one pipeline — validate, authorise, resolve, persist,
emit — so a membership change made by createRoom, by /invite or by a raw
PUT .../state/m.room.member is judged by the same authorisation rules.
Nothing talks to another server yet, and every operation that would need to
is refused with a message that says so. See
docs/rooms.md.
Phase 2 — the event core. Complete. The library every later phase is
built on: canonical JSON, the event model with its hashes and identifiers,
the redaction algorithm, event signing, the room version registry, the
authorisation rules and state resolution v2. Pure library code under
server/internal/matrix, verified against the spec's own test vectors.
See docs/event-core.md.
Phase 1 — accounts and sessions. Complete. A client can register, log in, manage its devices and set its profile.
Client-Server API:
POST /register, GET /register/available |
sign-up, with m.login.dummy and optional registration tokens |
GET, POST /login · POST /logout, /logout/all · POST /refresh |
sessions, with m.login.password and refresh tokens |
GET /account/whoami · GET /capabilities |
who am I, and what this build can do |
GET /devices, GET/PUT/DELETE /devices/{id} · POST /delete_devices |
device management; deletion re-asks for the password |
GET /profile/{user} and its displayname / avatar_url sub-resources |
profiles — reads are public, writes are your own |
GET/PUT /user/{user}/account_data/{type} and the per-room variant |
account data, stored and returned byte for byte |
POST /createRoom |
room versions 3 to 12, presets, initial_state, invites, aliases |
POST /join/{roomIdOrAlias} · POST /rooms/{id}/join, /leave |
joining by ID or alias, and leaving or rejecting an invite |
POST /rooms/{id}/invite, /kick, /ban, /unban |
membership, decided by the room's power levels |
PUT /rooms/{id}/send/{type}/{txn} |
messages, idempotent per transaction ID |
GET/PUT /rooms/{id}/state[/{type}[/{key}]] |
room state, read whole or one piece at a time |
PUT /rooms/{id}/redact/{event}/{txn} |
redactions, applied only when they take effect |
GET /rooms/{id}/event/{event} · /members (with ?at=) · /joined_members · /aliases |
reading a room |
GET /joined_rooms |
the rooms you are in |
GET/PUT/DELETE /directory/room/{alias} |
the alias directory |
GET/POST /publicRooms · GET/PUT /directory/list/room/{id} |
the public room directory |
GET /sync |
the event stream: long-polled, incremental, filtered, with lazy-loaded members |
GET /rooms/{id}/messages · /context/{event} |
paging a room's history, and one event with what surrounds it |
POST /user/{user}/filter · GET /user/{user}/filter/{id} |
filters, stored and returned byte for byte |
PUT /rooms/{id}/typing/{user} |
typing notifications, kept in memory and expired |
POST /rooms/{id}/receipt/{type}/{event} · /read_markers |
read receipts, public and private, and the read marker |
PUT /sendToDevice/{type}/{txn} |
device-to-device messaging, for E2EE in Phase 7 |
GET/PUT /presence/{user}/status |
presence — only while sync.presence is on, and it is off by default |
GET /_matrix/client/versions · /.well-known/matrix/client |
discovery |
/.well-known/matrix/server |
server discovery — only while federation is on |
GET /healthz · GET /metrics |
liveness with a database ping, and Prometheus |
anything else under /_matrix/ |
404 M_UNRECOGNIZED, as the spec requires |
Admin API under /_warp/admin/v1: the federation and registration
switches, user listing and creation, the room list and detail, purging a
room, removing a user from one, and the dashboard counters. See
docs/admin-api.md.
Also in place: argon2id passwords, hashed access and refresh tokens, per-endpoint rate limiting, YAML + environment configuration, structured logging, graceful shutdown, the storage interfaces with a working SQLite and PostgreSQL driver (and a PocketBase stub), the embedded migration runner and the runtime settings service.
Complement, the official integration suite, is wired up for the
federation-off profile: make complement runs the account, room and stream
tests — TestRegistration, TestLogin, TestDeviceManagement, the Phase 3
room tests and the Phase 4 TestSync*, TestMessages*, TestContext*,
TestFilter*, TestTyping*, TestReceipt* and TestToDevice*.
Quick start
Requires Go 1.26 or newer. No cgo, no C compiler, no database server: the default SQLite driver is pure Go.
cp warp.yaml.example warp.yaml
# edit global.server_name
make build
./bin/warp generate-keys
./bin/warp create-account --username you --admin
./bin/warp serve
Then:
curl localhost:8008/healthz
curl localhost:8008/_matrix/client/versions
Registration is off in a fresh install, which is why the first account is made from the command line. Turn it on from the admin API when you want others to sign up.
Without make, the same from the server directory:
go build -o ../bin/warp ./cmd/warp
Configuration
One YAML file, every field overridable from the environment. See
warp.yaml.example — each setting lists its WARP_*
variable. With no config file at all the server runs on defaults plus the
environment, which is how the container image is meant to be used:
docker build -t warp .
docker run -p 8008:8008 -v warp-data:/data -e WARP_SERVER_NAME=warp.example warp
An unknown field in the config file is an error, not a warning: a typo in a security-relevant setting should never be silently ignored.
Commands
| Command | What it does |
|---|---|
warp serve |
run the homeserver |
warp migrate [--status] |
apply (or list) pending database migrations |
warp generate-keys [--output path] [--key-id id] |
create the ed25519 signing key |
warp create-account --username name [--admin] |
create a local account, straight in the database |
warp version |
version and compiled-in storage drivers |
create-account talks to the database rather than to a running server, so
the first account on a new install can be made before anything is listening
and without turning registration on. It prompts for the password twice;
--password-file and --password are there for scripts.
The signing key is written as a single line, the same format Synapse uses:
ed25519 <key-id> <unpadded-base64-seed>. generate-keys refuses to
overwrite an existing key — losing it would invalidate every event this
server has ever signed.
Federation switch
Federation is off in a fresh install. While it is off, the federation
surface does not answer at all; /.well-known/matrix/server returns
404 M_UNRECOGNIZED, exactly as it would on a server that has no
federation API.
The switch is stored in the server_settings table and cached in memory,
so flipping it takes effect on the next request without a restart. In
Phase 0 the only thing behind the gate is the delegation document; the
outbound queue, key fetcher and remote media fetch join it in Phase 5. Set
federation.allow_runtime_toggle: false to pin the switch to the config
file.
Development
make test # unit tests (SQLite)
make lint # golangci-lint
make check # vet + test, what CI runs
make cover # coverage.html
make complement # the Complement subset for the phases that are done (needs Docker)
# the storage tests against PostgreSQL as well
WARP_TEST_POSTGRES_DSN='postgres://warp:warp@localhost/warp_test?sslmode=disable' make test-postgres
make test-race needs cgo and therefore a C toolchain; CI runs it on
Linux.
Layout
server/ the homeserver (Go module)
cmd/warp/ the binary: serve, migrate, generate-keys, create-account, version
internal/
config/ YAML + env configuration
logging/ metrics/ slog and Prometheus setup
httputil/ Matrix error envelope, CORS, router, middleware
ratelimit/ per-endpoint token buckets
federation/ the federation gate and allow/deny policy
settings/ runtime settings service (the switches)
userapi/ accounts, passwords, devices, tokens, account data
roomserver/ rooms: the input pipeline (docs/rooms.md)
clientapi/ the Client-Server API handlers
adminapi/ /_warp/admin/v1
setup/ wiring: storage, routes, graceful shutdown
matrix/ the event core (docs/event-core.md)
canonicaljson/ the canonical JSON encoding
signing/ ed25519 server keys, Signing JSON
id/ identifier grammars as they appear in events
roomversion/ the room version registry
event/ PDUs: hashes, event IDs, redaction, signing
auth/ the authorisation rules and power levels
stateres/ state resolution v2
storage/ interfaces + driver registry
migrations/ embedded migration runner
sqlstore/ shared database/sql implementation
sqlite/ postgres/ pocketbase/
test/complement/ the Complement homeserver image and runner
apps/ clients: ui, admin, web, desktop, mobile (Phase 1+)
docs/