@skyhook-io/radar-app 1.17.0 → 1.17.1

package/src/api/cnpg-recovery.ts

@@ -0,0 +1,262 @@
+import { useQuery, useQueryClient } from '@tanstack/react-query'
+import type { Grant } from '@skyhook-io/k8s-ui'
+import { apiFetch, ApiError, fetchJSON, useRadarFeature } from './client'
+import { actionErrorCode, type ActionCapability } from './actions'
+import { useReviewedActionMutation } from './reviewedActionMutation'
+import { apiUrl } from './config'
+import { shouldRetryRadarQuery } from './radarFeatures'
+
+export type CNPGReadState = 'ok' | 'denied' | 'notFound' | 'error' | 'skipped' | 'partial'
+
+export interface CNPGReadCoverage {
+  state: CNPGReadState
+  grant?: Grant
+  reason?: string
+}
+
+export interface CNPGContainerState {
+  name: string
+  state: 'waiting' | 'running' | 'terminated' | 'unknown'
+  reason?: string
+  message?: string
+  exitCode?: number
+  restarts: number
+  ready: boolean
+}
+
+export interface CNPGRecoveryPod {
+  name: string
+  uid: string
+  kind: 'job' | 'instance'
+  job?: string
+  ownerVerified: boolean
+  phase: string
+  ready: boolean
+  startedAt?: string
+  initContainers: CNPGContainerState[]
+  containers: CNPGContainerState[]
+}
+
+export interface CNPGRecoveryJob {
+  name: string
+  /** The Job's cnpg.io/jobRole label. */
+  role?: string
+  active: number
+  succeeded: number
+  failed: number
+  complete: boolean
+  failedWith?: string
+  startedAt?: string
+  completedAt?: string
+}
+
+export interface CNPGRecoveryEvent {
+  type: string
+  reason: string
+  message: string
+  kind: string
+  name: string
+  count: number
+  lastSeen?: string
+}
+
+export interface CNPGRestoreValidationRef {
+  namespace: string
+  name: string
+  uid?: string
+  verified: boolean
+}
+
+export interface CNPGRestoreValidation {
+  version: number
+  recordedAt: string
+  recordedBy?: string
+  checked: string
+  targetTime?: string
+  source?: CNPGRestoreValidationRef
+  target: CNPGRestoreValidationRef
+}
+
+export interface CNPGRecoverySpec {
+  sourceKind: 'objectStore' | 'barmanObjectStore' | 'backup' | 'volumeSnapshots' | 'unknown'
+  source?: string
+  objectStore?: string
+  serverName?: string
+  backup?: string
+  target?: Record<string, unknown>
+}
+
+export interface CNPGRecoveryResponse {
+  cluster: {
+    uid: string
+    phase?: string
+    phaseReason?: string
+    instances: number | null
+    readyInstances: number | null
+    currentPrimary?: string
+    createdAt?: string
+    ready?: { status: string; reason?: string; message?: string }
+  }
+  recovery: CNPGRecoverySpec | null
+  pods: CNPGRecoveryPod[]
+  jobs: CNPGRecoveryJob[]
+  events: CNPGRecoveryEvent[]
+  coverage: Record<'pods' | 'jobs' | 'events', CNPGReadCoverage>
+  validation?: CNPGRestoreValidation
+  validationError?: string
+  capturedAt: string
+}
+
+const clusterPath = (namespace: string, name: string) => `/cnpg/clusters/${encodeURIComponent(namespace)}/${encodeURIComponent(name)}`
+
+// /api/cnpg/clusters/{ns}/{name}/recovery — the restored Cluster's progress:
+// phase, the recovery Job's Pods and their init containers, the instances and
+// Warning events about them. Polled every 5s until the Cluster reports healthy.
+export function useCNPGRecovery(namespace: string, name: string, options?: { enabled?: boolean }) {
+  const { guard, gatedKey } = useRadarFeature('cnpgWorkspace')
+  return useQuery<CNPGRecoveryResponse>({
+    queryKey: ['cnpg', 'recovery', namespace, name, ...gatedKey],
+    queryFn: ({ signal }) => guard(() => fetchJSON<CNPGRecoveryResponse>(`${clusterPath(namespace, name)}/recovery`, signal)),
+    enabled: options?.enabled ?? true,
+    staleTime: 3_000,
+    refetchInterval: (query) => {
+      const d = query.state.data
+      return d?.recovery && d.cluster.phase !== 'Cluster in healthy state' ? 5_000 : 30_000
+    },
+    retry: (count, err) => shouldRetryRadarQuery(count, err) && !(err instanceof ApiError && (err.status === 403 || err.status === 404)) && count < 2,
+  })
+}
+
+export interface CNPGRestoreValidationRequest {
+  reviewedContext: string
+  uid: string
+  params: { checked: string; targetTime?: string; source?: { namespace: string; name: string } }
+}
+
+export function useRecordCNPGRestoreValidation(namespace: string, name: string, reviewedContext: string | undefined) {
+  const { guard } = useRadarFeature('cnpgWorkspace')
+  const queryClient = useQueryClient()
+  // The note does not change operational review facts, so its outcome lock is independent.
+  return useReviewedActionMutation<CNPGRestoreValidation, { request: CNPGRestoreValidationRequest }>(apiUrl(`${clusterPath(namespace, name)}/restore-validation`), reviewedContext, {
+    mutationFn: ({ request }) => guard(() =>
+      fetchJSON<CNPGRestoreValidation>(`${clusterPath(namespace, name)}/restore-validation`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(request),
+      })),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['cnpg', 'recovery', namespace, name] })
+      queryClient.invalidateQueries({ queryKey: ['cnpg', 'workspace'] })
+    },
+    onError: (err) => {
+      if (actionErrorCode(err) !== undefined) {
+        queryClient.invalidateQueries({ queryKey: ['cnpg', 'recovery', namespace, name] })
+        queryClient.invalidateQueries({ queryKey: ['cnpg', 'workspace'] })
+      }
+    },
+    meta: { successMessage: 'Validation note recorded' },
+  })
+}
+
+export interface CNPGReportOptions {
+  logs: boolean
+  queryText: boolean
+  tailLines: number
+}
+
+/** Fetches the report zip as the caller; returns the blob and its file name. */
+export async function downloadCNPGReport(namespace: string, name: string, opts: CNPGReportOptions): Promise<{ blob: Blob; filename: string }> {
+  const q = new URLSearchParams()
+  if (opts.logs) {
+    q.set('logs', 'true')
+    q.set('tailLines', String(opts.tailLines))
+    if (opts.queryText) q.set('queryText', 'true')
+  }
+  const qs = q.toString()
+  const res = await apiFetch(apiUrl(`${clusterPath(namespace, name)}/report${qs ? `?${qs}` : ''}`))
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: `HTTP ${res.status}` }))
+    throw new ApiError(err.error || `HTTP ${res.status}`, res.status, err)
+  }
+  const disposition = res.headers.get('Content-Disposition') ?? ''
+  const match = /filename="([^"]+)"/.exec(disposition)
+  return { blob: await res.blob(), filename: match?.[1] ?? `report_cluster_${name}.zip` }
+}
+
+// Operator diagnosis — additive fields on /api/cnpg/operator.
+
+export interface CNPGOperatorPod {
+  name: string
+  uid: string
+  phase: string
+  ready: boolean
+  startedAt?: string
+  restarts: number
+  leader: boolean
+  lastTermination?: { container: string; reason: string; exitCode: number; finishedAt?: string }
+}
+
+export interface CNPGOperatorLeader extends Omit<CNPGReadCoverage, 'state'> {
+  state: CNPGReadState | 'disabled'
+  lease?: string
+  holder?: string
+  holderPod?: string
+  holderIsCurrentPod: boolean
+  renewTime?: string
+  acquireTime?: string
+  leaseDurationSeconds?: number
+  transitions?: number
+  stale: boolean
+}
+
+export interface CNPGOperatorWebhookConfig extends CNPGReadCoverage {
+  kind: string
+  name: string
+  webhooks: { name: string; failurePolicy: string; caBundleSet: boolean; service?: string; url: boolean }[]
+}
+
+export interface CNPGOperatorWebhookService extends CNPGReadCoverage {
+  namespace: string
+  name: string
+  readyEndpoints: number | null
+  notReadyEndpoints: number | null
+}
+
+export interface CNPGOperatorReconcilePod {
+  pod: string
+  leader: boolean
+  startedAt?: string
+  state: 'ok' | 'partial' | 'denied' | 'unreachable' | 'error'
+  error?: string
+  reason?: string
+  capturedAt?: string
+  controllers: { controller: string; errors: number | null; total: number | null; results: Record<string, number> }[]
+}
+
+export interface CNPGOperatorDiagnosis {
+  namespace: string
+  deployment: string
+  pods: CNPGOperatorPod[]
+  podCoverage: CNPGReadCoverage
+  leader: CNPGOperatorLeader
+  watch: { all: boolean; namespaces: string[]; source: string; unresolved?: string }
+  webhooks: CNPGOperatorWebhookConfig[]
+  webhookServices: CNPGOperatorWebhookService[]
+  metricsPort: number
+  reconcile: CNPGOperatorReconcilePod[]
+  events: CNPGReadCoverage & { items: CNPGRecoveryEvent[] }
+}
+
+// /api/cnpg/restore/capability — whether the caller may create the restored
+// Cluster in `namespace` (create clusters, and the operator's webhook admits
+// writes), for every way into the restore dialog.
+export function useCNPGRestoreCapability(namespace: string) {
+  const { guard, gatedKey } = useRadarFeature('cnpgWorkspace')
+  return useQuery<ActionCapability>({
+    queryKey: ['cnpg', 'restore-capability', namespace, ...gatedKey],
+    queryFn: ({ signal }) => guard(() => fetchJSON<ActionCapability>(`/cnpg/restore/capability?namespace=${encodeURIComponent(namespace)}`, signal)),
+    enabled: !!namespace,
+    staleTime: 15_000,
+    retry: false,
+  })
+}

