Phase 0: bootstrap the Warp homeserver

Scaffolds the server module and everything Phase 0 of PLAN.md calls for:
a binary that boots, serves its discovery endpoints and nothing else yet.

- config: one YAML file plus per-field WARP_* environment overrides,
  unknown fields rejected, validation that reports every problem at once
- logging and metrics: slog, a Prometheus registry, per-route HTTP
  instrumentation labelled by pattern rather than path
- httputil: the Matrix error envelope, error-returning handlers, CORS,
  request logging, panic recovery, and a router over http.ServeMux
- endpoints: /_matrix/client/versions, /.well-known/matrix/client,
  /.well-known/matrix/server (gated), /healthz, /metrics, and
  M_UNRECOGNIZED for everything else
- storage: driver registry, shared database/sql base, checksummed
  migration runner, sqlite and postgres drivers, pocketbase stub
- settings: server_settings table behind a cached service, so the
  federation and registration switches change without a restart
- federation: the gate that makes federation a runtime mode
- cmd/warp: serve, migrate, generate-keys, version
- Makefile, golangci-lint v2, GitHub Actions CI (Linux and Windows tests,
  race on Linux, storage tests against PostgreSQL, lint, boot smoke test),
  Dockerfile, example config and docs

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

server/internal/storage/sqlstore/settings.go

@@ -0,0 +1,89 @@
+package sqlstore
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"time"
+)
+
+// SettingsQueries are the four statements the settings store needs. Each
+// driver writes them in its own placeholder style and upsert syntax.
+type SettingsQueries struct {
+	// Get binds (key) and selects setting_value.
+	Get string
+
+	// GetAll selects (setting_key, setting_value).
+	GetAll string
+
+	// Upsert binds (key, value, updated_at) and overwrites on conflict.
+	Upsert string
+
+	// Delete binds (key).
+	Delete string
+}
+
+// Settings is the server_settings key/value store. It is the persistence
+// behind the runtime federation and registration switches; the in-memory
+// cache lives one layer up, in the settings service.
+type Settings struct {
+	db *sql.DB
+	q  SettingsQueries
+}
+
+// NewSettings builds a settings store.
+func NewSettings(db *sql.DB, q SettingsQueries) *Settings {
+	return &Settings{db: db, q: q}
+}
+
+// Get returns the stored value for key; the boolean reports presence.
+func (s *Settings) Get(ctx context.Context, key string) (string, bool, error) {
+	var value string
+	err := s.db.QueryRowContext(ctx, s.q.Get, key).Scan(&value)
+	switch {
+	case errors.Is(err, sql.ErrNoRows):
+		return "", false, nil
+	case err != nil:
+		return "", false, fmt.Errorf("get setting %q: %w", key, err)
+	}
+	return value, true, nil
+}
+
+// GetAll returns every stored setting.
+func (s *Settings) GetAll(ctx context.Context) (map[string]string, error) {
+	rows, err := s.db.QueryContext(ctx, s.q.GetAll)
+	if err != nil {
+		return nil, fmt.Errorf("list settings: %w", err)
+	}
+	defer rows.Close()
+
+	out := map[string]string{}
+	for rows.Next() {
+		var k, v string
+		if err := rows.Scan(&k, &v); err != nil {
+			return nil, fmt.Errorf("scan setting: %w", err)
+		}
+		out[k] = v
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("list settings: %w", err)
+	}
+	return out, nil
+}
+
+// Set writes key, overwriting any previous value.
+func (s *Settings) Set(ctx context.Context, key, value string) error {
+	if _, err := s.db.ExecContext(ctx, s.q.Upsert, key, value, time.Now().UTC()); err != nil {
+		return fmt.Errorf("set setting %q: %w", key, err)
+	}
+	return nil
+}
+
+// Delete removes key. Removing an absent key is not an error.
+func (s *Settings) Delete(ctx context.Context, key string) error {
+	if _, err := s.db.ExecContext(ctx, s.q.Delete, key); err != nil {
+		return fmt.Errorf("delete setting %q: %w", key, err)
+	}
+	return nil
+}

