@skyhook-io/k8s-ui 1.13.3 → 1.13.4

package/src/types/core.ts

@@ -59,6 +59,55 @@ export interface WorkloadWritePermissions {
   rollouts: boolean
 }
 
+export type WorkloadContainerType = 'container' | 'initContainer'
+
+export interface WorkloadContainerImage {
+  type: WorkloadContainerType
+  name: string
+  image: string
+}
+
+export interface WorkloadImageTarget {
+  group: string
+  resource: string
+  kind: string
+  namespace: string
+  name: string
+}
+
+export type WorkloadUpdateBehaviorType =
+  | 'rolling'
+  | 'recreate'
+  | 'paused'
+  | 'onDelete'
+  | 'partitioned'
+  | 'canary'
+  | 'blueGreen'
+
+export interface WorkloadUpdateBehavior {
+  type: WorkloadUpdateBehaviorType
+  partition?: number
+  autoPromote?: boolean
+  gated?: boolean
+}
+
+export interface WorkloadImageInventory {
+  target: WorkloadImageTarget
+  containers: WorkloadContainerImage[]
+  behavior: WorkloadUpdateBehavior
+}
+
+export interface WorkloadImageUpdate {
+  type: WorkloadContainerType
+  name: string
+  previousImage: string
+  image: string
+}
+
+export interface SetWorkloadImagesResult extends WorkloadImageInventory {
+  object: Record<string, unknown>
+}
+
 export interface IntegrationCapability {
   state: CapacityIntegrationState
   reasonCode?: string
@@ -112,6 +161,7 @@ export interface CloudConnectCapability {
 export interface FeatureCapabilities {
   yamlReview?: boolean
   yamlSchemas?: boolean
+  workloadImages?: boolean
 }
 
 // DeploymentMode is the closed set of topologies Radar can run in.
@@ -304,6 +354,7 @@ export interface PodSummary {
 // K8s Event (from SSE stream)
 export interface K8sEvent {
   kind: string
+  group?: string
   namespace: string
   name: string
   operation: 'add' | 'update' | 'delete'
@@ -625,6 +676,7 @@ export type HPADiagnosisState =
   | 'metrics_unavailable'
   | 'metrics_incomplete'
   | 'unable_to_scale'
+  | 'scaled_to_zero'
   | 'disabled'
   | 'pinned'
   | 'stale'
@@ -683,6 +735,7 @@ export interface APIResource {
   name: string // Plural name (e.g., "deployments")
   namespaced: boolean
   isCrd: boolean
+  featured?: boolean
   verbs: string[]
 }
 
@@ -1434,6 +1487,8 @@ export interface WorkloadPodInfo {
   stepID?: string
   stepName?: string
   stepPhase?: string
+  revisionIdentity?: string
+  updatedRevision?: boolean
 }
 
 // SSE event types for workload log streaming

package/src/utils/api-resources.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { categorizeResources, findAPIResourceForRoute, formatGroupName, shortenGroupName } from './api-resources'
+import { categorizeResources, findAPIResourceForRoute, formatGroupName, isCoreBatchJob, shortenGroupName } from './api-resources'
 
 describe('findAPIResourceForRoute', () => {
   const resources = [
@@ -45,6 +45,7 @@ describe('formatGroupName', () => {
     expect(formatGroupName('sql.cnrm.cloud.google.com')).toBe('Config Connector')
     expect(formatGroupName('crd.k8s.amazonaws.com')).toBe('AWS VPC CNI')
     expect(formatGroupName('acid.zalan.do')).toBe('Zalando Postgres')
+    expect(formatGroupName('llm-d.ai')).toBe('llm-d')
   })
 
   it('formats unmapped API groups without exposing raw domain strings', () => {
@@ -86,4 +87,42 @@ describe('categorizeResources', () => {
     expect(networking?.resources.some(r => r.kind === 'WidgetRoute')).toBe(false)
     expect(networkingAPIs?.resources.map(r => r.kind)).toEqual(['WidgetRoute'])
   })
+
+  it('surfaces only the discovered Kubernetes 1.37 APIs in the generic category', () => {
+    const resources = [
+      { group: 'scheduling.k8s.io', version: 'v1beta1', kind: 'Workload', name: 'workloads', namespaced: true, isCrd: false, featured: true, verbs: ['get', 'list', 'watch'] },
+      { group: 'scheduling.k8s.io', version: 'v1beta1', kind: 'PodGroup', name: 'podgroups', namespaced: true, isCrd: false, featured: true, verbs: ['get', 'list', 'watch'] },
+      { group: 'scheduling.k8s.io', version: 'v1alpha3', kind: 'CompositePodGroup', name: 'compositepodgroups', namespaced: true, isCrd: false, featured: true, verbs: ['get', 'list', 'watch'] },
+      { group: 'certificates.k8s.io', version: 'v1', kind: 'PodCertificateRequest', name: 'podcertificaterequests', namespaced: true, isCrd: false, featured: true, verbs: ['get', 'list', 'watch'] },
+      { group: 'certificates.k8s.io', version: 'v1', kind: 'ClusterTrustBundle', name: 'clustertrustbundles', namespaced: false, isCrd: false, featured: true, verbs: ['get', 'list', 'watch'] },
+      { group: 'authentication.k8s.io', version: 'v1', kind: 'TokenReview', name: 'tokenreviews', namespaced: false, isCrd: false, verbs: ['list'] },
+    ]
+
+    const category = categorizeResources(resources).find(c => c.name === 'Other Kubernetes APIs')
+    expect(category?.resources.map((resource) => resource.kind)).toEqual([
+      'ClusterTrustBundle',
+      'CompositePodGroup',
+      'PodCertificateRequest',
+      'PodGroup',
+      'Workload',
+    ])
+    expect(category?.resources.some(resource => resource.kind === 'TokenReview')).toBe(false)
+  })
+
+  it('does not invent disabled 1.37 APIs or merge colliding CRDs', () => {
+    const categories = categorizeResources([
+      { group: 'kueue.x-k8s.io', version: 'v1beta1', kind: 'Workload', name: 'workloads', namespaced: true, isCrd: true, verbs: ['list'] },
+    ])
+
+    expect(categories.find(c => c.name === 'Other Kubernetes APIs')).toBeUndefined()
+    expect(categories.find(c => c.name === 'Kueue')?.resources.map(resource => resource.kind)).toEqual(['Workload'])
+  })
+})
+
+describe('isCoreBatchJob', () => {
+  it('distinguishes Kubernetes Jobs from same-kind custom resources', () => {
+    expect(isCoreBatchJob('Job', 'batch')).toBe(true)
+    expect(isCoreBatchJob('jobs')).toBe(true)
+    expect(isCoreBatchJob('Job', 'batch.volcano.sh')).toBe(false)
+  })
 })

package/src/utils/api-resources.ts

@@ -14,7 +14,6 @@ const STORAGE_KINDS = ['PersistentVolumeClaim', 'PersistentVolume', 'StorageClas
 const ACCESS_CONTROL_KINDS = ['ServiceAccount', 'Role', 'ClusterRole', 'RoleBinding', 'ClusterRoleBinding']
 const CLUSTER_KINDS = ['Node', 'Namespace', 'Event']
 const CORE_CATEGORY_NAMES = new Set(['Workloads', 'Networking', 'Configuration', 'Storage', 'Access Control', 'Cluster'])
-
 // Core resources that must always be present (fallback if API discovery misses them)
 export const CORE_RESOURCES: APIResource[] = [
   { group: '', version: 'v1', kind: 'Pod', name: 'pods', namespaced: true, isCrd: false, verbs: ['list', 'get', 'watch'] },
@@ -66,6 +65,11 @@ export function findAPIResourceForRoute(
     ?? resources?.find(matchesRoute)
 }
 
+export function isCoreBatchJob(kind: string, group?: string): boolean {
+  const normalizedKind = kind.toLowerCase()
+  return (normalizedKind === 'job' || normalizedKind === 'jobs') && (!group || group === 'batch')
+}
+
 // Resources that should be hidden from the sidebar
 const HIDDEN_KINDS = ['PodMetrics', 'NodeMetrics']
 
@@ -100,6 +104,7 @@ export function categorizeResources(resources: APIResource[]): ResourceCategory[
   const storage = coreResources.filter(r => STORAGE_KINDS.includes(r.kind))
   const accessControl = coreResources.filter(r => ACCESS_CONTROL_KINDS.includes(r.kind))
   const cluster = coreResources.filter(r => CLUSTER_KINDS.includes(r.kind))
+  const otherKubernetesAPIs = coreResources.filter(r => r.featured)
 
   const crds = uniqueResources.filter(r => r.isCrd)
   const crdGroups = new Map<string, APIResource[]>()
@@ -115,6 +120,7 @@ export function categorizeResources(resources: APIResource[]): ResourceCategory[
   addToCategory('Storage', storage)
   addToCategory('Access Control', accessControl)
   addToCategory('Cluster', cluster)
+  addToCategory('Other Kubernetes APIs', otherKubernetesAPIs)
 
   for (const [group, groupResources] of crdGroups) {
     addToCategory(formatGroupName(group), groupResources)
@@ -215,7 +221,11 @@ export function formatGroupName(group: string): string {
     'jobset.x-k8s.io': 'JobSet',
     'inference.networking.k8s.io': 'Inference Gateway',
     'inference.networking.x-k8s.io': 'Inference Gateway',
+    'llm-d.ai': 'llm-d',
     'nvidia.com': 'NVIDIA GPU Operator',
+    'apps.nvidia.com': 'NVIDIA NIM',
+    'amd.com': 'AMD GPU Operator',
+    'trainer.kubeflow.org': 'Kubeflow',
     'scheduling.run.ai': 'KAI Scheduler',
     'kai.scheduler': 'KAI Scheduler',
     'kaito.sh': 'KAITO',

package/src/utils/applications.ts

@@ -1,4 +1,5 @@
 import type { ResourceRef } from '../types/core'
+import { rolloutActivityLevel, type WorkloadRolloutActivity } from './workload-rollout'
 
 // Shared model for the Applications surface — host-agnostic. The OSS single-
 // cluster view and (eventually) the Cloud fleet view both build on these types
@@ -26,9 +27,58 @@ export interface AppWorkload {
   desired: number;
   restarts: number;
   reason?: string;
+  rollout?: WorkloadRolloutActivity;
   batch?: AppBatchSummary;
 }
 
+export interface AppRolloutSummary {
+  count: number
+  label: string
+  detail: string
+  details: string[]
+  health: AppHealth
+}
+
+export function rolloutDisplayHealth(activity: WorkloadRolloutActivity, workloadHealth: string): AppHealth {
+  const rolloutHealth: AppHealth = rolloutActivityLevel(activity)
+  const servingHealth = healthOf(workloadHealth)
+  return servingHealth === 'healthy' || servingHealth === 'neutral'
+    ? rolloutHealth
+    : worstHealth([rolloutHealth, servingHealth])
+}
+
+export function rolloutSummaryForApps(apps: AppRow[]): AppRolloutSummary | null {
+  const entries = apps.flatMap((app) => app.workloads
+    .filter((workload) => workload.rollout && (workload.rollout.active || workload.rollout.phase === 'stalled'))
+    .map((workload) => ({ app, workload, rollout: workload.rollout! })))
+  if (entries.length === 0) return null
+  const rank = (phase: WorkloadRolloutActivity['phase']) => {
+    if (phase === 'stalled') return 3
+    if (phase === 'paused') return 2
+    return 1
+  }
+  const worst = entries.reduce((current, entry) => rank(entry.rollout.phase) > rank(current.rollout.phase) ? entry : current)
+  const health = entries.reduce<AppHealth>(
+    (current, entry) => worstHealth([current, rolloutDisplayHealth(entry.rollout, entry.workload.health)]),
+    'neutral',
+  )
+  const stalled = entries.filter((entry) => entry.rollout.phase === 'stalled').length
+  const label = entries.length === 1
+    ? worst.rollout.label
+    : stalled > 0
+      ? stalled === entries.length
+        ? `${stalled} stalled`
+        : `${stalled} stalled · ${entries.length - stalled} waiting`
+      : `${entries.length} updating`
+  const details = entries.map(({ app, workload, rollout }) => {
+    const prefix = apps.length > 1 ? `${app.name} / ` : ''
+    return `${prefix}${workload.name}: ${rollout.label}${rollout.detail ? ` — ${rollout.detail}` : ''}`
+  })
+  const visibleDetails = details.slice(0, 8)
+  const detail = `${visibleDetails.join(' · ')}${details.length > visibleDetails.length ? ` · +${details.length - visibleDetails.length} more` : ''}`
+  return { count: entries.length, label, detail, details, health }
+}
+
 export interface AppBatchSummary {
   schedule?: string;
   suspended?: boolean;

package/src/utils/bulk-workload-actions.test.ts

@@ -2,6 +2,8 @@ import { describe, expect, it } from 'vitest'
 import {
   canBulkRestartKind,
   canBulkScaleKind,
+  canPatchWorkloadKind,
+  canSetWorkloadImages,
   intersectWorkloadWrites,
 } from './bulk-workload-actions'
 import type { Capabilities, WorkloadWritePermissions } from '../types/core'
@@ -28,6 +30,24 @@ describe('bulk workload action gating', () => {
     expect(canBulkRestartKind({ name: 'rollouts', group: 'argoproj.io' }, all)).toBe(true)
   })
 
+  it('shares exact group and kind checks with detail patch actions', () => {
+    const all = writes({ deployments: true, daemonSets: true, statefulSets: true, rollouts: true })
+
+    expect(canPatchWorkloadKind({ name: 'deployments', group: 'apps' }, all)).toBe(true)
+    expect(canPatchWorkloadKind({ name: 'rollouts', group: 'argoproj.io' }, all)).toBe(true)
+    expect(canPatchWorkloadKind({ name: 'deployments', group: 'example.com' }, all)).toBe(false)
+    expect(canPatchWorkloadKind({ name: 'services', group: '' }, all)).toBe(false)
+    expect(canPatchWorkloadKind({ name: 'deployments', group: 'apps' }, undefined)).toBe(false)
+  })
+
+  it('requires an explicit server advertisement for image updates', () => {
+    const all = writes({ deployments: true })
+
+    expect(canSetWorkloadImages({ name: 'deployments', group: 'apps' }, all, true)).toBe(true)
+    expect(canSetWorkloadImages({ name: 'deployments', group: 'apps' }, all, false)).toBe(false)
+    expect(canSetWorkloadImages({ name: 'deployments', group: 'apps' }, undefined, true)).toBe(false)
+  })
+
   it('requires the apps group for built-in workload restart', () => {
     const all = writes({ deployments: true, daemonSets: true, statefulSets: true })
 

package/src/utils/bulk-workload-actions.ts

@@ -8,6 +8,13 @@ export type BulkWorkloadKindInfo = {
 export function canBulkRestartKind(
   kind: BulkWorkloadKindInfo | null | undefined,
   writes: WorkloadWritePermissions | undefined,
+): boolean {
+  return canPatchWorkloadKind(kind, writes)
+}
+
+export function canPatchWorkloadKind(
+  kind: BulkWorkloadKindInfo | null | undefined,
+  writes: WorkloadWritePermissions | undefined,
 ): boolean {
   switch (kind?.name.toLowerCase()) {
     case 'deployments':
@@ -23,6 +30,14 @@ export function canBulkRestartKind(
   }
 }
 
+export function canSetWorkloadImages(
+  kind: BulkWorkloadKindInfo | null | undefined,
+  writes: WorkloadWritePermissions | undefined,
+  supported: boolean,
+): boolean {
+  return supported && canPatchWorkloadKind(kind, writes)
+}
+
 export function canBulkScaleKind(
   kind: BulkWorkloadKindInfo | null | undefined,
   writes: WorkloadWritePermissions | undefined,

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,