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.

Withdraw stale Settings access after a failed status refresh

pulse-triage[bot]cf3abe196db0
diff --git a/docs/release-control/v6/internal/subsystems/organization-settings.md b/docs/release-control/v6/internal/subsystems/organization-settings.md
index d088926b51..b00a2aa30f 100644
--- a/docs/release-control/v6/internal/subsystems/organization-settings.md
+++ b/docs/release-control/v6/internal/subsystems/organization-settings.md
@@ -65,6 +65,27 @@ late read/write results. Actual App browser proof at desktop and narrow widths
exercises the producer through Settings, its registry, API client and dialogs.
Synthetic proof is not native receiver delivery, IdP or original tenant recovery.
+### Failed Settings access checks withdraw the previous grant
+
+A same-reader security-status refresh keeps the mounted panel and its draft
+while checking. Once a refresh fails (including HTTP refusal, unavailable
+transport or invalid JSON/status shape), Settings discards the previous status,
+unmounts capability-gated panels and withdraws shared Settings capability links.
+It keeps the existing safe General fallback and explains that access is unknown,
+not that permission was denied or authentication disabled. Explicit Retry only
+checks status again; it does not change permissions or repeat a mutation.
+
+Status reads are deduplicated, cancellable and not automatically retried. Panel
+disposal cancels the read and prevents late status from restoring local or shared
+capabilities. A failed check does not reset the separate read-only/demo policy to
+permissive defaults. Successful checks still use the served capabilities and
+existing navigation rules, with no backend or authentication-policy change.
+Normal `useSettingsAccess.refresh` and existing access/navigation tests exercise
+failure, recovery, pending same-reader preservation and disposal. Actual-App
+browser proof covers the password-dialog close producer, failed check, safe
+fallback and read-only retry at desktop and narrow widths; it is not original
+administrator, IdP or installed recovery.
+
### Role administration belongs to the current reader
The existing Roles screen binds its accepted role inventory, unsaved permissions,
diff --git a/frontend-modern/src/components/Settings/Settings.tsx b/frontend-modern/src/components/Settings/Settings.tsx
index 910f6d78cb..d48ef6cd5b 100644
--- a/frontend-modern/src/components/Settings/Settings.tsx
+++ b/frontend-modern/src/components/Settings/Settings.tsx
@@ -27,6 +27,7 @@ import { useSettingsNavigation } from './useSettingsNavigation';
import { getSettingsLoadingState } from '@/utils/settingsShellPresentation';
import { isRouteableSettingsLocation } from './settingsNavigationModel';
import { canMountSettingsPanel } from './settingsNavVisibility';
+import { Button } from '@/components/shared/Button';
import NotFound from '@/pages/NotFound';
import { getRuntimeLimit, loadRuntimeCapabilities } from '@/stores/license';
@@ -70,12 +71,18 @@ const SettingsWorkspace: Component<SettingsProps> = (props) => {
// Security
const [showQuickSecuritySetup, setShowQuickSecuritySetup] = createSignal(false);
const [showQuickSecurityWizard, setShowQuickSecurityWizard] = createSignal(false);
- const { securityStatus, securityStatusLoading, flatTabs, filteredTabGroups, loadSecurityStatus } =
- useSettingsAccess({
- activeTab,
- setActiveTab,
- searchQuery,
- });
+ const {
+ securityStatus,
+ securityStatusLoading,
+ securityStatusError,
+ flatTabs,
+ filteredTabGroups,
+ loadSecurityStatus,
+ } = useSettingsAccess({
+ activeTab,
+ setActiveTab,
+ searchQuery,
+ });
const backupTransferFlow = useBackupTransferFlow({ securityStatus });
const systemSettings = useSystemSettingsState({
activeTab,
@@ -195,6 +202,26 @@ const SettingsWorkspace: Component<SettingsProps> = (props) => {
setActiveTab={setActiveTab}
isPro={isPro}
>
+ <Show when={securityStatusError()}>
+ <div
+ role="alert"
+ class="mb-4 space-y-3 rounded-md border border-border bg-surface-hover p-4 text-sm"
+ >
+ <p class="font-medium text-base-content">Settings access could not be verified</p>
+ <p class="text-muted">
+ Restricted settings are hidden until a fresh check succeeds. Retrying does not change
+ your permissions.
+ </p>
+ <Button
+ variant="secondary"
+ size="settingsAction"
+ disabled={securityStatusLoading()}
+ onClick={() => void loadSecurityStatus()}
+ >
+ {securityStatusLoading() ? 'Checking access…' : 'Retry access check'}
+ </Button>
+ </div>
+ </Show>
<Show
when={activeSettingsPanelEntry()}
fallback={securityStatusLoading() ? <SettingsPanelLoadingFallback /> : null}
diff --git a/frontend-modern/src/components/Settings/__tests__/useSettingsAccess.refresh.test.tsx b/frontend-modern/src/components/Settings/__tests__/useSettingsAccess.refresh.test.tsx
new file mode 100644
index 0000000000..250b8a22a5
--- /dev/null
+++ b/frontend-modern/src/components/Settings/__tests__/useSettingsAccess.refresh.test.tsx
@@ -0,0 +1,169 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { cleanup, render, waitFor } from '@solidjs/testing-library';
+import { createSignal, Show } from 'solid-js';
+import { useSettingsAccess } from '../useSettingsAccess';
+import { canMountSettingsPanel } from '../settingsNavVisibility';
+import {
+ syncSessionPresentationPolicy,
+ presentationPolicyIsReadOnly,
+} from '@/stores/sessionPresentationPolicy';
+import type { SecurityStatus } from '@/types/config';
+import type { SettingsTab } from '../settingsNavigationModel';
+import { sessionCanReadInfrastructureSettings } from '@/stores/sessionSettingsCapabilities';
+
+const { apiFetchMock } = vi.hoisted(() => ({ apiFetchMock: vi.fn() }));
+vi.mock('@/utils/apiClient', () => ({ apiFetch: apiFetchMock }));
+vi.mock('@/utils/logger', () => ({ logger: { debug: vi.fn(), error: vi.fn() } }));
+vi.mock('@/stores/license', () => ({
+ hasFeature: () => true,
+ runtimeCapabilitiesLoaded: () => true,
+ isHostedModeEnabled: () => false,
+ isRuntimeCapabilityBlocked: () => false,
+}));
+
+const grantedStatus = {
+ currentUsername: 'test-admin',
+ requiresAuth: true,
+ settingsCapabilities: { infrastructureRead: true, authenticationRead: true },
+};
+const response = (status: Partial<SecurityStatus> = grantedStatus) => ({
+ ok: true,
+ json: async () => status,
+});
+const deferred = <T,>() => {
+ let resolve!: (value: T) => void;
+ const promise = new Promise<T>((done) => {
+ resolve = done;
+ });
+ return { promise, resolve };
+};
+
+function mount() {
+ let access!: ReturnType<typeof useSettingsAccess>;
+ const view = render(() => {
+ const [activeTab, setActiveTab] = createSignal<SettingsTab>('security-auth');
+ access = useSettingsAccess({
+ activeTab,
+ setActiveTab,
+ searchQuery: () => '',
+ });
+ return (
+ <Show
+ when={canMountSettingsPanel('security-auth', access.securityStatus()?.settingsCapabilities)}
+ >
+ <p>Privileged panel</p>
+ </Show>
+ );
+ });
+ return { access, view };
+}
+
+describe('Settings capability refresh withdrawal', () => {
+ beforeEach(() => {
+ apiFetchMock.mockReset();
+ apiFetchMock.mockResolvedValue(response());
+ syncSessionPresentationPolicy(null);
+ });
+ afterEach(cleanup);
+
+ it.each([401, 403, 503])(
+ 'withdraws previously granted panels after a %i refresh',
+ async (status) => {
+ const { access, view } = mount();
+ await waitFor(() => expect(view.queryByText('Privileged panel')).not.toBeNull());
+ expect(sessionCanReadInfrastructureSettings()).toBe(true);
+ apiFetchMock.mockResolvedValue({ ok: false, status });
+ await access.loadSecurityStatus();
+ expect(access.securityStatus()).toBeNull();
+ expect(view.queryByText('Privileged panel')).toBeNull();
+ expect(sessionCanReadInfrastructureSettings()).toBe(false);
+ expect(access.securityStatusError()).toBe(true);
+ expect(apiFetchMock.mock.calls[1][1].retry).toBe(false);
+ },
+ );
+
+ it.each(['network', 'json'])(
+ 'withdraws previously granted panels after a %s failure',
+ async (failure) => {
+ const { access, view } = mount();
+ await waitFor(() => expect(view.queryByText('Privileged panel')).not.toBeNull());
+ if (failure === 'network')
+ apiFetchMock.mockRejectedValue(new Error('synthetic transport failure'));
+ else
+ apiFetchMock.mockResolvedValue({
+ ok: true,
+ json: async () => {
+ throw new SyntaxError('synthetic invalid JSON');
+ },
+ });
+ await access.loadSecurityStatus();
+ expect(access.securityStatus()).toBeNull();
+ expect(view.queryByText('Privileged panel')).toBeNull();
+ },
+ );
+
+ it('does not publish an in-flight capability response after disposal', async () => {
+ const pending = deferred<ReturnType<typeof response>>();
+ apiFetchMock.mockReturnValue(pending.promise);
+ const { access, view } = mount();
+ await waitFor(() => expect(apiFetchMock).toHaveBeenCalledTimes(1));
+ const request = access.loadSecurityStatus();
+ view.unmount();
+ pending.resolve(response());
+ await request;
+ expect(access.securityStatus()).toBeNull();
+ expect(sessionCanReadInfrastructureSettings()).toBe(false);
+ expect(apiFetchMock.mock.calls[0][1].signal.aborted).toBe(true);
+ await access.loadSecurityStatus();
+ expect(apiFetchMock).toHaveBeenCalledTimes(1);
+ });
+
+ it('keeps the same reader mounted while checking, then recovers only from a new successful check', async () => {
+ const { access, view } = mount();
+ await waitFor(() => expect(view.queryByText('Privileged panel')).not.toBeNull());
+ const pending = deferred<{ ok: boolean; status: number }>();
+ apiFetchMock.mockReturnValue(pending.promise);
+ const first = access.loadSecurityStatus();
+ const sameRequest = access.loadSecurityStatus();
+ expect(first).toBe(sameRequest);
+ expect(view.queryByText('Privileged panel')).not.toBeNull();
+ expect(access.securityStatusLoading()).toBe(true);
+ pending.resolve({ ok: false, status: 503 });
+ await first;
+ expect(view.queryByText('Privileged panel')).toBeNull();
+ expect(access.securityStatusError()).toBe(true);
+ apiFetchMock.mockResolvedValue(response());
+ await access.loadSecurityStatus();
+ expect(access.securityStatusError()).toBe(false);
+ expect(view.queryByText('Privileged panel')).not.toBeNull();
+ expect(sessionCanReadInfrastructureSettings()).toBe(true);
+ });
+
+ it('withdraws access without making a read-only session writable', async () => {
+ apiFetchMock.mockResolvedValue(
+ response({
+ ...grantedStatus,
+ presentationPolicy: { readOnly: true },
+ }),
+ );
+ const { access } = mount();
+ await waitFor(() => expect(access.securityStatusLoading()).toBe(false));
+ expect(presentationPolicyIsReadOnly()).toBe(true);
+ apiFetchMock.mockResolvedValue({ ok: false, status: 503 });
+ await access.loadSecurityStatus();
+ expect(presentationPolicyIsReadOnly()).toBe(true);
+ expect(access.securityStatus()).toBeNull();
+ });
+
+ it.each([null, [], 'unexpected'])(
+ 'does not accept malformed status %j as a fresh check',
+ async (body) => {
+ const { access } = mount();
+ await waitFor(() => expect(access.securityStatusLoading()).toBe(false));
+ apiFetchMock.mockResolvedValue({ ok: true, json: async () => body });
+ await access.loadSecurityStatus();
+ expect(access.securityStatus()).toBeNull();
+ expect(access.securityStatusError()).toBe(true);
+ },
+ );
+});
diff --git a/frontend-modern/src/components/Settings/useSettingsAccess.ts b/frontend-modern/src/components/Settings/useSettingsAccess.ts
index 2592dd3425..e369491d31 100644
--- a/frontend-modern/src/components/Settings/useSettingsAccess.ts
+++ b/frontend-modern/src/components/Settings/useSettingsAccess.ts
@@ -1,4 +1,13 @@
-import { Accessor, createEffect, createMemo, createSignal, onMount } from 'solid-js';
+import {
+ Accessor,
+ batch,
+ createEffect,
+ createMemo,
+ createSignal,
+ onCleanup,
+ onMount,
+} from 'solid-js';
+import { syncSessionSettingsCapabilities } from '@/stores/sessionSettingsCapabilities';
import {
presentationPolicyHidesCommercialSurfaces,
presentationPolicyHidesOrganizationSurfaces,
@@ -44,6 +53,7 @@ export function useSettingsAccess({
}: UseSettingsAccessParams) {
const [securityStatus, setSecurityStatus] = createSignal<SecurityStatus | null>(null);
const [securityStatusLoading, setSecurityStatusLoading] = createSignal(true);
+ const [securityStatusError, setSecurityStatusError] = createSignal(false);
const commercialSurfacesHidden = createMemo(() => {
const resolvedSecurityStatus = securityStatus();
if (resolvedSecurityStatus) {
@@ -97,7 +107,7 @@ export function useSettingsAccess({
const settingsCapabilities = securityStatus()?.settingsCapabilities ?? null;
// A failed status request is a resolved denial, not permission to expose
// capability-gated routes. Keep an existing successful status usable while
- // it refreshes, but fail closed once the first request settles without one.
+ // it refreshes, but withdraw it if that refresh cannot verify access.
const settingsCapabilitiesResolved = securityStatus() !== null || !securityStatusLoading();
return {
@@ -221,28 +231,60 @@ export function useSettingsAccess({
});
let securityStatusRequest: Promise<void> | null = null;
+ let securityStatusController: AbortController | null = null;
+ let disposed = false;
+
+ onCleanup(() => {
+ disposed = true;
+ securityStatusController?.abort();
+ });
async function fetchSecurityStatus() {
+ const controller = new AbortController();
+ securityStatusController = controller;
setSecurityStatusLoading(true);
try {
const { apiFetch } = await import('@/utils/apiClient');
- const response = await apiFetch('/api/security/status');
- if (response.ok) {
- const status = (await response.json()) as SecurityStatus;
- logger.debug('Security status loaded', status);
+ if (disposed) return;
+ const response = await apiFetch('/api/security/status', {
+ signal: controller.signal,
+ retry: false,
+ });
+ if (disposed) return;
+ if (!response.ok) {
+ throw new Error(`Security status request failed (${response.status})`);
+ }
+ const status = (await response.json()) as SecurityStatus;
+ if (disposed) return;
+ if (!status || typeof status !== 'object' || Array.isArray(status)) {
+ throw new Error('Invalid security status');
+ }
+ batch(() => {
syncSessionPresentationPolicy(status);
setSecurityStatus(status);
- } else {
- logger.error('Failed to fetch security status', { status: response.status });
- }
+ setSecurityStatusError(false);
+ });
} catch (error) {
+ if (disposed) return;
logger.error('Failed to fetch security status', error);
+ batch(() => {
+ // A previous grant is not evidence of current access. Unmount restricted
+ // panels and withdraw their links, without resetting the session's
+ // separate read-only/demo presentation policy to permissive defaults.
+ setSecurityStatus(null);
+ syncSessionSettingsCapabilities(null);
+ setSecurityStatusError(true);
+ });
} finally {
- setSecurityStatusLoading(false);
+ if (!disposed) {
+ securityStatusController = null;
+ setSecurityStatusLoading(false);
+ }
}
}
function loadSecurityStatus(): Promise<void> {
+ if (disposed) return Promise.resolve();
if (securityStatusRequest) {
return securityStatusRequest;
}
@@ -263,6 +305,7 @@ export function useSettingsAccess({
return {
securityStatus,
securityStatusLoading,
+ securityStatusError,
visibleTabGroups,
flatTabs,
filteredTabGroups,