@skyhook-io/radar-app 1.16.3 → 1.17.1

package/src/api/cnpg-ha.live.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest'
+import type { CNPGFleetRow } from '@skyhook-io/k8s-ui'
+import type { CNPGRuntimeResponse } from './cnpg'
+import { cnpgInstanceLive, cnpgLiveStandbyGaps, cnpgReplicationLive, withLiveReplication } from '../components/cnpg/runtimeAssessment'
+
+const rt = (status: any): CNPGRuntimeResponse => ({
+  cluster: { namespace: 'db', name: 'pg', uid: 'u' },
+  sampledAt: '2026-09-30T10:00:00Z',
+  permission: { proxy: 'allowed' },
+  instances: [
+    { pod: 'pg-1', role: 'primary', status, metrics: { state: 'ok' } },
+    { pod: 'pg-2', role: 'replica', status: { state: 'ok', replication: [] }, metrics: { state: 'ok' } },
+  ],
+})
+
+describe('live replication from an incomplete primary report', () => {
+  it('is unknown, never "0 streaming"', () => {
+    expect(cnpgReplicationLive(rt({ state: 'partial', incomplete: true, replication: null }))).toBeUndefined()
+    expect(cnpgReplicationLive(rt({ state: 'ok', replication: [] }))?.streaming).toBe(0)
+  })
+  it('carries the incomplete flag to the instance list', () => {
+    expect(cnpgInstanceLive(rt({ state: 'partial', incomplete: true }))?.[0].incomplete).toBe(true)
+  })
+})
+
+describe('standbys and slots from the live read', () => {
+  const row = (over: Partial<CNPGFleetRow> = {}): CNPGFleetRow =>
+    ({
+      key: 'db/pg',
+      namespace: 'db',
+      name: 'pg',
+      cluster: { metadata: { annotations: {} }, status: { currentPrimary: 'pg-6' } },
+      instances: { ready: 3, desired: 3 },
+      pods: [],
+      replication: { text: '2/2 Pods ready · lag unknown', tone: 'unknown' },
+      problems: [],
+      attention: false,
+      categories: new Set(),
+      hibernated: false,
+      ...over,
+    }) as unknown as CNPGFleetRow
+  const live = (standby1: any): CNPGRuntimeResponse => ({
+    cluster: { namespace: 'db', name: 'pg', uid: 'u' },
+    sampledAt: '2026-10-04T10:00:00Z',
+    permission: { proxy: 'allowed' },
+    instances: [
+      {
+        pod: 'pg-6',
+        role: 'primary',
+        status: {
+          state: 'ok',
+          timeline: 7,
+          currentLsn: '3/BC06F9E8',
+          replication: [{ applicationName: 'pg-2', state: 'streaming', replayLsn: '3/BC06F9E8' }],
+          slots: [
+            { name: '_cnpg_pg_1', type: 'physical', active: false, retainedBytes: 4.7e9 },
+            { name: '_cnpg_pg_2', type: 'physical', active: true, retainedBytes: 0 },
+          ],
+        },
+        metrics: { state: 'ok' },
+      },
+      { pod: 'pg-1', role: 'replica', status: standby1, metrics: { state: 'ok' } },
+      { pod: 'pg-2', role: 'replica', status: { state: 'ok', timeline: 7, roleDetail: 'streaming' }, metrics: { state: 'ok' } },
+    ],
+  })
+
+  it('a standby with no row on the primary is a gap, with what it reports about itself', () => {
+    const gaps = cnpgLiveStandbyGaps(row(), live({ state: 'ok', timeline: 4, replayPaused: true, roleDetail: 'replayPaused' }))
+    expect(gaps.map((g) => g.pod)).toEqual(['pg-1'])
+    expect(gaps[0].evidence).toEqual([
+      'it has no row in the primary’s pg_stat_replication',
+      'its WAL replay is paused',
+      'it is on timeline 4 while the primary is on 7',
+    ])
+  })
+  it('a fenced standby, or one running pg_rewind, is not a gap', () => {
+    const fenced = row({ cluster: { metadata: { annotations: { 'cnpg.io/fencedInstances': '["pg-1"]' } }, status: {} } } as any)
+    expect(cnpgLiveStandbyGaps(fenced, live({ state: 'ok', timeline: 7 }))).toEqual([])
+    expect(cnpgLiveStandbyGaps(row(), live({ state: 'ok', timeline: 7, roleDetail: 'pgRewind' }))).toEqual([])
+  })
+  it('raises the gap and the inactive slot as problems, and names the standby in the replication fact', () => {
+    const r = withLiveReplication(row(), live({ state: 'ok', timeline: 4, replayPaused: true }))
+    expect(r.replication.text).toBe('1 of 2 expected standbys streaming · pg-1 not connected')
+    expect(r.attention).toBe(true)
+    expect(r.problems.map((p) => p.id).sort()).toEqual(['slot:db/pg:_cnpg_pg_1', 'standby:db/pg:pg-1'])
+    expect(r.problems.find((p) => p.id === 'slot:db/pg:_cnpg_pg_1')!.title).toBe('Inactive slot _cnpg_pg_1 holds 4.4 GiB of WAL on pg-6 for pg-1')
+  })
+})
+
+describe('a live read replaces what it disproves', () => {
+  const base = (problems: any[]): CNPGFleetRow =>
+    ({
+      key: 'db/pg',
+      namespace: 'db',
+      name: 'pg',
+      cluster: { metadata: {}, status: {} },
+      instances: { ready: 2, desired: 2 },
+      pods: [],
+      replication: { text: '2/2 Pods ready · pg-2 not receiving WAL', tone: 'degraded' },
+      problems,
+      attention: true,
+      categories: new Set(['availability']),
+      hibernated: false,
+    }) as unknown as CNPGFleetRow
+  const fleetStandby = { id: 'standby:db/pg:pg-2', reason: 'CNPGStandbyNotReceiving', severity: 'warning', category: 'availability', title: 'pg-2 is not receiving WAL from the primary', subject: { kind: 'Pod', group: '', namespace: 'db', name: 'pg-2' }, source: 'measurement' }
+  const fleetSlot = { id: 'slot:db/pg:_cnpg_pg_2', reason: 'CNPGInactiveSlot', slot: '_cnpg_pg_2', severity: 'warning', category: 'availability', title: 'Inactive slot _cnpg_pg_2 holds 2 GiB', subject: { kind: 'Cluster', group: 'postgresql.cnpg.io', namespace: 'db', name: 'pg' }, source: 'measurement' }
+  const rt = (primaryStatus: any): CNPGRuntimeResponse => ({
+    cluster: { namespace: 'db', name: 'pg', uid: 'u' },
+    sampledAt: '2026-10-04T10:00:00Z',
+    permission: { proxy: 'allowed' },
+    instances: [
+      { pod: 'pg-1', role: 'primary', status: primaryStatus, metrics: { state: 'ok' } },
+      { pod: 'pg-2', role: 'replica', status: { state: 'ok', timeline: 1 }, metrics: { state: 'ok' } },
+    ],
+  })
+  it('clears the fleet’s standby and slot problems when the primary streams to it and the slot is active', () => {
+    const r = withLiveReplication(
+      base([fleetStandby, fleetSlot]),
+      rt({ state: 'ok', timeline: 1, replication: [{ applicationName: 'pg-2', state: 'streaming' }], slots: [{ name: '_cnpg_pg_2', type: 'physical', active: true, retainedBytes: 0 }] }),
+    )
+    expect(r.problems).toEqual([])
+    expect(r.attention).toBe(false)
+    expect(r.replication.text).toBe('1/1 streaming')
+  })
+  it('keeps a fleet slot warning the live read cannot disprove', () => {
+    // Unmeasured: inactive, retained bytes not reported.
+    const unmeasured = withLiveReplication(base([fleetSlot]), rt({ state: 'ok', timeline: 1, replication: [{ applicationName: 'pg-2', state: 'streaming' }], slots: [{ name: '_cnpg_pg_2', type: 'physical', active: false }] }))
+    expect(unmeasured.problems.map((p) => p.id)).toEqual(['slot:db/pg:_cnpg_pg_2'])
+    // Absent from a capped, partial list.
+    const partial = withLiveReplication(base([fleetSlot]), rt({ state: 'partial', replication: null, slots: [] }))
+    expect(partial.problems.map((p) => p.id)).toEqual(['slot:db/pg:_cnpg_pg_2'])
+    // Absent from a complete list: the slot is gone.
+    const gone = withLiveReplication(base([fleetSlot]), rt({ state: 'ok', timeline: 1, replication: [{ applicationName: 'pg-2', state: 'streaming' }], slots: [] }))
+    expect(gone.problems).toEqual([])
+  })
+  it('judges slots from a partial primary report the replication rows cannot use', () => {
+    const r = withLiveReplication(base([]), rt({ state: 'partial', incomplete: true, replication: null, slots: [{ name: '_cnpg_pg_2', type: 'physical', active: false, retainedBytes: 3 * 1024 ** 3 }] }))
+    expect(r.problems.map((p) => p.id)).toEqual(['slot:db/pg:_cnpg_pg_2'])
+  })
+})

