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.

Manage Proxmox TLS trust per existing polling endpoint

pulse-triage[bot]8e6d2485f1da
diff --git a/docs/release-control/v6/internal/subsystems/agent-lifecycle.md b/docs/release-control/v6/internal/subsystems/agent-lifecycle.md
index 7e89468b08..0793c2a030 100644
--- a/docs/release-control/v6/internal/subsystems/agent-lifecycle.md
+++ b/docs/release-control/v6/internal/subsystems/agent-lifecycle.md
@@ -15,6 +15,14 @@
## Purpose
+The connection editor exposes each member's actual runtime TLS endpoint.
+Its pin/CA controls submit only deliberately edited scopes, distinguish unknown
+first-use trust, and leave primary and other-member policy independent. Tests
+read the nodes API without enrolling agents or mutating background health.
+Address/credential changes must be saved before a stored-credential probe.
+The configured-node readback test and desktop/narrow consumer proof cover the
+saved policy and preservation of disabled collection, not installed recovery.
+
A trust edit round-trips explicit disabled PVE collection flags. It is not
permission to re-enable guest collection through a missing response field or
a new-connection default. `TestPVEEndpointTrustEditorPreservesDisabledCollectors`
diff --git a/docs/release-control/v6/internal/subsystems/api-contracts.md b/docs/release-control/v6/internal/subsystems/api-contracts.md
index 8c861bf851..c26f60cf74 100644
--- a/docs/release-control/v6/internal/subsystems/api-contracts.md
+++ b/docs/release-control/v6/internal/subsystems/api-contracts.md
@@ -21,6 +21,14 @@
## Purpose
+The node API client retains server-projected TLS endpoint and first-use fields,
+serialises explicit per-endpoint empty pin choices, and keeps credentials out
+of saved-connection test payloads. Nonempty malformed pin strings are preserved,
+not normalised into an empty CA choice. The editor's configured-node state consumes
+GET readback after saving trust instead of interpreting write-only overrides
+as configuration. `NodesAPI` tests and the configured-node readback test cover
+these client boundaries; peer edits never imply a cluster-wide trust reset.
+
Existing PVE `monitorVMs`, `monitorContainers`, `monitorStorage` and
`monitorBackups` response fields include false values. Omitting a disabled
scope would make the editor substitute its new-connection defaults and enable
diff --git a/docs/release-control/v6/internal/subsystems/organization-settings.md b/docs/release-control/v6/internal/subsystems/organization-settings.md
index 632c931959..cf552977bf 100644
--- a/docs/release-control/v6/internal/subsystems/organization-settings.md
+++ b/docs/release-control/v6/internal/subsystems/organization-settings.md
@@ -15,6 +15,31 @@
## Purpose
+### Proxmox endpoint trust in the existing connection editor
+
+The primary SSL fingerprint edits only its authority/base path. Each peer shows
+the server-projected `tlsEndpoint`, its own effective pin and, when applicable,
+unknown first-use state. A deliberate peer edit or CA-validation action submits
+only that endpoint; unchanged members are not cleared or assigned the primary
+pin. Explicit CA validation keeps Verify SSL enabled. Unknown first-use policy
+is not described as saved CA validation.
+
+Single-endpoint tests use stored credentials and optional draft TLS choices,
+not unsaved addresses or credentials. They do not save trust, mark background
+or agent health recovered, or claim other endpoints were tested. Draft edits
+invalidate earlier results, including a pending result from an older draft.
+After a successful trust save the configured-node owner reads back the actual
+server policy before reopening; write-only trust payloads are not cached as
+configuration. Disabled collection scope and secrets remain unchanged.
+
+Normal `nodeModalModel`, `useNodeModalState.connectionTest` and
+`NodeModalClusterMembersSection` tests cover partial trust submission, explicit
+empty choices, unknown members, saved-credential probes and stale-result
+invalidation. Desktop/narrow browser proof consumes actual source-produced
+node and probe responses through `NodeCredentialSlot` and the configured-node
+state owner. These fixtures do not establish native IdP, agent or appliance
+recovery.
+
Own organization role/share semantics and the canonical settings surfaces that
let users review organization metadata, manage membership, assign roles, and
create, review, and approve cross-organization shares.
diff --git a/frontend-modern/browser-verification/4472053bad0f3fc7.json b/frontend-modern/browser-verification/4472053bad0f3fc7.json
new file mode 100644
index 0000000000..47e2c1c107
--- /dev/null
+++ b/frontend-modern/browser-verification/4472053bad0f3fc7.json
@@ -0,0 +1,67 @@
+{
+ "version": 1,
+ "base_sha": "af1b1a48bd98a8d1881959c854997325a954babd",
+ "verified_at": "2026-10-27T07:59:24Z",
+ "result": "passed",
+ "changed_paths": [
+ "frontend-modern/src/api/nodes.ts",
+ "frontend-modern/src/components/Settings/NodeModalClusterMembersSection.tsx",
+ "frontend-modern/src/components/Settings/NodeModalMonitoringSection.tsx",
+ "frontend-modern/src/components/Settings/nodeModalModel.ts",
+ "frontend-modern/src/components/Settings/useInfrastructureConfiguredNodesState.ts",
+ "frontend-modern/src/components/Settings/useNodeModalState.ts",
+ "frontend-modern/src/types/nodes.ts",
+ "frontend-modern/src/utils/nodeModalPresentation.ts"
+ ],
+ "content_sha256": {
+ "frontend-modern/src/api/nodes.ts": "db598a556b38679bf81863808f170a86a4ab824def263a47f622855b38641bf0",
+ "frontend-modern/src/components/Settings/NodeModalClusterMembersSection.tsx": "224fd5c74d5d2f1290ba07e1e28a67ee2928a0541ba6ddd5a7b2e528bf487195",
+ "frontend-modern/src/components/Settings/NodeModalMonitoringSection.tsx": "b373049537c2b4e586ffec7adb57176c2d5a1da58c1e95c00dd9b772f4c87458",
+ "frontend-modern/src/components/Settings/nodeModalModel.ts": "54da9a46a8e6afc0da549c66f4337b5aa58b2ac562fbfea1d6a4bfe91c55ff38",
+ "frontend-modern/src/components/Settings/useInfrastructureConfiguredNodesState.ts": "ae12e4e5402af2633238f026384281d56f8189c27f5e36f8494395f09142240b",
+ "frontend-modern/src/components/Settings/useNodeModalState.ts": "b6e7e2cf36588d15794a22fd3459a8ae4524b412f946843b51723b148c7e96ac",
+ "frontend-modern/src/types/nodes.ts": "e6f0d2a402967e597a9b39b2c5920c88d5885e40fe13def5a76319d1d5532cae",
+ "frontend-modern/src/utils/nodeModalPresentation.ts": "8ae0f5105bb848979310133374bc265d27ae7799425d2f63aedfe9c87f6409a0"
+ },
+ "routes": [
+ "/settings/infrastructure"
+ ],
+ "viewports": [
+ {
+ "width": 1365,
+ "height": 1000
+ },
+ {
+ "width": 390,
+ "height": 844
+ }
+ ],
+ "states": [
+ "Separate primary and saved peer pins; preserved disabled collection flags",
+ "Qualified primary success while the peer still rejects its saved pin",
+ "Peer TLS failure and explicit pin update; save/authoritative readback/reopen",
+ "Explicit per-endpoint CA mode with verification enabled; empty policy saved/reopened",
+ "An old in-flight test result invalidated by a changed trust draft",
+ "Supplementary manually projected unknown-member state; deliberate CA choice, not silent pin clearing"
+ ],
+ "interactions": [
+ "Focus and Enter on the peer test control",
+ "Edit independently verified synthetic pin values; Test connection and Test TLS for beta",
+ "Save changes and reopen the actual configured-node owner after GET readback",
+ "Clear only selected primary/peer pins with Verify SSL still enabled",
+ "Change a peer draft while an earlier successful response is held, then release it",
+ "Use CA validation for beta explicitly; no generated credentials or agent action"
+ ],
+ "checks": 93,
+ "browsers": {
+ "playwright": "1.56.1",
+ "desktop-chromium": "141.0.7390.37",
+ "narrow-webkit": "26.0"
+ },
+ "evidence_scope": "Actual source-produced safe saved-node/probe frames from source-zvu2kva3 through production NodeCredentialSlot and configured-node state owner. Unknown-member supplemental GET projection is manual and distinguished in the evidence. Offline replay is not a live router, installed recovery, TLS identity of a reported endpoint, or agent-health acceptance.",
+ "native_pixel_review": {
+ "captures": 16,
+ "all_opened": true,
+ "limits": "Long pins scroll inside their input without page overflow. The result remains endpoint-qualified; tests do not prove background or agent health."
+ }
+}
diff --git a/frontend-modern/src/api/__tests__/nodes.test.ts b/frontend-modern/src/api/__tests__/nodes.test.ts
index 2c63265d62..95acdb3f7a 100644
--- a/frontend-modern/src/api/__tests__/nodes.test.ts
+++ b/frontend-modern/src/api/__tests__/nodes.test.ts
@@ -58,6 +58,9 @@ describe('NodesAPI', () => {
ip: ' 10.0.0.1 ',
ipOverride: ' 10.0.0.10 ',
fingerprint: ' fp ',
+ tlsEndpoint: ' https://pve-1.local:8006 ',
+ usesPrimaryTLS: true,
+ tlsFirstUse: false,
online: true,
lastSeen: ' 2026-03-04T00:00:00Z ',
pulseReachable: null,
@@ -86,7 +89,10 @@ describe('NodesAPI', () => {
guestURL: 'https://guest.local',
ip: '10.0.0.1',
ipOverride: '10.0.0.10',
- fingerprint: 'fp',
+ fingerprint: ' fp ',
+ tlsEndpoint: 'https://pve-1.local:8006',
+ usesPrimaryTLS: true,
+ tlsFirstUse: false,
online: true,
lastSeen: '2026-03-04T00:00:00Z',
lastPulseCheck: '2026-03-04T00:00:01Z',
@@ -284,6 +290,43 @@ describe('NodesAPI', () => {
});
});
+ it('tests one existing member with an explicit empty pin and no credential transfer', async () => {
+ vi.mocked(apiFetchJSON).mockResolvedValueOnce({ status: 'success' });
+ await NodesAPI.testExistingNode('pve-0', {
+ endpoint: 'https://peer.test:8006',
+ verifySSL: true,
+ fingerprint: '',
+ });
+ expect(apiFetchJSON).toHaveBeenCalledWith('/api/config/nodes/pve-0/test', {
+ method: 'POST',
+ body: JSON.stringify({
+ endpoint: 'https://peer.test:8006',
+ verifySSL: true,
+ fingerprint: '',
+ }),
+ });
+ });
+
+ it('does not normalise malformed nonempty member trust into CA mode', async () => {
+ vi.mocked(apiFetchJSON).mockResolvedValueOnce([
+ makePveNode({
+ clusterEndpoints: [
+ {
+ nodeId: 'peer',
+ nodeName: 'peer',
+ host: 'https://peer.test:8006',
+ ip: '',
+ online: true,
+ lastSeen: '',
+ fingerprint: ' ',
+ },
+ ],
+ }),
+ ]);
+ const [node] = await NodesAPI.getNodes();
+ expect('clusterEndpoints' in node && node.clusterEndpoints?.[0].fingerprint).toBe(' ');
+ });
+
describe('refreshClusterNodes', () => {
it('refreshes cluster nodes', async () => {
vi.mocked(apiFetchJSON).mockResolvedValueOnce({ status: 'ok', newNodeCount: 3 });
diff --git a/frontend-modern/src/api/nodes.ts b/frontend-modern/src/api/nodes.ts
index f0a8c38862..dc59a4c3f9 100644
--- a/frontend-modern/src/api/nodes.ts
+++ b/frontend-modern/src/api/nodes.ts
@@ -14,6 +14,7 @@ type RawClusterEndpoint = Partial<ClusterEndpoint>;
export type NodeConnectionTestTLSOptions = {
verifySSL?: boolean;
fingerprint?: string;
+ endpoint?: string;
};
const normalizeClusterEndpoint = (endpoint: RawClusterEndpoint): ClusterEndpoint => ({
@@ -30,7 +31,11 @@ const normalizeClusterEndpoint = (endpoint: RawClusterEndpoint): ClusterEndpoint
guestURL: optionalTrimmedString(endpoint.guestURL),
ip: trimmedString(endpoint.ip),
ipOverride: optionalTrimmedString(endpoint.ipOverride),
- fingerprint: optionalTrimmedString(endpoint.fingerprint),
+ // A malformed nonempty saved pin must not become an empty CA choice.
+ fingerprint: typeof endpoint.fingerprint === 'string' ? endpoint.fingerprint : undefined,
+ tlsEndpoint: optionalTrimmedString(endpoint.tlsEndpoint),
+ usesPrimaryTLS: strictBoolean(endpoint.usesPrimaryTLS),
+ tlsFirstUse: strictBoolean(endpoint.tlsFirstUse),
online: strictBoolean(endpoint.online),
lastSeen: trimmedString(endpoint.lastSeen),
pulseReachable: endpoint.pulseReachable ?? undefined,
diff --git a/frontend-modern/src/components/Settings/NodeModalClusterMembersSection.tsx b/frontend-modern/src/components/Settings/NodeModalClusterMembersSection.tsx
index f7fd5624a3..aad3bba683 100644
--- a/frontend-modern/src/components/Settings/NodeModalClusterMembersSection.tsx
+++ b/frontend-modern/src/components/Settings/NodeModalClusterMembersSection.tsx
@@ -1,4 +1,4 @@
-import { Component, For, Show, createMemo } from 'solid-js';
+import { Component, For, Show, createMemo, createUniqueId } from 'solid-js';
import type { ClusterEndpoint } from '@/types/nodes';
import type { NodeModalProps } from '@/components/Settings/nodeModalModel';
import type { NodeModalState } from '@/components/Settings/useNodeModalState';
@@ -25,6 +25,7 @@ export const NodeModalClusterMembersSection: Component<NodeModalClusterMembersSe
props,
) => {
const { modalProps, state } = props;
+ const trustDescriptionId = createUniqueId();
const endpoints = createMemo<ClusterEndpoint[]>(() => {
const node = modalProps.editingNode;
@@ -47,7 +48,7 @@ export const NodeModalClusterMembersSection: Component<NodeModalClusterMembersSe
</p>
<div class="rounded-md border border-border">
<For each={endpoints()}>
- {(endpoint) => (
+ {(endpoint, index) => (
<div class="grid gap-3 border-b border-border-subtle p-3 last:border-b-0 sm:grid-cols-[minmax(0,1fr)_minmax(0,1fr)]">
<div class="min-w-0">
<div class="flex items-center gap-1.5 text-sm text-base-content">
@@ -114,6 +115,85 @@ export const NodeModalClusterMembersSection: Component<NodeModalClusterMembersSe
class={controlClass()}
/>
</label>
+ <Show when={endpoint.tlsEndpoint}>
+ <div class="grid min-w-0 gap-2">
+ <p class="break-all text-xs text-muted">
+ TLS endpoint: {endpoint.tlsEndpoint}
+ </p>
+ <Show
+ when={!endpoint.usesPrimaryTLS}
+ fallback={
+ <p class="text-xs text-muted">
+ Uses the primary SSL settings. Editing them does not change other
+ members.
+ </p>
+ }
+ >
+ <label class="grid gap-1 text-xs text-muted">
+ Certificate fingerprint (optional)
+ <input
+ type="text"
+ value={
+ state.formData().clusterEndpointFingerprints[endpoint.tlsEndpoint!] ??
+ endpoint.fingerprint ??
+ ''
+ }
+ onInput={(event) =>
+ state.updateClusterEndpointFingerprint(
+ endpoint.tlsEndpoint!,
+ event.currentTarget.value,
+ )
+ }
+ aria-label={`Certificate fingerprint for ${endpoint.nodeName}`}
+ aria-describedby={`${trustDescriptionId}-${index()}`}
+ disabled={!endpoint.tlsEndpoint?.startsWith('https://')}
+ class={controlClass('font-mono')}
+ />
+ </label>
+ </Show>
+ <p id={`${trustDescriptionId}-${index()}`} class="text-xs text-muted">
+ {endpoint.usesPrimaryTLS
+ ? 'Primary endpoint only.'
+ : endpoint.tlsFirstUse &&
+ !state.formData().clusterEndpointTrustEdited[endpoint.tlsEndpoint!]
+ ? 'No saved member pin. Existing first-use policy applies; enter a verified pin or explicitly choose CA validation.'
+ : (state.formData().clusterEndpointFingerprints[
+ endpoint.tlsEndpoint!
+ ] ??
+ endpoint.fingerprint ??
+ '') !== ''
+ ? 'This endpoint must present the matching certificate.'
+ : state.formData().verifySSL
+ ? 'No pin: a trusted, hostname-matching certificate is required.'
+ : 'No pin and verification unchecked: certificate identity is not verified.'}
+ </p>
+ <Show
+ when={
+ !endpoint.usesPrimaryTLS &&
+ state.formData().verifySSL &&
+ endpoint.tlsEndpoint?.startsWith('https://')
+ }
+ >
+ <button
+ type="button"
+ class="min-h-11 justify-self-start rounded-md border border-border px-3 py-2 text-xs text-base-content hover:bg-surface-hover focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-600"
+ onClick={() =>
+ state.updateClusterEndpointFingerprint(endpoint.tlsEndpoint!, '')
+ }
+ >
+ Use CA validation for {endpoint.nodeName}
+ </button>
+ </Show>
+ <button
+ type="button"
+ class="min-h-11 justify-self-start rounded-md border border-border px-3 py-2 text-xs text-base-content hover:bg-surface-hover focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-600"
+ disabled={state.isTesting()}
+ onClick={() => void state.handleTestClusterEndpoint(endpoint)}
+ >
+ Test TLS for {endpoint.nodeName}
+ </button>
+ </div>
+ </Show>
</div>
</div>
)}
@@ -124,6 +204,13 @@ export const NodeModalClusterMembersSection: Component<NodeModalClusterMembersSe
optional. Enter an IP or hostname, with a port if it isn't 8006, only when Pulse cannot
reach the discovered address.
</p>
+ <p class={formHelpText}>
+ Trust edits apply only to the displayed TLS endpoint. Independently verify a renewed
+ certificate through an already-trusted administration channel before changing a pin. For
+ CA-managed certificates, clear only that endpoint's pin and keep Verify SSL enabled. Tests
+ use stored credentials without saving TLS edits or updating background/agent health. Save
+ address or credential changes before testing them.
+ </p>
</div>
</Show>
);
diff --git a/frontend-modern/src/components/Settings/NodeModalMonitoringSection.tsx b/frontend-modern/src/components/Settings/NodeModalMonitoringSection.tsx
index 27426343e4..a14068a0de 100644
--- a/frontend-modern/src/components/Settings/NodeModalMonitoringSection.tsx
+++ b/frontend-modern/src/components/Settings/NodeModalMonitoringSection.tsx
@@ -111,7 +111,8 @@ export const NodeModalMonitoringSection: Component<NodeModalMonitoringSectionPro
Form settings only, not a connection-test result.
<Show when={modalProps.nodeType === 'pve'}>
{' '}
- Cluster members may have their own saved fingerprints.
+ This fingerprint applies only to the primary endpoint. Other members retain their own
+ trust settings in Cluster members.
</Show>
</p>
</div>
diff --git a/frontend-modern/src/components/Settings/__tests__/InfrastructureOperationsModel.test.tsx b/frontend-modern/src/components/Settings/__tests__/InfrastructureOperationsModel.test.tsx
index 8701e73674..24962f8c6e 100644
--- a/frontend-modern/src/components/Settings/__tests__/InfrastructureOperationsModel.test.tsx
+++ b/frontend-modern/src/components/Settings/__tests__/InfrastructureOperationsModel.test.tsx
@@ -1,4 +1,13 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
+import { createRoot, createSignal } from 'solid-js';
+import { NodesAPI } from '@/api/nodes';
+import type { NodeConfigWithStatus } from '@/types/nodes';
+import { useInfrastructureConfiguredNodesState } from '../useInfrastructureConfiguredNodesState';
+
+vi.mock('@/api/nodes', () => ({ NodesAPI: { updateNode: vi.fn(), getNodes: vi.fn() } }));
+vi.mock('@/hooks/useUnifiedResources', () => ({
+ useUnifiedResources: () => ({ resources: () => [], aggregations: () => null }),
+}));
import type { ConnectedInfrastructureItem } from '@/types/api';
import type { UnifiedAgentRow } from '../infrastructureOperationsModel';
import infrastructureInstallerSectionSource from '../InfrastructureInstallerSection.tsx?raw';
@@ -571,3 +580,69 @@ describe('infrastructure operations model', () => {
);
});
});
+
+describe('configured-node trust readback', () => {
+ it('reopens the actual effective server policy without caching the write-only payload', async () => {
+ const existing = {
+ id: 'pve-0',
+ type: 'pve',
+ name: 'cluster',
+ host: 'https://primary.test:8006',
+ status: 'disconnected',
+ monitorVMs: false,
+ monitorContainers: false,
+ monitorStorage: false,
+ monitorBackups: false,
+ verifySSL: true,
+ clusterEndpoints: [],
+ user: 'fixture@pve',
+ monitorPhysicalDisks: false,
+ } satisfies NodeConfigWithStatus;
+ const returned = {
+ ...existing,
+ clusterEndpoints: [
+ {
+ nodeId: 'peer',
+ nodeName: 'peer',
+ host: 'https://peer.test:8006',
+ ip: '',
+ online: true,
+ lastSeen: '',
+ tlsEndpoint: 'https://peer.test:8006',
+ fingerprint: 'verified-member',
+ },
+ ],
+ };
+ vi.mocked(NodesAPI.updateNode).mockResolvedValueOnce({ success: true });
+ vi.mocked(NodesAPI.getNodes).mockResolvedValueOnce([returned]);
+ let dispose = () => {};
+ const state = createRoot((cleanup) => {
+ dispose = cleanup;
+ const [saving, setSaving] = createSignal(false);
+ return useInfrastructureConfiguredNodesState({
+ canReadInfrastructure: () => false,
+ temperatureMonitoringEnabled: () => false,
+ savingTemperatureSetting: saving,
+ setSavingTemperatureSetting: setSaving,
+ });
+ });
+ try {
+ const ok = await state.saveNode(
+ {
+ fingerprint: 'verified-primary',
+ clusterEndpointTrustOverrides: [
+ { endpoint: 'https://peer.test:8006', fingerprint: 'verified-member' },
+ ],
+ },
+ existing,
+ );
+ expect(ok).toBe(true);
+ expect(NodesAPI.getNodes).toHaveBeenCalledOnce();
+ expect(state.nodes()).toEqual([returned]);
+ expect(state.nodes()[0]).not.toHaveProperty('clusterEndpointTrustOverrides');
+ expect(state.nodes()[0]).toHaveProperty('monitorVMs', false);
+ } finally {
+ dispose();
+ }
+ });
+});
diff --git a/frontend-modern/src/components/Settings/__tests__/NodeModalClusterMembersSection.test.tsx b/frontend-modern/src/components/Settings/__tests__/NodeModalClusterMembersSection.test.tsx
index 47437d8011..5bbc7ffa40 100644
--- a/frontend-modern/src/components/Settings/__tests__/NodeModalClusterMembersSection.test.tsx
+++ b/frontend-modern/src/components/Settings/__tests__/NodeModalClusterMembersSection.test.tsx
@@ -164,4 +164,45 @@ describe('Cluster member connection diagnostics', () => {
expect(onSave.mock.calls[0][0]).not.toHaveProperty('password');
expect(fetch).not.toHaveBeenCalled();
});
+ it('edits only the displayed peer TLS endpoint and leaves the primary settings separate', () => {
+ const { onSave } = renderMembers([
+ member({
+ nodeName: 'primary',
+ tlsEndpoint: 'https://primary.test:8006',
+ usesPrimaryTLS: true,
+ fingerprint: 'primary-pin',
+ }),
+ member({ tlsEndpoint: 'https://member.test:8006', fingerprint: 'member-pin' }),
+ ]);
+ expect(
+ screen.queryByRole('textbox', { name: 'Certificate fingerprint for primary' }),
+ ).toBeNull();
+ const pin = screen.getByRole('textbox', { name: 'Certificate fingerprint for member' });
+ fireEvent.input(pin, { target: { value: '' } });
+ expect(
+ screen.getByText('No pin: a trusted, hostname-matching certificate is required.'),
+ ).toBeVisible();
+ fireEvent.click(screen.getByRole('button', { name: 'Save fixture' }));
+ expect(onSave).toHaveBeenCalledWith(
+ expect.objectContaining({
+ clusterEndpointTrustOverrides: [{ endpoint: 'https://member.test:8006', fingerprint: '' }],
+ }),
+ );
+ });
+ it('requires a deliberate CA choice for an unknown first-use member', () => {
+ const { onSave } = renderMembers([
+ member({ tlsEndpoint: 'https://member.test:8006', tlsFirstUse: true, fingerprint: '' }),
+ ]);
+ expect(screen.getByText(/No saved member pin/)).toBeVisible();
+ fireEvent.click(screen.getByRole('button', { name: 'Use CA validation for member' }));
+ expect(
+ screen.getByText('No pin: a trusted, hostname-matching certificate is required.'),
+ ).toBeVisible();
+ fireEvent.click(screen.getByRole('button', { name: 'Save fixture' }));
+ expect(onSave).toHaveBeenCalledWith(
+ expect.objectContaining({
+ clusterEndpointTrustOverrides: [{ endpoint: 'https://member.test:8006', fingerprint: '' }],
+ }),
+ );
+ });
});
diff --git a/frontend-modern/src/components/Settings/__tests__/nodeModalModel.test.ts b/frontend-modern/src/components/Settings/__tests__/nodeModalModel.test.ts
index 58e26a8fea..4ff1ea9caa 100644
--- a/frontend-modern/src/components/Settings/__tests__/nodeModalModel.test.ts
+++ b/frontend-modern/src/components/Settings/__tests__/nodeModalModel.test.ts
@@ -4,6 +4,7 @@ import {
applyClusterEndpointOverridesLocally,
applyClusterNodeDisplayNamesLocally,
buildClusterEndpointOverridesPayload,
+ buildClusterEndpointTrustOverridesPayload,
buildClusterNodeDisplayNameOverridesPayload,
PVE_MANUAL_PERMISSION_COMMAND,
} from '../nodeModalModel';
@@ -123,3 +124,39 @@ describe('applyClusterEndpointOverridesLocally', () => {
expect(applyClusterEndpointOverridesLocally(undefined, [])).toBeUndefined();
});
});
+
+describe('endpoint-scoped TLS decisions', () => {
+ it('does not copy the primary pin to peers or submit untouched trust', () => {
+ const endpoints = [
+ {
+ ...endpoint('primary'),
+ tlsEndpoint: 'https://primary.test:8006',
+ usesPrimaryTLS: true,
+ fingerprint: 'primary-pin',
+ },
+ { ...endpoint('peer'), tlsEndpoint: 'https://peer.test:8006', fingerprint: 'peer-pin' },
+ { ...endpoint('other'), tlsEndpoint: 'https://other.test:8006', fingerprint: 'other-pin' },
+ ];
+ expect(buildClusterEndpointTrustOverridesPayload(endpoints, {})).toBeUndefined();
+ expect(
+ buildClusterEndpointTrustOverridesPayload(endpoints, {
+ 'https://primary.test:8006': 'new-primary',
+ 'https://peer.test:8006': '',
+ 'https://other.test:8006': 'other-pin',
+ }),
+ ).toEqual([{ endpoint: 'https://peer.test:8006', fingerprint: '' }]);
+ });
+ it('requires an explicit choice before turning unknown first-use trust into CA mode', () => {
+ const peer = { ...endpoint('peer'), tlsEndpoint: 'https://peer.test:8006', tlsFirstUse: true };
+ expect(
+ buildClusterEndpointTrustOverridesPayload([peer], { [peer.tlsEndpoint]: '' }),
+ ).toBeUndefined();
+ expect(
+ buildClusterEndpointTrustOverridesPayload(
+ [peer],
+ { [peer.tlsEndpoint]: '' },
+ { [peer.tlsEndpoint]: true },
+ ),
+ ).toEqual([{ endpoint: peer.tlsEndpoint, fingerprint: '' }]);
+ });
+});
diff --git a/frontend-modern/src/components/Settings/__tests__/settingsArchitecture.test.ts b/frontend-modern/src/components/Settings/__tests__/settingsArchitecture.test.ts
index de3f2682b9..87fa14db9c 100644
--- a/frontend-modern/src/components/Settings/__tests__/settingsArchitecture.test.ts
+++ b/frontend-modern/src/components/Settings/__tests__/settingsArchitecture.test.ts
@@ -1382,6 +1382,8 @@ describe('settings architecture guardrails', () => {
expect(nodeModalClusterMembersSectionSource).toContain('Connection address for ');
// Only changed members ride the write-only PUT payload.
expect(nodeModalStateSource).toContain('buildClusterEndpointOverridesPayload(');
+ expect(nodeModalStateSource).toContain('buildClusterEndpointTrustOverridesPayload(');
+ expect(nodeModalStateSource).toContain('clusterEndpointTrustEdited');
expect(nodeModalModelSource).toContain('export const buildClusterEndpointOverridesPayload = (');
});
diff --git a/frontend-modern/src/components/Settings/__tests__/useNodeModalState.connectionTest.test.ts b/frontend-modern/src/components/Settings/__tests__/useNodeModalState.connectionTest.test.ts
index 2922257190..a3c9f0d58f 100644
--- a/frontend-modern/src/components/Settings/__tests__/useNodeModalState.connectionTest.test.ts
+++ b/frontend-modern/src/components/Settings/__tests__/useNodeModalState.connectionTest.test.ts
@@ -1,7 +1,7 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { createRoot } from 'solid-js';
import { NodesAPI } from '@/api/nodes';
-import type { NodeConfig } from '@/types/nodes';
+import type { ClusterEndpoint, NodeConfig } from '@/types/nodes';
import { useNodeModalState, type NodeModalState } from '../useNodeModalState';
import type { NodeModalProps } from '../nodeModalModel';
@@ -21,7 +21,7 @@ describe('connection tests with retained credentials', () => {
afterEach(() => dispose?.());
- const mount = (nodeType: NodeModalProps['nodeType']) => {
+ const mount = (nodeType: NodeModalProps['nodeType'], clusterEndpoints?: ClusterEndpoint[]) => {
let state!: NodeModalState;
dispose = createRoot((cleanup) => {
state = useNodeModalState({
@@ -35,6 +35,7 @@ describe('connection tests with retained credentials', () => {
tokenName: 'root@pam!pulse',
fingerprint: 'saved-pin',
verifySSL: true,
+ clusterEndpoints,
} as NodeConfig,
onClose: vi.fn(),
onSave: vi.fn(),
@@ -94,4 +95,64 @@ describe('connection tests with retained credentials', () => {
}),
);
});
+ const peer = {
+ nodeName: 'peer',
+ tlsEndpoint: 'https://peer.test:8006',
+ fingerprint: 'peer-pin',
+ ipOverride: '',
+ host: 'https://peer.test:8006',
+ ip: '',
+ nodeId: 'peer',
+ online: true,
+ lastSeen: '',
+ } satisfies ClusterEndpoint;
+
+ it('tests an explicit peer CA choice without copying the primary pin or saving', async () => {
+ const state = mount('pve', [peer]);
+ state.updateClusterEndpointFingerprint(peer.tlsEndpoint, '');
+ await state.handleTestClusterEndpoint(peer);
+ expect(NodesAPI.testExistingNode).toHaveBeenCalledWith('pve-saved', {
+ endpoint: peer.tlsEndpoint,
+ fingerprint: '',
+ verifySSL: true,
+ });
+ expect(NodesAPI.testConnection).not.toHaveBeenCalled();
+ expect(state.testResult()?.message).toContain('peer:');
+ state.updateClusterEndpointFingerprint(peer.tlsEndpoint, 'new-pin');
+ expect(state.testResult()).toBeNull();
+ });
+
+ it('refuses to claim a test of unsaved addresses using stored credentials', async () => {
+ const state = mount('pve', [peer]);
+ state.updateClusterEndpointOverride('peer', 'new-peer.test');
+ await state.handleTestClusterEndpoint(peer);
+ expect(NodesAPI.testExistingNode).not.toHaveBeenCalled();
+ expect(state.testResult()?.status).toBe('error');
+ state.updateField('host', 'https://changed-primary.test:8006');
+ await state.handleTestConnection();
+ expect(NodesAPI.testExistingNode).not.toHaveBeenCalled();
+ });
+
+ it('does not display an old in-flight success after trust changes', async () => {
+ const state = mount('pve', [peer]);
+ let complete!: (result: { status: string }) => void;
+ vi.mocked(NodesAPI.testExistingNode).mockReturnValueOnce(
+ new Promise((resolve) => {
+ complete = resolve;
+ }),
+ );
+ const pending = state.handleTestClusterEndpoint(peer);
+ state.updateClusterEndpointFingerprint(peer.tlsEndpoint, 'different-pin');
+ complete({ status: 'success' });
+ await pending;
+ expect(state.testResult()).toBeNull();
+ });
+ it('tests untouched member trust without implicitly clearing its saved policy', async () => {
+ const state = mount('pve', [peer]);
+ await state.handleTestClusterEndpoint(peer);
+ expect(NodesAPI.testExistingNode).toHaveBeenCalledWith('pve-saved', {
+ endpoint: peer.tlsEndpoint,
+ verifySSL: true,
+ });
+ });
});
diff --git a/frontend-modern/src/components/Settings/nodeModalModel.ts b/frontend-modern/src/components/Settings/nodeModalModel.ts
index bacb559215..5cdc26a9ce 100644
--- a/frontend-modern/src/components/Settings/nodeModalModel.ts
+++ b/frontend-modern/src/components/Settings/nodeModalModel.ts
@@ -1,6 +1,7 @@
import type {
ClusterEndpoint,
ClusterEndpointOverridePayload,
+ ClusterEndpointTrustOverridePayload,
ClusterNodeDisplayNameOverridePayload,
NodeConfig,
} from '@/types/nodes';
@@ -48,6 +49,26 @@ export const buildClusterEndpointOverridesPayload = (
return changed.length > 0 ? changed : undefined;
};
+// Submit only deliberately changed endpoint trust. The primary uses the SSL
+// settings field; peer decisions must never be inferred from that field.
+export const buildClusterEndpointTrustOverridesPayload = (
+ endpoints: ClusterEndpoint[] | undefined,
+ fingerprints: Record<string, string>,
+ edited: Record<string, boolean> = {},
+): ClusterEndpointTrustOverridePayload[] | undefined => {
+ const changed = new Map<string, string>();
+ for (const endpoint of endpoints ?? []) {
+ const target = endpoint.tlsEndpoint;
+ if (!target || endpoint.usesPrimaryTLS || !target.startsWith('https://')) continue;
+ const value = fingerprints[target];
+ if (value !== undefined && (edited[target] || value !== (endpoint.fingerprint ?? '')))
+ changed.set(target, value);
+ }
+ return changed.size
+ ? Array.from(changed, ([endpoint, fingerprint]) => ({ endpoint, fingerprint }))
+ : undefined;
+};
+
// Mirror a saved clusterEndpointOverrides payload onto locally cached
// endpoints so the editor reflects the save without a full nodes reload.
export const applyClusterEndpointOverridesLocally = (
diff --git a/frontend-modern/src/components/Settings/useInfrastructureConfiguredNodesState.ts b/frontend-modern/src/components/Settings/useInfrastructureConfiguredNodesState.ts
index 13b4118448..e96f517105 100644
--- a/frontend-modern/src/components/Settings/useInfrastructureConfiguredNodesState.ts
+++ b/frontend-modern/src/components/Settings/useInfrastructureConfiguredNodesState.ts
@@ -8,6 +8,7 @@ import type { Temperature } from '@/types/api';
import type { ResourceType } from '@/types/resource';
import type {
ClusterEndpointOverridePayload,
+ ClusterEndpointTrustOverridePayload,
ClusterNodeDisplayNameOverridePayload,
NodeConfig,
NodeConfigWithStatus,
@@ -310,11 +311,16 @@ export const useInfrastructureConfiguredNodesState = ({
await NodesAPI.updateNode(existingNode.id, nodeData as NodeConfig);
// clusterEndpointOverrides is a write-only payload field: mirror it
// onto the cached endpoints instead of spreading it onto the node.
- const { clusterEndpointOverrides, clusterNodeDisplayNameOverrides, ...nodePatch } =
- nodeData as Partial<NodeConfig> & {
- clusterEndpointOverrides?: ClusterEndpointOverridePayload[];
- clusterNodeDisplayNameOverrides?: ClusterNodeDisplayNameOverridePayload[];
- };
+ const {
+ clusterEndpointOverrides,
+ clusterNodeDisplayNameOverrides,
+ clusterEndpointTrustOverrides,
+ ...nodePatch
+ } = nodeData as Partial<NodeConfig> & {
+ clusterEndpointOverrides?: ClusterEndpointOverridePayload[];
+ clusterEndpointTrustOverrides?: ClusterEndpointTrustOverridePayload[];
+ clusterNodeDisplayNameOverrides?: ClusterNodeDisplayNameOverridePayload[];
+ };
setNodes(
nodes().map((node) => {
if (node.id !== existingNode.id) return node;
@@ -341,6 +347,9 @@ export const useInfrastructureConfiguredNodesState = ({
};
}),
);
+ // Read back the effective scoped TLS policy instead of guessing how
+ // primary/member URL aliases resolve on the server.
+ if (clusterEndpointTrustOverrides?.length || 'fingerprint' in nodeData) await loadNodes();
notificationStore.success('Node updated successfully');
} else {
await NodesAPI.addNode(nodeData as NodeConfig);
diff --git a/frontend-modern/src/components/Settings/useNodeModalState.ts b/frontend-modern/src/components/Settings/useNodeModalState.ts
index aed7340326..693524aa3e 100644
--- a/frontend-modern/src/components/Settings/useNodeModalState.ts
+++ b/frontend-modern/src/components/Settings/useNodeModalState.ts
@@ -1,5 +1,5 @@
import { createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
-import type { NodeConfig } from '@/types/nodes';
+import type { ClusterEndpoint, NodeConfig } from '@/types/nodes';
import { notificationStore } from '@/stores/notifications';
import { NodesAPI } from '@/api/nodes';
@@ -16,6 +16,7 @@ import {
import {
buildClusterEndpointOverridesPayload,
+ buildClusterEndpointTrustOverridesPayload,
buildClusterNodeDisplayNameOverridesPayload,
deriveNameFromHost,
type NodeModalProps,
@@ -33,6 +34,7 @@ const PROXMOX_SETUP_HOST_REQUIRED_MESSAGE = 'Proxmox setup host is required';
export const useNodeModalState = (props: NodeModalProps) => {
const [testResult, setTestResult] = createSignal<NodeModalTestResult | null>(null);
const [isTesting, setIsTesting] = createSignal(false);
+ let probeGeneration = 0;
const [formData, setFormData] = createSignal<NodeModalFormData>(
getNodeModalDefaultFormData(props.nodeType),
);
@@ -398,6 +400,15 @@ export const useNodeModalState = (props: NodeModalProps) => {
]),
)
: {},
+ clusterEndpointTrustEdited: {},
+ clusterEndpointFingerprints:
+ node.type === 'pve' && 'clusterEndpoints' in node
+ ? Object.fromEntries(
+ (node.clusterEndpoints ?? []).flatMap((endpoint) =>
+ endpoint.tlsEndpoint ? [[endpoint.tlsEndpoint, endpoint.fingerprint ?? '']] : [],
+ ),
+ )
+ : {},
clusterNodeDisplayNames:
node.type === 'pve' && 'clusterEndpoints' in node
? Object.fromEntries(
@@ -479,6 +490,13 @@ export const useNodeModalState = (props: NodeModalProps) => {
if (overrides) {
Object.assign(nodeData, { clusterEndpointOverrides: overrides });
}
+ const trustOverrides = buildClusterEndpointTrustOverridesPayload(
+ endpoints,
+ data.clusterEndpointFingerprints,
+ data.clusterEndpointTrustEdited,
+ );
+ if (trustOverrides)
+ Object.assign(nodeData, { clusterEndpointTrustOverrides: trustOverrides });
const displayNameOverrides = buildClusterNodeDisplayNameOverridesPayload(
endpoints,
data.clusterNodeDisplayNames,
@@ -493,6 +511,8 @@ export const useNodeModalState = (props: NodeModalProps) => {
const updateField = (field: string, value: string | boolean | number) => {
formEditedByUser = true;
+ probeGeneration++;
+ setTestResult(null);
if (field === 'host' && typeof value === 'string') {
setFormData((prev) => {
const next = { ...prev, host: value };
@@ -522,6 +542,8 @@ export const useNodeModalState = (props: NodeModalProps) => {
const updateClusterEndpointOverride = (nodeName: string, value: string) => {
formEditedByUser = true;
+ probeGeneration++;
+ setTestResult(null);
setFormData((prev) => ({
...prev,
clusterEndpointOverrides: { ...prev.clusterEndpointOverrides, [nodeName]: value },
@@ -536,6 +558,69 @@ export const useNodeModalState = (props: NodeModalProps) => {
}));
};
+ const updateClusterEndpointFingerprint = (endpoint: string, value: string) => {
+ formEditedByUser = true;
+ probeGeneration++;
+ setTestResult(null);
+ setFormData((prev) => ({
+ ...prev,
+ clusterEndpointFingerprints: { ...prev.clusterEndpointFingerprints, [endpoint]: value },
+ clusterEndpointTrustEdited: { ...prev.clusterEndpointTrustEdited, [endpoint]: true },
+ }));
+ };
+
+ const testSavedEndpoint = async (endpoint?: ClusterEndpoint) => {
+ const data = formData();
+ if (
+ data.host !== props.editingNode?.host ||
+ (endpoint &&
+ (data.clusterEndpointOverrides[endpoint.nodeName] ?? '') !== (endpoint.ipOverride ?? '')) ||
+ (endpoint && (data.password || data.tokenValue))
+ ) {
+ setTestResult({
+ status: 'error',
+ message:
+ 'Save changed addresses or credentials before testing this endpoint with stored credentials.',
+ });
+ return;
+ }
+ if (endpoint && !endpoint.tlsEndpoint) return;
+ const generation = ++probeGeneration;
+ setIsTesting(true);
+ setTestResult(null);
+ try {
+ const result = await NodesAPI.testExistingNode(props.editingNode!.id, {
+ verifySSL: data.verifySSL,
+ ...(!endpoint || endpoint.usesPrimaryTLS
+ ? { fingerprint: data.fingerprint }
+ : data.clusterEndpointTrustEdited[endpoint.tlsEndpoint!]
+ ? { fingerprint: data.clusterEndpointFingerprints[endpoint.tlsEndpoint!] ?? '' }
+ : {}),
+ ...(endpoint ? { endpoint: endpoint.tlsEndpoint } : {}),
+ });
+ if (generation !== probeGeneration) return;
+ setTestResult({
+ status: result.warnings?.length ? 'warning' : 'success',
+ message: `${endpoint ? endpoint.nodeName + ': ' : ''}${result.message || 'Endpoint connection successful; background collection was not tested.'}`,
+ warnings: result.warnings,
+ });
+ } catch (error) {
+ if (generation !== probeGeneration) return;
+ const message =
+ error instanceof Error
+ ? error.message.replace(/^API request failed: \d{3}\s*/, '')
+ : 'Connection failed';
+ setTestResult({
+ status: 'error',
+ message: `${endpoint ? endpoint.nodeName + ': ' : ''}${message}`,
+ });
+ } finally {
+ setIsTesting(false);
+ }
+ };
+
+ const handleTestClusterEndpoint = (endpoint: ClusterEndpoint) => testSavedEndpoint(endpoint);
+
const handleTestConnection = async () => {
const data = formData();
const normalizedName = data.name.trim() || deriveNameFromHost(data.host);
@@ -549,31 +634,7 @@ export const useNodeModalState = (props: NodeModalProps) => {
const hasNewToken = data.authType === 'token' && data.tokenValue;
if (!hasNewPassword && !hasNewToken) {
- setIsTesting(true);
- setTestResult(null);
-
- try {
- const result = await NodesAPI.testExistingNode(props.editingNode!.id, {
- verifySSL: data.verifySSL,
- fingerprint: data.fingerprint,
- });
- setTestResult({
- status: 'success',
- message: result.message || 'Connection successful',
- });
- } catch (error) {
- logger.error('Test existing node error:', error);
- let errorMessage = 'Connection failed';
- if (error instanceof Error) {
- errorMessage = error.message.replace(/^API request failed: \d{3}\s*/, '');
- }
- setTestResult({
- status: 'error',
- message: errorMessage,
- });
- } finally {
- setIsTesting(false);
- }
+ await testSavedEndpoint();
return;
}
}
@@ -646,6 +707,7 @@ export const useNodeModalState = (props: NodeModalProps) => {
formData,
handleSubmit,
handleTestConnection,
+ handleTestClusterEndpoint,
isAdvancedSetupMode,
isEditingExistingNode,
isTesting,
@@ -660,6 +722,7 @@ export const useNodeModalState = (props: NodeModalProps) => {
testResult,
testResultPresentation,
updateClusterEndpointOverride,
+ updateClusterEndpointFingerprint,
updateClusterNodeDisplayName,
updateField,
};
diff --git a/frontend-modern/src/types/nodes.ts b/frontend-modern/src/types/nodes.ts
index 48f22979f2..f33add5541 100644
--- a/frontend-modern/src/types/nodes.ts
+++ b/frontend-modern/src/types/nodes.ts
@@ -18,6 +18,9 @@ export interface ClusterEndpoint {
ip: string;
ipOverride?: string;
fingerprint?: string;
+ tlsEndpoint?: string;
+ usesPrimaryTLS?: boolean;
+ tlsFirstUse?: boolean;
online: boolean; // Proxmox's view: is the node online in the cluster?
lastSeen: string;
pulseReachable?: boolean | null; // Pulse's view: can Pulse reach this endpoint? null/undefined = not yet checked
@@ -41,6 +44,12 @@ export interface ClusterNodeDisplayNameOverridePayload {
displayName: string;
}
+// One existing runtime endpoint, never an inferred cluster-wide trust edit.
+export interface ClusterEndpointTrustOverridePayload {
+ endpoint: string;
+ fingerprint: string;
+}
+
export interface PVENodeConfig {
id: string;
name: string;
@@ -67,6 +76,7 @@ export interface PVENodeConfig {
// Write-only: per-member connection address overrides included in PUT
// payloads; never returned by the API.
clusterEndpointOverrides?: ClusterEndpointOverridePayload[];
+ clusterEndpointTrustOverrides?: ClusterEndpointTrustOverridePayload[];
// Write-only presentation overrides keyed by immutable node identity.
clusterNodeDisplayNameOverrides?: ClusterNodeDisplayNameOverridePayload[];
}
diff --git a/frontend-modern/src/utils/nodeModalPresentation.ts b/frontend-modern/src/utils/nodeModalPresentation.ts
index cdb2ba6384..77d73e9e29 100644
--- a/frontend-modern/src/utils/nodeModalPresentation.ts
+++ b/frontend-modern/src/utils/nodeModalPresentation.ts
@@ -37,6 +37,9 @@ export interface NodeModalFormData {
// PVE clusters: per-member connection address overrides keyed by node name.
// Empty string means "use the discovered address".
clusterEndpointOverrides: Record<string, string>;
+ // Effective TLS policy keyed by the server-projected runtime endpoint.
+ clusterEndpointFingerprints: Record<string, string>;
+ clusterEndpointTrustEdited: Record<string, boolean>;
// PVE clusters: optional labels keyed by immutable node identity.
// Empty string means "use the native Proxmox node name".
clusterNodeDisplayNames: Record<string, string>;
@@ -80,6 +83,8 @@ export function getNodeModalDefaultFormData(nodeType: NodeModalNodeType): NodeMo
monitorQuarantine: true,
monitorDomainStats: false,
clusterEndpointOverrides: {},
+ clusterEndpointFingerprints: {},
+ clusterEndpointTrustEdited: {},
clusterNodeDisplayNames: {},
};
}