Skip to content

armgit / Pulse

Public Imported from GitHub
0

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.

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.md
index 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` now
also accepts the registry's Kubernetes target kinds (`pod`, `k8s-cluster`,
`k8s-node`, `k8s-deployment`) as the `k8s` store type; that widens which
spellings 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.tsx
index 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.tsx
index 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.tsx
index 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.ts
index 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.ts
index 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.ts
index 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.go
index 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) f
return 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, true
diff --git a/internal/api/log_handlers.go b/internal/api/log_handlers.go
index 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 first
for _, 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.go
new file mode 100644
index 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)
+}