Add httpserver package: TLS HTTP server with chi

- Server wrapping chi.Mux + http.Server with TLS 1.3 minimum
- ListenAndServeTLS and graceful Shutdown
- LoggingMiddleware (method, path, status, duration, remote)
- StatusWriter for status code capture in middleware
- WriteJSON and WriteError helpers
- 8 tests

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

httpserver/server.go

@@ -0,0 +1,121 @@
+// Package httpserver provides TLS HTTP server setup with chi, standard
+// middleware, and graceful shutdown for Metacircular services.
+package httpserver
+
+import (
+	"context"
+	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+
+	"git.wntrmute.dev/kyle/mcdsl/config"
+)
+
+// Server wraps a chi router and an http.Server with the standard
+// Metacircular TLS configuration.
+type Server struct {
+	// Router is the chi router. Services register their routes on it.
+	Router *chi.Mux
+
+	// Logger is used by the logging middleware.
+	Logger *slog.Logger
+
+	httpSrv *http.Server
+	cfg     config.ServerConfig
+}
+
+// New creates a Server configured from cfg. The underlying http.Server
+// is configured with TLS 1.3 minimum and timeouts from the config.
+// Services access s.Router to register routes before calling
+// ListenAndServeTLS.
+func New(cfg config.ServerConfig, logger *slog.Logger) *Server {
+	r := chi.NewRouter()
+
+	s := &Server{
+		Router: r,
+		Logger: logger,
+		cfg:    cfg,
+	}
+
+	s.httpSrv = &http.Server{
+		Addr:    cfg.ListenAddr,
+		Handler: r,
+		TLSConfig: &tls.Config{
+			MinVersion: tls.VersionTLS13,
+		},
+		ReadTimeout:  cfg.ReadTimeout.Duration,
+		WriteTimeout: cfg.WriteTimeout.Duration,
+		IdleTimeout:  cfg.IdleTimeout.Duration,
+	}
+
+	return s
+}
+
+// ListenAndServeTLS starts the HTTPS server using the TLS certificate and
+// key from the config. It blocks until the server is shut down. Returns
+// nil if the server was shut down gracefully via [Server.Shutdown].
+func (s *Server) ListenAndServeTLS() error {
+	s.Logger.Info("starting server", "addr", s.cfg.ListenAddr)
+	err := s.httpSrv.ListenAndServeTLS(s.cfg.TLSCert, s.cfg.TLSKey)
+	if err != nil && err != http.ErrServerClosed {
+		return fmt.Errorf("httpserver: %w", err)
+	}
+	return nil
+}
+
+// Shutdown gracefully shuts down the server, waiting for in-flight
+// requests to complete. The provided context controls the shutdown
+// timeout.
+func (s *Server) Shutdown(ctx context.Context) error {
+	return s.httpSrv.Shutdown(ctx)
+}
+
+// LoggingMiddleware logs each HTTP request after it completes, including
+// method, path, status code, duration, and remote address.
+func (s *Server) LoggingMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		start := time.Now()
+		sw := &StatusWriter{ResponseWriter: w, Status: http.StatusOK}
+		next.ServeHTTP(sw, r)
+		s.Logger.Info("http",
+			"method", r.Method,
+			"path", r.URL.Path,
+			"status", sw.Status,
+			"duration", time.Since(start),
+			"remote", r.RemoteAddr,
+		)
+	})
+}
+
+// StatusWriter wraps an http.ResponseWriter to capture the status code.
+// It is exported for use in custom middleware.
+type StatusWriter struct {
+	http.ResponseWriter
+	// Status is the HTTP status code written to the response.
+	Status int
+}
+
+// WriteHeader captures the status code and delegates to the underlying
+// ResponseWriter.
+func (w *StatusWriter) WriteHeader(code int) {
+	w.Status = code
+	w.ResponseWriter.WriteHeader(code)
+}
+
+// WriteJSON writes v as JSON with the given HTTP status code.
+func WriteJSON(w http.ResponseWriter, status int, v any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(v)
+}
+
+// WriteError writes a standard Metacircular error response:
+// {"error": "message"}.
+func WriteError(w http.ResponseWriter, status int, message string) {
+	WriteJSON(w, status, map[string]string{"error": message})
+}