@skyhook-io/k8s-ui 1.10.4 → 1.11.0

package/src/components/resources/resource-utils-velero.test.ts

@@ -0,0 +1,237 @@
+import { describe, it, expect } from 'vitest'
+import { getCellFilterValue } from './resource-utils'
+import {
+  getBackupStatus,
+  getRestoreStatus,
+  getScheduleStatus,
+  isBackupActivePhase,
+  isBackupPartialFailurePhase,
+  isVeleroResource,
+  getScheduleCronInfo,
+  getBackupRepositoryStatus,
+} from './resource-utils-velero'
+
+const backup = (phase: string, extra: Record<string, unknown> = {}) => ({
+  apiVersion: 'velero.io/v1',
+  kind: 'Backup',
+  status: { phase, ...extra },
+})
+
+const schedule = (spec: Record<string, unknown>, status: Record<string, unknown> = {}) => ({
+  apiVersion: 'velero.io/v1',
+  kind: 'Schedule',
+  spec,
+  status,
+})
+
+// The status column's filter dropdown reads getCellFilterValue, which is keyed
+// on normalizeKindToPlural's output. Velero's Restore/Schedule keys are
+// group-qualified, so the unqualified plurals no longer reach it — if these
+// branches aren't kept in step, the filter silently falls through to raw
+// status.phase while the cell still renders the curated badge, and the two
+// disagree.
+describe('getCellFilterValue — Velero status column', () => {
+  it('filters a paused Schedule as Paused, matching what the cell renders', () => {
+    const paused = schedule({ paused: true }, { phase: 'Enabled' })
+    expect(getScheduleStatus(paused).text).toBe('Paused')
+    expect(getCellFilterValue(paused, 'status', 'veleroschedules')).toBe('Paused')
+  })
+
+  it('offers the BackupRepository dropdown the same string the badge shows', () => {
+    // Asserted as literals rather than against the reader: comparing the filter
+    // to getBackupRepositoryStatus().text passes even when both are wrong. The
+    // contract is that the dropdown offers "Not ready" — the label — and never
+    // the raw NotReady phase the generic fallback would have produced.
+    const repo = {
+      apiVersion: 'velero.io/v1',
+      kind: 'BackupRepository',
+      status: { phase: 'NotReady' },
+    }
+    expect(getBackupRepositoryStatus(repo).text).toBe('Not ready')
+    expect(getCellFilterValue(repo, 'status', 'backuprepositories')).toBe('Not ready')
+    expect(getCellFilterValue(repo, 'status', 'backuprepositories')).not.toBe('NotReady')
+  })
+
+  it('filters a validation-error-only Schedule as FailedValidation', () => {
+    // Velero leaves the phase empty on some validation failures. Falling
+    // through to status.phase would make the row unfilterable — the exact
+    // failure this integration exists to surface.
+    const invalid = schedule({ schedule: 'not-a-cron' }, { validationErrors: ['invalid schedule'] })
+    expect(getScheduleStatus(invalid).text).toBe('Rejected')
+    expect(getCellFilterValue(invalid, 'status', 'veleroschedules')).toBe('Rejected')
+  })
+
+  it('filters Restore phases through the curated reader', () => {
+    const restore = { apiVersion: 'velero.io/v1', kind: 'Restore', status: { phase: 'PartiallyFailed' } }
+    expect(getCellFilterValue(restore, 'status', 'velerorestores')).toBe('Partially failed')
+  })
+
+  it('lets a real failure outrank paused, so neither fact is lost', () => {
+    // Previously paused won outright and a paused+invalid schedule showed only
+    // "Paused" — the table gave no sign it was also broken. The badge now
+    // carries the failure (the fact to act on) and the cell adds a paused
+    // indicator alongside.
+    const pausedOnly = schedule({ paused: true }, { phase: 'Enabled' })
+    expect(getScheduleStatus(pausedOnly).text).toBe('Paused')
+
+    const pausedAndInvalid = schedule({ paused: true }, { phase: 'FailedValidation', validationErrors: ['bad cron'] })
+    expect(getScheduleStatus(pausedAndInvalid).text).toBe('Rejected')
+    // and it filters as the failure, so it is reachable from the status filter
+    expect(getCellFilterValue(pausedAndInvalid, 'status', 'veleroschedules')).toBe('Rejected')
+  })
+
+  it('leaves a foreign CRD sharing the plural on the generic reader', () => {
+    // rancher/backup-restore-operator ships restores.resources.cattle.io. It
+    // resolves to the unqualified key, which must NOT hit Velero's reader.
+    const rancher = { apiVersion: 'resources.cattle.io/v1', kind: 'Restore', status: { phase: 'Completed' } }
+    expect(getCellFilterValue(rancher, 'status', 'restores')).toBe('Completed')
+    const rancherPaused = { apiVersion: 'resources.cattle.io/v1', kind: 'Restore', spec: { paused: true }, status: {} }
+    expect(getCellFilterValue(rancherPaused, 'status', 'restores')).toBe('')
+  })
+
+  it('still filters BackupStorageLocation, whose key is not group-qualified', () => {
+    const bsl = { apiVersion: 'velero.io/v1', kind: 'BackupStorageLocation', status: { phase: 'Unavailable' } }
+    expect(getCellFilterValue(bsl, 'status', 'backupstoragelocations')).toBe('Unavailable')
+  })
+})
+
+describe('Velero Backup phase vocabulary', () => {
+  // The table label rule: sentence-case the upstream phase, diverge only where
+  // it does not fit. Each row below is (phase, label, level) — the label column
+  // is the contract, and the three departures from upstream are called out.
+  it.each([
+    ['Completed', 'Completed', 'healthy'],
+    ['New', 'New', 'unknown'],
+    ['Queued', 'Queued', 'neutral'],
+    ['Failed', 'Failed', 'unhealthy'],
+    ['Deleting', 'Deleting', 'degraded'],
+    ['Finalizing', 'Finalizing', 'neutral'],
+    // sentence-cased, not renamed
+    ['InProgress', 'In progress', 'neutral'],
+    ['ReadyToStart', 'Ready to start', 'neutral'],
+    ['PartiallyFailed', 'Partially failed', 'alert'],
+    // the three genuine departures
+    ['WaitingForPluginOperations', 'Plugin work', 'neutral'],
+    ['FailedValidation', 'Rejected', 'unhealthy'],
+    ['FinalizingPartiallyFailed', 'Partially failed', 'alert'],
+    ['WaitingForPluginOperationsPartiallyFailed', 'Partially failed', 'alert'],
+  ])('%s renders as "%s" (%s)', (phase, label, level) => {
+    const status = getBackupStatus(backup(phase))
+    expect(status.text).toBe(label)
+    expect(status.level).toBe(level)
+  })
+
+  // The collapse is deliberate and lossy: three distinct phases share one
+  // label, so the column cannot tell you whether a partially-failed run has
+  // finished. Pinned so the loss is a decision rather than a drift.
+  it('collapses all three partial-failure phases onto one label', () => {
+    const labels = ['PartiallyFailed', 'FinalizingPartiallyFailed', 'WaitingForPluginOperationsPartiallyFailed']
+      .map(p => getBackupStatus(backup(p)).text)
+    expect(new Set(labels)).toEqual(new Set(['Partially failed']))
+  })
+
+  // Two labels a reader cannot tell apart fail the way an exact duplicate
+  // does. Every other phase must stay distinguishable.
+  it('gives no two non-partial phases the same label', () => {
+    const phases = ['New','Queued','ReadyToStart','InProgress','WaitingForPluginOperations','Finalizing','Completed','Failed','FailedValidation','Deleting']
+    const labels = phases.map(p => getBackupStatus(backup(p)).text)
+    expect(new Set(labels).size).toBe(phases.length)
+  })
+
+  it('no longer knows the fictional Uploading phase', () => {
+    // "Uploading" is not in Velero's enum and never has been; it must not be
+    // special-cased back in.
+    expect(getBackupStatus(backup('Uploading')).level).toBe('unknown')
+  })
+
+  it('treats the partial phases as both active and partially failed', () => {
+    // Both are true at once: plugin operations are still running AND some items
+    // already failed. The renderer shows a progress bar and a warning banner.
+    expect(isBackupActivePhase('WaitingForPluginOperationsPartiallyFailed')).toBe(true)
+    expect(isBackupPartialFailurePhase('WaitingForPluginOperationsPartiallyFailed')).toBe(true)
+    expect(isBackupActivePhase('Failed')).toBe(false)
+    expect(isBackupPartialFailurePhase('Failed')).toBe(false)
+  })
+
+  it('gives Restore the same partial/validation vocabulary', () => {
+    expect(getRestoreStatus({ status: { phase: 'FailedValidation' } }).level).toBe('unhealthy')
+    expect(getRestoreStatus({ status: { phase: 'FinalizingPartiallyFailed' } }).level).toBe('alert')
+  })
+})
+
+describe('isVeleroResource', () => {
+  it('selects only the velero.io group', () => {
+    expect(isVeleroResource({ apiVersion: 'velero.io/v1' })).toBe(true)
+    expect(isVeleroResource({ apiVersion: 'resources.cattle.io/v1' })).toBe(false)
+    expect(isVeleroResource({ apiVersion: 'postgresql.cnpg.io/v1' })).toBe(false)
+    // A group that merely ends in velero.io must not match.
+    expect(isVeleroResource({ apiVersion: 'notvelero.io/v1' })).toBe(false)
+    expect(isVeleroResource({})).toBe(false)
+    expect(isVeleroResource(null)).toBe(false)
+  })
+})
+
+describe('getScheduleCronInfo', () => {
+  const sched = (schedule: string, status?: any) => ({ spec: { schedule }, status })
+
+  it('reads a recognised cron as raw plus plain English', () => {
+    const r = getScheduleCronInfo(sched('0 1 * * *'))
+    expect(r).toEqual({ cron: '0 1 * * *', readable: 'Daily at 1:00', malformed: false })
+  })
+
+  it('leaves readable empty when cronToHuman has no phrasing for the expression', () => {
+    // cronToHuman returns its input unchanged for shapes it does not recognise.
+    // Rendering that would print the same string on both lines.
+    const r = getScheduleCronInfo(sched('0 3 * * 0'))
+    expect(r.malformed).toBe(false)
+    expect(r.readable).toBe('')
+  })
+
+  it.each(['not-a-cron', 'bad-cron', '0 1 * *', '0 1 * * * *'])('flags %s as malformed', (c) => {
+    const r = getScheduleCronInfo(sched(c))
+    expect(r.malformed).toBe(true)
+    expect(r.readable).toBe('')
+    expect(r.cron).toBe(c)
+  })
+
+  it('does not flag timezone-prefixed crons, which Velero documents', () => {
+    // From Velero's own CLI docs:
+    //   velero schedule create x --schedule="CRON_TZ=America/New_York 0 3 * * *"
+    const r = getScheduleCronInfo(sched('CRON_TZ=America/New_York 0 3 * * *'))
+    expect(r.malformed).toBe(false)
+    expect(r.cron).toBe('CRON_TZ=America/New_York 0 3 * * *')
+    // No phrasing: "Daily at 3:00" would read as cluster time, which is exactly
+    // what the prefix says it is not.
+    expect(r.readable).toBe('')
+  })
+
+  it('accepts the legacy TZ= spelling and still catches a bad zoned expression', () => {
+    expect(getScheduleCronInfo(sched('TZ=UTC 0 3 * * *')).malformed).toBe(false)
+    expect(getScheduleCronInfo(sched('CRON_TZ=Europe/Berlin not-a-cron')).malformed).toBe(true)
+  })
+
+  it('does not flag @-descriptors, which the field count would reject', () => {
+    expect(getScheduleCronInfo(sched('@daily')).malformed).toBe(false)
+    expect(getScheduleCronInfo(sched('@every 1h')).malformed).toBe(false)
+  })
+
+  it('does not call a valid cron malformed just because the Schedule was rejected', () => {
+    // Observed live: a schedule can fail validation for a missing storage
+    // location while its cron is fine. Reddening the cron there accuses the
+    // wrong field, so malformed must not be derived from phase.
+    const r = getScheduleCronInfo(
+      sched('0 4 * * *', { phase: 'FailedValidation', validationErrors: ['storage location "gone" not found'] })
+    )
+    expect(r.malformed).toBe(false)
+    expect(r.readable).toBe('Daily at 4:00')
+  })
+
+  it('tolerates padded whitespace and trims the raw value', () => {
+    const r = getScheduleCronInfo(sched('  0   1   *   *   *  '))
+    expect(r.malformed).toBe(false)
+  })
+
+  it('renders a missing schedule as a dash, not as malformed', () => {
+    expect(getScheduleCronInfo({ spec: {} })).toEqual({ cron: '-', readable: '', malformed: false })
+  })
+})

