@skyhook-io/k8s-ui 1.16.3 → 1.17.1

package/src/components/cnpg/CNPGPoolerSummary.tsx

@@ -1,8 +1,27 @@
-import { getCNPGPoolerDeploymentName, getCNPGPoolerMode, getCNPGPoolerStatus, isCNPGPoolerPaused } from '../resources/resource-utils-cnpg'
+import { Tooltip } from '../ui/Tooltip'
+import type { ReactNode } from 'react'
+import { getCNPGPoolerDeploymentName, getCNPGPoolerMode, isCNPGPoolerPaused } from '../resources/resource-utils-cnpg'
 import type { CNPGWorkspaceResponse } from './workspace'
-import { FactGrid, FactRow, FactValue, RefLink, SummaryHeading, type CNPGNavigate } from './primitives'
 import { ClusterLink, NotReported, Note, ObjectProblems, PhaseBadge, SummaryShell } from './CNPGSharedSummary'
 import { refOf } from './relations'
+import {
+  POOLER_LIMIT_PARAMETERS,
+  aggregatePoolerPools,
+  poolerPodPressure,
+  poolerPressureCoverage,
+  poolerPressureFact,
+  observedPause,
+  poolerBackendService,
+  poolerReadiness,
+  type CNPGPoolerLive,
+  type CNPGPoolerPoolRow,
+} from './pooler'
+import { type NavigateToRef, RefLink } from '../ui/RefLink'
+import { toneTextClass } from '../ui/status-tone'
+import { FactGrid, FactRow, FactValue } from '../facts'
+import { Badge } from '../ui/Badge'
+import { summarizeSchedulerMessage } from '../resources/resource-utils'
+import { SectionHeading, FoldSection } from '../ui/FoldSection'
 
 const TYPE_LABEL: Record<string, string> = {
   rw: 'rw · routes to the primary',
@@ -14,36 +33,53 @@ export function CNPGPoolerSummary({
   resource,
   workspace,
   onNavigate,
+  live,
+  actions,
+  lead,
 }: {
   resource: any
   workspace: CNPGWorkspaceResponse | null
-  onNavigate?: CNPGNavigate
+  onNavigate?: NavigateToRef
+  /** Live reads a host adds (Deployment readiness, PgBouncer metrics and state). */
+  live?: CNPGPoolerLive
+  /** Operations rendered beside the paused state (pause / resume). */
+  actions?: ReactNode
+  /** Rendered first, e.g. a host's notice that a live read is stale. */
+  lead?: ReactNode
 }) {
   const ns = resource?.metadata?.namespace ?? ''
   const type = resource?.spec?.type
   const desired = resource?.spec?.instances
-  const scheduled = resource?.status?.instances
+  const reported = resource?.status?.instances
   const deployment = getCNPGPoolerDeploymentName(resource)
+  const paused = isCNPGPoolerPaused(resource)
+  const readiness = poolerReadiness(live?.deployment)
+  const observed = observedPause(live?.observed)
 
   return (
     <SummaryShell>
+      {lead}
       <ObjectProblems issues={workspace?.issues} subject={refOf(resource, 'Pooler')} onNavigate={onNavigate} />
 
-      <SummaryHeading>State</SummaryHeading>
+      <SectionHeading>State</SectionHeading>
       <FactGrid>
         <FactRow label="Status">
-          <PhaseBadge status={getCNPGPoolerStatus(resource)} />
-          {isCNPGPoolerPaused(resource) && <Note>PgBouncer is paused: it holds client connections instead of serving them.</Note>}
+          <div className="flex flex-wrap items-center gap-1">
+            <PhaseBadge status={{ text: readiness.text, color: '', level: readiness.level }} />
+            {paused && <Badge severity="warning" size="sm">Pause requested</Badge>}
+          </div>
+          {readiness.detail && <Note>{readiness.detail}</Note>}
+          <CNPGPoolerScheduling namespace={ns} pods={live?.pressure?.pods ?? []} onNavigate={onNavigate} />
         </FactRow>
         <FactRow label="Instances">
           <span>
-            {typeof scheduled === 'number' ? `${scheduled} scheduled` : <NotReported text="Scheduled count not reported" />}
+            {typeof reported === 'number' ? `Pooler status reports ${reported} ${reported === 1 ? 'instance' : 'instances'}` : <NotReported text="Pooler instance count not reported" />}
             <span className="text-theme-text-secondary">
               {' · '}
-              {typeof desired === 'number' ? `${desired} desired` : 'desired not set'}
+              {typeof desired === 'number' ? `${desired} requested` : 'requested count not set'}
             </span>
           </span>
-          <Note>The Pooler counts scheduled pods, not ready ones; readiness is on its Deployment.</Note>
+          <Note>status.instances is the operator’s count; observed readiness is on its Deployment and Pods.</Note>
         </FactRow>
         <FactRow label="Deployment">
           {deployment ? (
@@ -52,19 +88,210 @@ export function CNPGPoolerSummary({
             <NotReported />
           )}
         </FactRow>
-        <FactRow label="Connection pressure">
-          <FactValue fact={{ text: 'Not measured — needs PgBouncer metrics, which Radar does not read yet', tone: 'unknown' }} />
+        <FactRow label="Pause state">
+          <div className="flex flex-wrap items-center gap-x-3 gap-y-1">
+            <span>{paused ? 'Pause requested' : 'Serving requested (not paused)'}</span>
+            {actions}
+          </div>
+          <Note>spec.pgbouncer.paused is what was asked for; each PgBouncer applies it with PAUSE / RESUME.</Note>
+          {paused && <Note>When PgBouncer applies the pause, it holds client connections instead of serving them.</Note>}
+          {observed && (
+            <div className="mt-1">
+              <FactValue fact={{ text: `Observed: ${observed.text}`, tone: observed.level, source: 'Each PgBouncer’s SHOW STATE' }} />
+            </div>
+          )}
+        </FactRow>
+      </FactGrid>
+
+      <SectionHeading hint={live?.pressure ? 'live from each PgBouncer' : undefined}>Connections</SectionHeading>
+      {live?.pressure ? (
+        <PoolerPressure pressure={live.pressure} />
+      ) : (
+        <FactGrid>
+          <FactRow label="Connection pressure">
+            <FactValue fact={{ text: 'Not measured — needs PgBouncer metrics, which Radar does not read yet', tone: 'unknown' }} />
+          </FactRow>
+        </FactGrid>
+      )}
+
+      <SectionHeading>Limits</SectionHeading>
+      <FactGrid>
+        <FactRow label="Pool mode">
+          {getCNPGPoolerMode(resource) === 'transaction' ? 'A client uses a server connection only for each transaction.' : getCNPGPoolerMode(resource) === 'session' ? 'A client keeps one server connection for its whole session.' : 'A client uses a server connection for each statement.'}
+          <Note>{getCNPGPoolerMode(resource)}{!resource?.spec?.pgbouncer?.poolMode ? ' (default)' : ''}</Note>
         </FactRow>
+        {POOLER_LIMIT_PARAMETERS.map((p) => {
+          const v = resource?.spec?.pgbouncer?.parameters?.[p.key]
+          return (
+            <FactRow key={p.key} label={p.label}>
+              {v !== undefined ? (
+                <span className="font-mono">{String(v)}</span>
+              ) : (
+                <span className="text-theme-text-secondary">
+                  default{p.pgbouncerDefault ? <span className="text-theme-text-tertiary"> · PgBouncer uses {p.pgbouncerDefault}</span> : null}
+                </span>
+              )}
+              <Note>
+                <span className="font-mono">{p.key}</span>
+              </Note>
+            </FactRow>
+          )
+        })}
       </FactGrid>
 
-      <SummaryHeading>Routing</SummaryHeading>
+      <SectionHeading>Routing</SectionHeading>
       <FactGrid>
         <FactRow label="Cluster">
           <ClusterLink resource={resource} workspace={workspace} onNavigate={onNavigate} />
         </FactRow>
         <FactRow label="Type">{type ? TYPE_LABEL[type] ?? type : <NotReported text="Not set" />}</FactRow>
-        <FactRow label="Pool mode">{getCNPGPoolerMode(resource)}</FactRow>
+        {live?.service && (
+          <FactRow label="Path">
+            <PoolerPath resource={resource} live={live} onNavigate={onNavigate} />
+          </FactRow>
+        )}
       </FactGrid>
     </SummaryShell>
   )
 }
+
+function PoolerPath({ resource, live, onNavigate }: { resource: any; live: CNPGPoolerLive; onNavigate?: NavigateToRef }) {
+  const ns = resource?.metadata?.namespace ?? ''
+  const svc = live.service!
+  const backend = poolerBackendService(resource?.spec?.cluster?.name, resource?.spec?.type)
+  const svcState: Record<string, string> = { missing: 'does not exist', unreadable: 'no access', foreign: 'not controlled by this Pooler' }
+  return (
+    <div className="space-y-0.5">
+      <div>
+        Service <RefLink refTo={{ kind: 'Service', namespace: ns, name: svc.name }} onNavigate={onNavigate} mono />
+        {svc.state === 'ok' ? (
+          <span className="text-theme-text-secondary">{svc.port ? ` :${svc.port}` : ''}{svc.type ? ` · ${svc.type}` : ''}</span>
+        ) : (
+          <span className={toneTextClass('unknown')}> · {svcState[svc.state]}</span>
+        )}
+      </div>
+      <div className="text-theme-text-secondary">→ PgBouncer ({resource?.metadata?.name})</div>
+      <div className="text-theme-text-secondary">
+        → {backend ? <RefLink refTo={{ kind: 'Service', namespace: ns, name: backend }} onNavigate={onNavigate} mono /> : 'the cluster'}
+        {' '}of Cluster {resource?.spec?.cluster?.name ?? '—'}
+      </div>
+    </div>
+  )
+}
+
+// Pods take their client connections independently, so one can queue while
+// the sum still looks calm.
+function PoolerPodPressure({ pods }: { pods: NonNullable<CNPGPoolerLive['pressure']>['pods'] }) {
+  return (
+    <table className="mt-3 w-full text-sm">
+      <thead className="text-left text-[11px] uppercase tracking-wide text-theme-text-tertiary">
+        <tr>
+          <th className="py-1 pr-3">PgBouncer Pod</th>
+          <th className="pr-3 text-right">Clients active</th>
+          <th className="pr-3 text-right">Waiting</th>
+          <th className="pr-3 text-right">Servers active</th>
+          <th className="text-right">Max wait</th>
+        </tr>
+      </thead>
+      <tbody className="table-divide-subtle">
+        {poolerPodPressure(pods).map((r) =>
+          r.state === 'ok' || r.state === 'partial' ? (
+            <tr key={r.pod}>
+              <td className="py-1 pr-3 font-mono text-xs">
+                {r.pod}
+                {r.state === 'partial' && <span className="ml-1 font-sans text-theme-text-tertiary">partial</span>}
+              </td>
+              <td className="pr-3 text-right font-mono"><FactValue fact={poolerPressureFact(pods.filter((p) => p.pod === r.pod), 'clActive')} /></td>
+              <td className={`pr-3 text-right font-mono ${r.clWaiting ? toneTextClass('degraded') : ''}`}><FactValue fact={poolerPressureFact(pods.filter((p) => p.pod === r.pod), 'clWaiting')} /></td>
+              <td className="pr-3 text-right font-mono"><FactValue fact={poolerPressureFact(pods.filter((p) => p.pod === r.pod), 'svActive')} /></td>
+              <td className={`text-right font-mono ${r.maxwaitSeconds ? toneTextClass('degraded') : ''}`}><FactValue fact={poolerPressureFact(pods.filter((p) => p.pod === r.pod), 'maxwaitSeconds')} /></td>
+            </tr>
+          ) : (
+            <tr key={r.pod}>
+              <td className="py-1 pr-3 font-mono text-xs">{r.pod}</td>
+              <td colSpan={4} className="text-right text-xs text-theme-text-tertiary">
+                Not read: {r.error ?? r.state}
+              </td>
+            </tr>
+          ),
+        )}
+      </tbody>
+    </table>
+  )
+}
+
+function PoolerPressure({ pressure }: { pressure: NonNullable<CNPGPoolerLive['pressure']> }) {
+  if (pressure.state === 'loading') return <div className="text-sm text-theme-text-tertiary">Reading PgBouncer metrics…</div>
+  if (pressure.state === 'denied' || pressure.state === 'error') {
+    return <FactValue fact={{ text: `Not measured — ${pressure.reason ?? (pressure.state === 'denied' ? 'needs get pods/proxy' : 'read failed')}`, tone: 'unknown' }} />
+  }
+  const { reporting, limitation, empty } = poolerPressureCoverage(pressure.pods)
+  const rows = aggregatePoolerPools(reporting)
+  if (reporting.length === 0) {
+    return <CNPGPoolerUnmeasured pods={pressure.pods} />
+  }
+  return (
+    <div>
+      {rows.length === 0 ? (
+        <div className="text-sm text-theme-text-secondary">{empty}</div>
+      ) : (
+        <table className="w-full text-sm">
+          <thead className="text-left text-[11px] uppercase tracking-wide text-theme-text-tertiary">
+            <tr>
+              <th className="py-1 pr-3">Pool</th>
+              <th className="pr-3">Mode</th>
+              <th className="pr-3 text-right">Clients active</th>
+              <th className="pr-3 text-right">Waiting</th>
+              <th className="pr-3 text-right">Servers active / idle / used</th>
+              <th className="text-right">Max wait</th>
+            </tr>
+          </thead>
+          <tbody className="table-divide-subtle">
+            {rows.map((r: CNPGPoolerPoolRow) => (
+              <tr key={`${r.database}/${r.user}`}>
+                <td className="py-1 pr-3 font-mono text-xs">{r.database}/{r.user}</td>
+                <td className="pr-3 text-xs">{r.poolModes.join(', ') || '—'}</td>
+                <td className="pr-3 text-right font-mono"><FactValue fact={poolerPressureFact(pressure.pods, 'clActive', r)} /></td>
+                <td className={`pr-3 text-right font-mono ${r.clWaiting ? toneTextClass('degraded') : ''}`}><FactValue fact={poolerPressureFact(pressure.pods, 'clWaiting', r)} /></td>
+                <td className="pr-3 text-right font-mono"><FactValue fact={poolerPressureFact(pressure.pods, 'svActive', r)} /> / <FactValue fact={poolerPressureFact(pressure.pods, 'svIdle', r)} /> / <FactValue fact={poolerPressureFact(pressure.pods, 'svUsed', r)} /></td>
+                <td className={`text-right font-mono ${r.maxwaitSeconds ? toneTextClass('degraded') : ''}`}><FactValue fact={poolerPressureFact(pressure.pods, 'maxwaitSeconds', r)} /></td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      )}
+      <Note>
+        Summed over {reporting.length} of {pressure.pods.length} PgBouncer Pods{limitation ? ` · ${limitation}` : ''}. PgBouncer’s admin and
+        authentication pools are excluded.
+      </Note>
+      {pressure.pods.length > 1 && <PoolerPodPressure pods={pressure.pods} />}
+    </div>
+  )
+}
+
+export function CNPGPoolerScheduling({ namespace, pods, onNavigate }: { namespace: string; pods: NonNullable<CNPGPoolerLive['pressure']>['pods']; onNavigate?: NavigateToRef }) {
+  const byCause = new Map<string, typeof pods>()
+  for (const pod of pods) {
+    if (!pod.schedulingReason) continue
+    const cause = summarizeSchedulerMessage(pod.schedulingReason, { plain: true })
+    const group = byCause.get(cause) ?? []
+    group.push(pod)
+    byCause.set(cause, group)
+  }
+  return <>{[...byCause].map(([cause, blocked]) => <div key={cause} className={`mt-1 text-xs ${toneTextClass('degraded')}`}>
+    <div>Cannot be scheduled: {cause}.</div>
+    {blocked.map((p) => <div key={p.pod}>
+      <div className="mt-0.5 text-theme-text-secondary"><Tooltip content={p.pod} wrapperClassName="block max-w-full [&_button]:block [&_button]:max-w-full [&_button]:truncate [&_span.font-mono]:block [&_span.font-mono]:truncate"><RefLink refTo={{ kind: 'Pod', group: '', namespace, name: p.pod }} onNavigate={onNavigate} mono /></Tooltip></div>
+      <FoldSection title="Scheduler message" summary="" attention={false}><div className="break-words text-theme-text-secondary">{p.schedulingReason}</div></FoldSection>
+    </div>)}
+  </div>)}</>
+}
+
+export function CNPGPoolerUnmeasured({ pods }: { pods: NonNullable<CNPGPoolerLive['pressure']>['pods'] }) {
+  if (pods.length === 0) return <div className="text-theme-text-tertiary">Not measured: no PgBouncer answered</div>
+  return <>{pods.map((p) => <div key={p.pod} className="text-theme-text-tertiary">
+    Not measured: {p.state === 'denied' ? 'needs get pods/proxy' : p.reason ?? 'PgBouncer did not answer'}
+    <Note>{p.pod}</Note>
+    {p.error && <FoldSection title="Measurement details" summary="" attention={false}><div className="break-words text-xs">{p.error}</div></FoldSection>}
+  </div>)}</>
+}

package/src/components/cnpg/CNPGSharedSummary.tsx

@@ -3,8 +3,11 @@ import { Badge } from '../ui/Badge'
 import type { StatusBadge as StatusBadgeValue } from '../resources/resource-utils'
 import { CNPG_GROUP } from '../resources/resource-utils-cnpg'
 import type { CNPGWorkspaceIssue, CNPGWorkspaceResponse } from './workspace'
-import { FactValue, ProblemCallout, RefLink, type CNPGNavigate } from './primitives'
-import { clustersIn, healthSeverity, problemsForObject, relationUnavailable, targetCluster, type CNPGObjectRef } from './relations'
+import { healthToSeverity } from '../../utils/badge-colors'
+import { clustersIn, problemsForObject, relationUnavailable, targetCluster, type CNPGObjectRef } from './relations'
+import { type NavigateToRef, RefLink } from '../ui/RefLink'
+import { FactValue } from '../facts'
+import { ProblemCallout } from './primitives'
 
 const MAX_PROBLEMS = 3
 
@@ -20,7 +23,7 @@ export function ObjectProblems({
 }: {
   issues: CNPGWorkspaceIssue[] | undefined
   subject: CNPGObjectRef
-  onNavigate?: CNPGNavigate
+  onNavigate?: NavigateToRef
 }) {
   const problems = problemsForObject(issues, subject)
   if (problems.length === 0) return null
@@ -43,7 +46,7 @@ export function ObjectProblems({
 
 export function PhaseBadge({ status }: { status: StatusBadgeValue }) {
   return (
-    <Badge severity={healthSeverity(status.level)} size="sm">
+    <Badge severity={healthToSeverity(status.level)} size="sm">
       {status.text}
     </Badge>
   )
@@ -71,16 +74,20 @@ export function ClusterLink({
 }: {
   resource: any
   workspace: CNPGWorkspaceResponse | null
-  onNavigate?: CNPGNavigate
+  onNavigate?: NavigateToRef
 }) {
   const name = resource?.spec?.cluster?.name
   if (!name) return <NotReported text="Not set" />
   const ns = resource?.metadata?.namespace ?? ''
-  const visible = !!targetCluster(resource, clustersIn(workspace))
+  const clusters = clustersIn(workspace)
+  const visible = !!targetCluster(resource, clusters)
+  const replaced = !visible && clusters.some((c) => c.metadata?.namespace === ns && c.metadata?.name === name)
   return (
     <span>
-      <RefLink refTo={{ kind: 'Cluster', group: CNPG_GROUP, namespace: ns, name }} onNavigate={onNavigate} mono />
-      {workspace && !visible && !relationUnavailable(workspace, 'clusters', ns, 'Clusters') && (
+      <RefLink refTo={{ kind: 'Cluster', group: CNPG_GROUP, namespace: ns, name }} onNavigate={replaced ? undefined : onNavigate} mono />
+      {replaced ? (
+        <span className="text-theme-text-tertiary"> · an earlier Cluster of that name; the current one is a different object</span>
+      ) : workspace && !visible && !relationUnavailable(workspace, 'clusters', ns, 'Clusters') && (
         <span className="text-theme-text-tertiary"> · not found in this namespace</span>
       )}
     </span>

package/src/components/cnpg/CNPGWALArchivingFact.test.tsx

@@ -0,0 +1,39 @@
+// @vitest-environment jsdom
+import { act } from 'react'
+import { createRoot } from 'react-dom/client'
+import { expect, it, vi } from 'vitest'
+import { CNPGWALArchivingFact } from './CNPGClusterSummary'
+Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true })
+it('folds the raw condition and exposes relative age with the exact timestamp on hover', () => {
+  vi.useFakeTimers(); vi.setSystemTime(new Date('2026-10-01T13:00:00Z'))
+  const stamp = '2026-10-01T12:00:00Z'
+  const host = document.createElement('div'); document.body.append(host); const root = createRoot(host)
+  act(() => root.render(<CNPGWALArchivingFact fact={{ state: 'no_destination' as const, text: 'Not archived: no destination configured', tone: 'neutral', detail: 'WAL is not archived to recovery storage, so point-in-time recovery is unavailable.', operatorCondition: { type: 'ContinuousArchiving', status: 'True', message: 'Continuous archiving is working', lastTransitionTime: stamp } }} />))
+  expect(host.textContent).toContain('WAL is not archived to recovery storage')
+  const button = host.querySelector('button')!
+  expect(button.getAttribute('aria-expanded')).toBe('false')
+  const panel = document.getElementById(button.getAttribute('aria-controls')!)!
+  expect(panel.firstElementChild!.hasAttribute('inert')).toBe(true)
+  act(() => button.click())
+  expect(button.getAttribute('aria-expanded')).toBe('true')
+  expect(host.textContent).toContain('ContinuousArchiving: True')
+  expect(host.textContent).toContain('Continuous archiving is working')
+  expect(host.textContent).toContain('1h ago')
+  expect(host.querySelector('time')?.dateTime).toBe(stamp)
+  act(() => { host.querySelector('time')!.dispatchEvent(new MouseEvent('mouseover', { bubbles: true })); vi.advanceTimersByTime(350) })
+  expect(document.body.textContent).toContain(stamp)
+  act(() => root.unmount()); host.remove(); vi.useRealTimers()
+})
+
+it('keeps the compact verdict, consequence and per-row operator disclosure', () => {
+  const host = document.createElement('div'); const root = createRoot(host)
+  act(() => root.render(<CNPGWALArchivingFact compact fact={{ state: 'no_destination' as const, text: 'Archive destination absent', tone: 'neutral', detail: 'CloudNativePG still reports archiving as working because it accepts each WAL file without keeping it.', operatorCondition: { type: 'ContinuousArchiving', status: 'True', message: 'working' } }} />))
+  expect(host.textContent).toContain('Archive destination absent')
+  expect(host.textContent).toContain('No point-in-time recovery')
+  expect(host.textContent).not.toContain('because')
+  const fold = host.querySelector('button')!
+  expect(fold.textContent).toContain('Operator report')
+  act(() => fold.click())
+  expect(host.textContent).toContain('ContinuousArchiving: True')
+  act(() => root.unmount())
+})

package/src/components/cnpg/backupRuns.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+import { cnpgBackupRunInFlight, cnpgBackupRunsInWindow } from './backupRuns'
+
+const now = Date.parse('2026-10-05T12:00:00Z')
+const backup = (phase: string, ageDays: number) => ({ apiVersion: 'postgresql.cnpg.io/v1', metadata: { name: phase }, status: { phase, startedAt: new Date(now - ageDays * 86400000).toISOString() } })
+
+describe('backup run window', () => {
+  it('retains every in-flight phase regardless of age, including an unknown phase', () => {
+    const runs = ['pending', 'started', 'running', 'finalizing', 'walArchivingFailing', 'new-phase'].map((phase) => backup(phase, 10))
+    expect(cnpgBackupRunsInWindow(runs, now)).toHaveLength(runs.length)
+    expect(runs.every(cnpgBackupRunInFlight)).toBe(true)
+  })
+  it('applies the cutoff only to settled CNPG runs', () => {
+    const runs = [backup('completed', 10), backup('failed', 10), backup('completed', 2), backup('failed', 1), { ...backup('running', 1), apiVersion: 'velero.io/v1' }]
+    expect(cnpgBackupRunsInWindow(runs, now).map((r) => r.status.phase)).toEqual(['failed', 'completed'])
+  })
+})

package/src/components/cnpg/backupRuns.ts

@@ -0,0 +1,19 @@
+import { isApiGroup } from '../resources/resource-utils-cnpg'
+
+export const CNPG_BACKUP_RUN_WINDOW_MS = 7 * 24 * 60 * 60 * 1000
+
+export function cnpgBackupRunInFlight(backup: any): boolean {
+  return backup?.status?.phase !== 'completed' && backup?.status?.phase !== 'failed'
+}
+
+export function cnpgBackupRunTime(backup: any): string | undefined {
+  return backup?.status?.stoppedAt || backup?.status?.startedAt || backup?.metadata?.creationTimestamp
+}
+
+export function cnpgBackupRunsInWindow(backups: any[], now = Date.now()): any[] {
+  return backups.filter((b) => {
+    if (!isApiGroup(b.apiVersion, 'postgresql.cnpg.io')) return false
+    const time = Date.parse(cnpgBackupRunTime(b) ?? '')
+    return cnpgBackupRunInFlight(b) || (Number.isFinite(time) && now - time <= CNPG_BACKUP_RUN_WINDOW_MS)
+  }).sort((a, b) => Date.parse(cnpgBackupRunTime(b) ?? '') - Date.parse(cnpgBackupRunTime(a) ?? ''))
+}

package/src/components/cnpg/connect.test.ts

@@ -0,0 +1,124 @@
+import { cnpgEndpointAvailability } from './connect'
+import type { CNPGClusterHA } from './ha'
+import { describe, expect, it } from 'vitest'
+import { cnpgConnectInfo, cnpgConnectionURI, cnpgPortForwardCommand, cnpgPsqlCommand } from './connect'
+
+const cluster = (spec: any = {}) => ({ apiVersion: 'postgresql.cnpg.io/v1', kind: 'Cluster', metadata: { name: 'pg', namespace: 'db' }, spec: { instances: 3, ...spec } })
+
+describe('cnpgConnectInfo', () => {
+  it('forwards the actual Service port to the local template port', () => {
+    const endpoint = { ...cnpgConnectInfo(cluster()).endpoints[0], port: 6543 }
+    expect(cnpgPortForwardCommand(endpoint, 'db')).toBe('kubectl -n db port-forward service/pg-rw 5432:6543')
+    expect(cnpgPortForwardCommand(endpoint, 'db', 15432)).toBe('kubectl -n db port-forward service/pg-rw 15432:6543')
+  })
+  it('lists the default Services and names the Secret by convention when the spec does not', () => {
+    const info = cnpgConnectInfo(cluster())
+    expect(info.endpoints.map((e) => `${e.role} ${e.host}:${e.port}`)).toEqual(['rw pg-rw.db.svc:5432', 'ro pg-ro.db.svc:5432', 'r pg-r.db.svc:5432'])
+    expect(info.database).toEqual({ value: 'app', source: "CloudNativePG's default" })
+    expect(info.owner.value).toBe('app')
+    expect(info.secret).toEqual({ name: 'pg-app', source: 'name by convention (<cluster>-app)', byConvention: true })
+    expect(info.endpoints.find((e) => e.role === 'r')?.selects).toBe('any instance (may reach the primary; not read-only)')
+    expect(info.endpoints.find((e) => e.role === 'ro')?.selects).toBe('standbys only (read-only)')
+    const extra = cnpgConnectInfo(cluster({ managed: { services: { additional: [{ selectorType: 'r', serviceTemplate: { metadata: { name: 'pg-any' } } }] } } }))
+    expect(extra.endpoints.find((e) => e.name === 'pg-any')?.selects).toContain('not read-only')
+  })
+
+  it('reads database, owner and Secret the way CloudNativePG resolves them: recovery, pg_basebackup, then initdb', () => {
+    const info = cnpgConnectInfo(
+      cluster({
+        bootstrap: {
+          initdb: { database: 'orders', owner: 'orders_owner', secret: { name: 'init-secret' } },
+          recovery: { database: 'restored', secret: { name: 'recovery-secret' } },
+        },
+      }),
+    )
+    expect(info.database).toEqual({ value: 'restored', source: 'spec.bootstrap.recovery.database' })
+    expect(info.owner).toEqual({ value: 'orders_owner', source: 'spec.bootstrap.initdb.owner' })
+    expect(info.secret).toEqual({ name: 'recovery-secret', source: 'spec.bootstrap.recovery.secret.name', byConvention: false })
+  })
+
+  it('treats a distributed-topology replica (replica.primary names another cluster) as a replica, like the operator', () => {
+    expect(cnpgConnectInfo(cluster({ replica: { primary: 'pg-east', source: 'pg-east' } })).replicaCluster).toBe(true)
+    expect(cnpgConnectInfo(cluster({ replica: { primary: 'pg', source: 'pg-east' } })).replicaCluster).toBe(false)
+    expect(cnpgConnectInfo(cluster({ replica: { enabled: true, source: 'pg-east' } })).replicaCluster).toBe(true)
+    expect(cnpgConnectInfo(cluster()).replicaCluster).toBe(false)
+  })
+
+  it('owner defaults to the database name', () => {
+    expect(cnpgConnectInfo(cluster({ bootstrap: { initdb: { database: 'orders' } } })).owner).toEqual({
+      value: 'orders',
+      source: "CloudNativePG's default: the database's name",
+    })
+  })
+
+  it('does not invent a database for a monolithic import', () => {
+    const info = cnpgConnectInfo(cluster({ bootstrap: { initdb: { import: { type: 'monolith' } } } }))
+    expect(info.database.value).toBeUndefined()
+    expect(info.owner.value).toBeUndefined()
+  })
+
+  it('drops disabled default Services and adds managed and Pooler Services with their ports', () => {
+    const info = cnpgConnectInfo(
+      cluster({
+        managed: {
+          services: {
+            disabledDefaultServices: ['ro', 'r'],
+            additional: [{ selectorType: 'rw', serviceTemplate: { metadata: { name: 'pg-lb' }, spec: { type: 'LoadBalancer', ports: [{ port: 6543 }] } } }],
+          },
+        },
+      }),
+      [
+        { metadata: { name: 'pg-pooler-ro', namespace: 'db' }, spec: { cluster: { name: 'pg' }, type: 'ro' } },
+        { metadata: { name: 'other', namespace: 'db' }, spec: { cluster: { name: 'pg2' } } },
+        { metadata: { name: 'pg-pooler', namespace: 'elsewhere' }, spec: { cluster: { name: 'pg' } } },
+      ],
+    )
+    expect(info.disabled).toEqual(['ro', 'r'])
+    expect(info.endpoints.map((e) => `${e.role} ${e.name}:${e.port}${e.portFromTemplate ? '*' : ''}`)).toEqual(['rw pg-rw:5432', 'additional pg-lb:6543*', 'pooler pg-pooler-ro:5432'])
+    expect(info.endpoints[2].poolerType).toBe('ro')
+    expect(info.endpoints[1].selects).toBe('the primary (read-write)')
+  })
+
+  it('builds templates with a password placeholder only', () => {
+    const info = cnpgConnectInfo(cluster({ bootstrap: { initdb: { database: 'orders', owner: 'o w' } } }))
+    expect(cnpgConnectionURI(info.endpoints[0], info)).toBe('postgresql://o%20w:<password>@pg-rw.db.svc:5432/orders')
+    expect(cnpgPsqlCommand(info.endpoints[0], info)).toBe("psql -h pg-rw.db.svc -p 5432 -U 'o w' -d orders")
+    const quoted = cnpgConnectInfo(cluster({ bootstrap: { initdb: { database: "it's" } } }))
+    expect(cnpgPsqlCommand(quoted.endpoints[0], quoted)).toBe(`psql -h pg-rw.db.svc -p 5432 -U 'it'\\''s' -d 'it'\\''s'`)
+  })
+})
+
+it('pins port-forward to a shell-quoted kubeconfig context when supplied', () => {
+  const ep = cnpgConnectInfo({ metadata: { name: 'orders', namespace: 'prod' } }).endpoints[0]
+  expect(cnpgPortForwardCommand(ep, 'prod', 5432, 'kind-cnpg')).toBe('kubectl --context kind-cnpg -n prod port-forward service/orders-rw 5432:5432')
+  expect(cnpgPortForwardCommand(ep, 'prod', 5432, 'test context')).toContain("--context 'test context'")
+})
+
+it('reads rw endpoints separately from standby and any-instance Pod readiness', () => {
+  const eps = cnpgConnectInfo({ metadata: { name: 'orders', namespace: 'prod' } }).endpoints
+  const ha = { rwEndpoints: { state: 'ok', pods: ['orders-1'] }, pods: { state: 'ok' }, instances: [{ pod: 'orders-1', role: 'primary', ready: true }, { pod: 'orders-2', role: 'replica', ready: false }] } as CNPGClusterHA
+  expect(eps.map((ep) => cnpgEndpointAvailability(ep, ha).text)).toEqual(['Ready endpoints', 'Unavailable: no ready standby', 'Ready instance observed'])
+  expect(cnpgEndpointAvailability(eps[1], { ...ha, instances: [] }).text).toBe('Unavailable: no ready standby')
+  expect(eps.map((ep) => cnpgEndpointAvailability(ep).text)).toEqual(['Not checked', 'Not checked', 'Not checked'])
+  expect(cnpgEndpointAvailability(eps[0], { ...ha, rwEndpoints: { ...ha.rwEndpoints, state: 'denied' } }).text).toBe('Not checked')
+  expect(cnpgEndpointAvailability(eps[1], { ...ha, pods: { state: 'denied' } }).text).toBe('Not checked')
+  expect(cnpgEndpointAvailability(eps[1], { ...ha, instances: [{ ...ha.instances[0], role: 'unknown' }] }).text).toBe('Not checked')
+})
+
+it('keeps Pooler routing faithful for any-instance and unrecognized selectors', () => {
+  for (const [type, selects] of [['rw', 'the primary'], ['ro', 'the standbys'], ['r', 'any instance (may reach the primary; not read-only)'], ['future', 'selector future']]) {
+    const ep = cnpgConnectInfo(cluster(), [{ metadata: { name: 'pooler', namespace: 'db' }, spec: { cluster: { name: 'pg' }, type } }]).endpoints.find((e) => e.role === 'pooler')!
+    expect(ep.poolerType).toBe(type)
+    expect(ep.selects).toBe(`PgBouncer in front of ${selects}`)
+    expect(cnpgEndpointAvailability(ep).source).toBe('This Service’s availability has not been read')
+  }
+})
+it('names the denied grant, failed read, unknown role and unread source alongside Not checked', () => {
+  const eps = cnpgConnectInfo(cluster()).endpoints
+  const ha = { rwEndpoints: { state: 'denied', grant: { verb: 'list', group: 'discovery.k8s.io', resource: 'endpointslices', namespace: 'db' } }, pods: { state: 'error', reason: 'API timeout' }, instances: [] } as unknown as CNPGClusterHA
+  expect(cnpgEndpointAvailability(eps[0], ha)).toEqual({ text: 'Not checked', source: 'No access to Service EndpointSlices (needs list endpointslices (discovery.k8s.io) in namespace db)' })
+  expect(cnpgEndpointAvailability(eps[1], ha)).toEqual({ text: 'Not checked', source: 'instance Pods could not be read: API timeout' })
+  expect(cnpgEndpointAvailability(eps[0], undefined, 'Reading availability…').source).toBe('Reading availability…')
+  expect(cnpgEndpointAvailability(eps[0], undefined, 'Availability could not be read: timeout').source).toBe('Availability could not be read: timeout')
+  expect(cnpgEndpointAvailability(eps[1], { ...ha, pods: { state: 'ok' }, instances: [{ role: 'unknown', ready: true }] } as CNPGClusterHA).source).toBe('Ready instance roles were not reported')
+})