fa: wire GCWorker startup and shutdown in cmd/mediaplayer/main.go

- Refactor main into run(args) for testability and clean error propagation.
- Create slog.Logger from cfg.LogLevel using TextHandler.
- Instantiate service.NewGCWorker with store, clock, cfg.MediaRoot, and
  time.Duration(cfg.GCIntervalMinutes)*time.Minute.
- Start GCWorker after construction and defer Stop for graceful shutdown.
- Add cmd/mediaplayer/main_test.go as an integration smoke test wiring the
  GCWorker against a real SQLite store.

2 files changed, 85 insertions, 6 deletions

diff --git a/cmd/mediaplayer/main.go b/cmd/mediaplayer/main.go
index cb99869..3419763 100644
--- a/cmd/mediaplayer/main.go
+++ b/cmd/mediaplayer/main.go
@@ -5,6 +5,7 @@ import (
 	"flag"
 	"fmt"
 	"log"
+	"log/slog"
 	"net/http"
 	"os"
 	"os/signal"
@@ -23,22 +24,31 @@ import (
 )
 
 func main() {
-	versionFlag := flag.Bool("version", false, "print version and exit")
-	flag.Parse()
+	if err := run(os.Args[1:]); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func run(args []string) error {
+	fs := flag.NewFlagSet("mediaplayer", flag.ContinueOnError)
+	versionFlag := fs.Bool("version", false, "print version and exit")
+	if err := fs.Parse(args); err != nil {
+		return err
+	}
 
 	if *versionFlag {
 		fmt.Println(internal.Version)
-		os.Exit(0)
+		return nil
 	}
 
 	cfg, err := internal.LoadConfig()
 	if err != nil {
-		log.Fatalf("failed to load config: %v", err)
+		return fmt.Errorf("failed to load config: %w", err)
 	}
 
 	store, err := repository.Open(cfg.DBPath)
 	if err != nil {
-		log.Fatalf("failed to open database: %v", err)
+		return fmt.Errorf("failed to open database: %w", err)
 	}
 	defer func() {
 		if err := store.Close(); err != nil {
@@ -46,6 +56,22 @@ func main() {
 		}
 	}()
 
+	// Build logger aligned with the configured log level.
+	var level slog.Level
+	switch cfg.LogLevel {
+	case "debug":
+		level = slog.LevelDebug
+	case "info":
+		level = slog.LevelInfo
+	case "warn":
+		level = slog.LevelWarn
+	case "error":
+		level = slog.LevelError
+	default:
+		level = slog.LevelInfo
+	}
+	logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: level}))
+
 	clk := clock.RealClock{}
 	hasher := auth.NewBCryptHasher(12)
 	sm := auth.NewSessionManager(store, clk, time.Duration(cfg.SessionTimeoutHours)*time.Hour)
@@ -59,6 +85,11 @@ func main() {
 
 	progressSvc := service.NewProgressService(store, clk)
 
+	// Start the background GC worker that hard-deletes soft-deleted media.
+	gcWorker := service.NewGCWorker(store, clk, cfg.MediaRoot, time.Duration(cfg.GCIntervalMinutes)*time.Minute, logger)
+	gcWorker.Start()
+	defer gcWorker.Stop()
+
 	staticFS := http.Dir("web")
 	server := api.NewServer(store, hasher, sm, cfg, mediaSvc, adminSvc, progressSvc, staticFS)
 
@@ -80,7 +111,8 @@ func main() {
 	shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 	if err := gs.Server.Shutdown(shutdownCtx); err != nil {
-		log.Fatalf("failed to shutdown server: %v", err)
+		return fmt.Errorf("failed to shutdown server: %w", err)
 	}
 	log.Println("server stopped")
+	return nil
 }
diff --git a/cmd/mediaplayer/main_test.go b/cmd/mediaplayer/main_test.go
new file mode 100644
index 0000000..08b9d92
--- /dev/null
+++ b/cmd/mediaplayer/main_test.go
@@ -0,0 +1,47 @@
+package main
+
+import (
+	"log/slog"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"codeberg.org/snonux/play/internal"
+	"codeberg.org/snonux/play/internal/clock"
+	"codeberg.org/snonux/play/internal/repository"
+	"codeberg.org/snonux/play/internal/service"
+)
+
+// TestGCWorkerWiring verifies that the GC worker can be constructed with the
+// same dependencies used in main, started, and stopped cleanly against a real
+// SQLite store. This is an integration-friendly smoke test for the wiring.
+func TestGCWorkerWiring(t *testing.T) {
+	tmpDir := t.TempDir()
+	dbPath := filepath.Join(tmpDir, "test.db")
+	mediaRoot := filepath.Join(tmpDir, "media")
+	if err := os.MkdirAll(mediaRoot, 0o755); err != nil {
+		t.Fatalf("mkdir media root: %v", err)
+	}
+
+	store, err := repository.Open(dbPath)
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	defer func() {
+		if err := store.Close(); err != nil {
+			t.Logf("close db: %v", err)
+		}
+	}()
+
+	cfg := &internal.Config{
+		GCIntervalMinutes: 1,
+	}
+
+	logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelError}))
+	clk := clock.RealClock{}
+
+	w := service.NewGCWorker(store, clk, mediaRoot, time.Duration(cfg.GCIntervalMinutes)*time.Minute, logger)
+	w.Start()
+	w.Stop() // must not panic even after interacting with real store
+}