package/src/components/resources/resource-utils-velero.ts

@@ -1,35 +1,136 @@
 // Velero CRD utility functions
 
 import type { StatusBadge } from './resource-utils'
-import { healthColors, formatAge, formatDuration } from './resource-utils'
+import { healthColors, formatAge, formatDuration, cronToHuman } from './resource-utils'
+
+// Several Velero plurals are shared with other operators —
+// rancher/backup-restore-operator ships backups/restores.resources.cattle.io,
+// CNPG ships backups.postgresql.cnpg.io, and `schedules` is a common CRD name.
+// Renderers, status readers and cells must therefore select on the API group,
+// not on the plural alone, or a foreign resource renders through Velero's UI.
+export function isVeleroResource(resource: any): boolean {
+  return typeof resource?.apiVersion === 'string' && resource.apiVersion.startsWith('velero.io/')
+}
+
+// ============================================================================
+// TABLE LABELS
+// ============================================================================
+
+// The rule: sentence-case the upstream phase; diverge only where it does not
+// fit. Most of the status column is therefore Velero's own vocabulary as
+// typography, not a rename — which is what keeps it recognisable next to
+// `velero backup describe`. The exact phase stays reachable in the detail
+// drawer and in the badge tooltip.
+//
+// The budget is 96px: a w-36 column less 32px of cell padding and 16px of badge
+// padding. Labels are held to at least 8px of headroom — sub-pixel shortfalls
+// still render an ellipsis, and the ellipsis glyph costs two more characters.
+const VELERO_LABEL_EXCEPTIONS: Record<string, string> = {
+  // 175px, so no defensible column width. "Finishing up" was the obvious
+  // alternative and is worse: a reader cannot tell it apart from the real
+  // `Finalizing` phase, and two labels that look like the same state fail the
+  // way an exact duplicate does, only more slowly.
+  WaitingForPluginOperations: 'Plugin work',
+  // "Validation failed" measures 91px — inside the noise floor at a 96px
+  // budget — and the Schedule cell needs room for a paused indicator beside it.
+  // "Rejected" also states the actionable fact: Velero refused this before it
+  // ran, so nothing happened at all.
+  FailedValidation: 'Rejected',
+  // 237px and 147px. Both collapse onto the plain partial-failure label, which
+  // makes the column non-injective: from the table you cannot tell whether a
+  // partially-failed run has finished. That is acceptable only because the
+  // drawer prints the raw `.status.phase` next to the badge — see
+  // `VeleroPhaseValue`. Remove that and this stops being a display choice and
+  // becomes lost information.
+  WaitingForPluginOperationsPartiallyFailed: 'Partially failed',
+  FinalizingPartiallyFailed: 'Partially failed',
+}
+
+// PartiallyFailed -> "Partially failed", ReadyToStart -> "Ready to start".
+function sentenceCasePhase(phase: string): string {
+  return phase
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .split(' ')
+    .map((word, i) => (i === 0 ? word : word.toLowerCase()))
+    .join(' ')
+}
+
+// The table label for a Velero phase. Display only — the issues engine and MCP
+// keep the raw phase, because those are API surfaces read by agents rather than
+// a column read by a human.
+export function veleroPhaseLabel(phase: string): string {
+  if (!phase) return 'Unknown'
+  return VELERO_LABEL_EXCEPTIONS[phase] ?? sentenceCasePhase(phase)
+}
 
 // ============================================================================
 // BACKUP UTILITIES
 // ============================================================================
 