package/src/api/cnpg-sessions.ts

@@ -0,0 +1,175 @@
+import { useQuery } from '@tanstack/react-query'
+import type { Grant } from '@skyhook-io/k8s-ui'
+import { fetchJSON, useRadarFeature } from './client'
+import type { CNPGClusterFacts, CNPGRuntimeSourceState } from './cnpg'
+import type { ActionCapability } from './actions'
+
+const enc = encodeURIComponent
+
+export interface CNPGBackend {
+  pid: number
+  blockedBy: number[]
+  /** PostgreSQL's own backend_start; a cancel or terminate echoes it verbatim. */
+  backendStart: string
+  state?: string
+  waitEventType?: string
+  waitEvent?: string
+  user?: string
+  database?: string
+  application?: string
+  clientAddr?: string
+  backendType?: string
+  backendAgeSeconds?: number
+  xactAgeSeconds?: number
+  queryAgeSeconds?: number
+  stateAgeSeconds?: number
+  query?: string
+  queryTruncated?: boolean
+}
+
+export interface CNPGSessionInstance {
+  pod: string
+  role: 'primary' | 'replica' | 'unknown'
+  cpuRequest?: string
+  cpuLimit?: string
+  memoryRequest?: string
+  memoryLimit?: string
+}
+
+export interface CNPGSessionsResponse {
+  cluster: { namespace: string; name: string; uid: string }
+  pod: string
+  podUID?: string
+  role?: string
+  sampledAt: string
+  permission: { exec: 'allowed' | 'denied' | 'unknown'; grant?: Grant }
+  state: CNPGRuntimeSourceState | 'unavailable'
+  error?: string
+  reason?: string
+  capturedAt?: string
+  serverTime?: string
+  maxConnections?: number
+  superuserReservedConnections?: number
+  clientBackends?: number
+  involvedTotal?: number
+  truncated?: boolean
+  /** Only the backends in a blocking relation: blocking another, or waiting on one. */
+  sessions?: CNPGBackend[]
+  instances: CNPGSessionInstance[]
+}
+
+// /api/cnpg/clusters/{ns}/{name}/sessions — who blocks whom on one instance,
+// read with fixed SQL over the caller's pods/exec. Denied is a state, not an error.
+export function useCNPGSessions(namespace: string, name: string, pod?: string, enabled = true) {
+  const { guard, gatedKey } = useRadarFeature('cnpgWorkspace')
+  return useQuery<CNPGSessionsResponse>({
+    queryKey: ['cnpg', 'sessions', namespace, name, pod ?? '', ...gatedKey],
+    queryFn: ({ signal }) => guard(() =>
+      fetchJSON<CNPGSessionsResponse>(`/cnpg/clusters/${enc(namespace)}/${enc(name)}/sessions${pod ? `?pod=${enc(pod)}` : ''}`, signal)),
+    enabled: enabled && !!name,
+    refetchInterval: (q) => (q.state.data?.state === 'denied' ? false : 10_000),
+    refetchIntervalInBackground: false,
+    staleTime: 5_000,
+    retry: false,
+  })
+}
+
+export interface CNPGDestroyPVC {
+  name: string
+  uid: string
+  role?: string
+  tablespace?: string
+  owned: boolean
+  detached: boolean
+  capacity?: string
+  storageClass?: string
+}
+
+export interface CNPGDestroyPlan {
+  uid: string
+  context: string
+  facts: CNPGClusterFacts
+  pod: string
+  podUID: string
+  role: string
+  pvcsReadable: boolean
+  pvcReason?: string
+  pvcs: CNPGDestroyPVC[]
+  jobsReadable: boolean
+  jobs: { name: string; uid: string }[]
+  actions: { delete: ActionCapability; keep: ActionCapability }
+}
+
+export function useCNPGDestroyPlan(namespace: string, name: string, pod: string, enabled = true) {
+  const { guard, gatedKey } = useRadarFeature('cnpgWorkspace')
+  return useQuery<CNPGDestroyPlan>({
+    queryKey: ['cnpg', 'destroy-plan', namespace, name, pod, ...gatedKey],
+    queryFn: ({ signal }) => guard(() => fetchJSON<CNPGDestroyPlan>(`/cnpg/clusters/${enc(namespace)}/${enc(name)}/instances/${enc(pod)}/destroy-plan`, signal)),
+    enabled: enabled && !!pod,
+    staleTime: 0,
+    retry: false,
+  })
+}
+
+export interface CNPGPoolerFacts {
+  generation: number
+  cluster: string
+  type: string
+  instances?: number
+  /** Desired state (spec.pgbouncer.paused); each PgBouncer applies it on its own. */
+  paused: boolean
+  poolMode?: string
+  parameters: Record<string, string>
+  terminating: boolean
+  deployment: {
+    name: string
+    state: 'ok' | 'missing' | 'unreadable' | 'foreign'
+    replicas?: number
+    readyReplicas?: number
+    updatedReplicas?: number
+    availableReplicas?: number
+  }
+  service: { name: string; state: 'ok' | 'missing' | 'unreadable' | 'foreign'; type?: string; port?: number }
+}
+
+export interface CNPGPoolerCapabilities {
+  uid: string
+  resourceVersion: string
+  context: string
+  facts: CNPGPoolerFacts
+  actions: { pause: ActionCapability; resume: ActionCapability; observeState: ActionCapability }
+}
+
+export function useCNPGPoolerCapabilities(namespace: string, name: string, enabled = true) {
+  const { guard, gatedKey } = useRadarFeature('cnpgWorkspace')
+  return useQuery<CNPGPoolerCapabilities>({
+    queryKey: ['cnpg', 'capabilities', 'poolers', namespace, name, ...gatedKey],
+    queryFn: ({ signal }) => guard(() => fetchJSON<CNPGPoolerCapabilities>(`/cnpg/poolers/${enc(namespace)}/${enc(name)}/capabilities`, signal)),
+    enabled: enabled && !!name,
+    staleTime: 5_000,
+    refetchInterval: 30_000,
+    retry: false,
+  })
+}
+
+export interface CNPGPgBouncerStateResponse {
+  pooler: { namespace: string; name: string; uid: string }
+  sampledAt: string
+  permission: { exec: 'allowed' | 'denied' | 'unknown'; grant?: Grant }
+  pods: { pod: string; state: CNPGRuntimeSourceState; error?: string; paused?: boolean; suspended?: boolean; active?: boolean }[]
+}
+
+// /api/cnpg/poolers/{ns}/{name}/pgbouncer-state — each PgBouncer's own SHOW
+// STATE, the only place "paused" is observed rather than requested.
+export function useCNPGPgBouncerState(namespace: string, name: string, enabled = true) {
+  const { guard, gatedKey } = useRadarFeature('cnpgWorkspace')
+  return useQuery<CNPGPgBouncerStateResponse>({
+    queryKey: ['cnpg', 'pgbouncer-state', namespace, name, ...gatedKey],
+    queryFn: ({ signal }) => guard(() => fetchJSON<CNPGPgBouncerStateResponse>(`/cnpg/poolers/${enc(namespace)}/${enc(name)}/pgbouncer-state`, signal)),
+    enabled: enabled && !!name,
+    refetchInterval: (q) => (q.state.data?.permission.exec === 'denied' ? false : 15_000),
+    refetchIntervalInBackground: false,
+    staleTime: 5_000,
+    retry: false,
+  })
+}