package/src/api/cnpg-ha.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest'
+import type { CNPGFleetRow, Grant } from '@skyhook-io/k8s-ui'
+import type { CNPGRuntimeResponse } from './cnpg'
+import { cnpgInstanceLiveUnavailable, cnpgReplicationGap, withLiveReplication } from '../components/cnpg/runtimeAssessment'
+
+function row(desired: number | null): CNPGFleetRow {
+  return {
+    instances: { ready: 1, desired },
+    pods: [{ name: 'pg-1', role: 'primary', ready: true }],
+    replication: { text: 'Lag unknown', tone: 'unknown' },
+    key: 'db/pg',
+    problems: [],
+    categories: new Set(),
+  } as unknown as CNPGFleetRow
+}
+
+function runtime(replication: { state: string; replayLag?: number }[]): CNPGRuntimeResponse {
+  return {
+    instances: [{ pod: 'pg-1', role: 'primary', status: { state: 'ok', capturedAt: '2026-09-30T12:00:00Z', replication } }],
+  } as unknown as CNPGRuntimeResponse
+}
+
+describe('withLiveReplication', () => {
+  it('counts expected standbys from spec.instances, so missing standby Pods are not healthy', () => {
+    const r = withLiveReplication(row(3), runtime([]))
+    expect(r.replication).toMatchObject({ tone: 'degraded', text: '0 of 2 expected standbys streaming' })
+    const one = withLiveReplication(row(3), runtime([{ state: 'streaming', replayLag: 0 }]))
+    expect(one.replication).toMatchObject({ tone: 'degraded', text: expect.stringContaining('1 of 2 expected standbys streaming') })
+  })
+  it('says the replay delay covers only the standbys that are connected', () => {
+    const one = withLiveReplication(row(3), runtime([{ state: 'streaming', replayLag: 0 }]))
+    expect(one.replication.text).toBe('1 of 2 expected standbys streaming · max replay delay 0 s (connected standbys only)')
+    const all = withLiveReplication(row(2), runtime([{ state: 'streaming', replayLag: 0 }]))
+    expect(all.replication.text).toBe('1/1 streaming · max replay delay 0 s')
+  })
+  it('is healthy only when every expected standby streams', () => {
+    const r = withLiveReplication(row(2), runtime([{ state: 'streaming', replayLag: 0.1 }]))
+    expect(r.replication.tone).toBe('healthy')
+  })
+  it('is unknown when spec.instances is not reported', () => {
+    expect(withLiveReplication(row(null), runtime([])).replication.tone).toBe('unknown')
+  })
+})
+
+describe('cnpgInstanceLiveUnavailable', () => {
+  const rt = (proxy: 'allowed' | 'denied', grant?: Grant) => ({ permission: { proxy, grant }, instances: [] }) as unknown as CNPGRuntimeResponse
+  it('names the grant only when the proxy is denied', () => {
+    expect(cnpgInstanceLiveUnavailable(rt('denied', { verb: 'get', resource: 'pods', subresource: 'proxy', namespace: 'db' }), undefined)).toBe('needs get pods/proxy in namespace db')
+    expect(cnpgInstanceLiveUnavailable(rt('allowed'), undefined)).toBeUndefined()
+    expect(cnpgInstanceLiveUnavailable(undefined, undefined)).toBe('instance managers not read yet')
+    expect(cnpgInstanceLiveUnavailable(undefined, new Error('boom'))).toBe('the runtime read failed: boom')
+  })
+})
+
+describe('cnpgReplicationGap', () => {
+  it('says why the primary’s replication rows are missing', () => {
+    const rt = (instances: unknown[]) => ({ permission: { proxy: 'allowed' }, instances }) as unknown as CNPGRuntimeResponse
+    expect(cnpgReplicationGap(rt([{ pod: 'pg-1', role: 'primary', status: { state: 'unreachable', error: 'PostgreSQL is not running on this instance' } }]), undefined)).toBe(
+      'pg-1 did not report (PostgreSQL is not running on this instance)',
+    )
+    expect(cnpgReplicationGap(rt([{ pod: 'pg-1', role: 'primary', status: { state: 'ok', replication: [] } }]), undefined)).toBeUndefined()
+    expect(cnpgReplicationGap({ permission: { proxy: 'denied', grant: { verb: 'get', resource: 'pods', subresource: 'proxy', namespace: 'db' } }, instances: [] } as unknown as CNPGRuntimeResponse, undefined)).toBe(
+      'needs get pods/proxy in namespace db',
+    )
+  })
+})
+
+describe('withLiveReplication with a missing standby', () => {
+  it('takes the worse of the missing standby and the lag', () => {
+    const rt = {
+      permission: { proxy: 'allowed' },
+      instances: [{ pod: 'pg-1', role: 'primary', status: { state: 'ok', capturedAt: 't', replication: [{ applicationName: 'pg-2', state: 'streaming', replayLag: 72 }] } }],
+    } as unknown as CNPGRuntimeResponse
+    const out = withLiveReplication(row(3), rt)
+    expect(out.replication.tone).toBe('unhealthy')
+    expect(out.replication.text).toContain('1 of 2 expected standbys streaming')
+  })
+})