+// Phases in which a Backup or Restore is still executing. Velero has no
+// single "running" flag — the set below is the v1.18 enum minus the terminal
+// and pre-start phases. `Finalizing`/`WaitingForPluginOperations` and their
+// *PartiallyFailed twins are still doing work, so the progress bar applies.
+const BACKUP_ACTIVE_PHASES = new Set([
+  'InProgress',
+  'WaitingForPluginOperations',
+  'WaitingForPluginOperationsPartiallyFailed',
+  'Finalizing',
+  'FinalizingPartiallyFailed',
+])
+
+// Phases meaning "some of the backup made it, some didn't". Distinct from a
+// plain failure: the data is partially recoverable.
+const BACKUP_PARTIAL_PHASES = new Set([
+  'PartiallyFailed',
+  'FinalizingPartiallyFailed',
+  'WaitingForPluginOperationsPartiallyFailed',
+])
+
+export function isBackupActivePhase(phase: string): boolean {
+  return BACKUP_ACTIVE_PHASES.has(phase)
+}
+
+export function isBackupPartialFailurePhase(phase: string): boolean {
+  return BACKUP_PARTIAL_PHASES.has(phase)
+}
+
 export function getBackupStatus(resource: any): StatusBadge {
   const phase = resource.status?.phase || ''
 
   switch (phase) {
     case 'Completed':
-      return { text: 'Completed', color: healthColors.healthy, level: 'healthy' }
+      return { text: veleroPhaseLabel('Completed'), color: healthColors.healthy, level: 'healthy' }
     case 'InProgress':
-      return { text: 'InProgress', color: healthColors.neutral, level: 'neutral' }
-    case 'Uploading':
-      return { text: 'Uploading', color: healthColors.neutral, level: 'neutral' }
+    case 'WaitingForPluginOperations':
+    case 'Finalizing':
+    case 'Queued':
+    case 'ReadyToStart':
+      return { text: veleroPhaseLabel(phase), color: healthColors.neutral, level: 'neutral' }
+    // Partial failure is worse than "degraded" (some data is already lost) but
+    // not a total loss — the orange `alert` tier separates the two.
     case 'PartiallyFailed':
-      return { text: 'PartiallyFailed', color: healthColors.degraded, level: 'degraded' }
+    case 'FinalizingPartiallyFailed':
+    case 'WaitingForPluginOperationsPartiallyFailed':
+      return { text: veleroPhaseLabel(phase), color: healthColors.alert, level: 'alert' }
     case 'Failed':
-      return { text: 'Failed', color: healthColors.unhealthy, level: 'unhealthy' }
+    case 'FailedValidation':
+      return { text: veleroPhaseLabel(phase), color: healthColors.unhealthy, level: 'unhealthy' }
     case 'Deleting':
-      return { text: 'Deleting', color: healthColors.degraded, level: 'degraded' }
+      return { text: veleroPhaseLabel('Deleting'), color: healthColors.degraded, level: 'degraded' }
     case 'New':
-      return { text: 'New', color: healthColors.unknown, level: 'unknown' }
+      return { text: veleroPhaseLabel('New'), color: healthColors.unknown, level: 'unknown' }
     default:
-      return { text: phase || 'Unknown', color: healthColors.unknown, level: 'unknown' }
+      return { text: veleroPhaseLabel(phase), color: healthColors.unknown, level: 'unknown' }
   }
 }
 