package/src/api/cnpg-storage.ts

@@ -0,0 +1,138 @@
+import { useQuery } from '@tanstack/react-query'
+import type { CNPGDiskReading, CNPGMetricIsolation, Grant } from '@skyhook-io/k8s-ui'
+import { fetchJSON, useRadarFeature } from './client'
+
+export type CNPGPVCRole = 'PG_DATA' | 'PG_WAL' | 'PG_TABLESPACE'
+
+export interface CNPGStorageCoverage {
+  state: string
+  grant?: Grant
+  reason?: string
+  /** On Prometheus usage: how the series were tied to this cluster. */
+  isolation?: CNPGMetricIsolation
+}
+
+export interface CNPGStorageVolumeUsage {
+  /** ok | noSeries | invalid | noPrometheus | denied | error | notRead | ambiguous | scopeMismatch */
+  state: string
+  usedBytes?: number
+  capacityBytes?: number
+  ratio?: number
+}
+
+export interface CNPGStorageVolume {
+  claim: string
+  role: CNPGPVCRole | string
+  tablespace?: string
+  phase?: string
+  requested?: string
+  requestedBytes?: number
+  capacity?: string
+  capacityBytes?: number
+  /** allowVolumeExpansion is absent when the class could not be read. */
+  storageClass: { name?: string; allowVolumeExpansion?: boolean; reason?: string }
+  resize: { conditions?: { type: string; message?: string; since?: string }[]; allocatedStatus?: string; pending?: boolean }
+  /** Which Cluster status list names the claim: healthy | initializing | resizing | dangling | unusable. */
+  clusterState?: string
+  usage: CNPGStorageVolumeUsage
+}
+
+export interface CNPGStorageSource {
+  state: string
+  error?: string
+  reason?: string
+  capturedAt?: string
+}
+
+export interface CNPGStorageWAL {
+  slotInventoryTruncated?: boolean
+  status: CNPGStorageSource
+  metrics: CNPGStorageSource
+  volume?: string
+  sizeBytes?: number
+  segments?: number
+  readyToArchive?: number
+  lastArchivedAt?: string
+  lastFailedAt?: string
+  lastFailedWal?: string
+  archivingFailed?: boolean
+  slots?: { slot: string; bytes: number }[]
+  slotInventory?: { name: string; active?: boolean; retainedBytes?: number }[] | null
+}
+
+export interface CNPGStorageInstance {
+  name: string
+  /** primary | replica | noInstance (a claim whose instance the Cluster no longer lists) | unknown */
+  role: string
+  volumes: CNPGStorageVolume[]
+  wal?: CNPGStorageWAL
+}
+
+export interface CNPGStorageTarget {
+  role: CNPGPVCRole
+  tablespace?: string
+  field: string
+  declared?: string
+  storageClass?: string
+}
+
+export interface CNPGStorageFinding {
+  severity: 'warning' | 'critical'
+  instance: string
+  claim: string
+  role: string
+  tablespace?: string
+  ratio: number
+  message: string
+}
+
+export interface CNPGClusterStorageResponse {
+  cluster: { namespace: string; name: string; uid: string }
+  sampledAt: string
+  volumes: CNPGStorageCoverage
+  usage: CNPGStorageCoverage
+  usageSource: string
+  wal: CNPGStorageCoverage
+  expansion: { targets: CNPGStorageTarget[]; resizeInUseVolumes?: boolean }
+  instances: CNPGStorageInstance[]
+  findings: CNPGStorageFinding[]
+  excluded?: { claim: string; reason: string }[]
+}
+
+// /api/cnpg/clusters/{ns}/{name}/storage — the Cluster's claims, their
+// measured use and each instance's WAL, every source with its own coverage.
+export function useCNPGClusterStorage(namespace: string, name: string, enabled = true) {
+  const { guard, gatedKey } = useRadarFeature('cnpgWorkspace')
+  return useQuery<CNPGClusterStorageResponse>({
+    queryKey: ['cnpg', 'storage', namespace, name, ...gatedKey],
+    queryFn: ({ signal }) => guard(() => fetchJSON<CNPGClusterStorageResponse>(`/cnpg/clusters/${encodeURIComponent(namespace)}/${encodeURIComponent(name)}/storage`, signal)),
+    enabled: enabled && !!name,
+    refetchInterval: 30_000,
+    refetchIntervalInBackground: false,
+    staleTime: 10_000,
+    retry: false,
+    placeholderData: (prev) => prev,
+  })
+}
+
+export interface CNPGFleetDiskResponse {
+  sampledAt: string
+  source: string
+  clusters: CNPGDiskReading[]
+}
+
+// /api/cnpg/disk — the fullest measured volume of each visible Cluster. Read
+// with the same namespace set as the workspace so the two join row for row.
+export function useCNPGFleetDisk(namespaces: string[], enabled = true) {
+  const { guard, gatedKey } = useRadarFeature('cnpgWorkspace')
+  const ns = [...namespaces].sort().join(',')
+  return useQuery<CNPGFleetDiskResponse>({
+    queryKey: ['cnpg', 'disk', ns, ...gatedKey],
+    queryFn: ({ signal }) => guard(() => fetchJSON<CNPGFleetDiskResponse>(`/cnpg/disk${ns ? `?namespaces=${encodeURIComponent(ns)}` : ''}`, signal)),
+    enabled,
+    staleTime: 20_000,
+    refetchInterval: 60_000,
+    retry: false,
+    placeholderData: (prev) => prev,
+  })
+}