package/src/api/cnpg-ha.ts

@@ -0,0 +1,19 @@
+import { useQuery } from '@tanstack/react-query'
+import type { CNPGClusterHA } from '@skyhook-io/k8s-ui'
+import { fetchJSON, useRadarFeature } from './client'
+
+// /api/cnpg/clusters/{ns}/{name}/ha — quorum, disruption budgets, Leases,
+// failure domains, Jobs, image drift and certificate renewal ownership. Each
+// part is authorized on its own and says when it could not be read.
+export function useCNPGClusterHA(namespace: string, name: string, options?: { enabled?: boolean; refetchInterval?: number | false }) {
+  const { guard, gatedKey } = useRadarFeature('cnpgWorkspace')
+  return useQuery<CNPGClusterHA>({
+    queryKey: ['cnpg', 'ha', namespace, name, ...gatedKey],
+    queryFn: ({ signal }) => guard(() => fetchJSON<CNPGClusterHA>(`/cnpg/clusters/${encodeURIComponent(namespace)}/${encodeURIComponent(name)}/ha`, signal)),
+    enabled: (options?.enabled ?? true) && !!name,
+    staleTime: 10_000,
+    refetchInterval: options?.refetchInterval ?? 30_000,
+    refetchIntervalInBackground: false,
+    retry: false,
+  })
+}

