@@ -1,6 +1,7 @@
-package main
+package server
 
 import (
+	"context"
 	"fmt"
 	"io"
 	"log"
@@ -9,6 +10,8 @@ "mime"
 	"net"
 	"net/http"
 	"os"
+	"path"
+	"slices"
 	"strings"
 	"time"
 
@@ -16,15 +19,29 @@ cfg "website/internal/config"
 
 	"github.com/getsentry/sentry-go"
 	sentryhttp "github.com/getsentry/sentry-go/http"
+	"github.com/pkg/errors"
 	"github.com/shengyanli1982/law"
 )
 
 var config *cfg.Config
 
+type Config struct {
+	Production    bool    `conf:"default:false"`
+	InDevServer   bool    `conf:"default:false"`
+	Root          string  `conf:"default:website"`
+	ListenAddress string  `conf:"default:localhost"`
+	Port          string  `conf:"default:3000,short:p"`
+	BaseURL       cfg.URL `conf:"default:http://localhost:3000,short:b"`
+}
+
 type HTTPError struct {
 	Error   error
 	Message string
 	Code    int
+}
+
+type Server struct {
+	*http.Server
 }
 
 func canonicalisePath(path string) (cPath string, differs bool) {
@@ -52,6 +69,7 @@ }
 	}
 	w.Header().Add("ETag", file.etag)
 	w.Header().Add("Vary", "Accept-Encoding")
+	w.Header().Add("Content-Security-Policy", config.CSP.String())
 	for k, v := range config.Extra.Headers {
 		w.Header().Add(k, v)
 	}
@@ -93,20 +111,28 @@ }
 	}
 }
 
-func startServer(runtimeConfig *Config) {
+func applyDevModeOverrides(config *cfg.Config) {
+	config.CSP.ScriptSrc = slices.Insert(config.CSP.ScriptSrc, 0, "'unsafe-inline'")
+	config.CSP.ConnectSrc = slices.Insert(config.CSP.ConnectSrc, 0, "'self'")
+}
+
+func New(runtimeConfig *Config) (*Server, error) {
 	fixupMIMETypes()
 
-	c, err := cfg.GetConfig()
+	var err error
+	config, err = cfg.GetConfig()
 	if err != nil {
-		log.Panicf("parsing configuration file: %v", err)
+		return nil, errors.WithMessage(err, "error parsing configuration file")
+	}
+	if runtimeConfig.InDevServer {
+		applyDevModeOverrides(config)
 	}
-	config = c
 
-	prefix := "website/public"
+	prefix := path.Join(runtimeConfig.Root, "public")
 	slog.Debug("registering content files", "prefix", prefix)
 	err = registerContentFiles(prefix)
 	if err != nil {
-		log.Panicf("registering content files: %v", err)
+		return nil, errors.WithMessagef(err, "registering content files")
 	}
 
 	env := "development"
@@ -121,13 +147,14 @@ Release:          CommitSHA,
 		Environment:      env,
 	})
 	if err != nil {
-		log.Panic("could not set up sentry")
+		return nil, errors.WithMessage(err, "could not set up sentry")
 	}
 	defer sentry.Flush(2 * time.Second)
 	sentryHandler := sentryhttp.New(sentryhttp.Options{
 		Repanic: true,
 	})
 
+	top := http.NewServeMux()
 	mux := http.NewServeMux()
 	slog.Debug("binding main handler to", "host", runtimeConfig.BaseURL.Hostname()+"/")
 	mux.Handle(runtimeConfig.BaseURL.Hostname()+"/", webHandler(serveFile))
@@ -143,7 +170,7 @@ logWriter = law.NewWriteAsyncer(os.Stdout, nil)
 	} else {
 		logWriter = os.Stdout
 	}
-	http.Handle("/",
+	top.Handle("/",
 		sentryHandler.Handle(
 			wrapHandlerWithLogging(mux, wrappedHandlerOptions{
 				defaultHostname: runtimeConfig.BaseURL.Hostname(),
@@ -152,10 +179,43 @@ }),
 		),
 	)
 	// no logging, no sentry
-	http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
+	top.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
 
-	listenAddress := net.JoinHostPort(runtimeConfig.ListenAddress, fmt.Sprint(runtimeConfig.Port))
-	log.Fatal(http.ListenAndServe(listenAddress, nil))
+	listenAddress := net.JoinHostPort(runtimeConfig.ListenAddress, runtimeConfig.Port)
+	return &Server{
+		&http.Server{
+			Addr:    listenAddress,
+			Handler: top,
+		},
+	}, nil
+}
+
+func (s *Server) Start() error {
+	if err := s.ListenAndServe(); err != http.ErrServerClosed {
+		return err
+	}
+	return nil
+}
+
+func (s *Server) Stop() chan struct{} {
+	slog.Debug("stop called")
+
+	idleConnsClosed := make(chan struct{})
+
+	go func() {
+		slog.Debug("shutting down server")
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+		err := s.Server.Shutdown(ctx)
+		slog.Debug("server shut down")
+		if err != nil {
+			// Error from closing listeners, or context timeout:
+			log.Printf("HTTP server Shutdown: %v", err)
+		}
+		close(idleConnsClosed)
+	}()
+
+	return idleConnsClosed
 }