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/setup/phase1_test.go

@@ -0,0 +1,169 @@
+package setup_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/dariuszjaniak/warp/server/internal/config"
+	"github.com/dariuszjaniak/warp/server/internal/setup"
+	"github.com/dariuszjaniak/warp/server/internal/userapi"
+)
+
+// post sends a JSON body through the fully wrapped handler.
+func post(t *testing.T, srv *setup.Server, path string, body any, token string) *httptest.ResponseRecorder {
+	t.Helper()
+
+	raw, err := json.Marshal(body)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req := httptest.NewRequest(http.MethodPost, path, bytes.NewReader(raw))
+	req.Header.Set("Content-Type", "application/json")
+	if token != "" {
+		req.Header.Set("Authorization", "Bearer "+token)
+	}
+	rec := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(rec, req)
+	return rec
+}
+
+// getWithToken is `get` plus an access token.
+func getWithToken(t *testing.T, srv *setup.Server, path, token string) *httptest.ResponseRecorder {
+	t.Helper()
+	req := httptest.NewRequest(http.MethodGet, path, nil)
+	req.Header.Set("Authorization", "Bearer "+token)
+	rec := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(rec, req)
+	return rec
+}
+
+// TestClientAPIIsWiredUp walks a client's first minutes through the whole
+// stack — middleware, router, metrics, components — rather than through a
+// hand-built router, which is what the per-package tests use. It is here to
+// catch a route that was written but never registered.
+func TestClientAPIIsWiredUp(t *testing.T) {
+	srv := newTestServer(t, func(c *config.Config) {
+		c.Registration.Enabled = true
+		// The limiter keys on the client address, and every httptest
+		// request comes from the same one.
+		c.ClientAPI.RateLimit.Enabled = false
+	})
+
+	rec := post(t, srv, "/_matrix/client/v3/register",
+		map[string]any{"username": "alice", "password": "sUp3rs3kr1t"}, "")
+	if rec.Code != http.StatusUnauthorized {
+		t.Fatalf("register status = %d, want 401 (body: %s)", rec.Code, rec.Body.String())
+	}
+	session := decode[map[string]any](t, rec)["session"]
+
+	rec = post(t, srv, "/_matrix/client/v3/register", map[string]any{
+		"username": "alice",
+		"password": "sUp3rs3kr1t",
+		"auth":     map[string]any{"type": "m.login.dummy", "session": session},
+	}, "")
+	if rec.Code != http.StatusOK {
+		t.Fatalf("register status = %d, want 200 (body: %s)", rec.Code, rec.Body.String())
+	}
+	registered := decode[map[string]any](t, rec)
+	token, _ := registered["access_token"].(string)
+	if token == "" {
+		t.Fatalf("registration returned no access token: %s", rec.Body.String())
+	}
+
+	for _, path := range []string{
+		"/_matrix/client/v3/account/whoami",
+		"/_matrix/client/v3/capabilities",
+		"/_matrix/client/v3/devices",
+		"/_matrix/client/v3/sync",
+	} {
+		if rec := getWithToken(t, srv, path, token); rec.Code != http.StatusOK {
+			t.Errorf("GET %s = %d, want 200 (body: %s)", path, rec.Code, rec.Body.String())
+		}
+	}
+
+	// Profiles are reachable without a token.
+	if rec := get(t, srv, http.MethodGet, "/_matrix/client/v3/profile/@alice:warp.example"); rec.Code != http.StatusOK {
+		t.Errorf("GET /profile = %d, want 200 (body: %s)", rec.Code, rec.Body.String())
+	}
+
+	rec = post(t, srv, "/_matrix/client/v3/login", map[string]any{
+		"type":       "m.login.password",
+		"identifier": map[string]any{"type": "m.id.user", "user": "alice"},
+		"password":   "sUp3rs3kr1t",
+	}, "")
+	if rec.Code != http.StatusOK {
+		t.Fatalf("login status = %d, want 200 (body: %s)", rec.Code, rec.Body.String())
+	}
+}
+
+// TestAdminAPIIsWiredUp does the same for /_warp/admin/v1, and checks the
+// one thing only the full stack can show: that the admin routes are labelled
+// for the metrics like any other.
+func TestAdminAPIIsWiredUp(t *testing.T) {
+	srv := newTestServer(t, func(c *config.Config) { c.Metrics.Enabled = true })
+
+	account, err := srv.Users().CreateAccount(t.Context(), userapi.NewAccountRequest{
+		Localpart: "root",
+		Password:  "sUp3rs3kr1t",
+		Admin:     true,
+	})
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+	session, err := srv.Users().CreateSession(t.Context(), userapi.SessionRequest{
+		Localpart: account.Localpart,
+	})
+	if err != nil {
+		t.Fatalf("CreateSession: %v", err)
+	}
+
+	rec := getWithToken(t, srv, "/_warp/admin/v1/stats", session.AccessToken)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("GET /stats = %d, want 200 (body: %s)", rec.Code, rec.Body.String())
+	}
+	if got := decode[map[string]any](t, rec)["server_name"]; got != "warp.example" {
+		t.Errorf("server_name = %v", got)
+	}
+
+	// Flipping federation through the admin API must take effect on the
+	// gate, with no restart: PLAN.md section 3.
+	if rec := get(t, srv, http.MethodGet, "/.well-known/matrix/server"); rec.Code != http.StatusNotFound {
+		t.Fatalf("with federation off, /.well-known/matrix/server = %d, want 404", rec.Code)
+	}
+
+	req := httptest.NewRequest(http.MethodPut, "/_warp/admin/v1/federation",
+		bytes.NewReader([]byte(`{"enabled":true}`)))
+	req.Header.Set("Authorization", "Bearer "+session.AccessToken)
+	rec = httptest.NewRecorder()
+	srv.Handler().ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("PUT /federation = %d, want 200 (body: %s)", rec.Code, rec.Body.String())
+	}
+	if !srv.Settings().FederationEnabled() {
+		t.Error("the federation switch did not take effect")
+	}
+
+	metrics := get(t, srv, http.MethodGet, "/metrics").Body.String()
+	if !strings.Contains(metrics, `route="GET /_warp/admin/v1/stats"`) {
+		t.Error("admin routes are not labelled in the metrics")
+	}
+}
+
+// TestRegistrationIsOffByDefault is the posture a new install starts in:
+// private, with no way in until the operator opens one.
+func TestRegistrationIsOffByDefault(t *testing.T) {
+	srv := newTestServer(t, nil)
+
+	rec := post(t, srv, "/_matrix/client/v3/register",
+		map[string]any{"username": "alice", "password": "sUp3rs3kr1t"}, "")
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("status = %d, want 403 with registration off (body: %s)", rec.Code, rec.Body.String())
+	}
+	if code := decode[map[string]string](t, rec)["errcode"]; code != "M_FORBIDDEN" {
+		t.Errorf("errcode = %q, want M_FORBIDDEN", code)
+	}
+}

