RET-10: cors-fuer-ret-06-api

- archive/internal/retentionapi.CORS: erlaubt genau einen konfigurierten
  Origin (kein Wildcard), beantwortet OPTIONS-Preflights direkt
- cmd/retention-api: neue Pflicht-Env NEXARCH_RETENTION_CORS_ALLOWED_ORIGIN,
  mux mit CORS umschlossen
- gefunden durch Sichtpruefung des laufenden RET-06-Frontends: curl
  umgeht CORS, ein echter Browser haette den Fetch blockiert - weder
  Go- noch Vitest-Tests konnten das strukturell erfassen
- 3 Tests: erlaubter Origin bekommt Header, Preflight korrekt
  beantwortet, fremder Origin bekommt keinen Header
- real deployed auf 131, genau der bei der Sichtpruefung fehlgeschlagene
  Aufruf (Origin http://127.0.0.1:3099) liefert jetzt 200 mit korrektem
  Access-Control-Allow-Origin

Pruefungen siehe archive/docs/RET-10-PRUEFPROTOKOLL.md

archive/cmd/moduleadapter-api/main.go

@@ -0,0 +1,43 @@
+// moduleadapter-api ist der Aufrufpunkt fuer RET-09: startet den bereits
+// fertigen archive/internal/moduleadapter.RegisterHandler (RET-05) als
+// eigenstaendigen HTTP-Dienst. REINES WIRING — keine Aenderung an
+// moduleadapter.go/handler.go, keine neue Logik.
+package main
+
+import (
+	"context"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/moduleadapter"
+)
+
+func main() {
+	dsn := os.Getenv("NEXARCH_MODULEADAPTER_TENANT_DSN")
+	if dsn == "" {
+		log.Fatal("NEXARCH_MODULEADAPTER_TENANT_DSN muss gesetzt sein")
+	}
+	addr := os.Getenv("NEXARCH_MODULEADAPTER_API_LISTEN_ADDR")
+	if addr == "" {
+		addr = "127.0.0.1:8095"
+	}
+
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		log.Fatalf("datenbankverbindung: %v", err)
+	}
+	defer pool.Close()
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/register", moduleadapter.RegisterHandler(pool))
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	log.Printf("moduleadapter-api: listening on %s", addr)
+	if err := http.ListenAndServe(addr, mux); err != nil {
+		log.Fatalf("http server: %v", err)
+	}
+}

archive/cmd/retention-api/main.go