package/src/api/cnpg-history.ts

@@ -0,0 +1,123 @@
+import { useQuery } from '@tanstack/react-query'
+import type { CNPGFleetMetricsReading, Grant } from '@skyhook-io/k8s-ui'
+import { fetchJSON, useRadarFeature } from './client'
+import { shouldRetryRadarQuery } from './radarFeatures'
+import type { CNPGClusterActivityResponse } from './cnpg'
+
+export type CNPGHistoryRange = '15m' | '1h' | '6h' | '24h'
+
+export const CNPG_HISTORY_RANGES: { id: CNPGHistoryRange; label: string }[] = [
+  { id: '15m', label: '15 min' },
+  { id: '1h', label: '1 h' },
+  { id: '6h', label: '6 h' },
+  { id: '24h', label: '24 h' },
+]
+
+export interface CNPGHistoryPoint {
+  timestamp: number
+  value: number | null
+}
+
+export interface CNPGHistorySeries {
+  labels: Record<string, string>
+  dataPoints: CNPGHistoryPoint[]
+}
+
+export interface CNPGHistoryChart {
+  id: string
+  title: string
+  unit: string
+  /** The PromQL families the chart is built from. */
+  source: string
+  /** The label naming each series (pod, state, datname, persistentvolumeclaim or series). */
+  seriesBy: string
+  /** ok | empty (scraped, nothing to plot) | noSeries (not scraped) | denied | ambiguous | scopeMismatch | error | notRead */
+  state: string
+  reason?: string
+  grant?: Grant
+  thresholds?: { value: number; label: string }[]
+  series: CNPGHistorySeries[]
+  omitted?: number
+  steps: number
+  covered: number
+}
+
+export interface CNPGClusterHistoryResponse {
+  cluster: { namespace: string; name: string; uid: string }
+  /** prometheus | none (Radar has no Prometheus; `reason` says why) */
+  source: 'prometheus' | 'none'
+  /** ok | ambiguous | scopeMismatch | error, for the query as a whole */
+  state?: string
+  reason?: string
+  range: CNPGHistoryRange
+  start?: string
+  end?: string
+  stepSeconds?: number
+  selector?: string
+  isolation?: { mode: 'configured' | 'verified' | 'unverified'; labels?: Record<string, string>; note: string }
+  /** The volume chart's own match: claims are tied to the cluster apart from Pods. */
+  pvcIsolation?: { mode: 'configured' | 'verified' | 'unverified'; labels?: Record<string, string>; note: string }
+  sampledAt: string
+  charts: CNPGHistoryChart[]
+}
+
+// /api/cnpg/clusters/{ns}/{name}/history — server-built Prometheus range
+// queries for the Runtime Trends section.
+export function useCNPGClusterHistory(namespace: string, name: string, range: CNPGHistoryRange, enabled = true) {
+  const { guard, gatedKey } = useRadarFeature('cnpgWorkspace')
+  return useQuery<CNPGClusterHistoryResponse>({
+    queryKey: ['cnpg', 'history', namespace, name, range, ...gatedKey],
+    queryFn: ({ signal }) => guard(() =>
+      fetchJSON<CNPGClusterHistoryResponse>(
+        `/cnpg/clusters/${encodeURIComponent(namespace)}/${encodeURIComponent(name)}/history?range=${range}`,
+        signal,
+      )),
+    enabled: enabled && !!name,
+    refetchInterval: range === '15m' ? 30_000 : 60_000,
+    refetchIntervalInBackground: false,
+    staleTime: 10_000,
+    retry: false,
+    placeholderData: (prev) => (prev?.range === range ? prev : undefined),
+  })
+}
+
+export interface CNPGFleetMetricsResponse {
+  sampledAt: string
+  source: 'prometheus' | 'none'
+  reason?: string
+  lagSource: string
+  growthSource: string
+  clusters: CNPGFleetMetricsReading[]
+}
+
+// /api/cnpg/fleet-metrics — each visible Cluster's largest standby replay lag
+// and volume growth, read with the workspace's namespace set.
+export function useCNPGFleetMetrics(namespaces: string[], enabled = true) {
+  const { guard, gatedKey } = useRadarFeature('cnpgWorkspace')
+  const ns = [...namespaces].sort().join(',')
+  return useQuery<CNPGFleetMetricsResponse>({
+    queryKey: ['cnpg', 'fleet-metrics', ns, ...gatedKey],
+    queryFn: ({ signal }) => guard(() => fetchJSON<CNPGFleetMetricsResponse>(`/cnpg/fleet-metrics${ns ? `?namespaces=${encodeURIComponent(ns)}` : ''}`, signal)),
+    enabled,
+    staleTime: 20_000,
+    refetchInterval: 60_000,
+    retry: false,
+    placeholderData: (prev) => prev,
+  })
+}
+
+// The Cluster's activity inside one interval, both bounds applied server-side.
+export function useCNPGClusterActivityWindow(namespace: string, name: string, since: string, until: string, enabled = true) {
+  const { guard, gatedKey } = useRadarFeature('cnpgWorkspace')
+  return useQuery<CNPGClusterActivityResponse>({
+    queryKey: ['cnpg', 'activity-window', namespace, name, since, until, ...gatedKey],
+    queryFn: ({ signal }) => guard(() =>
+      fetchJSON<CNPGClusterActivityResponse>(
+        `/cnpg/clusters/${encodeURIComponent(namespace)}/${encodeURIComponent(name)}/activity?since=${encodeURIComponent(since)}&until=${encodeURIComponent(until)}&limit=500`,
+        signal,
+      )),
+    enabled: enabled && !!name,
+    staleTime: 30_000,
+    retry: shouldRetryRadarQuery,
+  })
+}