server/internal/setup/routes.go

@@ -11,9 +11,10 @@ import (
 // SpecVersions is what GET /_matrix/client/versions reports.
 //
 // Keep it honest: a version belongs here once the endpoints a client
-// actually uses from it work. Phase 0 serves only /versions and
-// /.well-known, so the list stays minimal and grows as the C-S API lands in
-// Phases 1 to 4.
+// actually uses from it work. Phase 1 adds accounts, sessions, devices,
+// profiles and account data; rooms and /sync are still missing, so the list
+// is a promise about the identity half of the API only and grows as
+// Phases 3 and 4 land.
 var SpecVersions = []string{"v1.13", "v1.14"}
 
 // UnstableFeatures advertises MSC support. Simplified Sliding Sync
@@ -46,7 +47,7 @@ type healthResponse struct {
 	Error    string `json:"error,omitempty"`
 }
 
-// routes registers every endpoint Phase 0 serves.
+// routes registers every endpoint this server serves.
 func (s *Server) routes() *httputil.Router {
 	r := httputil.NewRouter(s.metrics.Instrument)
 
@@ -57,6 +58,9 @@ func (s *Server) routes() *httputil.Router {
 	// surface, so it goes through the gate and disappears with it.
 	r.Handle("GET /.well-known/matrix/server", s.federation.ProtectFunc(s.handleWellKnownServer))
 
+	s.clientAPI.RegisterRoutes(r)
+	s.adminAPI.RegisterRoutes(r)
+
 	r.HandleFunc("GET /healthz", s.handleHealth)
 	if s.cfg.Metrics.Enabled {
 		r.Handle("GET "+s.cfg.Metrics.Path, s.metrics.Handler())

server/internal/setup/server.go

@@ -13,7 +13,9 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/dariuszjaniak/warp/server/internal/adminapi"
 	"github.com/dariuszjaniak/warp/server/internal/buildinfo"
+	"github.com/dariuszjaniak/warp/server/internal/clientapi"
 	"github.com/dariuszjaniak/warp/server/internal/config"
 	"github.com/dariuszjaniak/warp/server/internal/federation"
 	"github.com/dariuszjaniak/warp/server/internal/httputil"
@@ -22,6 +24,7 @@ import (
 	"github.com/dariuszjaniak/warp/server/internal/settings"
 	"github.com/dariuszjaniak/warp/server/internal/storage"
 	_ "github.com/dariuszjaniak/warp/server/internal/storage/drivers" // link in the storage drivers
+	"github.com/dariuszjaniak/warp/server/internal/userapi"
 )
 
 // Server is a configured, not yet listening homeserver.
@@ -35,6 +38,10 @@ type Server struct {
 	federation *federation.Gate
 	signingKey *signing.KeyPair
 
+	users     *userapi.API
+	clientAPI *clientapi.ClientAPI
+	adminAPI  *adminapi.AdminAPI
+
 	handler http.Handler
 
 	// addr is the address Run is listening on; empty until then.
@@ -123,6 +130,47 @@ func New(ctx context.Context, cfg *config.Config, opts Options) (*Server, error)
 		log.Info("federation switch applied", "enabled", snap.FederationEnabled)
 	})
 
+	s.users, err = userapi.New(userapi.Options{
+		ServerName:           cfg.Global.ServerName,
+		Store:                s.db.Users(),
+		AccessTokenLifetime:  cfg.ClientAPI.AccessTokenLifetime,
+		RefreshTokenLifetime: cfg.ClientAPI.RefreshTokenLifetime,
+		Logger:               log,
+	})
+	if err != nil {
+		_ = s.closeDB()
+		return nil, err
+	}
+
+	s.clientAPI, err = clientapi.New(clientapi.Options{
+		ServerName:         cfg.Global.ServerName,
+		ClientBaseURL:      cfg.ClientBaseURL(),
+		Users:              s.users,
+		Settings:           settingsService,
+		Federation:         s.federation,
+		Registration:       cfg.Registration,
+		RateLimit:          cfg.ClientAPI.RateLimit,
+		TrustXForwardedFor: cfg.ClientAPI.TrustXForwardedFor,
+		Logger:             log,
+	})
+	if err != nil {
+		_ = s.closeDB()
+		return nil, err
+	}
+
+	s.adminAPI, err = adminapi.New(adminapi.Options{
+		ServerName: cfg.Global.ServerName,
+		Users:      s.users,
+		Settings:   settingsService,
+		Federation: s.federation,
+		Database:   s.db,
+		Logger:     log,
+	})
+	if err != nil {
+		_ = s.closeDB()
+		return nil, err
+	}
+
 	s.handler = httputil.Chain(s.routes(),
 		httputil.Recoverer,
 		httputil.RequestLogger(log),
@@ -170,6 +218,10 @@ func (s *Server) Settings() *settings.Service { return s.settings }
 // Database exposes the storage handle.
 func (s *Server) Database() storage.Database { return s.db }
 
+// Users exposes the userapi component, which `warp create-account` and the
+// tests use to create accounts without going through HTTP.
+func (s *Server) Users() *userapi.API { return s.users }
+
 // SigningKey returns the server signing key, or nil when it was skipped.
 func (s *Server) SigningKey() *signing.KeyPair { return s.signingKey }