server/internal/storage/sqlstore/sqlstore.go

@@ -0,0 +1,124 @@
+// Package sqlstore holds the parts of a storage driver that are identical
+// for every database/sql backend: the migration plumbing and the
+// server_settings table. The sqlite and postgres drivers differ only in
+// their DSN handling, placeholder style and upsert syntax, all of which
+// they pass in here.
+package sqlstore
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"io/fs"
+	"log/slog"
+
+	"github.com/dariuszjaniak/warp/server/internal/storage"
+	"github.com/dariuszjaniak/warp/server/internal/storage/migrations"
+)
+
+// Options describe one database/sql backend.
+type Options struct {
+	// DriverName is the Warp driver name, e.g. "sqlite".
+	DriverName string
+
+	// DB is the already-opened pool.
+	DB *sql.DB
+
+	// Dialect supplies the migration bookkeeping statements.
+	Dialect migrations.Dialect
+
+	// MigrationsFS and MigrationsDir locate the embedded .sql files.
+	MigrationsFS  fs.FS
+	MigrationsDir string
+
+	// Settings holds the statements for the server_settings table.
+	Settings SettingsQueries
+
+	// Logger is used for migration progress.
+	Logger *slog.Logger
+}
+
+// Store is the shared implementation of storage.Database. Drivers embed it
+// and add their own component stores as those are built.
+type Store struct {
+	opts     Options
+	db       *sql.DB
+	log      *slog.Logger
+	settings *Settings
+}
+
+// New builds a Store. It does not touch the database.
+func New(opts Options) (*Store, error) {
+	if opts.DB == nil {
+		return nil, errors.New("sqlstore: DB must not be nil")
+	}
+	if opts.Logger == nil {
+		opts.Logger = slog.Default()
+	}
+	return &Store{
+		opts:     opts,
+		db:       opts.DB,
+		log:      opts.Logger,
+		settings: NewSettings(opts.DB, opts.Settings),
+	}, nil
+}
+
+// DB exposes the pool for driver-specific code and tests.
+func (s *Store) DB() *sql.DB { return s.db }
+
+// Driver implements storage.Database.
+func (s *Store) Driver() string { return s.opts.DriverName }
+
+// Ping implements storage.Database.
+func (s *Store) Ping(ctx context.Context) error { return s.db.PingContext(ctx) }
+
+// Close implements storage.Database.
+func (s *Store) Close() error { return s.db.Close() }
+
+// Settings implements storage.Database.
+func (s *Store) Settings() storage.SettingsStore { return s.settings }
+
+// Migrate implements storage.Database.
+func (s *Store) Migrate(ctx context.Context) error {
+	ms, err := s.migrations()
+	if err != nil {
+		return err
+	}
+	applied, err := migrations.Status(ctx, s.db, s.opts.Dialect)
+	if err != nil {
+		return err
+	}
+	if err := migrations.CheckNotAhead(applied, ms); err != nil {
+		return err
+	}
+	n, err := migrations.Run(ctx, s.db, s.opts.Dialect, ms, s.log)
+	if err != nil {
+		return err
+	}
+	if n == 0 {
+		s.log.Debug("database schema is up to date", "migrations", len(ms))
+	}
+	return nil
+}
+
+// PendingMigrations implements storage.Database.
+func (s *Store) PendingMigrations(ctx context.Context) ([]string, error) {
+	ms, err := s.migrations()
+	if err != nil {
+		return nil, err
+	}
+	pending, err := migrations.Pending(ctx, s.db, s.opts.Dialect, ms)
+	if err != nil {
+		return nil, err
+	}
+	out := make([]string, 0, len(pending))
+	for _, m := range pending {
+		out = append(out, fmt.Sprintf("%04d_%s", m.Version, m.Name))
+	}
+	return out, nil
+}
+
+func (s *Store) migrations() ([]migrations.Migration, error) {
+	return migrations.Load(s.opts.MigrationsFS, s.opts.MigrationsDir)
+}