package/src/api/cnpg-inspect.ts

@@ -0,0 +1,102 @@
+import { useQuery } from '@tanstack/react-query'
+import type { Grant } from '@skyhook-io/k8s-ui'
+import { fetchJSON, useRadarFeature } from './client'
+import type { CNPGRuntimeSourceState } from './cnpg'
+
+const enc = encodeURIComponent
+
+interface CNPGInspectSource {
+  state: CNPGRuntimeSourceState
+  error?: string
+  capturedAt?: string
+}
+
+export interface CNPGTimelineSwitch {
+  from: number
+  to: number
+  switchLsn: string
+  /** PostgreSQL's own text, e.g. "before 2026-10-01 12:00:00+00" or "no recovery target specified". */
+  reason: string
+}
+
+export interface CNPGDatabaseContents {
+  tables: number
+  /** The planner's estimate (pg_class.reltuples); it can be stale. */
+  estimatedRows: number
+  /** Tables without an estimate (never analyzed; before PostgreSQL 14 also an empty one), not counted as zero. */
+  noEstimate: number
+  largest: { name: string; estimatedRows?: number; bytes: number }[]
+}
+
+export interface CNPGRestoreChecksResponse extends CNPGInspectSource {
+  cluster: { namespace: string; name: string; uid: string }
+  pod: string
+  sampledAt: string
+  permission: { exec: 'allowed' | 'denied' | 'unknown'; grant?: Grant }
+  /** spec.bootstrap.recovery.recoveryTarget as declared. */
+  target?: Record<string, unknown>
+  database: string
+  inRecovery?: boolean
+  timeline?: number
+  history?: CNPGTimelineSwitch[]
+  historyMissing?: boolean
+  databaseCount?: number
+  databases?: { name: string; bytes: number }[]
+  roleCount?: number
+  roles?: { name: string; canLogin: boolean }[]
+  contents?: CNPGDatabaseContents
+  contentsSource?: CNPGInspectSource
+}
+
+// /api/cnpg/clusters/{ns}/{name}/restore-checks — what Radar reads in a
+// restored cluster's primary over the caller's pods/exec. Denied is a state.
+export function useCNPGRestoreChecks(namespace: string, name: string, enabled = true) {
+  const { guard, gatedKey } = useRadarFeature('cnpgWorkspace')
+  return useQuery<CNPGRestoreChecksResponse>({
+    queryKey: ['cnpg', 'restore-checks', namespace, name, ...gatedKey],
+    queryFn: ({ signal }) => guard(() => fetchJSON<CNPGRestoreChecksResponse>(`/cnpg/clusters/${enc(namespace)}/${enc(name)}/restore-checks`, signal)),
+    enabled: enabled && !!name,
+    staleTime: 60_000,
+    retry: false,
+  })
+}
+
+export interface CNPGParameterSetting {
+  name: string
+  /** PostgreSQL's display; null when the connection itself sets the parameter. */
+  value: string | null
+  setByClient?: boolean
+  source: string
+  /** pg_settings.context: when a change takes effect. */
+  context: string
+  pendingRestart: boolean
+}
+
+export interface CNPGInstanceSettings extends CNPGInspectSource {
+  pod: string
+  role: 'primary' | 'replica' | 'unknown'
+  settings?: CNPGParameterSetting[]
+}
+
+export interface CNPGParametersResponse extends CNPGInspectSource {
+  cluster: { namespace: string; name: string; uid: string }
+  sampledAt: string
+  permission: { exec: 'allowed' | 'denied' | 'unknown'; grant?: Grant }
+  declared: { name: string; value: string }[]
+  omitted?: number
+  skipped?: string[]
+  instances: CNPGInstanceSettings[]
+}
+
+// /api/cnpg/clusters/{ns}/{name}/parameters — the declared parameters as each
+// instance's PostgreSQL reports them. Observation only.
+export function useCNPGParameters(namespace: string, name: string, enabled = true) {
+  const { guard, gatedKey } = useRadarFeature('cnpgWorkspace')
+  return useQuery<CNPGParametersResponse>({
+    queryKey: ['cnpg', 'parameters', namespace, name, ...gatedKey],
+    queryFn: ({ signal }) => guard(() => fetchJSON<CNPGParametersResponse>(`/cnpg/clusters/${enc(namespace)}/${enc(name)}/parameters`, signal)),
+    enabled: enabled && !!name,
+    staleTime: 30_000,
+    retry: false,
+  })
+}

