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/httputil/errors.go

@@ -25,6 +25,13 @@ const (
 	ErrCodeInvalidParam   = "M_INVALID_PARAM"
 	ErrCodeTooLarge       = "M_TOO_LARGE"
 	ErrCodeUnsupportedVer = "M_UNSUPPORTED_ROOM_VERSION"
+
+	// Account and session codes, added with the userapi in Phase 1.
+	ErrCodeUserInUse       = "M_USER_IN_USE"
+	ErrCodeInvalidUsername = "M_INVALID_USERNAME"
+	ErrCodeUserDeactivated = "M_USER_DEACTIVATED"
+	ErrCodeExclusive       = "M_EXCLUSIVE"
+	ErrCodeWeakPassword    = "M_WEAK_PASSWORD"
 )
 
 // MatrixError is the standard Matrix error envelope. Every non-2xx response
@@ -130,3 +137,26 @@ func LimitExceeded(retryAfterMS int64) *MatrixError {
 func InternalError() *MatrixError {
 	return NewError(http.StatusInternalServerError, ErrCodeUnknown, "Internal server error")
 }
+
+// UserInUse is M_USER_IN_USE (400): the requested user name is taken.
+func UserInUse() *MatrixError {
+	return NewError(http.StatusBadRequest, ErrCodeUserInUse, "Desired user ID is already taken")
+}
+
+// InvalidUsername is M_INVALID_USERNAME (400): the user name is not usable,
+// either because of its characters or its length.
+func InvalidUsername(format string, args ...any) *MatrixError {
+	return NewError(http.StatusBadRequest, ErrCodeInvalidUsername, format, args...)
+}
+
+// UserDeactivated is M_USER_DEACTIVATED (403).
+func UserDeactivated() *MatrixError {
+	return NewError(http.StatusForbidden, ErrCodeUserDeactivated, "This account has been deactivated")
+}
+
+// Unknown is M_UNKNOWN with an explicit status, for the handful of cases the
+// spec answers with that code rather than a specific one — an unsupported
+// login type, for instance.
+func Unknown(status int, format string, args ...any) *MatrixError {
+	return NewError(status, ErrCodeUnknown, format, args...)
+}

server/internal/httputil/json.go

@@ -1,6 +1,7 @@
 package httputil
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
@@ -67,26 +68,44 @@ func WriteError(w http.ResponseWriter, r *http.Request, err error) {
 // DecodeJSON reads a JSON request body into v, enforcing MaxRequestBody and
 // mapping a missing, oversized or malformed body onto the right Matrix error.
 func DecodeJSON(w http.ResponseWriter, r *http.Request, v any) error {
+	present, err := DecodeOptionalJSON(w, r, v)
+	if err != nil {
+		return err
+	}
+	if !present {
+		return NotJSON()
+	}
+	return nil
+}
+
+// DecodeOptionalJSON is DecodeJSON for an endpoint whose body may legitimately
+// be absent, reporting whether there was one. A malformed body is still an
+// error: only a genuinely empty one is "not sent".
+//
+// DELETE /devices/{deviceId} is the case this exists for. A client sends it
+// with no body at all, because it does not know until the 401 comes back that
+// the endpoint is interactive.
+func DecodeOptionalJSON(w http.ResponseWriter, r *http.Request, v any) (bool, error) {
 	body := http.MaxBytesReader(w, r.Body, MaxRequestBody)
 	data, err := io.ReadAll(body)
 	if err != nil {
 		var tooLarge *http.MaxBytesError
 		if errors.As(err, &tooLarge) {
-			return NewError(http.StatusRequestEntityTooLarge, ErrCodeTooLarge, "Request body too large")
+			return false, NewError(http.StatusRequestEntityTooLarge, ErrCodeTooLarge, "Request body too large")
 		}
-		return NotJSON()
+		return false, NotJSON()
 	}
-	if len(data) == 0 {
-		return NotJSON()
+	if len(bytes.TrimSpace(data)) == 0 {
+		return false, nil
 	}
 	if err := json.Unmarshal(data, v); err != nil {
 		var typeErr *json.UnmarshalTypeError
 		if errors.As(err, &typeErr) {
-			return BadJSON("Invalid value for field %q", typeErr.Field)
+			return false, BadJSON("Invalid value for field %q", typeErr.Field)
 		}
-		return NotJSON()
+		return false, NotJSON()
 	}
-	return nil
+	return true, nil
 }
 
 // Handler is an http.Handler whose errors are turned into Matrix envelopes by