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
End withdrawn System Logs token reads and show connection loss
pulse-triage[bot]b732ff2b40ed
diff --git a/docs/release-control/v6/internal/subsystems/security-privacy.md b/docs/release-control/v6/internal/subsystems/security-privacy.mdindex cfd2f55691..298768d99f 100644--- a/docs/release-control/v6/internal/subsystems/security-privacy.md+++ b/docs/release-control/v6/internal/subsystems/security-privacy.md@@ -3940,3 +3940,23 @@ already read from the chart route. `normalizeMetricsHistoryResourceType` nowalso accepts the registry's Kubernetes target kinds (`pod`, `k8s-cluster`,`k8s-node`, `k8s-deployment`) as the `k8s` store type; that widens whichspellings reach the same store type, not who may read it.++### System Logs retains its existing route authority throughout a token stream++`GET /api/logs/stream` keeps the instance-admin and `settings:read` gates, its+existing SSE log-line format and session/proxy admission. A token reader must+also retain its admitted credential, principal, selected organization and+instance-wide authority before every replayed or live line. Revocation, expiry,+scope withdrawal, rebinding or a disallowed runtime role ends only that reader;+an idle token reader is rechecked every 15 seconds without emitting a log or+heartbeat. Already admitted response bytes cannot be retracted. Independent+readers and server logging continue. The existing current-inventory snapshot+validator is shared with monitoring streams, with the required scope explicit.++The existing System Logs panel reports native connection state, not a green+Streaming indication after EOF or a denied reconnect. Display pause is still+local and does not hide a connection failure; no failure cause or recovery is+inferred. Tests: `internal/api/log_stream_auth_test.go`,+`frontend-modern/src/components/Settings/__tests__/useSystemLogsPanelState.test.tsx`,+`frontend-modern/src/components/Settings/__tests__/SystemLogsPanel.safety.test.tsx`+and `frontend-modern/src/utils/__tests__/systemLogsPresentation.test.ts`.diff --git a/frontend-modern/src/components/Settings/SystemLogsPanel.tsx b/frontend-modern/src/components/Settings/SystemLogsPanel.tsxindex bbb9360366..079ce222f2 100644--- a/frontend-modern/src/components/Settings/SystemLogsPanel.tsx+++ b/frontend-modern/src/components/Settings/SystemLogsPanel.tsx@@ -22,7 +22,8 @@ export const SystemLogsPanel: Component = () => {const displayHelpId = createUniqueId();const bundleHelpId = createUniqueId();- const streamPresentation = () => getSystemLogStreamPresentation(state.isPaused());+ const streamPresentation = () =>+ getSystemLogStreamPresentation(state.isPaused(), state.connectionState());return (<div class="space-y-6">@@ -117,9 +118,9 @@ export const SystemLogsPanel: Component = () => {)}</div>- <div class="text-xs text-muted flex justify-between px-1 pt-4">+ <div class="text-xs text-muted flex flex-wrap gap-2 justify-between px-1 pt-4"><span>{getSystemLogBufferSummary(state.logs().length, state.maxLogs)}</span>- <span class="flex items-center gap-2">+ <span role="status" class="flex items-center gap-2"><div class={`w-2 h-2 rounded-full ${streamPresentation().indicatorClass}`}></div>{streamPresentation().label}</span>diff --git a/frontend-modern/src/components/Settings/__tests__/SystemLogsPanel.safety.test.tsx b/frontend-modern/src/components/Settings/__tests__/SystemLogsPanel.safety.test.tsxindex d730fd4075..512bec62db 100644--- a/frontend-modern/src/components/Settings/__tests__/SystemLogsPanel.safety.test.tsx+++ b/frontend-modern/src/components/Settings/__tests__/SystemLogsPanel.safety.test.tsx@@ -11,6 +11,9 @@ vi.mock('@/stores/notifications', () => ({class DisplayStream {static instances: DisplayStream[] = [];+ static CLOSED = 2;+ readyState = 0;+ onopen: (() => void) | null = null;onmessage: ((event: { data: string }) => void) | null = null;onerror: (() => void) | null = null;close = vi.fn();@@ -43,6 +46,29 @@ describe('SystemLogsPanel control safety', () => {vi.unstubAllGlobals();});+ it('does not call a disconnected or reconnecting native stream Streaming, even when the display is paused', async () => {+ const { stream } = await mountPanel();+ expect(screen.getByRole('status')).toHaveTextContent('Connecting');+ stream.onopen?.();+ expect(screen.getByRole('status')).toHaveTextContent('Streaming');+ stream.readyState = 0;+ stream.onerror?.();+ expect(screen.getByRole('status')).toHaveTextContent('Reconnecting');+ fireEvent.click(screen.getByRole('button', { name: 'Pause Stream' }));+ expect(screen.getByRole('status')).toHaveTextContent('Reconnecting · paused');+ stream.readyState = 2;+ stream.onerror?.();+ expect(screen.getByRole('status')).toHaveTextContent('Disconnected · paused');+ expect(screen.getByRole('status')).not.toHaveTextContent('Streaming');+ fireEvent.click(screen.getByRole('button', { name: 'Clear Log Output' }));+ expect(screen.getByRole('status')).toHaveTextContent('Disconnected · paused');+ stream.onopen?.();+ expect(screen.getByRole('status')).toHaveTextContent('Paused');+ fireEvent.click(screen.getByRole('button', { name: 'Resume Stream' }));+ expect(screen.getByRole('status')).toHaveTextContent('Streaming');+ expect(apiFetchJSON.mock.calls).toEqual([['/api/logs/level']]);+ });+it('describes the server-wide threshold at the level control without changing it on mount', async () => {await mountPanel();const select = screen.getByRole('combobox', { name: 'Server Log Level:' });diff --git a/frontend-modern/src/components/Settings/__tests__/useSystemLogsPanelState.test.tsx b/frontend-modern/src/components/Settings/__tests__/useSystemLogsPanelState.test.tsxindex 131e562221..39f830286a 100644--- a/frontend-modern/src/components/Settings/__tests__/useSystemLogsPanelState.test.tsx+++ b/frontend-modern/src/components/Settings/__tests__/useSystemLogsPanelState.test.tsx@@ -12,6 +12,9 @@ vi.mock('@/utils/logger', () => ({ logger: { debug: vi.fn(), error: vi.fn() } })class FixtureEventSource {static instances: FixtureEventSource[] = [];+ static CLOSED = 2;+ readyState = 0;+ onopen: (() => void) | null = null;onmessage: ((event: MessageEvent<string>) => void) | null = null;onerror: (() => void) | null = null;close = vi.fn();@@ -96,6 +99,37 @@ afterEach(() => {});describe('live system log rendering', () => {+ it('reports native connection state independently of display pause, and recovers without clearing accepted lines', async () => {+ const { state, stream, view } = await mount();+ expect(state.connectionState()).toBe('connecting');+ stream.onopen?.();+ expect(state.connectionState()).toBe('streaming');+ stream.send('accepted before disconnect');+ flushFrame();+ state.togglePaused();+ stream.readyState = 0;+ stream.onerror?.();+ expect(state.connectionState()).toBe('reconnecting');+ expect(state.isPaused()).toBe(true);+ expect(state.logs()).toEqual(['accepted before disconnect']);+ stream.readyState = 2;+ stream.onerror?.();+ expect(state.connectionState()).toBe('disconnected');+ expect(stream.close).not.toHaveBeenCalled();+ stream.readyState = 1;+ stream.onopen?.();+ expect(state.connectionState()).toBe('streaming');+ stream.send('not collected while paused');+ flushFrame();+ expect(state.logs()).toEqual(['accepted before disconnect']);+ view.unmount();+ stream.onerror?.();+ stream.onopen?.();+ expect(state.connectionState()).toBe('streaming');+ expect(stream.close).toHaveBeenCalledTimes(1);+ expect(mocks.api.mock.calls).toEqual([['/api/logs/level']]);+ });+it('publishes and scrolls once per frame, after the accepted rows render', async () => {const { state, stream, measure, scroll, publish, container } = await mount();stream.send('first');diff --git a/frontend-modern/src/components/Settings/useSystemLogsPanelState.ts b/frontend-modern/src/components/Settings/useSystemLogsPanelState.tsindex ce5853da80..2b24ffde3e 100644--- a/frontend-modern/src/components/Settings/useSystemLogsPanelState.ts+++ b/frontend-modern/src/components/Settings/useSystemLogsPanelState.ts@@ -2,6 +2,7 @@ import { createSignal, onCleanup, onMount } from 'solid-js';import { apiFetchJSON } from '@/utils/apiClient';import { notificationStore } from '@/stores/notifications';import { logger } from '@/utils/logger';+import type { SystemLogConnectionState } from '@/utils/systemLogsPresentation';const MAX_LOGS = 1000;@@ -10,6 +11,8 @@ export function useSystemLogsPanelState() {const [isPaused, setIsPaused] = createSignal(false);const [level, setLevel] = createSignal('info');const [isLoading, setIsLoading] = createSignal(true);+ const [connectionState, setConnectionState] =+ createSignal<SystemLogConnectionState>('connecting');let logContainer: HTMLDivElement | undefined;let eventSource: EventSource | null = null;@@ -69,9 +72,16 @@ export function useSystemLogsPanelState() {if (disposed) return;eventSource = new EventSource('/api/logs/stream');+ const source = eventSource;- eventSource.onmessage = (event) => {- if (disposed || isPaused()) return;+ source.onopen = () => {+ if (!disposed) setConnectionState('streaming');+ };++ source.onmessage = (event) => {+ if (disposed) return;+ setConnectionState('streaming');+ if (isPaused()) return;pendingLogs[pendingNext] = event.data;pendingNext = (pendingNext + 1) % MAX_LOGS;@@ -84,9 +94,14 @@ export function useSystemLogsPanelState() {}};- eventSource.onerror = () => {+ source.onerror = () => {if (disposed) return;- logger.debug('SSE stream disconnected, reconnecting...');+ // Native EventSource retries transient EOF, but stops after a denied+ // reconnect. Neither state is evidence of a live stream or its cause.+ setConnectionState(+ source.readyState === EventSource.CLOSED ? 'disconnected' : 'reconnecting',+ );+ logger.debug('SSE log stream disconnected');};};@@ -139,6 +154,7 @@ export function useSystemLogsPanelState() {return {clearLogs,+ connectionState,handleDownload,handleLevelChange,isLoading,diff --git a/frontend-modern/src/utils/__tests__/systemLogsPresentation.test.ts b/frontend-modern/src/utils/__tests__/systemLogsPresentation.test.tsindex 8bc169db8c..199000d11e 100644--- a/frontend-modern/src/utils/__tests__/systemLogsPresentation.test.ts+++ b/frontend-modern/src/utils/__tests__/systemLogsPresentation.test.ts@@ -55,6 +55,21 @@ describe('systemLogsPresentation', () => {});});+ it('gives connection loss precedence over display state without changing Pause/Resume controls', () => {+ for (const [connection, label] of [+ ['connecting', 'Connecting'],+ ['reconnecting', 'Reconnecting'],+ ['disconnected', 'Disconnected'],+ ] as const) {+ for (const paused of [false, true]) {+ const result = getSystemLogStreamPresentation(paused, connection);+ expect(result.label).toBe(label + (paused ? ' · paused' : ''));+ expect(result.indicatorClass).not.toContain('emerald');+ expect(result.toggleTitle).toBe(paused ? 'Resume Stream' : 'Pause Stream');+ }+ }+ });+it('formats the canonical log buffer summary', () => {expect(getSystemLogBufferSummary(24, 500)).toBe('Buffer: 24 / 500 lines');});diff --git a/frontend-modern/src/utils/systemLogsPresentation.ts b/frontend-modern/src/utils/systemLogsPresentation.tsindex 1cd12325ea..a545d66bcd 100644--- a/frontend-modern/src/utils/systemLogsPresentation.ts+++ b/frontend-modern/src/utils/systemLogsPresentation.ts@@ -5,6 +5,8 @@ export type SystemLogStreamPresentation = {toggleTitle: string;};+export type SystemLogConnectionState = 'connecting' | 'streaming' | 'reconnecting' | 'disconnected';+export type SystemLogLevelOption = {value: 'debug' | 'info' | 'warn' | 'error';label: string;@@ -64,8 +66,22 @@ export function getSystemLogLineClass(log: string): string {return 'text-slate-300';}-export function getSystemLogStreamPresentation(paused: boolean): SystemLogStreamPresentation {- return paused ? STREAM_PRESENTATION.paused : STREAM_PRESENTATION.live;+export function getSystemLogStreamPresentation(+ paused: boolean,+ connection: SystemLogConnectionState = 'streaming',+): SystemLogStreamPresentation {+ const display = paused ? STREAM_PRESENTATION.paused : STREAM_PRESENTATION.live;+ if (connection === 'streaming') return display;+ const labels = {+ connecting: 'Connecting',+ reconnecting: 'Reconnecting',+ disconnected: 'Disconnected',+ };+ return {+ ...display,+ indicatorClass: connection === 'disconnected' ? 'bg-slate-400' : 'bg-amber-400',+ label: `${labels[connection]}${paused ? ' · paused' : ''}`,+ };}export function getSystemLogBufferSummary(logCount: number, maxLogs: number): string {diff --git a/internal/api/agent_events_auth.go b/internal/api/agent_events_auth.goindex bf01ddfa41..fe288ebc22 100644--- a/internal/api/agent_events_auth.go+++ b/internal/api/agent_events_auth.go@@ -39,6 +39,13 @@ func agentEventTokenRevalidator(cfg *config.Config, req *http.Request) func() bo// WebSocket writes outlive the HTTP handler and must not race its middleware.// A nil callback preserves existing session/proxy authentication behaviour.func monitoringTokenSnapshotRevalidator(cfg *config.Config, req *http.Request) func() (*config.APITokenRecord, bool) {+ return tokenStreamSnapshotRevalidator(cfg, req, config.ScopeMonitoringRead)+}++// tokenStreamSnapshotRevalidator preserves the stream's admitted credential,+// principal and organization while checking its current operation-specific+// scope. Callers must retain any additional route policy (e.g. instance admin).+func tokenStreamSnapshotRevalidator(cfg *config.Config, req *http.Request, scope string) func() (*config.APITokenRecord, bool) {admitted := getAPITokenRecordFromRequest(req)if admitted == nil {return nil@@ -71,7 +78,7 @@ func monitoringTokenSnapshotRevalidator(cfg *config.Config, req *http.Request) freturn nil, false}if current.ID != admitted.ID || apiTokenAuthenticatedUser(current) != apiTokenAuthenticatedUser(admitted) ||- !current.HasScope(config.ScopeMonitoringRead) || !checker.CheckAccess(current, "", orgID).Allowed {+ !current.HasScope(scope) || !checker.CheckAccess(current, "", orgID).Allowed {return nil, false}return current, truediff --git a/internal/api/log_handlers.go b/internal/api/log_handlers.goindex f5827c67ba..0fed42c7ac 100644--- a/internal/api/log_handlers.go+++ b/internal/api/log_handlers.go@@ -29,6 +29,20 @@ func NewLogHandlers(cfg *config.Config, persistence *config.ConfigPersistence) *// HandleStreamLogs streams logs using SSE (Server-Sent Events)func (h *LogHandlers) HandleStreamLogs(w http.ResponseWriter, r *http.Request) {+ revalidate := tokenStreamSnapshotRevalidator(h.config, r, config.ScopeSettingsRead)+ allowed := func() bool {+ if revalidate == nil {+ // Existing browser-session/proxy admission remains with the route.+ return true+ }+ current, ok := revalidate()+ return ok && tokenActsForInstance(current)+ }+ if !allowed() {+ http.Error(w, "Authentication required", http.StatusUnauthorized)+ return+ }+flusher, ok := w.(http.Flusher)if !ok {http.Error(w, "Streaming not supported", http.StatusInternalServerError)@@ -45,6 +59,9 @@ func (h *LogHandlers) HandleStreamLogs(w http.ResponseWriter, r *http.Request) {// Send history firstfor _, line := range history {+ if !allowed() {+ return+ }if _, err := fmt.Fprintf(w, "data: %s\n\n", line); err != nil {return}@@ -52,6 +69,14 @@ func (h *LogHandlers) HandleStreamLogs(w http.ResponseWriter, r *http.Request) {flusher.Flush()notify := r.Context().Done()+ // End an idle withdrawn token reader too, without generating log entries,+ // writing keepalive frames or changing session/proxy stream behaviour.+ var recheck <-chan time.Time+ if revalidate != nil {+ ticker := time.NewTicker(15 * time.Second)+ defer ticker.Stop()+ recheck = ticker.C+ }for {select {@@ -59,12 +84,19 @@ func (h *LogHandlers) HandleStreamLogs(w http.ResponseWriter, r *http.Request) {if !ok {return}+ if !allowed() {+ return+ }if _, err := fmt.Fprintf(w, "data: %s\n\n", msg); err != nil {return}flusher.Flush()case <-notify:return+ case <-recheck:+ if !allowed() {+ return+ }}}}diff --git a/internal/api/log_stream_auth_test.go b/internal/api/log_stream_auth_test.gonew file mode 100644index 0000000000..20fb82147e--- /dev/null+++ b/internal/api/log_stream_auth_test.go@@ -0,0 +1,256 @@+package api++import (+ "bufio"+ "context"+ "fmt"+ "io"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"+ "time"++ "github.com/rcourtman/pulse-go-rewrite/internal/config"+ "github.com/rcourtman/pulse-go-rewrite/internal/logging"+ internalauth "github.com/rcourtman/pulse-go-rewrite/pkg/auth"+)++const logStreamToken = "synthetic-log-stream-token.12345678"+const logStreamControl = "synthetic-log-control-token.12345678"++func newLogStreamRouter(t *testing.T) (*Router, *config.Config, *httptest.Server) {+ t.Helper()+ // System Logs needs settings:read, not monitoring:read or ai:execute.+ cfg := newTestConfigWithTokens(t,+ newTokenRecord(t, logStreamToken, []string{config.ScopeSettingsRead}, nil),+ newTokenRecord(t, logStreamControl, []string{config.ScopeWildcard}, nil))+ router := NewRouter(cfg, nil, nil, nil, nil, "test")+ cleanupTestRouter(t, router)+ server := httptest.NewServer(router.Handler())+ t.Cleanup(server.Close)+ return router, cfg, server+}++func openLogStream(t *testing.T, server *httptest.Server, raw, transport string) *bufio.Reader {+ t.Helper()+ marker := "admitted-" + t.Name() + "-" + transport+ logging.GetBroadcaster().Write([]byte(marker))+ ctx, cancel := context.WithTimeout(context.Background(), 25*time.Second)+ t.Cleanup(cancel)+ req, _ := http.NewRequestWithContext(ctx, http.MethodGet, server.URL+"/api/logs/stream", nil)+ 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)+ }+ resp, err := server.Client().Do(req)+ if err != nil {+ t.Fatal(err)+ }+ t.Cleanup(func() { resp.Body.Close() })+ if resp.StatusCode != http.StatusOK {+ body, _ := io.ReadAll(resp.Body)+ t.Fatalf("log stream admission = %d: %s", resp.StatusCode, body)+ }+ reader := bufio.NewReader(resp.Body)+ readLogStreamMarker(t, reader, marker)+ return reader+}++func readLogStreamMarker(t *testing.T, reader *bufio.Reader, marker string) {+ t.Helper()+ for {+ line, err := reader.ReadString('\n')+ if err != nil {+ t.Fatalf("log stream before marker %q: %v", marker, err)+ }+ if line == "data: "+marker+"\n" {+ return+ }+ }+}++func wantLogStreamClosed(t *testing.T, reader *bufio.Reader, forbidden string) {+ t.Helper()+ remaining, err := io.ReadAll(reader)+ if err != nil {+ t.Fatalf("withdrawn log stream did not reach EOF: %v", err)+ }+ if strings.Contains(string(remaining), forbidden) {+ t.Fatalf("withdrawn log stream disclosed %q", forbidden)+ }+}++func TestLogStreamRejectsWithdrawnTokenAuthority(t *testing.T) {+ for _, transport := range []string{"header", "bearer"} {+ for _, change := range []string{"revoked", "expired", "settings_read_removed", "org_rebound", "multi_org_rebound", "identity_replaced", "principal_replaced", "invalid_role"} {+ t.Run(transport+"/"+change, func(t *testing.T) {+ _, cfg, server := newLogStreamRouter(t)+ control := openLogStream(t, server, logStreamControl, "header")+ primary := openLogStream(t, server, logStreamToken, transport)+ 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 "settings_read_removed":+ cfg.APITokens[0].Scopes = []string{config.ScopeMonitoringRead}+ case "org_rebound":+ cfg.APITokens[0].OrgID = "tenant-only"+ case "multi_org_rebound":+ cfg.APITokens[0].OrgIDs = []string{"default", "tenant-only"}+ case "identity_replaced":+ cfg.APITokens[0].ID = "other-credential"+ case "principal_replaced":+ cfg.APITokens[0].Metadata = map[string]string{apiTokenMetadataOwnerUserID: "other-owner"}+ case "invalid_role":+ cfg.APITokens[0].Metadata = map[string]string{internalauth.RuntimeRoleMetadataKey: internalauth.RuntimeRoleActionRunner}+ }+ config.Mu.Unlock()+ marker := "not-for-withdrawn-reader-" + t.Name()+ logging.GetBroadcaster().Write([]byte(marker))+ wantLogStreamClosed(t, primary, marker)+ readLogStreamMarker(t, control, marker)+ })+ }+ }+}++func TestLogStreamDurableHTTPRevocation(t *testing.T) {+ router, cfg, server := newLogStreamRouter(t)+ primary := openLogStream(t, server, logStreamToken, "header")+ id := cfg.APITokens[0].ID+ req, _ := http.NewRequest(http.MethodDelete, server.URL+"/api/security/tokens/"+id, nil)+ req.Header.Set("X-API-Token", logStreamControl)+ resp, err := server.Client().Do(req)+ if err != nil {+ t.Fatal(err)+ }+ body, _ := io.ReadAll(resp.Body)+ resp.Body.Close()+ if resp.StatusCode != http.StatusNoContent {+ t.Fatalf("real token deletion = %d: %s", resp.StatusCode, body)+ }+ persisted, err := router.persistence.LoadAPITokens()+ if err != nil || len(persisted) != 1 || persisted[0].ID == id {+ t.Fatalf("deletion not persisted: %v, %d tokens", err, len(persisted))+ }+ const forbidden = "private-log-after-persisted-token-deletion"+ logging.GetBroadcaster().Write([]byte(forbidden))+ wantLogStreamClosed(t, primary, forbidden)+ req, _ = http.NewRequest(http.MethodGet, server.URL+"/api/logs/stream", nil)+ req.Header.Set("X-API-Token", logStreamToken)+ resp, err = server.Client().Do(req)+ if err != nil {+ t.Fatal(err)+ }+ defer resp.Body.Close()+ if resp.StatusCode != http.StatusUnauthorized {+ t.Fatalf("withdrawn reconnect = %d, want 401", resp.StatusCode)+ }+}++type logStreamMutationWriter struct {+ *httptest.ResponseRecorder+ afterWrite func(string)+ afterFlush func()+}++func (w *logStreamMutationWriter) Write(p []byte) (int, error) {+ n, err := w.ResponseRecorder.Write(p)+ if w.afterWrite != nil {+ w.afterWrite(string(p))+ }+ return n, err+}++func (w *logStreamMutationWriter) Flush() {+ w.ResponseRecorder.Flush()+ if w.afterFlush != nil {+ f := w.afterFlush+ w.afterFlush = nil+ f()+ }+}++func TestLogStreamChecksHistoryAndQueuedLines(t *testing.T) {+ for _, stage := range []string{"before_history", "between_history_lines", "queued_live_line"} {+ t.Run(stage, func(t *testing.T) {+ cfg := newTestConfigWithTokens(t, newTokenRecord(t, logStreamToken, []string{config.ScopeSettingsRead}, nil))+ revoke := func() {+ config.Mu.Lock()+ cfg.RemoveAPIToken(cfg.APITokens[0].ID)+ config.Mu.Unlock()+ }+ first, forbidden := "first-history-"+t.Name(), "private-later-line-"+t.Name()+ logging.GetBroadcaster().Write([]byte(first))+ logging.GetBroadcaster().Write([]byte(forbidden))+ writer := &logStreamMutationWriter{ResponseRecorder: httptest.NewRecorder()}+ if stage == "between_history_lines" {+ writer.afterWrite = func(line string) {+ if strings.Contains(line, first) {+ revoke()+ }+ }+ }+ if stage == "queued_live_line" {+ // Different sentinel: this one was never in the replay snapshot.+ forbidden += "-queued"+ writer.afterFlush = func() {+ revoke()+ logging.GetBroadcaster().Write([]byte(forbidden))+ }+ }+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)+ defer cancel()+ req := httptest.NewRequest(http.MethodGet, "/api/logs/stream", nil).WithContext(ctx)+ req.Header.Set("X-API-Token", logStreamToken)+ handler := NewLogHandlers(cfg, nil)+ AuthContextMiddleware(cfg, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if stage == "before_history" {+ revoke()+ }+ handler.HandleStreamLogs(w, r)+ })).ServeHTTP(writer, req)+ if strings.Contains(writer.Body.String(), forbidden) {+ t.Fatalf("withdrawn reader received %q at %s", forbidden, stage)+ }+ if stage == "before_history" && writer.Code != http.StatusUnauthorized {+ t.Fatalf("withdrawn initial admission = %d, want 401", writer.Code)+ }+ })+ }+}++func TestLogStreamIdleTokenWithdrawal(t *testing.T) {+ _, cfg, server := newLogStreamRouter(t)+ primary := openLogStream(t, server, logStreamToken, "header")+ config.Mu.Lock()+ cfg.RemoveAPIToken(cfg.APITokens[0].ID)+ config.Mu.Unlock()+ // No log write wakes the handler: use the production 15-second recheck.+ wantLogStreamClosed(t, primary, "data:")+}++func TestLogStreamPreservesAdminSession(t *testing.T) {+ _, cfg, server := newLogStreamRouter(t)+ config.Mu.Lock()+ cfg.AuthUser = "log-admin"+ config.Mu.Unlock()+ session := fmt.Sprintf("synthetic-log-session-%d", time.Now().UnixNano())+ GetSessionStore().CreateSession(session, time.Hour, "fixture", "127.0.0.1", "log-admin")+ t.Cleanup(func() { GetSessionStore().DeleteSession(session) })+ reader := openLogStream(t, server, session, "session")+ config.Mu.Lock()+ cfg.RemoveAPIToken(cfg.APITokens[0].ID)+ config.Mu.Unlock()+ const marker = "permitted-admin-session-after-unrelated-token-removal"+ logging.GetBroadcaster().Write([]byte(marker))+ readLogStreamMarker(t, reader, marker)+}