Phase 1: accounts and sessions

Implements PLAN.md Phase 1. A client can now register, log in, manage its
devices and set its profile; an operator can create accounts and flip the
runtime switches. There are still no rooms and no real /sync.

userapi: accounts, argon2id passwords in PHC format, devices, access and
refresh tokens stored as SHA-256 hashes, account data and the admin flag.
Its storage interface is storage.UserStore, implemented once in sqlstore
with `?` placeholders; the postgres driver supplies a rebind function and
unique-violation recognition rather than keeping a second copy of thirty
statements. Timestamps in these tables are int64 milliseconds, the unit the
Client-Server API uses on the wire.

Client-Server API: register (user-interactive auth with m.login.dummy and
optional registration tokens), register/available, token validity, login
with m.login.password, logout, logout/all, refresh, account/whoami,
capabilities, devices/* with password-gated deletion, profile/*, global and
per-room account data.

GET /sync is a deliberate placeholder: it answers a valid token with an
empty but well-formed response and refuses a revoked one. Phase 1 has no
rooms, so that is the whole truth, and it is what makes session revocation
observable. Phase 4 replaces it with the syncapi.

Auth middleware resolves a bearer token (header or the legacy query
parameter) to a device and user, answering an expired token with the soft
logout the spec asks for. Rate limiting is a token bucket per endpoint class
keyed on the client address, returning M_LIMIT_EXCEEDED with retry_after_ms.

adminapi v1 under /_warp/admin/v1: admin-only auth via a normal Matrix
token, GET/PUT /federation and /registration driving internal/settings and
reporting a config-pinned switch as a 409, GET/POST /users, GET /stats.

warp create-account [--admin] creates the first account straight in the
database, so a new install with registration off has a way in.

Complement is wired up for the federation=off profile: an image meeting its
contract, an entrypoint that configures Warp entirely from WARP_*
variables, and a runner that builds, clones and executes the target set
(TestRegistration, TestLogin, TestDeviceManagement). It has not been run
yet -- there is no container runtime on the development machine -- so the
three tests' assertions were read from the Complement sources and pinned as
httptest tests instead, and CI gained a job that runs the real thing.

Also fixes a .gitignore bug from Phase 0: the unanchored `warp` pattern,
meant for the built binary, also matched the directory server/cmd/warp and
silently excluded the entire command package from the repository. The
binary patterns are now anchored to the repository root, and cmd/warp is
committed for the first time.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

server/internal/clientapi/sync.go

@@ -0,0 +1,73 @@
+package clientapi
+
+import (
+	"net/http"
+
+	"github.com/dariuszjaniak/warp/server/internal/httputil"
+	"github.com/dariuszjaniak/warp/server/internal/userapi"
+)
+
+// syncResponse is the subset of the /sync body that is meaningful before
+// there are any rooms.
+type syncResponse struct {
+	NextBatch   string          `json:"next_batch"`
+	Rooms       syncRooms       `json:"rooms"`
+	Presence    syncEventList   `json:"presence"`
+	AccountData syncEventList   `json:"account_data"`
+	ToDevice    syncEventList   `json:"to_device"`
+	DeviceLists syncDeviceLists `json:"device_lists"`
+}
+
+type syncRooms struct {
+	Join   map[string]any `json:"join"`
+	Invite map[string]any `json:"invite"`
+	Leave  map[string]any `json:"leave"`
+	Knock  map[string]any `json:"knock"`
+}
+
+type syncEventList struct {
+	Events []any `json:"events"`
+}
+
+type syncDeviceLists struct {
+	Changed []string `json:"changed"`
+	Left    []string `json:"left"`
+}
+
+// syncPlaceholderToken is the only stream position Phase 1 can be at.
+//
+// It is a real token shape rather than an empty string so that a client
+// storing it and sending it back as ?since= gets the same answer, which is
+// the correct one: nothing has happened.
+const syncPlaceholderToken = "s0_0"
+
+// handleSync implements GET /_matrix/client/v3/sync as far as Phase 1 can.
+//
+// This is a placeholder, and deliberately a working one. There are no rooms
+// until Phase 3 and no event streams until Phase 4, so an empty sync is not
+// a lie — it is the complete state of this server. What it buys in the
+// meantime is the thing every client and the test suite check first: that a
+// valid token syncs and a revoked one does not. Without it, "logging out
+// invalidates the session" cannot be observed at all.
+//
+// Phase 4 replaces this wholesale with the syncapi: stream tokens, long
+// polling, filters and lazy-loaded members.
+func (c *ClientAPI) handleSync(w http.ResponseWriter, _ *http.Request, _ userapi.Authenticated) error {
+	// The `timeout` parameter is ignored rather than honoured: blocking for
+	// 30 seconds to return a response that cannot change would hold a
+	// connection open for nothing.
+	httputil.WriteJSON(w, http.StatusOK, syncResponse{
+		NextBatch: syncPlaceholderToken,
+		Rooms: syncRooms{
+			Join:   map[string]any{},
+			Invite: map[string]any{},
+			Leave:  map[string]any{},
+			Knock:  map[string]any{},
+		},
+		Presence:    syncEventList{Events: []any{}},
+		AccountData: syncEventList{Events: []any{}},
+		ToDevice:    syncEventList{Events: []any{}},
+		DeviceLists: syncDeviceLists{Changed: []string{}, Left: []string{}},
+	})
+	return nil
+}