+// Backups queued behind the concurrency limit (v1.18+) report their position.
+export function getBackupQueuePosition(resource: any): number | null {
+  const pos = resource.status?.queuePosition
+  return typeof pos === 'number' ? pos : null
+}
+
 export function getBackupStorageLocation(resource: any): string {
   return resource.spec?.storageLocation || 'default'
 }
@@ -115,25 +216,36 @@ export function getBackupVolumeSnapshotLocations(resource: any): string[] {
 // RESTORE UTILITIES
 // ============================================================================
 
+// Restore shares Backup's phase vocabulary except for the pre-start
+// (`Queued`/`ReadyToStart`) and `Deleting` phases, which only Backup has.
 export function getRestoreStatus(resource: any): StatusBadge {
   const phase = resource.status?.phase || ''
 
   switch (phase) {
     case 'Completed':
-      return { text: 'Completed', color: healthColors.healthy, level: 'healthy' }
+      return { text: veleroPhaseLabel('Completed'), color: healthColors.healthy, level: 'healthy' }
     case 'InProgress':
-      return { text: 'InProgress', color: healthColors.neutral, level: 'neutral' }
+    case 'WaitingForPluginOperations':
+    case 'Finalizing':
+      return { text: veleroPhaseLabel(phase), color: healthColors.neutral, level: 'neutral' }
     case 'PartiallyFailed':
-      return { text: 'PartiallyFailed', color: healthColors.degraded, level: 'degraded' }
+    case 'FinalizingPartiallyFailed':
+    case 'WaitingForPluginOperationsPartiallyFailed':
+      return { text: veleroPhaseLabel(phase), color: healthColors.alert, level: 'alert' }
     case 'Failed':
-      return { text: 'Failed', color: healthColors.unhealthy, level: 'unhealthy' }
+    case 'FailedValidation':
+      return { text: veleroPhaseLabel(phase), color: healthColors.unhealthy, level: 'unhealthy' }
     case 'New':
-      return { text: 'New', color: healthColors.unknown, level: 'unknown' }
+      return { text: veleroPhaseLabel('New'), color: healthColors.unknown, level: 'unknown' }
     default:
-      return { text: phase || 'Unknown', color: healthColors.unknown, level: 'unknown' }
+      return { text: veleroPhaseLabel(phase), color: healthColors.unknown, level: 'unknown' }
   }
 }
 
+export function getRestoreValidationErrors(resource: any): string[] {
+  return resource.status?.validationErrors || []
+}
+
 export function getRestoreBackupName(resource: any): string {
   return resource.spec?.backupName || '-'
 }
@@ -191,24 +303,78 @@ export function getScheduleStatus(resource: any): StatusBadge {
   const phase = resource.status?.phase || ''
   const isPaused = resource.spec?.paused === true
 
+  // Velero leaves the phase empty on some validation failures and only records
+  // the reason in status.validationErrors, so the array is the authoritative
+  // signal — a schedule with errors is not producing backups whatever the phase.
+  const isRejected = phase === 'FailedValidation' || getScheduleValidationErrors(resource).length > 0
+
+  // A real failure outranks paused. Pausing is a state the operator chose; being
+  // rejected is one they need to fix, and it survives resuming. When both are
+  // true the cell renders this badge plus a separate paused indicator, so
+  // neither fact is lost — previously paused won outright and the table showed
+  // no sign the schedule was also invalid.
+  if (isRejected) {
+    return { text: veleroPhaseLabel('FailedValidation'), color: healthColors.unhealthy, level: 'unhealthy' }
+  }
+
   if (isPaused) {
     return { text: 'Paused', color: healthColors.degraded, level: 'degraded' }
   }
 
   switch (phase) {
     case 'Enabled':
-      return { text: 'Enabled', color: healthColors.healthy, level: 'healthy' }
+      return { text: veleroPhaseLabel('Enabled'), color: healthColors.healthy, level: 'healthy' }
     case 'FailedValidation':
-      return { text: 'FailedValidation', color: healthColors.unhealthy, level: 'unhealthy' }
+      return { text: veleroPhaseLabel('FailedValidation'), color: healthColors.unhealthy, level: 'unhealthy' }
     default:
-      return { text: phase || 'Unknown', color: healthColors.unknown, level: 'unknown' }
+      return { text: veleroPhaseLabel(phase), color: healthColors.unknown, level: 'unknown' }
   }
 }
 
+export function getScheduleValidationErrors(resource: any): string[] {
+  return resource.status?.validationErrors || []
+}
+
 export function getScheduleCron(resource: any): string {
   return resource.spec?.schedule || '-'
 }
 
+// The schedule cell shows the raw cron with its plain-English reading beneath,
+// matching CronJob. Two departures from that cell, both deliberate:
+//
+// `readable` is empty when cronToHuman gives the expression back unchanged —
+// it recognises a handful of shapes and returns the input for the rest, so
+// rendering unconditionally prints the same string twice (which CronJob does).
+//
+// `malformed` is a field-count check, the same thing Velero's own parser
+// complains about first ("expected exactly 5 fields"). It is deliberately not
+// derived from FailedValidation: a schedule can be rejected for a missing
+// storage location while its cron is perfectly good, and reddening the cron
+// there would accuse the wrong field. `@`-descriptors pass unflagged, and a
+// 5-field expression with an out-of-range number is not caught — the status
+// badge carries Velero's verdict, so under-marking beats a false accusation.
+export function getScheduleCronInfo(resource: any): {
+  cron: string
+  readable: string
+  malformed: boolean
+} {
+  const cron = (resource.spec?.schedule || '').trim()
+  if (!cron) return { cron: '-', readable: '', malformed: false }
+
+  // Velero documents `CRON_TZ=America/New_York 0 3 * * *`, and robfig/cron also
+  // accepts the legacy `TZ=` spelling. Both put a sixth token in front of the
+  // expression, so the prefix comes off before anything is counted.
+  const zoned = /^(CRON_TZ|TZ)=(\S+)\s+/i.exec(cron)
+  const bare = zoned ? cron.slice(zoned[0].length) : cron
+
+  const malformed = !bare.startsWith('@') && bare.split(/\s+/).length !== 5
+  // No plain-English line for a zoned expression: "Daily at 3:00" reads as
+  // cluster time, and the whole point of the prefix is that it isn't. The raw
+  // value already names the zone.
+  const readable = malformed || zoned ? '' : cronToHuman(bare)
+  return { cron, readable: readable === cron ? '' : readable, malformed }
+}
+
 export function getScheduleLastBackup(resource: any): string {
   const lastBackup = resource.status?.lastBackup
   if (!lastBackup) return 'Never'
@@ -236,11 +402,11 @@ export function getBSLStatus(resource: any): StatusBadge {
 
   switch (phase) {
     case 'Available':
-      return { text: 'Available', color: healthColors.healthy, level: 'healthy' }
+      return { text: veleroPhaseLabel('Available'), color: healthColors.healthy, level: 'healthy' }
     case 'Unavailable':
-      return { text: 'Unavailable', color: healthColors.unhealthy, level: 'unhealthy' }
+      return { text: veleroPhaseLabel('Unavailable'), color: healthColors.unhealthy, level: 'unhealthy' }
     default:
-      return { text: phase || 'Unknown', color: healthColors.unknown, level: 'unknown' }
+      return { text: veleroPhaseLabel(phase), color: healthColors.unknown, level: 'unknown' }
   }
 }
 
@@ -291,3 +457,29 @@ export function getVSLProvider(resource: any): string {
 export function getVSLConfig(resource: any): Record<string, string> {
   return resource.spec?.config || {}
 }
+
+// ============================================================================
+// BACKUP REPOSITORY UTILITIES
+// ============================================================================
+
+export function getBackupRepositoryStatus(resource: any): StatusBadge {
+  const phase = resource.status?.phase || ''
+
+  switch (phase) {
+    case 'Ready':
+      return { text: veleroPhaseLabel('Ready'), color: healthColors.healthy, level: 'healthy' }
+    case 'NotReady':
+      return { text: veleroPhaseLabel('NotReady'), color: healthColors.unhealthy, level: 'unhealthy' }
+    case 'New':
+      return { text: veleroPhaseLabel('New'), color: healthColors.unknown, level: 'unknown' }
+    default:
+      return { text: veleroPhaseLabel(phase), color: healthColors.unknown, level: 'unknown' }
+  }
+}
+
+// kopia | restic. Worth scanning for: restic is being retired — v1.17 stopped
+// creating new restic backups and v1.19 drops restic restore — so a restic
+// repository is a migration liability, not just a configuration detail.
+export function getBackupRepositoryType(resource: any): string {
+  return resource.spec?.repositoryType || '-'
+}