Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
Withhold report downloads after credential withdrawal
pulse-triage[bot]b4c317d0ae64
diff --git a/internal/api/contract_test.go b/internal/api/contract_test.goindex 900ba5cbfd..5e9e6bc516 100644--- a/internal/api/contract_test.go+++ b/internal/api/contract_test.go@@ -29132,3 +29132,10 @@ func TestContractSupportBundleStopsAfterAdmittedPrefix(t *testing.T) {}}}++// Report downloads, including supported endpoint decorators, must not disclose+// results after persisted credential withdrawal. Existing org-admin/settings+// and license gates, independent readers and background work remain unchanged.+func TestContractReportDownloadWithdrawal(t *testing.T) {+ reportDownloadNativeWithdrawal(t)+}diff --git a/internal/api/log_bundle_authority_test.go b/internal/api/log_bundle_authority_test.goindex 9e4ab721ff..f41e97c399 100644--- a/internal/api/log_bundle_authority_test.go+++ b/internal/api/log_bundle_authority_test.go@@ -8,12 +8,12 @@ import (func TestSupportBundleMediaDoesNotWidenAssistantResults(t *testing.T) {for _, policy := range []struct {name, media string- zip bool- }{{"json", "application/json", false}, {"zip", "application/zip", true}} {+ policy responseMediaPolicy+ }{{"json", "application/json", responseMediaJSON}, {"zip", "application/zip", responseMediaZIP}} {for _, provided := range []string{"", "application/json", "application/zip", "text/html", "image/svg+xml", "application/json; invalid"} {t.Run(policy.name+"/"+provided, func(t *testing.T) {base := httptest.NewRecorder()- writer := &tokenResponseWriter{writer: base, header: base.Header().Clone(), allowed: func() bool { return true }, zipDownload: policy.zip}+ writer := &tokenResponseWriter{writer: base, header: base.Header().Clone(), allowed: func() bool { return true }, media: policy.policy}writer.Header()["content-type"] = []string{"text/html"}writer.Header().Set("Content-Type", provided)if _, err := writer.Write([]byte("synthetic bytes")); err != nil {diff --git a/internal/api/log_handlers.go b/internal/api/log_handlers.goindex a467422a0d..b3d585af79 100644--- a/internal/api/log_handlers.go+++ b/internal/api/log_handlers.go@@ -110,7 +110,7 @@ func (h *LogHandlers) HandleDownloadBundle(w http.ResponseWriter, r *http.Reques// Raw logs are private even though the system summary is allowlisted.// Recheck the admitted token/session at each actual ZIP transport write,// without buffering the archive or withdrawing other readers/work.- retainResponseAuthority(h.config, config.ScopeSettingsRead, true, true, h.writeDownloadBundle)(w, r)+ retainResponseAuthority(h.config, config.ScopeSettingsRead, true, responseMediaZIP, h.writeDownloadBundle)(w, r)}func (h *LogHandlers) writeDownloadBundle(w http.ResponseWriter, r *http.Request) {diff --git a/internal/api/report_download_authority_test.go b/internal/api/report_download_authority_test.gonew file mode 100644index 0000000000..b7b987fdf6--- /dev/null+++ b/internal/api/report_download_authority_test.go@@ -0,0 +1,186 @@+package api++import (+ "fmt"+ "io"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"+ "time"++ "github.com/rcourtman/pulse-go-rewrite/internal/config"+)++func TestReportDownloadMediaPoliciesStaySeparate(t *testing.T) {+ for _, policy := range []responseMediaPolicy{responseMediaJSON, responseMediaZIP, responseMediaReport, responseMediaPolicy(255)} {+ for _, provided := range []string{"", "application/json", "application/zip", "application/pdf", "text/csv", "text/csv; charset=utf-8", "text/csv; charset=windows-1252", "text/html", "image/svg+xml", "application/json; invalid"} {+ t.Run(fmt.Sprint(policy)+"/"+provided, func(t *testing.T) {+ base := httptest.NewRecorder()+ w := &tokenResponseWriter{writer: base, header: base.Header().Clone(), allowed: func() bool { return true }, media: policy}+ w.Header()["content-type"] = []string{"text/html"}+ w.Header()["x-content-type-options"] = []string{"sniff"}+ w.Header().Set("Content-Type", provided)+ const payload = "<script>synthetic data, never executable</script>"+ _, err := w.Write([]byte(payload))+ if err != nil {+ t.Fatal(err)+ }+ want := "text/plain; charset=utf-8"+ switch policy {+ case responseMediaJSON:+ if provided == "application/json" {+ want = provided+ }+ case responseMediaZIP:+ if provided == "application/zip" {+ want = provided+ }+ case responseMediaReport:+ switch {+ case provided == "application/json", provided == "application/pdf":+ want = provided+ case strings.HasPrefix(provided, "text/csv"):+ want = "text/csv; charset=utf-8"+ }+ }+ if base.Header().Get("Content-Type") != want || base.Header().Get("X-Content-Type-Options") != "nosniff" || base.Body.String() != payload {+ t.Fatalf("media or payload changed: %v", base.Header())+ }+ for _, alias := range []string{"content-type", "x-content-type-options"} {+ if _, ok := base.Header()[alias]; ok {+ t.Fatal("noncanonical media header escaped")+ }+ }+ })+ }+ }+}++func TestReportDownloadCurrentAuthorityAndPrefix(t *testing.T) {+ for _, transport := range []string{"header", "bearer", "session"} {+ changes := []string{"revoked", "expired", "scope", "org", "identity", "principal", "unrelated_scope"}+ if transport == "session" {+ changes = []string{"invalidated", "expired", "principal", "replaced", "recovery"}+ }+ for _, change := range changes {+ for _, prefix := range []bool{false, true} {+ name := change + "/before_output"+ if prefix {+ name = change + "/after_prefix"+ }+ t.Run(transport+"/"+name, func(t *testing.T) {+ cfg := newTestConfigWithTokens(t, newTokenRecord(t, logStreamToken, []string{config.ScopeSettingsRead, config.ScopeAIExecute}, nil))+ const session = "synthetic-report-prefix-session"+ if transport == "session" {+ InitSessionStore(t.TempDir())+ GetSessionStore().CreateSession(session, time.Hour, "fixture", "127.0.0.1", "operator")+ t.Cleanup(func() { GetSessionStore().DeleteSession(session) })+ }+ req := httptest.NewRequest(http.MethodGet, "/synthetic-report", nil)+ switch transport {+ case "bearer":+ req.Header.Set("Authorization", "Bearer "+logStreamToken)+ case "session":+ req.AddCookie(&http.Cookie{Name: cookieNameSession, Value: session})+ default:+ req.Header.Set("X-API-Token", logStreamToken)+ }+ base := httptest.NewRecorder()+ var late http.ResponseWriter+ guard := retainResponseAuthority(cfg, config.ScopeSettingsRead, false, responseMediaReport, func(w http.ResponseWriter, r *http.Request) {+ late = w+ w.Header().Set("Content-Type", "text/csv; charset=utf-8")+ w.Header().Set("Content-Disposition", "attachment; filename=synthetic.csv")+ if prefix {+ if _, err := w.Write([]byte("admitted,prefix\n")); err != nil {+ t.Fatal(err)+ }+ }+ if transport == "session" {+ mutateReadSession(session, change)+ } else {+ config.Mu.Lock()+ switch change {+ case "revoked":+ cfg.RemoveAPIToken(cfg.APITokens[0].ID)+ case "expired":+ past := time.Now().Add(-time.Second)+ cfg.APITokens[0].ExpiresAt = &past+ case "scope":+ cfg.APITokens[0].Scopes = []string{config.ScopeMonitoringRead}+ case "org":+ cfg.APITokens[0].OrgID = "different-organization"+ case "identity":+ cfg.APITokens[0].ID = "different-credential"+ case "principal":+ cfg.APITokens[0].Metadata = map[string]string{apiTokenMetadataOwnerUserID: "different-owner"}+ case "unrelated_scope":+ cfg.APITokens[0].Scopes = []string{config.ScopeSettingsRead}+ }+ config.Mu.Unlock()+ }+ n, err := w.Write([]byte("private,result\n"))+ if change == "unrelated_scope" {+ if err != nil || n == 0 {+ t.Fatal("unrelated scope removal broke report read")+ }+ } else if n != 0 || err != io.ErrClosedPipe {+ t.Fatalf("withdrawn write=%d %v", n, err)+ }+ if r.Context().Err() != nil {+ t.Fatal("withdrawal cancelled independent generation")+ }+ })+ AuthContextMiddleware(cfg, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if !CheckAuth(cfg, w, r) {+ t.Fatal("synthetic admission failed")+ }+ guard(w, r)+ })).ServeHTTP(base, req)+ if _, err := late.Write([]byte("late output")); err != io.ErrClosedPipe {+ t.Fatal("returned writer reopened")+ }+ switch {+ case change == "unrelated_scope":+ if base.Code != http.StatusOK || !strings.Contains(base.Body.String(), "private,result") {+ t.Fatal("independent scope denied")+ }+ case prefix:+ if base.Code != http.StatusOK || base.Body.String() != "admitted,prefix\n" {+ t.Fatalf("admitted prefix changed: %d %s", base.Code, base.Body)+ }+ default:+ if base.Code != http.StatusUnauthorized || base.Body.String() != "Authentication required\n" || base.Header().Get("Content-Disposition") != "" {+ t.Fatal("private report response escaped after withdrawal")+ }+ }+ })+ }+ }+ }+}++func TestReportDownloadKeepsOrganizationBoundAuthority(t *testing.T) {+ record := newTokenRecord(t, logStreamToken, []string{config.ScopeSettingsRead}, nil)+ record.OrgID = "org-a"+ cfg := newTestConfigWithTokens(t, record)+ req := httptest.NewRequest(http.MethodGet, "/synthetic-report", nil).WithContext(orgScopeContext("org-a"))+ req.Header.Set("X-API-Token", logStreamToken)+ base := httptest.NewRecorder()+ handler := retainResponseAuthority(cfg, config.ScopeSettingsRead, false, responseMediaReport, func(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Content-Type", "text/csv")+ if _, err := w.Write([]byte("own-org,report\n")); err != nil {+ t.Fatal(err)+ }+ })+ AuthContextMiddleware(cfg, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if !CheckAuth(cfg, w, r) {+ t.Fatal("org credential admission failed")+ }+ handler(w, r)+ })).ServeHTTP(base, req)+ if base.Code != http.StatusOK || base.Body.String() != "own-org,report\n" {+ t.Fatalf("org settings reader acquired an instance-admin requirement: %d %s", base.Code, base.Body)+ }+}diff --git a/internal/api/report_download_lifetime_test.go b/internal/api/report_download_lifetime_test.gonew file mode 100644index 0000000000..709aff4e25--- /dev/null+++ b/internal/api/report_download_lifetime_test.go@@ -0,0 +1,204 @@+package api++import (+ "context"+ "io"+ "net/http"+ "net/http/httptest"+ "strings"+ "sync"+ "testing"+ "time"++ "github.com/rcourtman/pulse-go-rewrite/internal/config"+ "github.com/rcourtman/pulse-go-rewrite/pkg/extensions"+ pkglicensing "github.com/rcourtman/pulse-go-rewrite/pkg/licensing"+ "github.com/rcourtman/pulse-go-rewrite/pkg/reporting"+)++// Decorate the real public endpoint adapter at its supported extension seam.+// This holds admitted generation, not authentication, before its first output.+// No private implementation or installed workload is involved.+type heldReportDownloads struct {+ extensions.ReportingAdminEndpoints+ entered chan struct{}+ release chan struct{}+ once sync.Once+}++func (h *heldReportDownloads) run(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {+ h.once.Do(func() { close(h.entered) })+ select {+ case <-h.release:+ case <-r.Context().Done():+ return+ }+ next(w, r)+}+func (h *heldReportDownloads) HandleGenerateReport(w http.ResponseWriter, r *http.Request) {+ h.run(w, r, h.ReportingAdminEndpoints.HandleGenerateReport)+}+func (h *heldReportDownloads) HandleGenerateMultiReport(w http.ResponseWriter, r *http.Request) {+ h.run(w, r, h.ReportingAdminEndpoints.HandleGenerateMultiReport)+}+func (h *heldReportDownloads) HandleExportVMInventory(w http.ResponseWriter, r *http.Request) {+ h.run(w, r, h.ReportingAdminEndpoints.HandleExportVMInventory)+}++type reportDownloadCase struct{ name, method, path, body string }++func reportDownloadCases() []reportDownloadCase {+ return []reportDownloadCase{+ {"single_get", http.MethodGet, "/api/admin/reports/generate?format=csv&resourceType=vm&resourceId=fixture-node-100", ""},+ {"single_post", http.MethodPost, "/api/admin/reports/generate", `{"resourceType":"vm","resourceId":"fixture-node-100","format":"csv"}`},+ {"fleet", http.MethodPost, "/api/admin/reports/generate-multi", `{"resources":[{"resourceType":"vm","resourceId":"fixture-node-100"}],"format":"csv"}`},+ {"inventory", http.MethodGet, "/api/admin/reports/inventory/vms/export?format=csv", ""},+ }+}++func newHeldReportDownloadRouter(t *testing.T) (*Router, *config.Config, *httptest.Server, *heldReportDownloads) {+ t.Helper()+ held := &heldReportDownloads{entered: make(chan struct{}), release: make(chan struct{})}+ SetReportingAdminEndpointsBinder(func(defaults extensions.ReportingAdminEndpoints, _ extensions.ReportingAdminRuntime) extensions.ReportingAdminEndpoints {+ held.ReportingAdminEndpoints = defaults+ return held+ })+ t.Cleanup(func() { SetReportingAdminEndpointsBinder(nil) })+ cfg := newTestConfigWithTokens(t,+ newTokenRecord(t, logStreamToken, []string{config.ScopeSettingsRead}, nil),+ newTokenRecord(t, logStreamControl, []string{config.ScopeWildcard}, nil))+ cfg.AuthUser = "operator"+ router := NewRouter(cfg, nil, nil, nil, nil, "test")+ cleanupTestRouter(t, router)+ setLicenseTierForHandlersForTests(t, router.licenseHandlers, "default", pkglicensing.TierEnterprise)+ inventory, _, _, _, _ := inventoryScheduleFixture(t)+ router.reportingHandlers.mtMonitor.Store(inventory.reportMonitorManager())+ // The existing real handlers perform all parsing, scoping, generation and+ // activity accounting. Only the performance engine's data source is synthetic.+ original := reporting.GetEngine()+ reporting.SetEngine(&stubReportingEngine{data: []byte("synthetic,private-report\n"), contentType: "text/csv"})+ t.Cleanup(func() { reporting.SetEngine(original) })+ server := httptest.NewServer(router.Handler())+ // Unblock on any failed assertion before waiting for server cleanup.+ t.Cleanup(func() {+ select {+ case <-held.release:+ default:+ close(held.release)+ }+ server.Close()+ })+ return router, cfg, server, held+}++func reportDownloadRequest(t *testing.T, ctx context.Context, server *httptest.Server, tc reportDownloadCase, raw, transport string) *http.Request {+ t.Helper()+ req, err := http.NewRequestWithContext(ctx, tc.method, server.URL+tc.path, strings.NewReader(tc.body))+ if err != nil {+ t.Fatal(err)+ }+ if tc.method == http.MethodPost {+ req.Header.Set("Content-Type", "application/json")+ }+ switch transport {+ case "bearer":+ req.Header.Set("Authorization", "Bearer "+raw)+ case "session":+ req.AddCookie(&http.Cookie{Name: cookieNameSession, Value: raw})+ req.Header.Set("X-CSRF-Token", generateCSRFToken(raw))+ default:+ req.Header.Set("X-API-Token", raw)+ }+ return req+}++func reportDownloadNativeWithdrawal(t *testing.T) {+ for _, tc := range reportDownloadCases() {+ for _, transport := range []string{"header", "bearer", "session"} {+ t.Run(tc.name+"/"+transport, func(t *testing.T) {+ router, cfg, server, held := newHeldReportDownloadRouter(t)+ raw := logStreamToken+ if transport == "session" {+ raw = "synthetic-held-report-session"+ GetSessionStore().CreateSession(raw, time.Hour, "fixture", "127.0.0.1", cfg.AuthUser)+ t.Cleanup(func() { GetSessionStore().DeleteSession(raw) })+ }+ ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)+ defer cancel()+ req := reportDownloadRequest(t, ctx, server, tc, raw, transport)+ type result struct {+ response *http.Response+ err error+ }+ done := make(chan result, 1)+ go func() { response, err := server.Client().Do(req); done <- result{response, err} }()+ select {+ case <-held.entered:+ case response := <-done:+ t.Fatalf("generation not admitted: response=%v err=%v", response.response, response.err)+ case <-ctx.Done():+ t.Fatal("generation did not reach hold")+ }+ if transport == "session" {+ logoutReadSession(t, server.URL, raw)+ } else {+ config.Mu.RLock()+ id := cfg.APITokens[0].ID+ config.Mu.RUnlock()+ deletion, _ := http.NewRequestWithContext(ctx, http.MethodDelete, server.URL+"/api/security/tokens/"+id, nil)+ deletion.Header.Set("X-API-Token", logStreamControl)+ response, err := server.Client().Do(deletion)+ if err != nil {+ t.Fatal(err)+ }+ response.Body.Close()+ persisted, err := router.persistence.LoadAPITokens()+ if response.StatusCode != http.StatusNoContent || err != nil || len(persisted) != 1 || persisted[0].ID == id {+ t.Fatal("DELETE did not persist withdrawal")+ }+ }+ fresh, err := server.Client().Do(reportDownloadRequest(t, ctx, server, tc, raw, transport))+ if err != nil {+ t.Fatal(err)+ }+ fresh.Body.Close()+ if fresh.StatusCode != http.StatusUnauthorized {+ t.Fatalf("fresh admission=%d", fresh.StatusCode)+ }+ close(held.release)+ var completed result+ select {+ case completed = <-done:+ case <-ctx.Done():+ t.Fatal("held report did not finish")+ }+ if completed.err != nil {+ t.Fatal(completed.err)+ }+ body, err := io.ReadAll(completed.response.Body)+ completed.response.Body.Close()+ if err != nil {+ t.Fatal(err)+ }+ marker := "private-report"+ if tc.name == "inventory" {+ marker = "inventory-vm-000"+ }+ if completed.response.StatusCode != http.StatusUnauthorized || string(body) != "Authentication required\n" || completed.response.Header.Get("Content-Disposition") != "" {+ t.Errorf("held report=%d after persisted withdrawal (private data disclosed=%v), want generic 401 without attachment", completed.response.StatusCode, strings.Contains(string(body), marker))+ }+ // An independent settings reader still receives the original real-handler+ // download. Withdrawal does not cancel a job or alter an inventory/schedule.+ control, err := server.Client().Do(reportDownloadRequest(t, ctx, server, tc, logStreamControl, "header"))+ if err != nil {+ t.Fatal(err)+ }+ controlBody, err := io.ReadAll(control.Body)+ control.Body.Close()+ if err != nil || control.StatusCode != http.StatusOK || !strings.Contains(string(controlBody), marker) || control.Header.Get("Content-Disposition") == "" {+ t.Fatalf("independent report lost: %d %v", control.StatusCode, err)+ }+ })+ }+ }+}diff --git a/internal/api/router_routes_licensing.go b/internal/api/router_routes_licensing.goindex ae00e3ec89..ce30f55a09 100644--- a/internal/api/router_routes_licensing.go+++ b/internal/api/router_routes_licensing.go@@ -153,6 +153,8 @@ func (r *Router) registerOrgLicenseRoutesGroup(orgHandlers *OrgHandlers, rbacHan// the request organization's inventory and metrics store, and schedules// live in that organization's config, so an org manager may use them in// their own organization.+ // Slow downloads retain the admitted token/session through output, including+ // extension renderers. Withdrawal does not cancel schedules or other work.r.mux.HandleFunc("/api/admin/reports/catalog", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceNodes, func(w http.ResponseWriter, req *http.Request) {if !ensureOrgAdminSession(r.config, w, req) {return@@ -163,19 +165,19 @@ func (r *Router) registerOrgLicenseRoutesGroup(orgHandlers *OrgHandlers, rbacHanif !ensureOrgAdminSession(r.config, w, req) {return}- RequireLicenseFeature(r.licenseHandlers, featureAdvancedReportingValue, RequireScope(config.ScopeSettingsRead, reportingAdminEndpoints.HandleGenerateReport))(w, req)+ RequireLicenseFeature(r.licenseHandlers, featureAdvancedReportingValue, RequireScope(config.ScopeSettingsRead, retainResponseAuthority(r.config, config.ScopeSettingsRead, false, responseMediaReport, reportingAdminEndpoints.HandleGenerateReport)))(w, req)}))r.mux.HandleFunc("/api/admin/reports/generate-multi", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceNodes, func(w http.ResponseWriter, req *http.Request) {if !ensureOrgAdminSession(r.config, w, req) {return}- RequireLicenseFeature(r.licenseHandlers, featureAdvancedReportingValue, RequireScope(config.ScopeSettingsRead, reportingAdminEndpoints.HandleGenerateMultiReport))(w, req)+ RequireLicenseFeature(r.licenseHandlers, featureAdvancedReportingValue, RequireScope(config.ScopeSettingsRead, retainResponseAuthority(r.config, config.ScopeSettingsRead, false, responseMediaReport, reportingAdminEndpoints.HandleGenerateMultiReport)))(w, req)}))r.mux.HandleFunc("/api/admin/reports/inventory/vms/export", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceNodes, func(w http.ResponseWriter, req *http.Request) {if !ensureOrgAdminSession(r.config, w, req) {return}- RequireLicenseFeature(r.licenseHandlers, featureAdvancedReportingValue, RequireScope(config.ScopeSettingsRead, reportingAdminEndpoints.HandleExportVMInventory))(w, req)+ RequireLicenseFeature(r.licenseHandlers, featureAdvancedReportingValue, RequireScope(config.ScopeSettingsRead, retainResponseAuthority(r.config, config.ScopeSettingsRead, false, responseMediaReport, reportingAdminEndpoints.HandleExportVMInventory)))(w, req)}))r.mux.HandleFunc("GET /api/admin/reports/schedules", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceNodes, func(w http.ResponseWriter, req *http.Request) {if !ensureOrgAdminSession(r.config, w, req) {diff --git a/internal/api/token_response_authority.go b/internal/api/token_response_authority.goindex 9963105fc7..a9c3913a1e 100644--- a/internal/api/token_response_authority.go+++ b/internal/api/token_response_authority.go@@ -15,13 +15,23 @@ import (// handler waits for a provider. Keep the original work/context lifetime, but// recheck authority at disclosure, including headers and error responses.func retainTokenResponseAuthority(cfg *config.Config, scope string, instanceAdmin bool, next http.HandlerFunc) http.HandlerFunc {- return retainResponseAuthority(cfg, scope, instanceAdmin, false, next)+ return retainResponseAuthority(cfg, scope, instanceAdmin, responseMediaJSON, next)}-// retainResponseAuthority also serves the existing private diagnostic download.-// The caller selects JSON or ZIP, never arbitrary executable media. Authority,-// closure and plain-text refusals stay shared with synchronous Assistant results.-func retainResponseAuthority(cfg *config.Config, scope string, instanceAdmin bool, zipDownload bool, next http.HandlerFunc) http.HandlerFunc {+// responseMediaPolicy is a closed transport choice. Adding report downloads+// must not let a report renderer widen Assistant results or diagnostic ZIPs.+type responseMediaPolicy uint8++const (+ responseMediaJSON responseMediaPolicy = iota+ responseMediaZIP+ responseMediaReport+)++// retainResponseAuthority serves slow synchronous results and private downloads.+// It preserves the route's existing gates and work lifetime; the media policy+// selects only that transport's data formats, never arbitrary executable media.+func retainResponseAuthority(cfg *config.Config, scope string, instanceAdmin bool, media responseMediaPolicy, next http.HandlerFunc) http.HandlerFunc {return func(w http.ResponseWriter, r *http.Request) {revalidate := tokenStreamSnapshotRevalidator(cfg, r, scope)sessionAllowed := sessionReadRevalidator(r)@@ -41,7 +51,7 @@ func retainResponseAuthority(cfg *config.Config, scope string, instanceAdmin boohttp.Error(w, "Authentication required", http.StatusUnauthorized)return}- writer := &tokenResponseWriter{writer: w, header: w.Header().Clone(), allowed: allowed, zipDownload: zipDownload}+ writer := &tokenResponseWriter{writer: w, header: w.Header().Clone(), allowed: allowed, media: media}defer writer.close()next(writer, r)// A bodyless handler must not implicitly return 200 after withdrawal.@@ -54,13 +64,13 @@ func retainResponseAuthority(cfg *config.Config, scope string, instanceAdmin boo// write produces a generic 401, not false-success/empty JSON; after any admitted// response bytes, denial only stops further output, never appends an auth error.type tokenResponseWriter struct {- writer http.ResponseWriter- header http.Header- allowed func() bool- zipDownload bool- mu sync.Mutex- started bool- closed bool+ writer http.ResponseWriter+ header http.Header+ allowed func() bool+ media responseMediaPolicy+ mu sync.Mutex+ started bool+ closed bool}func (w *tokenResponseWriter) Header() http.Header { return w.header }@@ -97,15 +107,29 @@ func (w *tokenResponseWriter) commitLocked(status int) {// types must not allow HTTP sniffing or an extension to render HTML.// Leave payload bytes alone: HTML-escaping JSON would corrupt data.mediaType, _, err := mime.ParseMediaType(w.header.Get("Content-Type"))- expectedType := "application/json"- if w.zipDownload {- expectedType = "application/zip"- }- if err == nil && mediaType == expectedType {- header.Set("Content-Type", expectedType)- } else {- header.Set("Content-Type", "text/plain; charset=utf-8")+ pinnedType := "text/plain; charset=utf-8"+ if err == nil {+ switch w.media {+ case responseMediaJSON:+ if mediaType == "application/json" {+ pinnedType = mediaType+ }+ case responseMediaZIP:+ if mediaType == "application/zip" {+ pinnedType = mediaType+ }+ case responseMediaReport:+ // Existing PDF/CSV attachments and structured API errors.+ // CSV is UTF-8; never forward renderer-supplied parameters.+ switch mediaType {+ case "application/pdf", "application/json":+ pinnedType = mediaType+ case "text/csv":+ pinnedType = "text/csv; charset=utf-8"+ }+ }}+ header.Set("Content-Type", pinnedType)header.Set("X-Content-Type-Options", "nosniff")w.writer.WriteHeader(status)// Informational headers do not commit the final response.