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/sqlite/sqlite.go

@@ -0,0 +1,136 @@
+// Package sqlite implements the storage interfaces on modernc.org/sqlite,
+// a pure-Go SQLite with no cgo. It is the development and single-user
+// driver; PostgreSQL is the production one.
+package sqlite
+
+import (
+	"context"
+	"database/sql"
+	"embed"
+	"fmt"
+	"log/slog"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+
+	_ "modernc.org/sqlite" // registers the "sqlite" database/sql driver
+
+	"github.com/dariuszjaniak/warp/server/internal/storage"
+	"github.com/dariuszjaniak/warp/server/internal/storage/migrations"
+	"github.com/dariuszjaniak/warp/server/internal/storage/sqlstore"
+)
+
+//go:embed migrations/*.sql
+var migrationFiles embed.FS
+
+func init() {
+	storage.Register(storage.DriverSQLite, Open)
+}
+
+// dialect is the migration bookkeeping for SQLite.
+var dialect = migrations.Dialect{
+	Name: storage.DriverSQLite,
+	CreateTable: `CREATE TABLE IF NOT EXISTS schema_migrations (
+		version    INTEGER PRIMARY KEY,
+		name       TEXT      NOT NULL,
+		checksum   TEXT      NOT NULL,
+		applied_at TIMESTAMP NOT NULL
+	)`,
+	SelectApplied: `SELECT version, name, checksum, applied_at FROM schema_migrations ORDER BY version`,
+	InsertApplied: `INSERT INTO schema_migrations (version, name, checksum, applied_at) VALUES (?, ?, ?, ?)`,
+}
+
+var settingsQueries = sqlstore.SettingsQueries{
+	Get:    `SELECT setting_value FROM server_settings WHERE setting_key = ?`,
+	GetAll: `SELECT setting_key, setting_value FROM server_settings`,
+	Upsert: `INSERT INTO server_settings (setting_key, setting_value, updated_at) VALUES (?, ?, ?)
+		ON CONFLICT (setting_key) DO UPDATE SET setting_value = excluded.setting_value, updated_at = excluded.updated_at`,
+	Delete: `DELETE FROM server_settings WHERE setting_key = ?`,
+}
+
+// Database is the SQLite implementation of storage.Database.
+type Database struct {
+	*sqlstore.Store
+}
+
+// Open connects to the SQLite file named by cfg.ConnectionString.
+//
+// The connection string is a modernc.org/sqlite DSN: "file:warp.db" with
+// optional "_pragma=..." parameters. The parent directory is created if it
+// does not exist, because a missing directory is the single most common
+// first-run failure.
+//
+// Writes are serialised onto one connection: SQLite allows a single writer,
+// and letting database/sql open several write connections turns that into
+// SQLITE_BUSY under concurrency rather than a queue.
+func Open(ctx context.Context, cfg storage.Config, log *slog.Logger) (storage.Database, error) {
+	dsn := cfg.ConnectionString
+	if dsn == "" {
+		return nil, fmt.Errorf("sqlite: connection_string must not be empty")
+	}
+	if err := ensureParentDir(dsn); err != nil {
+		return nil, err
+	}
+
+	db, err := sql.Open("sqlite", dsn)
+	if err != nil {
+		return nil, err
+	}
+	db.SetMaxOpenConns(1)
+	db.SetMaxIdleConns(1)
+	db.SetConnMaxLifetime(cfg.ConnMaxLifetime)
+
+	if err := db.PingContext(ctx); err != nil {
+		_ = db.Close()
+		return nil, fmt.Errorf("sqlite: connect: %w", err)
+	}
+
+	store, err := sqlstore.New(sqlstore.Options{
+		DriverName:    storage.DriverSQLite,
+		DB:            db,
+		Dialect:       dialect,
+		MigrationsFS:  migrationFiles,
+		MigrationsDir: "migrations",
+		Settings:      settingsQueries,
+		Logger:        log,
+	})
+	if err != nil {
+		_ = db.Close()
+		return nil, err
+	}
+	return &Database{Store: store}, nil
+}
+
+// ensureParentDir creates the directory holding the database file. In-memory
+// databases (":memory:" or "mode=memory") have no directory.
+func ensureParentDir(dsn string) error {
+	path := filePathFromDSN(dsn)
+	if path == "" {
+		return nil
+	}
+	dir := filepath.Dir(path)
+	if dir == "" || dir == "." {
+		return nil
+	}
+	if err := os.MkdirAll(dir, 0o750); err != nil {
+		return fmt.Errorf("sqlite: create database directory %s: %w", dir, err)
+	}
+	return nil
+}
+
+// filePathFromDSN extracts the filesystem path from a SQLite DSN, or "" for
+// an in-memory database.
+func filePathFromDSN(dsn string) string {
+	path := strings.TrimPrefix(dsn, "file:")
+	if i := strings.IndexAny(path, "?"); i >= 0 {
+		path = path[:i]
+	}
+	if unescaped, err := url.PathUnescape(path); err == nil {
+		path = unescaped
+	}
+	if path == "" || path == ":memory:" || strings.Contains(dsn, "mode=memory") {
+		return ""
+	}
+	return path
+}