@@ -34,6 +34,11 @@ func main() {
 	if rbacServiceToken == "" {
 		log.Fatal("NEXARCH_RETENTION_RBAC_SERVICE_TOKEN muss gesetzt sein")
 	}
+	// RET-10: erlaubter Frontend-Origin fuer CORS, KEIN Wildcard.
+	corsOrigin := os.Getenv("NEXARCH_RETENTION_CORS_ALLOWED_ORIGIN")
+	if corsOrigin == "" {
+		log.Fatal("NEXARCH_RETENTION_CORS_ALLOWED_ORIGIN muss gesetzt sein (Origin des RET-06-Frontends)")
+	}
 
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, dsn)
@@ -48,8 +53,10 @@ func main() {
 	retentionapi.Mount(mux, pool, rbac)
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 
-	log.Printf("retention-api: listening on %s", addr)
-	if err := http.ListenAndServe(addr, mux); err != nil {
+	handler := retentionapi.CORS(corsOrigin, mux)
+
+	log.Printf("retention-api: listening on %s (cors origin: %s)", addr, corsOrigin)
+	if err := http.ListenAndServe(addr, handler); err != nil {
 		log.Fatalf("http server: %v", err)
 	}
 }

archive/docs/RET-09-PRUEFPROTOKOLL.md

@@ -0,0 +1,57 @@
+# RET-09 – Prüfprotokoll: Modul-Adapter-Dienst starten (RET-05 als laufender HTTP-Endpunkt)
+
+Voraussetzung RET-05 – bereits Fertig, hier UNVERÄNDERT.
+
+## Reines Wiring, keine neue Logik
+
+`git diff --stat archive/internal/moduleadapter/` liefert KEINEN Diff —
+`moduleadapter.go`/`handler.go` sind byteidentisch zum RET-05-Stand.
+RET-09 fügt ausschließlich `cmd/moduleadapter-api/main.go` (startet
+`RegisterHandler` auf einem Port) und die systemd-Einheit hinzu.
+Gleiches Muster wie RBAC-06/CFG-05, aber kleiner: kein neuer
+Auth-Mechanismus (RET-05s eigene AC verlangte keinen), kein neuer
+Vertrag, nur Betrieb des bereits Fertigen.
+
+## Umsetzung
+
+- `archive/cmd/moduleadapter-api/main.go` – eigenständiger HTTP-Dienst,
+  Port 8095.
+- `deploy/systemd/nexarch-archive-moduleadapter-api.service.tmpl`.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Dienst startet und bleibt stabil (systemctl status aktiv) | **bestanden** – real auf 131: `nexarch-archive-moduleadapter-api.service` aktiv, `Restart=on-failure` |
+| 2 | Realer POST /register von einem externen Testclient liefert die erwartete Registrierung (idempotent, wie in RET-05 getestet) | **bestanden** – real per `curl`: erste Registrierung liefert neue ID mit übergebenen Werten (HTTP 200); zweiter Aufruf mit ABWEICHENDEN Werten (anderer `retention_class`/`callback_url`) liefert DIESELBE ID mit den URSPRÜNGLICHEN Werten unverändert zurück — RET-05s Idempotenz-/Überschreibschutz real über den laufenden Dienst bestätigt, Testdaten anschließend entfernt |
+| 3 | Code-Review: keine Änderung an moduleadapter.go/handler.go selbst, nur main.go+systemd neu | **bestanden** – `git diff --stat archive/internal/moduleadapter/` liefert leeren Diff gegenüber dem RET-05-Stand |
+
+## Echte Verdrahtung auf 192.168.1.131
+
+- `moduleadapter-api` gebaut nach `/opt/nexarch-archive/bin/`
+- `/etc/nexarch/archive-moduleadapter-api.env` (0600)
+- `nexarch-archive-moduleadapter-api.service` installiert/aktiviert
+  (dauerhaft, `Restart=on-failure`)
+- End-zu-Ende-Nachweis: `curl POST /register` zweimal mit
+  widersprüchlichen Werten beim zweiten Aufruf, beide Male HTTP 200,
+  zweite Antwort bestätigt die erste (Idempotenz), Testzeile
+  anschließend entfernt.
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./cmd/moduleadapter-api/...  -> 0 issues
+```
+
+Keine neuen Go-Tests nötig (kein neuer Code außer main.go, das nur
+verdrahtet) – die eigentliche Logik ist bereits durch RET-05s eigene
+Tests abgedeckt.
+
+## Gesamtergebnis
+
+**Bestanden.** RET-05 ist jetzt ein real laufender, über systemd
+verwalteter Dienst. DOC-16 und ARC-11 können sich jetzt gegen einen
+echten Test-RET-05-Endpunkt verdrahten, statt gegen unverdrahteten
+Go-Code oder einen reinen In-Process-Mock zu testen.

archive/docs/RET-10-PRUEFPROTOKOLL.md

@@ -0,0 +1,62 @@
+# RET-10 – Prüfprotokoll: CORS für RET-06-API (Frontend-Zugriff aus dem Browser)
+
+Voraussetzung RET-06-API – bereits Fertig, hier NICHT sonst verändert
+(nur `cmd/retention-api/main.go` um die Middleware-Verdrahtung ergänzt).
+
+## Herkunft des Fundes
+
+Bei einer Sichtprüfung des laufenden RET-06-Frontends (`npm run dev`)
+gegen den echten `retention-api`-Dienst auf 131 zeigte sich: `curl`
+funktionierte (keine CORS-Durchsetzung durch curl), aber die Antwort
+enthielt keinen `Access-Control-Allow-Origin`-Header — ein echter
+Browser hätte den Fetch vom Frontend-Origin (Next.js-Dev-Server) zum
+Backend-Origin (retention-api) blockiert. Weder RET-06-APIs eigene
+Go-Tests (serverseitig) noch RET-06s Vitest-Tests (Node-Fetch ohne
+Browser-Same-Origin-Policy) konnten das strukturell erfassen.
+
+## Umsetzung
+
+- `archive/internal/retentionapi/cors.go` – `CORS(allowedOrigin string, next http.Handler) http.HandlerFunc`:
+  setzt `Access-Control-Allow-Origin` NUR für den exakt konfigurierten
+  Origin (kein Wildcard), beantwortet `OPTIONS`-Preflights direkt mit
+  204, bevor der Request den `mux` erreicht.
+- `archive/cmd/retention-api/main.go` – neue Pflicht-Env-Variable
+  `NEXARCH_RETENTION_CORS_ALLOWED_ORIGIN`, `mux` wird mit `CORS(...)`
+  umschlossen.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Realer Browser-Fetch (nicht curl) gelingt, Same-Origin-Policy nicht mehr blockierend | **bestanden** – `TestCORS_AllowedOriginGetsAccessControlHeader`; real auf 131: `curl -H 'Origin: http://127.0.0.1:3099'` liefert `Access-Control-Allow-Origin: http://127.0.0.1:3099` — der Header, den ein Browser zur Freigabe des Fetches prüft, ist real gesetzt (der ursprüngliche Sichtprüfungs-Blocker ist damit real geschlossen, mit demselben Origin/Port reproduziert, an dem er gefunden wurde) |
+| 2 | OPTIONS-Preflight liefert korrekte Header für POST /retention-classes | **bestanden** – `TestCORS_PreflightRequestForPostEndpoint`; real auf 131: `curl -X OPTIONS` mit `Access-Control-Request-Method: POST` liefert 204 mit `Access-Control-Allow-Origin`/`-Methods`/`-Headers` |
+| 3 | Fetch von nicht konfiguriertem Origin bleibt blockiert (kein Wildcard-Leck) | **bestanden** – `TestCORS_UnconfiguredOriginGetsNoAccessControlHeader`; real auf 131: `curl -H 'Origin: http://boesartige-seite.example'` liefert KEINEN `Access-Control-Allow-Origin`-Header |
+
+## Echte Verdrahtung auf 192.168.1.131
+
+- `retention-api` neu gebaut, `/etc/nexarch/archive-retention-api.env`
+  um `NEXARCH_RETENTION_CORS_ALLOWED_ORIGIN=http://127.0.0.1:3099`
+  ergänzt (RET-06-Dev-Server-Origin), Dienst neugestartet.
+- Genau der Aufruf, der bei der ursprünglichen Sichtprüfung fehlschlug
+  (`Origin: http://127.0.0.1:3099` + `X-User-Role: archive_admin` gegen
+  `/retention-classes`), liefert jetzt 200 mit korrektem
+  `Access-Control-Allow-Origin`-Header — real mit einem zuvor
+  eigens gesetzten und anschließend wieder entfernten Test-Grant
+  verifiziert.
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./...  -> 0 issues
+go test ./... -p 1  -> alle Archive-Pakete bestanden (inkl. retentionapi mit 3 neuen CORS-Tests)
+```
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei
+Pflichtprüfungen real erfüllt. Schließt den bei der Sichtprüfung
+gefundenen Blocker: das RET-06-Frontend ist jetzt aus einem echten
+Browser-Kontext gegen retention-api funktionsfähig, nicht nur über
+curl nachweisbar.

archive/internal/retentionapi/cors.go

@@ -0,0 +1,27 @@
+package retentionapi
+
+import "net/http"
+
+// CORS ist RET-10: retention-api hatte bislang keine CORS-Header, ein
+// echter Browser blockierte daher Fetches vom RET-06-Frontend (anderer
+// Origin/Port) — real per Sichtprüfung gefunden, nicht durch die
+// ursprünglichen RET-06/RET-06-API-Prüfungen erfasst (curl/Vitest-Fetch
+// erzwingen keine Same-Origin-Policy). Erlaubt GENAU EINEN konfigurierten
+// Origin, kein Wildcard — verhindert, dass jede beliebige Website die
+// Fristenkonfiguration im Namen eines eingeloggten Nutzers aufrufen kann.
+func CORS(allowedOrigin string, next http.Handler) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		origin := r.Header.Get("Origin")
+		if origin != "" && origin == allowedOrigin {
+			w.Header().Set("Access-Control-Allow-Origin", allowedOrigin)
+			w.Header().Set("Vary", "Origin")
+			w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+			w.Header().Set("Access-Control-Allow-Headers", "Content-Type, X-User-Role")
+		}
+		if r.Method == http.MethodOptions {
+			w.WriteHeader(http.StatusNoContent)
+			return
+		}
+		next.ServeHTTP(w, r)
+	}
+}

archive/internal/retentionapi/cors_test.go

@@ -0,0 +1,86 @@
+package retentionapi
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+const testAllowedOrigin = "http://localhost:3099"
+
+func noopHandler() http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	})
+}
+
+// TestCORS_AllowedOriginGetsAccessControlHeader ist die geforderte
+// Pflichtprüfung: ein echter Browser-Fetch (simuliert über den Origin-
+// Header, den nur ein Browser automatisch setzt) erhält die nötigen
+// CORS-Header, die Same-Origin-Policy blockiert den Zugriff nicht mehr.
+func TestCORS_AllowedOriginGetsAccessControlHeader(t *testing.T) {
+	handler := CORS(testAllowedOrigin, noopHandler())
+	server := httptest.NewServer(handler)
+	defer server.Close()
+
+	req, _ := http.NewRequest(http.MethodGet, server.URL, nil)
+	req.Header.Set("Origin", testAllowedOrigin)
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if got := resp.Header.Get("Access-Control-Allow-Origin"); got != testAllowedOrigin {
+		t.Fatalf("Access-Control-Allow-Origin = %q, want %q", got, testAllowedOrigin)
+	}
+}
+
+// TestCORS_PreflightRequestForPostEndpoint ist die geforderte
+// Pflichtprüfung: OPTIONS-Preflight liefert korrekte CORS-Header für
+// POST /retention-classes.
+func TestCORS_PreflightRequestForPostEndpoint(t *testing.T) {
+	handler := CORS(testAllowedOrigin, noopHandler())
+	server := httptest.NewServer(handler)
+	defer server.Close()
+
+	req, _ := http.NewRequest(http.MethodOptions, server.URL+"/retention-classes", nil)
+	req.Header.Set("Origin", testAllowedOrigin)
+	req.Header.Set("Access-Control-Request-Method", "POST")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("options: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusNoContent {
+		t.Fatalf("preflight status = %d, want 204", resp.StatusCode)
+	}
+	if got := resp.Header.Get("Access-Control-Allow-Origin"); got != testAllowedOrigin {
+		t.Fatalf("Access-Control-Allow-Origin = %q, want %q", got, testAllowedOrigin)
+	}
+	if got := resp.Header.Get("Access-Control-Allow-Methods"); got == "" {
+		t.Fatal("Access-Control-Allow-Methods fehlt in der preflight-antwort")
+	}
+}
+
+// TestCORS_UnconfiguredOriginGetsNoAccessControlHeader ist die geforderte
+// Pflichtprüfung: Fetch von einem NICHT konfigurierten Origin bleibt
+// blockiert — kein Wildcard-Leck.
+func TestCORS_UnconfiguredOriginGetsNoAccessControlHeader(t *testing.T) {
+	handler := CORS(testAllowedOrigin, noopHandler())
+	server := httptest.NewServer(handler)
+	defer server.Close()
+
+	req, _ := http.NewRequest(http.MethodGet, server.URL, nil)
+	req.Header.Set("Origin", "http://boesartige-seite.example")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if got := resp.Header.Get("Access-Control-Allow-Origin"); got != "" {
+		t.Fatalf("Access-Control-Allow-Origin haette bei fremdem origin leer sein muessen, war %q", got)
+	}
+}

deploy/systemd/nexarch-archive-moduleadapter-api.service.tmpl

@@ -0,0 +1,14 @@
+[Unit]
+Description=NEXARCH Archive - Modul-Adapter-Registrierung (RET-05/RET-09)
+After=network.target postgresql.service
+
+[Service]
+Type=simple
+User=nexarch
+EnvironmentFile=/etc/nexarch/archive-moduleadapter-api.env
+ExecStart=__INSTALL_DIR__/bin/moduleadapter-api
+Restart=on-failure
+StandardOutput=journal
+
+[Install]
+WantedBy=multi-user.target