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

@@ -0,0 +1,44 @@
+package postgres
+
+import (
+	"errors"
+	"strconv"
+	"strings"
+
+	"github.com/jackc/pgx/v5/pgconn"
+)
+
+// uniqueViolation is the SQLSTATE class PostgreSQL raises for a duplicate
+// key, whichever constraint caught it.
+const uniqueViolation = "23505"
+
+// isUniqueViolation reports whether err is PostgreSQL complaining about a
+// duplicate key.
+func isUniqueViolation(err error) bool {
+	var pgErr *pgconn.PgError
+	return errors.As(err, &pgErr) && pgErr.Code == uniqueViolation
+}
+
+// rebind turns the `?` placeholders the shared component stores are written
+// with into PostgreSQL's numbered form. It is a straight scan rather than a
+// SQL parser, which is safe because the statements it sees are constants in
+// this repository: none of them contains a `?` inside a string literal, and
+// none is built from user input beyond a run of placeholders.
+func rebind(query string) string {
+	if !strings.Contains(query, "?") {
+		return query
+	}
+	var b strings.Builder
+	b.Grow(len(query) + 8)
+	n := 0
+	for i := range len(query) {
+		if query[i] != '?' {
+			b.WriteByte(query[i])
+			continue
+		}
+		n++
+		b.WriteByte('$')
+		b.WriteString(strconv.Itoa(n))
+	}
+	return b.String()
+}

server/internal/storage/postgres/errors_test.go

