@skyhook-io/k8s-ui 1.13.0 → 1.13.4

package/src/utils/format.ts

@@ -126,12 +126,15 @@ export function parseMemoryToBytes(memString: string): number {
   const num = parseFloat(match[1])
   const suffix = match[2]
 
-  // Binary suffixes (powers of 1024)
+  // Binary suffixes (powers of 1024). Pi/Ei are real inputs at cluster scale —
+  // an aggregate of a thousand 1TiB nodes serializes as "1Pi".
   const binarySuffixes: Record<string, number> = {
     'Ki': 1024,
     'Mi': 1024 ** 2,
     'Gi': 1024 ** 3,
     'Ti': 1024 ** 4,
+    'Pi': 1024 ** 5,
+    'Ei': 1024 ** 6,
   }
 
   // Decimal suffixes (powers of 1000)
@@ -141,6 +144,8 @@ export function parseMemoryToBytes(memString: string): number {
     'M': 1000 ** 2,
     'G': 1000 ** 3,
     'T': 1000 ** 4,
+    'P': 1000 ** 5,
+    'E': 1000 ** 6,
   }
 
   if (suffix in binarySuffixes) {
@@ -164,6 +169,80 @@ export function formatMemoryString(memString: string): string {
   return formatMemoryBytes(parseMemoryToBytes(memString))
 }
 
+// =============================================================================
+// Quantity Parsing (counts)
+// =============================================================================
+
+/**
+ * Every suffix a `resource.Quantity` can carry, in the API's own groupings:
+ * decimal SI in powers of 1000 (including the sub-unit n/u/m), and binary SI in
+ * powers of 1024. `K` is not canonical Kubernetes — only lowercase `k` is — but
+ * it is accepted here for the same leniency `parseMemoryToBytes` already has.
+ */
+const QUANTITY_SUFFIXES: Record<string, number> = {
+  n: 1e-9,
+  u: 1e-6,
+  m: 1e-3,
+  k: 1e3,
+  K: 1e3,
+  M: 1e6,
+  G: 1e9,
+  T: 1e12,
+  P: 1e15,
+  E: 1e18,
+  Ki: 1024,
+  Mi: 1024 ** 2,
+  Gi: 1024 ** 3,
+  Ti: 1024 ** 4,
+  Pi: 1024 ** 5,
+  Ei: 1024 ** 6,
+}
+
+/**
+ * Parse a Kubernetes `resource.Quantity` into a plain number.
+ *
+ * Counts are the surface that needs this. A Quantity's canonical serialization
+ * collapses trailing zeros into an SI suffix, so a node started with
+ * `--max-pods=1000` reports `"1k"` and not `"1000"` — read as a raw integer
+ * that is 1, so a usage bar divides by 1 instead of 1000. Any count that is
+ * a multiple of 1000 hits it.
+ *
+ * Unlike `parseMemoryToBytes`, an unrecognised suffix yields 0 rather than the
+ * bare number: a Quantity this cannot read is better reported as unknown by the
+ * caller than silently turned into a plausible-looking wrong number.
+ *
+ * @param quantity - K8s quantity like "1k", "216", "3000m", "2Gi", "1e3"
+ * @returns The value as a number, or 0 when it cannot be parsed
+ */
+export function parseQuantityToNumber(quantity: string | number | null | undefined): number {
+  if (typeof quantity === 'number') return Number.isFinite(quantity) ? quantity : 0
+  if (!quantity) return 0
+
+  const str = String(quantity).trim()
+  if (!str) return 0
+
+  // Decimal-exponent form. A Quantity's suffix is either an SI suffix or an
+  // exponent, never both, so this is decided before the suffix table — which
+  // also keeps "1E3" (1000) from being read as exa (1e18).
+  const exponent = str.match(/^([+-]?\d+(?:\.\d+)?)[eE]([+-]?\d+)$/)
+  if (exponent) {
+    const value = Number(`${exponent[1]}e${exponent[2]}`)
+    return Number.isFinite(value) ? value : 0
+  }
+
+  const match = str.match(/^([+-]?\d+(?:\.\d+)?)\s*([A-Za-z]*)$/)
+  if (!match) return 0
+
+  const num = parseFloat(match[1])
+  if (!Number.isFinite(num)) return 0
+
+  const suffix = match[2]
+  if (!suffix) return num
+
+  const multiplier = QUANTITY_SUFFIXES[suffix]
+  return multiplier === undefined ? 0 : num * multiplier
+}
+
 // =============================================================================
 // Dashboard Metrics Formatting (different units from metrics-server)
 // =============================================================================

package/src/utils/inClusterConsent.test.ts

@@ -26,6 +26,15 @@ describe('inClusterConsent', () => {
     expect(inClusterConsentGiven('prod')).toBe(false)
   })
 
+  it('does not trust consent stored under the visible-name key format', () => {
+    const store: Record<string, string> = { 'radar.inClusterConsent.prod': '1' }
+    vi.stubGlobal('localStorage', {
+      getItem: (k: string) => (k in store ? store[k] : null),
+      setItem: (k: string, v: string) => { store[k] = v },
+    })
+    expect(inClusterConsentGiven('prod')).toBe(false)
+  })
+
   it('does not throw when localStorage is unavailable, and reports not-given', () => {
     vi.stubGlobal('localStorage', {
       getItem: () => { throw new Error('denied') },

package/src/utils/inClusterConsent.ts

@@ -1,9 +1,9 @@
 // Consent memory for the mutating in-cluster reachability test (it creates a
-// short-lived Job/pod). Keyed by CLUSTER so a "don't ask again" on one cluster
+// short-lived Job/pod). Keyed by an opaque source identity so a "don't ask again" on one cluster
 // never silently suppresses the confirm on another - the cluster the pod lands
 // in is the whole point of asking. Switching kube-context re-prompts.
 //
-// No cluster identity → no memory of ANY kind: the operator is asked on every
+// No source identity → no memory of ANY kind: the operator is asked on every
 // run. localStorage is per-ORIGIN, and one origin (Radar Hub) can front many
 // clusters, so a shared fallback key would let "don't ask again" on one cluster
 // suppress the pod-creating confirm on all of them - and even an in-memory
@@ -11,22 +11,22 @@
 // The dialog hides its "don't ask again" checkbox in that case, so nothing is
 // promised that doesn't stick.
 
-const key = (cluster: string) => `radar.inClusterConsent.${cluster}`
+const key = (clusterKey: string) => `radar.inClusterConsent.v2.${clusterKey}`
 
-export function inClusterConsentGiven(cluster?: string): boolean {
-  if (!cluster) return false
+export function inClusterConsentGiven(clusterKey?: string): boolean {
+  if (!clusterKey) return false
   try {
-    return localStorage.getItem(key(cluster)) === '1'
+    return localStorage.getItem(key(clusterKey)) === '1'
   } catch {
     // localStorage unavailable (private mode / non-browser) - fail toward asking.
     return false
   }
 }
 
-export function rememberInClusterConsent(cluster?: string): void {
-  if (!cluster) return
+export function rememberInClusterConsent(clusterKey?: string): void {
+  if (!clusterKey) return
   try {
-    localStorage.setItem(key(cluster), '1')
+    localStorage.setItem(key(clusterKey), '1')
   } catch {
     // Non-fatal: if we can't persist, the user is simply asked again next time.
   }

package/src/utils/index.ts

@@ -9,6 +9,7 @@ export * from './animation'
 export * from './resource-hierarchy'
 export * from './log-format'
 export * from './download'
+export * from './clipboard'
 export * from './env-from'
 export * from './extended-resources'
 export * from './api-resources'

package/src/utils/navigation.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, expect, afterEach } from 'vitest'
 import { englishPlural } from './pluralize'
-import { kindToPlural, pluralToKind, refToSelectedResource, initNavigationMap, resetNavigationMap, laneId, laneResourceKey, groupQualifiesLaneId, parseLaneId } from './navigation'
+import { kindToPlural, kindToPluralWithGroup, pluralToKind, refToSelectedResource, initNavigationMap, resetNavigationMap, laneId, laneResourceKey, groupQualifiesLaneId, parseLaneId } from './navigation'
 
 afterEach(() => {
   resetNavigationMap()
@@ -224,6 +224,24 @@ describe('initNavigationMap', () => {
     ])
     expect(pluralToKind('pods')).toBe('Pod')
   })
+
+  test('keeps the virtual PodGroup alias distinct from scheduling PodGroup', () => {
+    initNavigationMap([
+      { group: 'scheduling.k8s.io', version: 'v1beta1', kind: 'PodGroup', name: 'podgroups', namespaced: true, isCrd: false, verbs: ['get', 'list'] },
+      { group: 'example.io', version: 'v1', kind: 'PodGroup', name: 'custompodgroups', namespaced: true, isCrd: true, verbs: ['get', 'list'] },
+    ])
+
+    expect(kindToPlural('PodGroup')).toBe('pods')
+    expect(kindToPluralWithGroup('PodGroup', 'scheduling.k8s.io')).toBe('podgroups')
+    expect(kindToPluralWithGroup('PodGroup', 'example.io')).toBe('custompodgroups')
+    expect(kindToPluralWithGroup('podgroups', 'scheduling.k8s.io')).toBe('podgroups')
+  })
+
+  test('preserves aliases and plural slugs before group discovery is initialized', () => {
+    expect(kindToPluralWithGroup('PodGroup', 'scheduling.k8s.io')).toBe('podgroups')
+    expect(kindToPluralWithGroup('CalicoGlobalNetworkPolicy', 'projectcalico.org')).toBe('globalnetworkpolicies')
+    expect(kindToPluralWithGroup('schedules', 'velero.io')).toBe('schedules')
+  })
 })
 
 describe('refToSelectedResource', () => {
@@ -241,6 +259,18 @@ describe('refToSelectedResource', () => {
     })
   })
 
+  test('uses the API group when a real resource collides with a virtual kind', () => {
+    initNavigationMap([
+      { group: 'scheduling.k8s.io', version: 'v1beta1', kind: 'PodGroup', name: 'podgroups', namespaced: true, isCrd: false, verbs: ['get', 'list'] },
+    ])
+    expect(refToSelectedResource({ kind: 'PodGroup', name: 'batch', namespace: 'default', group: 'scheduling.k8s.io' })).toEqual({
+      kind: 'podgroups',
+      name: 'batch',
+      namespace: 'default',
+      group: 'scheduling.k8s.io',
+    })
+  })
+
   test('preserves group field', () => {
     const result = refToSelectedResource({
       kind: 'Certificate',

package/src/utils/navigation.ts

@@ -42,10 +42,15 @@ const BUILTIN_PLURAL_TO_KIND: Record<string, string> = {
   networkpolicies: 'NetworkPolicy',
 }
 
+const BUILTIN_GROUP_KIND_TO_PLURAL: Record<string, string> = {
+  'scheduling.k8s.io/podgroup': 'podgroups',
+}
+
 // Dynamic map built from API discovery — populated by initNavigationMap().
 // Once populated, this is the source of truth for all kind↔plural lookups.
 let discoveredPluralToKind: Record<string, string> | null = null
 let discoveredKindToPlural: Record<string, string> | null = null
+let discoveredGroupKindToPlural: Record<string, string> | null = null
 
 /**
  * Initialize navigation maps from discovered API resources.
@@ -55,6 +60,7 @@ let discoveredKindToPlural: Record<string, string> | null = null
 export function initNavigationMap(resources: APIResource[]) {
   const p2k: Record<string, string> = { ...BUILTIN_PLURAL_TO_KIND }
   const k2p: Record<string, string> = {}
+  const gk2p: Record<string, string> = {}
   for (const r of resources) {
     const plural = r.name.toLowerCase()
     // First-wins on plurals: BUILTIN_PLURAL_TO_KIND seeds canonical core mappings
@@ -62,15 +68,18 @@ export function initNavigationMap(resources: APIResource[]) {
     // "pods" with kind "PodMetrics") cannot hijack the core mapping.
     if (!(plural in p2k)) p2k[plural] = r.kind
     k2p[r.kind.toLowerCase()] = plural
+    gk2p[`${r.group}/${r.kind.toLowerCase()}`] = plural
   }
   discoveredPluralToKind = p2k
   discoveredKindToPlural = k2p
+  discoveredGroupKindToPlural = gk2p
 }
 
 /** Reset navigation maps to builtin-only state. For testing. */
 export function resetNavigationMap() {
   discoveredPluralToKind = null
   discoveredKindToPlural = null
+  discoveredGroupKindToPlural = null
 }
 
 function getPluralToKind(): Record<string, string> {
@@ -90,6 +99,8 @@ export function kindToPlural(kind: string): string {
   // Already a known plural — return as-is to prevent double-pluralization
   if (kindLower in pluralToKindMap) return kindLower
 
+  if (kindLower === 'podgroup') return 'pods'
+
   // Lookup from discovered API resources (singular kind → plural name)
   if (discoveredKindToPlural && kindLower in discoveredKindToPlural) {
     return discoveredKindToPlural[kindLower]
@@ -99,7 +110,6 @@ export function kindToPlural(kind: string): string {
   const aliases: Record<string, string> = {
     horizontalpodautoscaler: 'horizontalpodautoscalers',
     pvc: 'persistentvolumeclaims',
-    podgroup: 'pods',
     caliconetworkpolicy: 'networkpolicies',
     calicoglobalnetworkpolicy: 'globalnetworkpolicies',
     calicostagednetworkpolicy: 'stagednetworkpolicies',
@@ -122,6 +132,15 @@ export function kindToPlural(kind: string): string {
   return englishPlural(kindLower)
 }
 
+export function kindToPluralWithGroup(kind: string, group: string): string {
+  if (!group) return kindToPlural(kind)
+  const kindLower = kind.toLowerCase()
+  const pluralToKindMap = getPluralToKind()
+  if (kindLower in pluralToKindMap) return kindLower
+  const groupKind = `${group}/${kindLower}`
+  return discoveredGroupKindToPlural?.[groupKind] ?? BUILTIN_GROUP_KIND_TO_PLURAL[groupKind] ?? kindToPlural(kind)
+}
+
 /**
  * Convert a plural API resource name (e.g., "deployments") back to singular PascalCase kind (e.g., "Deployment").
  * Inverse of kindToPlural. Converts plural API resource names from URLs back to
@@ -151,7 +170,7 @@ export function refToSelectedResource(
   ref: Pick<ResourceRef, 'kind' | 'name' | 'group'> & { namespace?: string },
 ): SelectedResource {
   return {
-    kind: kindToPlural(ref.kind),
+    kind: kindToPluralWithGroup(ref.kind, ref.group ?? ''),
     namespace: ref.namespace ?? '',
     name: ref.name,
     group: ref.group,

package/src/utils/workload-rollout.ts

@@ -0,0 +1,292 @@
+import type { WorkloadPodInfo } from '../types/core'
+
+export type WorkloadRolloutPhase =
+  | 'idle'
+  | 'applying'
+  | 'progressing'
+  | 'waiting'
+  | 'paused'
+  | 'partition-reached'
+  | 'stalled'
+
+export interface WorkloadRolloutActivity {
+  phase: WorkloadRolloutPhase
+  active: boolean
+  manual: boolean
+  label: string
+  detail?: string
+  desired: number
+  updated: number
+  ready: number
+  available: number
+}
+
+export function isArgoRolloutResource(resource: any): boolean {
+  return String(resource?.apiVersion || '').startsWith('argoproj.io/')
+}
+
+export function rolloutMayAdvanceAutomatically(activity: WorkloadRolloutActivity): boolean {
+  return activity.phase === 'applying' ||
+    activity.phase === 'progressing' ||
+    (activity.phase === 'waiting' && !activity.manual)
+}
+
+export function isRolloutActivityVisible(activity: WorkloadRolloutActivity): boolean {
+  return activity.active || activity.phase === 'stalled'
+}
+
+export function getObservedGeneration(resource: any): number {
+  const observed = resource?.status?.observedGeneration
+  if (typeof observed === 'number' && Number.isFinite(observed)) return observed
+  return typeof observed === 'string' && /^\d+$/.test(observed)
+    ? Number.parseInt(observed, 10)
+    : 0
+}
+
+export function getWorkloadRolloutActivity(
+  resource: any,
+  kind?: string,
+  workloadPods?: WorkloadPodInfo[],
+): WorkloadRolloutActivity {
+  const normalized = (kind || resource?.kind || '').toLowerCase().replace(/s$/, '')
+  if (normalized === 'rollout' && !isArgoRolloutResource(resource)) {
+    return activity('idle', false, false, 'Stable', '', 0, 0, 0, 0)
+  }
+  let result: WorkloadRolloutActivity
+  switch (normalized) {
+    case 'deployment':
+      result = deploymentActivity(resource)
+      break
+    case 'statefulset':
+      result = statefulSetActivity(resource)
+      break
+    case 'daemonset':
+      result = daemonSetActivity(resource)
+      break
+    case 'rollout':
+      result = argoRolloutActivity(resource)
+      break
+    default:
+      result = activity('idle', false, false, 'Stable', '', 0, 0, 0, 0)
+  }
+  return withUpdatedRevisionFailure(result, workloadPods)
+}
+
+function deploymentActivity(resource: any): WorkloadRolloutActivity {
+  const spec = resource?.spec || {}
+  const status = resource?.status || {}
+  const desired = spec.replicas ?? 1
+  const updated = status.updatedReplicas ?? 0
+  const ready = status.readyReplicas ?? 0
+  const available = status.availableReplicas ?? 0
+  const base = activity('idle', false, false, 'Stable', '', desired, updated, ready, available)
+  const progress = (status.conditions || []).find((condition: any) => condition.type === 'Progressing')
+
+  if ((status.observedGeneration ?? 0) < (resource?.metadata?.generation ?? 0)) {
+    return merge(base, 'applying', true, 'Applying change', 'Waiting for the Deployment controller to observe generation')
+  }
+  if (progress?.status === 'False' || progress?.reason === 'ProgressDeadlineExceeded') {
+    return merge(base, 'stalled', false, 'Rollout stalled', progress.message || 'Progress deadline exceeded')
+  }
+  const old = Math.max(0, (status.replicas ?? 0) - updated)
+  const pending = updated < desired || old > 0
+  if (spec.paused) {
+    return merge(base, 'paused', pending, 'Rollout paused', pending ? `Paused at ${updated}/${desired} updated` : 'No rollout is pending')
+  }
+  if (desired === 0) return merge(base, 'idle', false, 'Scaled to zero', 'No replicas requested')
+  if (!pending) return merge(base, 'idle', false, 'Stable', `${available}/${desired} available`)
+  if (spec.strategy?.type === 'Recreate') {
+    if (updated === 0 && old > 0) {
+      return merge(base, 'waiting', true, 'Replacing replicas', `Waiting for old replicas to stop · ${available} available`)
+    }
+    return updated === 0
+      ? merge(base, 'waiting', true, 'Waiting for new revision', replicaDetail(updated, desired, available))
+      : merge(base, 'progressing', true, 'Replacing replicas', replicaDetail(updated, desired, available))
+  }
+  if (updated === 0) return merge(base, 'waiting', true, 'Waiting for new revision', replicaDetail(updated, desired, available))
+  return old === 0 && updated === (status.replicas ?? 0)
+    ? merge(base, 'progressing', true, 'Scaling', replicaDetail(updated, desired, available))
+    : merge(base, 'progressing', true, 'Rolling out', replicaDetail(updated, desired, available))
+}
+
+function statefulSetActivity(resource: any): WorkloadRolloutActivity {
+  const spec = resource?.spec || {}
+  const status = resource?.status || {}
+  const desired = spec.replicas ?? 1
+  const updated = status.updatedReplicas ?? 0
+  const ready = status.readyReplicas ?? 0
+  const base = activity('idle', false, false, 'Stable', '', desired, updated, ready, ready)
+
+  if ((status.observedGeneration ?? 0) < (resource?.metadata?.generation ?? 0)) {
+    return merge(base, 'applying', true, 'Applying change', 'Waiting for the StatefulSet controller to observe generation')
+  }
+  if (desired === 0) return merge(base, 'idle', false, 'Scaled to zero', 'No replicas requested')
+  if (spec.updateStrategy?.type === 'OnDelete') {
+    return updated === desired && ready === desired
+      ? merge(base, 'idle', false, 'Stable', `${ready}/${desired} ready`)
+      : mergeManual(base, 'waiting', true, 'Waiting for Pod restart', `OnDelete strategy · ${updated}/${desired} updated`)
+  }
+  const partition = spec.updateStrategy?.rollingUpdate?.partition ?? 0
+  const target = Math.max(0, desired - partition)
+  if (updated >= target) {
+    const pendingRevision = Boolean(status.currentRevision && status.updateRevision && status.currentRevision !== status.updateRevision)
+    return partition > 0 && pendingRevision
+      ? merge(base, 'partition-reached', false, 'Partition reached', `${partition}/${desired} Pods intentionally retained`)
+      : merge(base, 'idle', false, 'Stable', `${ready}/${desired} ready`)
+  }
+  const detail = `${updated}/${target} target Pods updated · ${ready}/${desired} ready`
+  return updated === 0
+    ? merge(base, 'waiting', true, 'Waiting for new revision', detail)
+    : merge(base, 'progressing', true, 'Rolling out', detail)
+}
+
+function daemonSetActivity(resource: any): WorkloadRolloutActivity {
+  const spec = resource?.spec || {}
+  const status = resource?.status || {}
+  const desired = status.desiredNumberScheduled ?? 0
+  const updated = status.updatedNumberScheduled ?? 0
+  const ready = status.numberReady ?? 0
+  const available = status.numberAvailable ?? 0
+  const base = activity('idle', false, false, 'Stable', '', desired, updated, ready, available)
+
+  if ((status.observedGeneration ?? 0) < (resource?.metadata?.generation ?? 0)) {
+    return merge(base, 'applying', true, 'Applying change', 'Waiting for the DaemonSet controller to observe generation')
+  }
+  if (desired === 0) return merge(base, 'idle', false, 'No targets', 'Selector matches no nodes')
+  if (spec.updateStrategy?.type === 'OnDelete') {
+    return updated === desired && available === desired
+      ? merge(base, 'idle', false, 'Stable', `${available}/${desired} available`)
+      : mergeManual(base, 'waiting', true, 'Waiting for Pod restart', `OnDelete strategy · ${updated}/${desired} updated`)
+  }
+  if (updated === desired) return merge(base, 'idle', false, 'Stable', `${available}/${desired} available`)
+  return updated === 0
+    ? merge(base, 'waiting', true, 'Waiting for new revision', replicaDetail(updated, desired, available))
+    : merge(base, 'progressing', true, 'Rolling out', replicaDetail(updated, desired, available))
+}
+
+function argoRolloutActivity(resource: any): WorkloadRolloutActivity {
+  const spec = resource?.spec || {}
+  const status = resource?.status || {}
+  const desired = spec.replicas ?? ((status.replicas ?? 0) || 1)
+  const updated = status.updatedReplicas ?? 0
+  const ready = status.readyReplicas ?? 0
+  const available = status.availableReplicas ?? 0
+  const base = activity('idle', false, false, 'Stable', '', desired, updated, ready, available)
+  const detail = argoDetail(resource, updated, desired, available)
+  const observedGeneration = getObservedGeneration(resource)
+  if (observedGeneration > 0 && observedGeneration < (resource?.metadata?.generation ?? 0)) {
+    return merge(base, 'applying', true, 'Applying change', 'Waiting for the Rollout controller to observe generation')
+  }
+  const failedCondition = (status.conditions || []).find((condition: any) =>
+    (condition.type === 'InvalidSpec' && condition.status === 'True') ||
+    (condition.type === 'Progressing' && (condition.status === 'False' || condition.reason === 'ProgressDeadlineExceeded')),
+  )
+  if (failedCondition || status.abort) {
+    return merge(base, 'stalled', false, 'Rollout stalled', failedCondition?.message || failedCondition?.reason || status.message || (status.abort ? 'The Rollout was aborted' : '') || 'The Rollout controller reported a failed revision')
+  }
+  switch (String(status.phase || '').toLowerCase()) {
+    case 'degraded':
+    case 'error':
+    case 'failed':
+    case 'aborted':
+      return merge(base, 'stalled', false, 'Rollout stalled', status.message || 'The Rollout controller reported a failed revision')
+    case 'paused':
+      return merge(base, 'paused', true, 'Rollout paused', detail)
+    case 'progressing':
+      return updated === 0
+        ? merge(base, 'waiting', true, 'Waiting for new revision', detail)
+        : merge(base, 'progressing', true, 'Rolling out', detail)
+    case 'healthy':
+      return merge(base, 'idle', false, 'Stable', `${available}/${desired} available`)
+    default:
+      return desired > 0 && (updated < desired || available < desired)
+        ? merge(base, 'applying', true, 'Applying change', detail)
+        : merge(base, 'idle', false, 'Stable', status.message || '')
+  }
+}
+
+function withUpdatedRevisionFailure(
+  rollout: WorkloadRolloutActivity,
+  pods?: WorkloadPodInfo[],
+): WorkloadRolloutActivity {
+  if ((!rollout.active && rollout.phase !== 'stalled') || rollout.phase === 'applying' || !pods) return rollout
+  const failed = pods
+    .filter((pod) => pod.updatedRevision === true && pod.healthLevel === 'unhealthy')
+    .sort((a, b) => a.name.localeCompare(b.name))[0]
+  if (!failed) return rollout
+  const reason = failed.reason || failed.lastTerminationReason || failed.phase || 'Pod failed'
+  return merge(rollout, 'stalled', false, 'New revision cannot start', `${reason} · Pod ${failed.name}`)
+}
+
+export function getArgoRolloutStepNumber(resource: any): number | null {
+  const steps = resource?.spec?.strategy?.canary?.steps || []
+  const currentIndex = resource?.status?.currentStepIndex
+  if (steps.length === 0 || typeof currentIndex !== 'number') return null
+  return Math.min(Math.max(currentIndex + 1, 1), steps.length)
+}
+
+function argoDetail(resource: any, updated: number, desired: number, available: number): string {
+  const stepNumber = getArgoRolloutStepNumber(resource)
+  const step = stepNumber === null ? '' : `Step ${stepNumber} · `
+  return `${step}${updated}/${desired} updated · ${available} available`
+}
+
+function replicaDetail(updated: number, desired: number, available: number): string {
+  return `${updated}/${desired} updated · ${available} available`
+}
+
+function activity(
+  phase: WorkloadRolloutPhase,
+  active: boolean,
+  manual: boolean,
+  label: string,
+  detail: string,
+  desired: number,
+  updated: number,
+  ready: number,
+  available: number,
+): WorkloadRolloutActivity {
+  return { phase, active, manual, label, detail, desired, updated, ready, available }
+}
+
+function merge(
+  base: WorkloadRolloutActivity,
+  phase: WorkloadRolloutPhase,
+  active: boolean,
+  label: string,
+  detail: string,
+): WorkloadRolloutActivity {
+  return { ...base, phase, active, manual: false, label, detail }
+}
+
+function mergeManual(
+  base: WorkloadRolloutActivity,
+  phase: WorkloadRolloutPhase,
+  active: boolean,
+  label: string,
+  detail: string,
+): WorkloadRolloutActivity {
+  return { ...base, phase, active, manual: true, label, detail }
+}
+
+export function rolloutActivityLevel(activity: WorkloadRolloutActivity): 'healthy' | 'neutral' | 'degraded' | 'unhealthy' {
+  switch (activity.phase) {
+    case 'stalled':
+      return 'unhealthy'
+    case 'paused':
+      return 'degraded'
+    case 'waiting':
+      return activity.manual ? 'degraded' : 'neutral'
+    case 'applying':
+    case 'progressing':
+    case 'partition-reached':
+      return 'neutral'
+    default:
+      return activity.label === 'Stable' ? 'healthy' : 'neutral'
+  }
+}
+
+export function rolloutActivityBadge(activity: WorkloadRolloutActivity): { text: string; color: string; level: 'healthy' | 'neutral' | 'degraded' | 'unhealthy' } {
+  const level = rolloutActivityLevel(activity)
+  return { text: activity.label, color: `status-${level}`, level }
+}