package/src/api/cnpg-protection.ts

@@ -0,0 +1,112 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
+import { apiUrl } from './config'
+import { useReviewedActionMutation } from './reviewedActionMutation'
+import type { CNPGSchedulePreview } from '@skyhook-io/k8s-ui'
+import { fetchJSON, useRadarFeature } from './client'
+import type { ActionRequest } from './actions'
+import { cnpgPath, type CNPGActionResult } from './cnpg'
+
+export interface CNPGArchivingParams {
+  objectStore: string
+  serverName: string
+  acknowledgeArchive: boolean
+}
+export interface CNPGArchivingFacts {
+  clusterConfig: string
+  objectStoreUID: string
+  objectStoreConfig: string
+  objectStore: string
+  serverName: string
+}
+export interface CNPGArchivingPreview {
+  context: string
+  uid: string
+  facts: CNPGArchivingFacts
+  destination: string
+  endpoint?: string
+  plugin: Record<string, unknown>
+  warnings: string[]
+  unchanged: boolean
+}
+export interface CNPGScheduleMethodFacts {
+  clusterUID: string
+  clusterConfig: string
+  scheduleConfig: string
+}
+export interface CNPGScheduleMethodPreview {
+  context: string
+  uid: string
+  cluster: string
+  previousMethod: string
+  facts: CNPGScheduleMethodFacts
+  unchanged: boolean
+}
+
+export function useCNPGArchivingPreview(namespace: string, name: string) {
+  const { guard } = useRadarFeature('cnpgProtectionSetup')
+  return useMutation<CNPGArchivingPreview, Error, { reviewedContext: string; objectStore: string; serverName: string }>(
+    {
+      mutationFn: (request) =>
+        guard(() =>
+          fetchJSON(`${cnpgPath('clusters', namespace, name)}/protection/preview`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(request),
+          }),
+        ),
+    },
+  )
+}
+
+export function useCNPGScheduleMethodPreview(namespace: string, name: string) {
+  const { guard, gatedKey } = useRadarFeature('cnpgProtectionSetup')
+  return useQuery<CNPGScheduleMethodPreview>({
+    queryKey: ['cnpg', 'method-preview', namespace, name, ...gatedKey],
+    queryFn: ({ signal }) =>
+      guard(() => fetchJSON(`${cnpgPath('scheduledbackups', namespace, name)}/method-preview`, signal)),
+    enabled: !!name,
+    retry: false,
+    staleTime: 5_000,
+  })
+}
+
+export function useCNPGDraftSchedulePreview(namespace: string, name: string, schedule: string, enabled = true) {
+  const { guard, gatedKey } = useRadarFeature('cnpgProtectionSetup')
+  return useQuery<CNPGSchedulePreview>({
+    queryKey: ['cnpg', 'draft-schedule-preview', namespace, name, schedule, ...gatedKey],
+    queryFn: ({ signal }) =>
+      guard(() =>
+        fetchJSON(
+          `${cnpgPath('clusters', namespace, name)}/schedule-preview?schedule=${encodeURIComponent(schedule)}`,
+          signal,
+        ),
+      ),
+    enabled: enabled && !!name,
+    retry: false,
+    staleTime: 30_000,
+    placeholderData: (previous) => previous,
+  })
+}
+
+type ProtectionAction =
+  | { kind: 'clusters'; action: 'configureArchiving'; request: ActionRequest<CNPGArchivingFacts, CNPGArchivingParams> }
+  | { kind: 'scheduledbackups'; action: 'repairMethod'; request: ActionRequest<CNPGScheduleMethodFacts> }
+
+export function useCNPGProtectionAction<Kind extends ProtectionAction['kind']>(kind: Kind, namespace: string, name: string, reviewedContext: string | undefined) {
+  const { guard } = useRadarFeature('cnpgProtectionSetup')
+  const client = useQueryClient()
+  return useReviewedActionMutation<CNPGActionResult, Extract<ProtectionAction, { kind: Kind }>>(apiUrl(cnpgPath(kind, namespace, name)), reviewedContext, {
+    mutationFn: ({ kind, action, request }) =>
+      guard(() =>
+        fetchJSON(`${cnpgPath(kind, namespace, name)}/actions/${action}`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(request),
+        }),
+      ),
+    onSettled: () => {
+      client.invalidateQueries({ queryKey: ['cnpg'] })
+      client.invalidateQueries({ queryKey: ['resource'] })
+    },
+  })
+}

