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/userapi/userid.go

@@ -0,0 +1,119 @@
+package userapi
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+// MaxUserIDLength is the spec's cap on a user ID, sigil and server name
+// included.
+const MaxUserIDLength = 255
+
+// Errors from parsing and validating identifiers. Callers map these onto
+// M_INVALID_USERNAME or M_UNKNOWN depending on the endpoint.
+var (
+	// ErrInvalidLocalpart means the localpart is empty, too long, or
+	// contains a character the spec does not allow.
+	ErrInvalidLocalpart = errors.New("invalid user name")
+
+	// ErrInvalidUserID means the string is not a well-formed user ID.
+	ErrInvalidUserID = errors.New("invalid user ID")
+
+	// ErrForeignServer means a well-formed user ID belongs to another
+	// homeserver. Answering for it needs federation.
+	ErrForeignServer = errors.New("user ID belongs to another server")
+)
+
+// NormaliseLocalpart lower-cases a localpart.
+//
+// The spec's grammar for the localpart of a user ID allows only lowercase
+// letters, so a client sending "User-UPPER" is asking for "user-upper"
+// rather than making a mistake. Both registration and login normalise, which
+// is also what Synapse does and what Complement checks.
+func NormaliseLocalpart(localpart string) string {
+	return strings.ToLower(localpart)
+}
+
+// ValidateLocalpart checks a normalised localpart against the user ID
+// grammar of the Client-Server API: lowercase letters, digits, and the
+// characters . _ = - / +.
+//
+// serverName is needed because the 255-byte limit applies to the whole user
+// ID, so how long a localpart may be depends on where it lives.
+func ValidateLocalpart(localpart, serverName string) error {
+	if localpart == "" {
+		return fmt.Errorf("%w: must not be empty", ErrInvalidLocalpart)
+	}
+	if n := len("@" + localpart + ":" + serverName); n > MaxUserIDLength {
+		return fmt.Errorf("%w: the resulting user ID would be %d bytes, the limit is %d",
+			ErrInvalidLocalpart, n, MaxUserIDLength)
+	}
+	for _, r := range localpart {
+		if !isLocalpartRune(r) {
+			return fmt.Errorf("%w: %q is not allowed; use lowercase letters, digits or . _ = - / +",
+				ErrInvalidLocalpart, r)
+		}
+	}
+	return nil
+}
+
+// isLocalpartRune reports whether r may appear in a user ID localpart. The
+// range is deliberately byte-oriented: the grammar is ASCII only, so any
+// multi-byte rune falls through to false.
+func isLocalpartRune(r rune) bool {
+	switch {
+	case r >= 'a' && r <= 'z', r >= '0' && r <= '9':
+		return true
+	case r == '.', r == '_', r == '=', r == '-', r == '/', r == '+':
+		return true
+	default:
+		return false
+	}
+}
+
+// UserID assembles "@localpart:serverName".
+func (a *API) UserID(localpart string) string {
+	return "@" + localpart + ":" + a.serverName
+}
+
+// ParseLocalUserID turns a user identifier into a normalised localpart on
+// this server.
+//
+// It accepts both forms clients send: a full "@user:server" ID and a bare
+// localpart, which the login endpoint has always allowed. A full ID naming
+// another server is ErrForeignServer — a distinct case from a malformed one,
+// because that is the answer federation would change.
+func (a *API) ParseLocalUserID(identifier string) (string, error) {
+	if identifier == "" {
+		return "", fmt.Errorf("%w: must not be empty", ErrInvalidUserID)
+	}
+	if !strings.HasPrefix(identifier, "@") {
+		localpart := NormaliseLocalpart(identifier)
+		if err := ValidateLocalpart(localpart, a.serverName); err != nil {
+			return "", err
+		}
+		return localpart, nil
+	}
+	if len(identifier) > MaxUserIDLength {
+		return "", fmt.Errorf("%w: longer than %d bytes", ErrInvalidUserID, MaxUserIDLength)
+	}
+
+	localpart, serverName, ok := strings.Cut(identifier[1:], ":")
+	if !ok || serverName == "" {
+		return "", fmt.Errorf("%w: expected @localpart:servername", ErrInvalidUserID)
+	}
+	// Server names are compared case-insensitively for the same reason the
+	// federation allowlist is: every real deployment uses a DNS name, and
+	// treating "Warp.example" as somebody else would turn a client's
+	// capitalisation into a login failure.
+	if !strings.EqualFold(serverName, a.serverName) {
+		return "", fmt.Errorf("%w: %s", ErrForeignServer, serverName)
+	}
+
+	localpart = NormaliseLocalpart(localpart)
+	if err := ValidateLocalpart(localpart, a.serverName); err != nil {
+		return "", err
+	}
+	return localpart, nil
+}