package/src/api/cnpg.legacy-reads.test.ts

@@ -0,0 +1,43 @@
+import { beforeEach, expect, it, vi } from 'vitest'
+import { useQuery } from '@tanstack/react-query'
+import { fetchJSON } from './client'
+import { useCNPGClusterActivity, useCNPGOperator, useCNPGWorkspace, useCNPGRuntime } from './cnpg'
+import { guardRadarFeature, radarFeatureSupport } from './radarFeatures'
+
+vi.mock('@tanstack/react-query', () => ({ useQuery: vi.fn(), useMutation: vi.fn(), useQueryClient: vi.fn() }))
+vi.mock('./client', () => ({
+  fetchJSON: vi.fn(),
+  useRadarFeature: () => {
+    const support = radarFeatureSupport('cnpgWorkspace', { features: { resourceIssues: true } }, 'v1.16.0')
+    return { support, gatedKey: ['radar-feature-unsupported'], guard: (request: () => Promise<unknown>) => guardRadarFeature('cnpgWorkspace', support, {}, request) }
+  },
+}))
+beforeEach(() => vi.clearAllMocks())
+
+it('still reads the shipped workspace, operator and activity on a server without the new flag', async () => {
+  const kinds = ['clusters', 'backups', 'scheduledBackups', 'poolers', 'databases', 'publications', 'subscriptions', 'imageCatalogs', 'clusterImageCatalogs', 'objectStores', 'pods']
+  const workspace = { installed: true, context: 'test', namespaces: ['db'], coverage: Object.fromEntries(kinds.map(k => [k, { state: 'full' }])), objects: Object.fromEntries(kinds.map(k => [k, []])), issues: [], audit: [], backupsOmitted: 0 }
+  vi.mocked(fetchJSON).mockResolvedValue(workspace)
+  useCNPGWorkspace(['db'])
+  useCNPGOperator()
+  useCNPGClusterActivity('db', 'pg')
+  const queries = vi.mocked(useQuery).mock.calls.map(([options]) => options)
+  for (const query of queries) {
+    const fn = query.queryFn
+    if (typeof fn !== 'function') throw new Error('Expected a query function')
+    await fn({ signal: new AbortController().signal } as any)
+  }
+  expect(vi.mocked(fetchJSON).mock.calls.map(([path]) => path)).toEqual([
+    '/cnpg/workspace?namespaces=db', '/cnpg/operator', expect.stringMatching(/^\/cnpg\/clusters\/db\/pg\/activity\?since=.*&limit=500$/),
+  ])
+  expect(queries[0].queryKey).toEqual(['cnpg', 'workspace', 'db'])
+})
+
+it('refuses the new live-runtime contract before fetching from the same old server', async () => {
+  useCNPGRuntime('db', 'pg')
+  const query = vi.mocked(useQuery).mock.calls[0][0]
+  const fn = query.queryFn
+  if (typeof fn !== 'function') throw new Error('Expected a query function')
+  await expect(fn({ signal: new AbortController().signal } as any)).rejects.toMatchObject({ feature: 'cnpgWorkspace' })
+  expect(fetchJSON).not.toHaveBeenCalled()
+})

package/src/api/cnpg.pooler-runtime.test.ts

@@ -0,0 +1,15 @@
+import { expect, it, vi } from 'vitest'
+import { useQuery } from '@tanstack/react-query'
+import { useCNPGPoolerRuntime } from './cnpg'
+
+vi.mock('@tanstack/react-query', () => ({ useQuery: vi.fn(), useMutation: vi.fn(), useQueryClient: vi.fn() }))
+vi.mock('./client', () => ({ fetchJSON: vi.fn(), useRadarFeature: () => ({ guard: (f: () => unknown) => f(), gatedKey: [] }) }))
+
+it('keeps the scheduling inventory fresh even when live proxy measurements are denied', () => {
+  useCNPGPoolerRuntime('prod', 'pooler')
+  const options = vi.mocked(useQuery).mock.calls[0][0]
+  const interval = options.refetchInterval
+  const deniedQuery = { state: { data: { permission: { proxy: 'denied' }, pods: [{ pod: 'pending', schedulingReason: 'Unschedulable' }] } } }
+  expect(typeof interval === 'function' ? interval(deniedQuery as any) : interval).toBe(30000)
+  expect(options.refetchIntervalInBackground).toBe(false)
+})