package/src/api/cnpg-recovery.test.tsx

@@ -0,0 +1,60 @@
+// @vitest-environment jsdom
+import { act } from 'react'
+import { createRoot } from 'react-dom/client'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { expect, it, vi } from 'vitest'
+import { fetchJSON } from './client'
+import { apiUrl } from './config'
+import { useReviewedActionMutation } from './reviewedActionMutation'
+import { useRecordCNPGRestoreValidation, type CNPGRestoreValidationRequest } from './cnpg-recovery'
+
+vi.mock('./client', async (importOriginal) => ({
+  ...await importOriginal<typeof import('./client')>(),
+  fetchJSON: vi.fn(),
+  useRadarFeature: () => ({ guard: <T,>(read: () => T) => read() }),
+}))
+
+;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
+
+it('retains an unknown validation-note result through remount without changing its HTTP body', async () => {
+  const client = new QueryClient({ defaultOptions: { mutations: { retry: false } } })
+  const invalidate = vi.spyOn(client, 'invalidateQueries')
+  const host = document.body.appendChild(document.createElement('div'))
+  const root = createRoot(host)
+  const send = vi.mocked(fetchJSON).mockRejectedValue(new TypeError('Connection lost'))
+  let current!: ReturnType<typeof useRecordCNPGRestoreValidation>
+  let operational!: ReturnType<typeof useReviewedActionMutation<void, { request: { reviewedContext: string } }>>
+  const operationalWrite = vi.fn(async () => {})
+  function Dialog() {
+    current = useRecordCNPGRestoreValidation('db', 'restored', 'ctx')
+    operational = useReviewedActionMutation(apiUrl('/cnpg/clusters/db/restored'), 'ctx', { mutationFn: operationalWrite })
+    return null
+  }
+  const mount = (open: boolean) => act(() => root.render(<QueryClientProvider client={client}>{open && <Dialog />}</QueryClientProvider>))
+  const request: CNPGRestoreValidationRequest = { reviewedContext: 'ctx', uid: 'restored-uid', params: { checked: 'Application query passed' } }
+  const attempt = () => act(async () => {
+    await current.mutateAsync({ request }).catch(() => {})
+    await new Promise(resolve => setTimeout(resolve, 0))
+  })
+  try {
+    mount(true)
+    await attempt()
+    expect(send).toHaveBeenCalledWith('/cnpg/clusters/db/restored/restore-validation', expect.objectContaining({ body: JSON.stringify(request) }))
+    expect(invalidate).toHaveBeenCalledWith({ queryKey: ['cnpg', 'recovery', 'db', 'restored'] })
+    expect(invalidate).toHaveBeenCalledWith({ queryKey: ['cnpg', 'workspace'] })
+    expect(client.getMutationCache().getAll()[0].options.meta?.errorMessage).toBeUndefined()
+    await act(async () => { await operational.mutateAsync({ request: { reviewedContext: 'ctx' } }) })
+    expect(operationalWrite).toHaveBeenCalledOnce()
+    mount(false)
+    client.clear()
+    mount(true)
+    expect(current.outcomeError?.message).toContain('Connection lost')
+    await attempt()
+    expect(send).toHaveBeenCalledTimes(1)
+  } finally {
+    act(() => root.unmount())
+    client.clear()
+    host.remove()
+    send.mockReset()
+  }
+})