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 audit evidence after credential withdrawal
pulse-triage[bot]ffa96dd81e36
diff --git a/internal/api/audit_read_authority_test.go b/internal/api/audit_read_authority_test.gonew file mode 100644index 0000000000..b130ab7b45--- /dev/null+++ b/internal/api/audit_read_authority_test.go@@ -0,0 +1,14 @@+package api++import (+ "github.com/rcourtman/pulse-go-rewrite/internal/config"+ "testing"+)++func TestAuditReadCurrentAuthorityAndPrefix(t *testing.T) {+ responseCurrentAuthorityAndPrefix(t, config.ScopeAuditRead, responseMediaAudit)+}++func TestAuditReadKeepsOrganizationBoundAuthority(t *testing.T) {+ responseKeepsOrganizationBoundAuthority(t, config.ScopeAuditRead, responseMediaAudit)+}diff --git a/internal/api/audit_read_lifetime_test.go b/internal/api/audit_read_lifetime_test.gonew file mode 100644index 0000000000..3ea4d11fb5--- /dev/null+++ b/internal/api/audit_read_lifetime_test.go@@ -0,0 +1,277 @@+package api++import (+ "context"+ "io"+ "net/http"+ "net/http/httptest"+ "strings"+ "sync"+ "sync/atomic"+ "testing"+ "time"++ "github.com/rcourtman/pulse-go-rewrite/internal/config"+ "github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"+ "github.com/rcourtman/pulse-go-rewrite/pkg/audit"+ pkglicensing "github.com/rcourtman/pulse-go-rewrite/pkg/licensing"+)++// Only synthetic in-memory evidence: hold the real handlers' storage read,+// after actual Router authentication/permission/licence/scope admission.+type auditReadHold struct {+ armed atomic.Bool+ entered, release chan struct{}+ once sync.Once+}++func (h *auditReadHold) wait() {+ if h.armed.Load() {+ h.once.Do(func() { close(h.entered) })+ <-h.release+ }+}+func (h *auditReadHold) unblock() {+ select {+ case <-h.release:+ default:+ close(h.release)+ }+}++type heldAuditLogger struct {+ hold *auditReadHold+ event audit.Event+}++func (l *heldAuditLogger) Record(audit.Event) error { return nil }+func (l *heldAuditLogger) Query(f audit.QueryFilter) ([]audit.Event, error) {+ l.hold.wait()+ if f.ID != "" && f.ID != l.event.ID {+ return []audit.Event{}, nil+ }+ return []audit.Event{l.event}, nil+}+func (l *heldAuditLogger) Count(audit.QueryFilter) (int, error) { return 1, nil }+func (l *heldAuditLogger) Close() error { return nil }+func (l *heldAuditLogger) GetWebhookURLs() []string { return nil }+func (l *heldAuditLogger) UpdateWebhookURLs([]string) error { return nil }+func (l *heldAuditLogger) VerifySignature(e audit.Event) bool {+ return e.Signature == l.event.Signature+}++type heldAuditResourceStore struct {+ unifiedresources.ResourceStore+ hold *auditReadHold+}++func (s *heldAuditResourceStore) GetActionAudits(id string, since time.Time, limit int) ([]unifiedresources.ActionAuditRecord, error) {+ s.hold.wait()+ return s.ResourceStore.GetActionAudits(id, since, limit)+}+func (s *heldAuditResourceStore) GetActionLifecycleEvents(id string, since time.Time, limit int) ([]unifiedresources.ActionLifecycleEvent, error) {+ s.hold.wait()+ return s.ResourceStore.GetActionLifecycleEvents(id, since, limit)+}+func (s *heldAuditResourceStore) GetExportAudits(since time.Time, limit int) ([]unifiedresources.ExportAuditRecord, error) {+ s.hold.wait()+ return s.ResourceStore.GetExportAudits(since, limit)+}++type auditReadCase struct{ name, path, marker string }++func auditReadCases() []auditReadCase {+ return []auditReadCase{+ {"list", "/api/audit", "private-audit-fixture"},+ {"list_slash", "/api/audit/", "private-audit-fixture"},+ {"verify", "/api/audit/private-audit-fixture/verify", "verified"},+ {"export_json", "/api/audit/export?format=json&verify=true", "private-audit-fixture"},+ {"export_csv", "/api/audit/export?format=csv&verify=true", "private-audit-fixture"},+ {"summary", "/api/audit/summary?verify=true", "config_change"},+ {"actions", "/api/audit/actions", "private-action-fixture"},+ {"lifecycle", "/api/audit/actions/private-action-fixture/events", "private-action-fixture"},+ {"exports", "/api/audit/exports", "private-export-fixture"},+ }+}++func newHeldAuditReadRouter(t *testing.T) (*Router, *config.Config, *httptest.Server, *auditReadHold) {+ t.Helper()+ cfg := newTestConfigWithTokens(t,+ newTokenRecord(t, logStreamToken, []string{config.ScopeAuditRead}, 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)+ hold := &auditReadHold{entered: make(chan struct{}), release: make(chan struct{})}+ now := time.Date(2026, 11, 1, 12, 0, 0, 0, time.UTC)+ logger := &heldAuditLogger{hold: hold, event: audit.Event{ID: "private-audit-fixture", Timestamp: now, EventType: "config_change", User: "fixture-operator", IP: "192.0.2.10", Path: "/synthetic/private-setting", Success: true, Details: "synthetic private audit evidence", Signature: "synthetic-signature"}}+ priorManager := GetTenantAuditManager()+ SetTenantAuditManager(nil)+ t.Cleanup(func() { SetTenantAuditManager(priorManager) })+ setAuditLogger(t, logger)+ store := unifiedresources.NewMemoryStore()+ if err := store.RecordActionAudit(unifiedresources.ActionAuditRecord{ID: "private-action-fixture", CreatedAt: now, UpdatedAt: now, State: unifiedresources.ActionStateCompleted, Request: unifiedresources.ActionRequest{RequestID: "fixture-request", ResourceID: "vm:100", CapabilityName: "restart", RequestedBy: "fixture-operator"}}); err != nil {+ t.Fatal(err)+ }+ if err := store.RecordActionLifecycleEvent(unifiedresources.ActionLifecycleEvent{ActionID: "private-action-fixture", Timestamp: now, State: unifiedresources.ActionStateCompleted}); err != nil {+ t.Fatal(err)+ }+ if err := store.RecordExportAudit(unifiedresources.ExportAuditRecord{ID: "private-export-fixture", Timestamp: now, Actor: "fixture-operator", EnvelopeHash: "synthetic-hash", Decision: unifiedresources.ExportAllowed, Destination: "synthetic-destination"}); err != nil {+ t.Fatal(err)+ }+ handlers := NewAuditHandlers()+ handlers.SetResourceStoreProvider(func(string) (unifiedresources.ResourceStore, error) {+ return &heldAuditResourceStore{ResourceStore: store, hold: hold}, nil+ })+ // Re-register the production group with its existing provider seam, avoiding+ // a real database. Retain the full Router middleware and real DELETE/logout.+ original := router.mux+ router.mux = http.NewServeMux()+ router.registerOrgLicenseRoutesGroup(nil, nil, handlers)+ router.mux.Handle("/api/security/", original)+ router.mux.Handle("/api/logout", original)+ server := httptest.NewServer(router.Handler())+ t.Cleanup(func() { hold.unblock(); server.Close() })+ return router, cfg, server, hold+}++func auditReadRequest(t *testing.T, ctx context.Context, server *httptest.Server, path, raw, transport string) *http.Request {+ t.Helper()+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, server.URL+path, nil)+ if err != nil {+ t.Fatal(err)+ }+ switch transport {+ case "bearer":+ req.Header.Set("Authorization", "Bearer "+raw)+ case "session":+ req.AddCookie(&http.Cookie{Name: cookieNameSession, Value: raw})+ default:+ req.Header.Set("X-API-Token", raw)+ }+ return req+}++func auditReadNativeWithdrawal(t *testing.T) {+ for _, tc := range auditReadCases() {+ for _, transport := range []string{"header", "bearer", "session"} {+ t.Run(tc.name+"/"+transport, func(t *testing.T) {+ router, cfg, server, hold := newHeldAuditReadRouter(t)+ ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)+ defer cancel()+ raw := logStreamToken+ if transport == "session" {+ raw = "synthetic-audit-session"+ GetSessionStore().CreateSession(raw, time.Hour, "fixture", "127.0.0.1", cfg.AuthUser)+ t.Cleanup(func() { GetSessionStore().DeleteSession(raw) })+ }+ hold.armed.Store(true)+ type result struct {+ response *http.Response+ err error+ }+ done := make(chan result, 1)+ go func() {+ r, e := server.Client().Do(auditReadRequest(t, ctx, server, tc.path, raw, transport))+ done <- result{r, e}+ }()+ select {+ case <-hold.entered:+ case r := <-done:+ t.Fatalf("read not admitted: %v %v", r.response, r.err)+ case <-ctx.Done():+ t.Fatal("read did not reach storage 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(auditReadRequest(t, ctx, server, tc.path, raw, transport))+ if err != nil {+ t.Fatal(err)+ }+ fresh.Body.Close()+ if fresh.StatusCode != http.StatusUnauthorized {+ t.Fatalf("fresh admission=%d", fresh.StatusCode)+ }+ hold.unblock()+ var completed result+ select {+ case completed = <-done:+ case <-ctx.Done():+ t.Fatal("held read 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)+ }+ if completed.response.StatusCode != http.StatusUnauthorized || string(body) != "Authentication required\n" || completed.response.Header.Get("Content-Disposition") != "" || completed.response.Header.Get("X-Event-Count") != "" {+ t.Errorf("held audit=%d after persisted withdrawal (private evidence=%v), want generic 401 without attachment/count", completed.response.StatusCode, strings.Contains(string(body), tc.marker))+ }+ control, err := server.Client().Do(auditReadRequest(t, ctx, server, tc.path, 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), tc.marker) {+ t.Fatalf("independent audit read lost: %d %s %v", control.StatusCode, controlBody, err)+ }+ })+ }+ }+}++func TestAuditReadNativeWithdrawal(t *testing.T) { auditReadNativeWithdrawal(t) }++func TestAuditReadPreservesAdmission(t *testing.T) {+ for _, gate := range []string{"scope", "licence", "session_admin"} {+ t.Run(gate, func(t *testing.T) {+ router, cfg, server, _ := newHeldAuditReadRouter(t)+ raw, transport, want := logStreamToken, "header", http.StatusForbidden+ switch gate {+ case "scope":+ config.Mu.Lock()+ cfg.APITokens[0].Scopes = []string{config.ScopeMonitoringRead}+ config.Mu.Unlock()+ case "licence":+ setLicenseTierForHandlersForTests(t, router.licenseHandlers, "default", pkglicensing.TierFree)+ want = http.StatusPaymentRequired+ case "session_admin":+ raw, transport = "synthetic-nonadmin-audit-session", "session"+ GetSessionStore().CreateSession(raw, time.Hour, "fixture", "127.0.0.1", "different-user")+ t.Cleanup(func() { GetSessionStore().DeleteSession(raw) })+ }+ for _, tc := range auditReadCases() {+ response, err := server.Client().Do(auditReadRequest(t, context.Background(), server, tc.path, raw, transport))+ if err != nil {+ t.Fatal(err)+ }+ body, err := io.ReadAll(response.Body)+ response.Body.Close()+ if err != nil || response.StatusCode != want || strings.Contains(string(body), tc.marker) || response.Header.Get("Content-Disposition") != "" {+ t.Errorf("%s gate=%d %s, want %d", tc.name, response.StatusCode, body, want)+ }+ }+ })+ }+}diff --git a/internal/api/contract_test.go b/internal/api/contract_test.goindex 5e9e6bc516..4a28715504 100644--- a/internal/api/contract_test.go+++ b/internal/api/contract_test.go@@ -29139,3 +29139,10 @@ func TestContractSupportBundleStopsAfterAdmittedPrefix(t *testing.T) {func TestContractReportDownloadWithdrawal(t *testing.T) {reportDownloadNativeWithdrawal(t)}++// Audit evidence stays behind current admitted authority even when storage+// returns after a persisted DELETE/logout. Existing admission, signed evidence+// and independent readers remain unchanged.+func TestContractAuditReadWithdrawal(t *testing.T) {+ auditReadNativeWithdrawal(t)+}diff --git a/internal/api/report_download_authority_test.go b/internal/api/report_download_authority_test.goindex b7b987fdf6..446167bb56 100644--- a/internal/api/report_download_authority_test.go+++ b/internal/api/report_download_authority_test.go@@ -13,7 +13,7 @@ import ()func TestReportDownloadMediaPoliciesStaySeparate(t *testing.T) {- for _, policy := range []responseMediaPolicy{responseMediaJSON, responseMediaZIP, responseMediaReport, responseMediaPolicy(255)} {+ for _, policy := range []responseMediaPolicy{responseMediaJSON, responseMediaZIP, responseMediaReport, responseMediaAudit, 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()@@ -36,6 +36,13 @@ func TestReportDownloadMediaPoliciesStaySeparate(t *testing.T) {if provided == "application/zip" {want = provided}+ case responseMediaAudit:+ switch {+ case provided == "application/json":+ want = provided+ case strings.HasPrefix(provided, "text/csv"):+ want = "text/csv; charset=utf-8"+ }case responseMediaReport:switch {case provided == "application/json", provided == "application/pdf":@@ -58,6 +65,10 @@ func TestReportDownloadMediaPoliciesStaySeparate(t *testing.T) {}func TestReportDownloadCurrentAuthorityAndPrefix(t *testing.T) {+ responseCurrentAuthorityAndPrefix(t, config.ScopeSettingsRead, responseMediaReport)+}++func responseCurrentAuthorityAndPrefix(t *testing.T, scope string, media responseMediaPolicy) {for _, transport := range []string{"header", "bearer", "session"} {changes := []string{"revoked", "expired", "scope", "org", "identity", "principal", "unrelated_scope"}if transport == "session" {@@ -70,7 +81,7 @@ func TestReportDownloadCurrentAuthorityAndPrefix(t *testing.T) {name = change + "/after_prefix"}t.Run(transport+"/"+name, func(t *testing.T) {- cfg := newTestConfigWithTokens(t, newTokenRecord(t, logStreamToken, []string{config.ScopeSettingsRead, config.ScopeAIExecute}, nil))+ cfg := newTestConfigWithTokens(t, newTokenRecord(t, logStreamToken, []string{scope, config.ScopeAIExecute}, nil))const session = "synthetic-report-prefix-session"if transport == "session" {InitSessionStore(t.TempDir())@@ -88,7 +99,7 @@ func TestReportDownloadCurrentAuthorityAndPrefix(t *testing.T) {}base := httptest.NewRecorder()var late http.ResponseWriter- guard := retainResponseAuthority(cfg, config.ScopeSettingsRead, false, responseMediaReport, func(w http.ResponseWriter, r *http.Request) {+ guard := retainResponseAuthority(cfg, scope, false, media, func(w http.ResponseWriter, r *http.Request) {late = ww.Header().Set("Content-Type", "text/csv; charset=utf-8")w.Header().Set("Content-Disposition", "attachment; filename=synthetic.csv")@@ -116,7 +127,7 @@ func TestReportDownloadCurrentAuthorityAndPrefix(t *testing.T) {case "principal":cfg.APITokens[0].Metadata = map[string]string{apiTokenMetadataOwnerUserID: "different-owner"}case "unrelated_scope":- cfg.APITokens[0].Scopes = []string{config.ScopeSettingsRead}+ cfg.APITokens[0].Scopes = []string{scope}}config.Mu.Unlock()}@@ -162,13 +173,17 @@ func TestReportDownloadCurrentAuthorityAndPrefix(t *testing.T) {}func TestReportDownloadKeepsOrganizationBoundAuthority(t *testing.T) {- record := newTokenRecord(t, logStreamToken, []string{config.ScopeSettingsRead}, nil)+ responseKeepsOrganizationBoundAuthority(t, config.ScopeSettingsRead, responseMediaReport)+}++func responseKeepsOrganizationBoundAuthority(t *testing.T, scope string, media responseMediaPolicy) {+ record := newTokenRecord(t, logStreamToken, []string{scope}, 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) {+ handler := retainResponseAuthority(cfg, scope, false, media, 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)diff --git a/internal/api/router_routes_licensing.go b/internal/api/router_routes_licensing.goindex ce30f55a09..571ee43ee4 100644--- a/internal/api/router_routes_licensing.go+++ b/internal/api/router_routes_licensing.go@@ -53,49 +53,49 @@ func (r *Router) registerOrgLicenseRoutesGroup(orgHandlers *OrgHandlers, rbacHanif !ensureAdminSession(r.config, w, req) {return}- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, auditAdminEndpoints.HandleListEvents)))(w, req)+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaJSON, auditAdminEndpoints.HandleListEvents))))(w, req)}))r.mux.HandleFunc("GET /api/audit/", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceAuditLogs, func(w http.ResponseWriter, req *http.Request) {if !ensureAdminSession(r.config, w, req) {return}- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, auditAdminEndpoints.HandleListEvents)))(w, req)+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaJSON, auditAdminEndpoints.HandleListEvents))))(w, req)}))r.mux.HandleFunc("GET /api/audit/{id}/verify", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceAuditLogs, func(w http.ResponseWriter, req *http.Request) {if !ensureAdminSession(r.config, w, req) {return}- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityVerify, auditAdminEndpoints.HandleVerifyEvent)))(w, req)+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityVerify, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaJSON, auditAdminEndpoints.HandleVerifyEvent))))(w, req)}))r.mux.HandleFunc("GET /api/audit/export", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceAuditLogs, func(w http.ResponseWriter, req *http.Request) {if !ensureAdminSession(r.config, w, req) {return}- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityExport, auditAdminEndpoints.HandleExportEvents)))(w, req)+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityExport, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaAudit, auditAdminEndpoints.HandleExportEvents))))(w, req)}))r.mux.HandleFunc("GET /api/audit/summary", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceAuditLogs, func(w http.ResponseWriter, req *http.Request) {if !ensureAdminSession(r.config, w, req) {return}- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivitySummary, auditAdminEndpoints.HandleSummary)))(w, req)+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivitySummary, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaJSON, auditAdminEndpoints.HandleSummary))))(w, req)}))r.mux.HandleFunc("GET /api/audit/actions", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceAuditLogs, func(w http.ResponseWriter, req *http.Request) {if !ensureAdminSession(r.config, w, req) {return}- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, auditHandlers.HandleListUnifiedActionAudits)))(w, req)+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaJSON, auditHandlers.HandleListUnifiedActionAudits))))(w, req)}))r.mux.HandleFunc("GET /api/audit/actions/{id}/events", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceAuditLogs, func(w http.ResponseWriter, req *http.Request) {if !ensureAdminSession(r.config, w, req) {return}- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, auditHandlers.HandleListUnifiedActionLifecycleEvents)))(w, req)+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaJSON, auditHandlers.HandleListUnifiedActionLifecycleEvents))))(w, req)}))r.mux.HandleFunc("GET /api/audit/exports", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceAuditLogs, func(w http.ResponseWriter, req *http.Request) {if !ensureAdminSession(r.config, w, req) {return}- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityExport, auditHandlers.HandleListUnifiedExportAudits)))(w, req)+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityExport, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaJSON, auditHandlers.HandleListUnifiedExportAudits))))(w, req)}))// RBAC routes (Phase 2 - Enterprise feature)diff --git a/internal/api/token_response_authority.go b/internal/api/token_response_authority.goindex a9c3913a1e..3c9a255767 100644--- a/internal/api/token_response_authority.go+++ b/internal/api/token_response_authority.go@@ -26,6 +26,7 @@ const (responseMediaJSON responseMediaPolicy = iotaresponseMediaZIPresponseMediaReport+ responseMediaAudit)// retainResponseAuthority serves slow synchronous results and private downloads.@@ -118,6 +119,14 @@ func (w *tokenResponseWriter) commitLocked(status int) {if mediaType == "application/zip" {pinnedType = mediaType}+ case responseMediaAudit:+ // Audit exports are structured evidence, never report PDFs.+ switch mediaType {+ case "application/json":+ pinnedType = mediaType+ case "text/csv":+ pinnedType = "text/csv; charset=utf-8"+ }case responseMediaReport:// Existing PDF/CSV attachments and structured API errors.// CSV is UTF-8; never forward renderer-supplied parameters.