@@ -0,0 +1,51 @@
+package postgres
+
+import "testing"
+
+// TestRebind covers the translation the shared component stores depend on.
+// It runs without a database, which matters: it is the one part of the
+// PostgreSQL driver that can be tested on a machine without PostgreSQL, and
+// a mistake here breaks every statement at once.
+func TestRebind(t *testing.T) {
+	for name, tc := range map[string]struct{ in, want string }{
+		"no placeholders": {
+			in:   `SELECT COUNT(*) FROM user_accounts`,
+			want: `SELECT COUNT(*) FROM user_accounts`,
+		},
+		"one placeholder": {
+			in:   `SELECT password_hash FROM user_accounts WHERE localpart = ?`,
+			want: `SELECT password_hash FROM user_accounts WHERE localpart = $1`,
+		},
+		"numbered in order": {
+			in:   `INSERT INTO user_accounts (localpart, admin) VALUES (?, ?)`,
+			want: `INSERT INTO user_accounts (localpart, admin) VALUES ($1, $2)`,
+		},
+		"past nine": {
+			in:   `VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			want: `VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`,
+		},
+		"leaves the escape clause alone": {
+			in:   `WHERE localpart LIKE ? ESCAPE '!'`,
+			want: `WHERE localpart LIKE $1 ESCAPE '!'`,
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			if got := rebind(tc.in); got != tc.want {
+				t.Errorf("rebind(%q) = %q, want %q", tc.in, got, tc.want)
+			}
+		})
+	}
+}
+
+func TestIsUniqueViolationIgnoresOtherErrors(t *testing.T) {
+	if isUniqueViolation(nil) {
+		t.Error("nil is not a unique violation")
+	}
+	if isUniqueViolation(errOther{}) {
+		t.Error("an unrelated error was reported as a unique violation")
+	}
+}
+
+type errOther struct{}
+
+func (errOther) Error() string { return "something else went wrong" }

server/internal/storage/postgres/migrations/0002_userapi.sql

@@ -0,0 +1,69 @@
+-- Accounts, devices, tokens and account data: the userapi tables.
+--
+-- Timestamps are milliseconds since the Unix epoch, the unit the
+-- Client-Server API uses on the wire, so values go in and out unconverted
+-- and both SQL drivers store the same numbers.
+--
+-- Tokens are stored as SHA-256 hashes, never in the clear: they are bearer
+-- credentials that by default never expire, and one hash per request is
+-- cheap next to what a leaked database dump would otherwise hand over.
+
+CREATE TABLE IF NOT EXISTS user_accounts (
+    localpart     TEXT    NOT NULL PRIMARY KEY,
+    -- An empty hash means the account has no password and cannot use
+    -- m.login.password; it is not a hash that anything can match.
+    password_hash TEXT    NOT NULL DEFAULT '',
+    display_name  TEXT    NOT NULL DEFAULT '',
+    avatar_url    TEXT    NOT NULL DEFAULT '',
+    admin         BOOLEAN NOT NULL DEFAULT FALSE,
+    deactivated   BOOLEAN NOT NULL DEFAULT FALSE,
+    created_at_ms BIGINT  NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS user_devices (
+    localpart     TEXT   NOT NULL REFERENCES user_accounts (localpart) ON DELETE CASCADE,
+    device_id     TEXT   NOT NULL,
+    display_name  TEXT   NOT NULL DEFAULT '',
+    created_at_ms BIGINT NOT NULL,
+    last_seen_ms  BIGINT NOT NULL DEFAULT 0,
+    last_seen_ip  TEXT   NOT NULL DEFAULT '',
+    user_agent    TEXT   NOT NULL DEFAULT '',
+    PRIMARY KEY (localpart, device_id)
+);
+
+CREATE TABLE IF NOT EXISTS user_access_tokens (
+    token_hash    TEXT   NOT NULL PRIMARY KEY,
+    localpart     TEXT   NOT NULL,
+    device_id     TEXT   NOT NULL,
+    created_at_ms BIGINT NOT NULL,
+    -- 0 means the token never expires.
+    expires_at_ms BIGINT NOT NULL DEFAULT 0,
+    FOREIGN KEY (localpart, device_id)
+        REFERENCES user_devices (localpart, device_id) ON DELETE CASCADE
+);
+
+-- Revoking a device deletes its tokens by this index, not by table scan.
+CREATE INDEX IF NOT EXISTS user_access_tokens_device_idx
+    ON user_access_tokens (localpart, device_id);
+
+CREATE TABLE IF NOT EXISTS user_refresh_tokens (
+    token_hash    TEXT   NOT NULL PRIMARY KEY,
+    localpart     TEXT   NOT NULL,
+    device_id     TEXT   NOT NULL,
+    created_at_ms BIGINT NOT NULL,
+    expires_at_ms BIGINT NOT NULL DEFAULT 0,
+    FOREIGN KEY (localpart, device_id)
+        REFERENCES user_devices (localpart, device_id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS user_refresh_tokens_device_idx
+    ON user_refresh_tokens (localpart, device_id);
+
+CREATE TABLE IF NOT EXISTS user_account_data (
+    localpart TEXT NOT NULL REFERENCES user_accounts (localpart) ON DELETE CASCADE,
+    -- Empty for global account data; a room ID for per-room account data.
+    room_id   TEXT NOT NULL DEFAULT '',
+    data_type TEXT NOT NULL,
+    content   TEXT NOT NULL,
+    PRIMARY KEY (localpart, room_id, data_type)
+);

server/internal/storage/postgres/postgres.go

@@ -69,13 +69,15 @@ func Open(ctx context.Context, cfg storage.Config, log *slog.Logger) (storage.Da
 	}
 
 	store, err := sqlstore.New(sqlstore.Options{
-		DriverName:    storage.DriverPostgres,
-		DB:            db,
-		Dialect:       dialect,
-		MigrationsFS:  migrationFiles,
-		MigrationsDir: "migrations",
-		Settings:      settingsQueries,
-		Logger:        log,
+		DriverName:        storage.DriverPostgres,
+		DB:                db,
+		Dialect:           dialect,
+		MigrationsFS:      migrationFiles,
+		MigrationsDir:     "migrations",
+		Settings:          settingsQueries,
+		Rebind:            rebind,
+		IsUniqueViolation: isUniqueViolation,
+		Logger:            log,
 	})
 	if err != nil {
 		_ = db.Close()