@skyhook-io/radar-app 1.8.6 → 1.8.8

package/src/components/execution/batch-run-actions.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest'
+import type { WorkloadRun } from '../../api/client'
+import { batchRunNextStep } from './batch-run-actions'
+
+function run(phase: string, counts: Partial<Pick<WorkloadRun, 'podFailed' | 'podSucceeded' | 'podRunning' | 'podPending'>> = {}): WorkloadRun {
+  return {
+    kind: 'jobs',
+    namespace: 'jobs',
+    name: 'example',
+    phase,
+    active: phase === 'Running' || phase === 'Pending',
+    ...counts,
+  }
+}
+
+describe('batchRunNextStep', () => {
+  it.each([
+    ['failed Pod', { podFailed: 1 }],
+    ['succeeded Pod', { podSucceeded: 1 }],
+    ['running Pod', { podRunning: 1 }],
+  ])('sends a failed run with a %s to logs', (_label, counts) => {
+    expect(batchRunNextStep(run('Failed', counts), true, true)).toBe('logs')
+  })
+
+  it('uses timeline for an error without a container outcome', () => {
+    expect(batchRunNextStep(run('Error'), true, false)).toBe('timeline')
+  })
+
+  it('does not treat a pending Pod as log evidence', () => {
+    expect(batchRunNextStep(run('Failed', { podPending: 1 }), true, true)).toBe('timeline')
+  })
+
+  it('uses timeline when historical Pods have been garbage-collected', () => {
+    expect(batchRunNextStep(run('Failed', { podFailed: 1 }), true, false)).toBe('timeline')
+  })
+
+  it('waits for live Pod evidence before recommending logs', () => {
+    expect(batchRunNextStep(run('Failed', { podFailed: 1 }), true, undefined)).toBeNull()
+  })
+
+  it('uses timeline when log access is unavailable', () => {
+    expect(batchRunNextStep(run('Failed', { podFailed: 1 }), false, true)).toBe('timeline')
+  })
+
+  it.each(['Running', 'Pending', 'Succeeded', 'Suspended', 'Unknown'])('does not suggest an action for %s runs', (phase) => {
+    expect(batchRunNextStep(run(phase, { podFailed: 1, podRunning: 1 }), true, true)).toBeNull()
+  })
+})

package/src/components/execution/batch-run-actions.ts

@@ -0,0 +1,24 @@
+import type { WorkloadRun } from '../../api/client'
+
+export type BatchRunNextStep = 'logs' | 'timeline'
+
+export function isFailedRunPhase(phase: string): boolean {
+  return phase === 'Failed' || phase === 'Error'
+}
+
+export function batchRunHasContainerOutcome(run: WorkloadRun): boolean {
+  return (
+    (run.podFailed ?? 0) > 0 ||
+    (run.podSucceeded ?? 0) > 0 ||
+    (run.podRunning ?? 0) > 0
+  )
+}
+
+export function batchRunNextStep(run: WorkloadRun, canViewLogs: boolean, hasLivePods: boolean | undefined): BatchRunNextStep | null {
+  if (!isFailedRunPhase(run.phase)) return null
+
+  const hasContainerOutcome = batchRunHasContainerOutcome(run)
+  if (canViewLogs && hasContainerOutcome && hasLivePods === undefined) return null
+
+  return canViewLogs && hasContainerOutcome && hasLivePods ? 'logs' : 'timeline'
+}

package/src/components/execution/batch-timeline.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest'
+import type { WorkloadRun } from '../../api/client'
+import { workloadRunTimelineEvents } from './batch-timeline'
+
+describe('workloadRunTimelineEvents', () => {
+  it('builds lifecycle events for every retained run', () => {
+    const runs: WorkloadRun[] = [
+      {
+        kind: 'jobs',
+        namespace: 'dev',
+        name: 'nightly-1',
+        phase: 'Succeeded',
+        active: false,
+        scheduledAt: '2026-01-01T00:00:00Z',
+        startedAt: '2026-01-01T00:00:02Z',
+        finishedAt: '2026-01-01T00:01:00Z',
+      },
+      {
+        kind: 'jobs',
+        namespace: 'dev',
+        name: 'nightly-2',
+        phase: 'Failed',
+        active: false,
+        startedAt: '2026-01-02T00:00:00Z',
+        finishedAt: '2026-01-02T00:00:10Z',
+        message: 'backoff limit reached',
+      },
+    ]
+
+    const events = workloadRunTimelineEvents(runs)
+
+    expect(events).toHaveLength(5)
+    expect(events.map((event) => event.reason)).toEqual([
+      'Job scheduled',
+      'Job started',
+      'Job succeeded',
+      'Job started',
+      'Job failed',
+    ])
+    expect(events.at(-1)).toMatchObject({ eventType: 'Warning', message: 'backoff limit reached', name: 'nightly-2' })
+  })
+
+  it('uses Workflow resource identity for Argo runs', () => {
+    const events = workloadRunTimelineEvents([{
+      kind: 'workflows',
+      namespace: 'dev',
+      name: 'migration-abc',
+      phase: 'Error',
+      active: false,
+      startedAt: '2026-01-01T00:00:00Z',
+      finishedAt: '2026-01-01T00:00:01Z',
+    }])
+
+    expect(events[0]).toMatchObject({ kind: 'Workflow', apiVersion: 'argoproj.io/v1alpha1', reason: 'Workflow started' })
+    expect(events[1]).toMatchObject({ eventType: 'Warning', reason: 'Workflow errored' })
+  })
+})

package/src/components/execution/batch-timeline.ts

@@ -0,0 +1,46 @@
+import type { TimelineEvent } from '@skyhook-io/k8s-ui'
+import type { WorkloadRun } from '../../api/client'
+
+export function workloadRunTimelineEvents(runs: WorkloadRun[]): TimelineEvent[] {
+  const events: TimelineEvent[] = []
+  for (const run of runs) {
+    const kind = run.kind === 'workflows' ? 'Workflow' : 'Job'
+    const apiVersion = run.kind === 'workflows' ? 'argoproj.io/v1alpha1' : 'batch/v1'
+    const prefix = `batch-run:${run.kind}:${run.namespace}:${run.name}`
+    const createdAt = run.startedAt || run.scheduledAt
+    if (run.scheduledAt) {
+      events.push(runTimelineEvent(run, kind, apiVersion, `${prefix}:scheduled`, run.scheduledAt, 'Normal', `${kind} scheduled`, createdAt))
+    }
+    if (run.startedAt) {
+      events.push(runTimelineEvent(run, kind, apiVersion, `${prefix}:started`, run.startedAt, 'Normal', `${kind} started`, createdAt))
+    }
+    if (run.finishedAt) {
+      const failed = run.phase === 'Failed' || run.phase === 'Error'
+      events.push(runTimelineEvent(run, kind, apiVersion, `${prefix}:finished`, run.finishedAt, failed ? 'Warning' : 'Normal', `${kind} ${runPhaseVerb(run.phase)}`, createdAt, run.message))
+    }
+  }
+  return events.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp) || a.id.localeCompare(b.id))
+}
+
+function runTimelineEvent(run: WorkloadRun, kind: string, apiVersion: string, id: string, timestamp: string, eventType: 'Normal' | 'Warning', reason: string, createdAt?: string, message?: string): TimelineEvent {
+  return {
+    id,
+    timestamp,
+    source: 'historical',
+    kind,
+    apiVersion,
+    namespace: run.namespace,
+    name: run.name,
+    createdAt,
+    eventType,
+    reason,
+    message,
+  }
+}
+
+function runPhaseVerb(phase: string): string {
+  if (phase === 'Succeeded') return 'succeeded'
+  if (phase === 'Failed') return 'failed'
+  if (phase === 'Error') return 'errored'
+  return phase.toLowerCase()
+}

package/src/components/execution/execution-definition.test.ts

@@ -0,0 +1,208 @@
+import { describe, expect, it } from 'vitest'
+import { executionDefinitionFingerprint, executionDefinitionSummary } from './execution-definition'
+
+describe('executionDefinitionSummary', () => {
+  it('explains a Kubernetes Job pod template and effective defaults', () => {
+    const summary = executionDefinitionSummary('CronJob', {
+      spec: {
+        jobTemplate: {
+          spec: {
+            completions: 2,
+            template: {
+              spec: {
+                containers: [{
+                  name: 'backup',
+                  image: 'example/backup:v2',
+                  command: ['/bin/backup'],
+                  args: ['--full'],
+                  envFrom: [{ configMapRef: { name: 'backup-config' } }],
+                  resources: { requests: { cpu: '100m', memory: '256Mi' }, limits: { cpu: '1', memory: '1Gi' } },
+                }],
+                restartPolicy: 'OnFailure',
+                imagePullSecrets: [{ name: 'registry-credentials' }],
+                volumes: [{ name: 'projected', projected: { sources: [{ secret: { name: 'projected-secret' } }, { configMap: { name: 'projected-config' } }] } }],
+              },
+            },
+          },
+        },
+      },
+    })
+
+    expect(summary).toMatchObject({
+      shape: 'Pod · 1 container',
+      serviceAccount: 'default',
+      retry: 'Backoff limit 6 · restart OnFailure',
+      parallelism: '1 parallel · 2 completions · NonIndexed',
+      configMaps: ['backup-config', 'projected-config'],
+      secrets: ['projected-secret', 'registry-credentials'],
+      imagePullSecrets: ['registry-credentials'],
+      externalTemplates: [],
+      units: [{
+        name: 'backup',
+        type: 'Container',
+        image: 'example/backup:v2',
+        command: '/bin/backup --full',
+        requests: 'CPU 0.10 cores · memory 256 MiB',
+        limits: 'CPU 1 core · memory 1.00 GiB',
+      }],
+    })
+  })
+
+  it('explains Argo DAG shape, executable templates, policy, and dependencies', () => {
+    const summary = executionDefinitionSummary('WorkflowTemplate', {
+      spec: {
+        entrypoint: 'main',
+        serviceAccountName: 'migrator',
+        parallelism: 3,
+        activeDeadlineSeconds: 600,
+        imagePullSecrets: [{ name: 'workflow-registry' }],
+        templates: [
+          { name: 'main', dag: { tasks: [{ name: 'prepare' }, { name: 'publish' }] } },
+          {
+            name: 'worker',
+            imagePullSecrets: [{ name: 'template-registry' }],
+            retryStrategy: { limit: 2, retryPolicy: 'OnError', backoff: { duration: '5s' } },
+            container: {
+              image: 'example/worker:v3',
+              command: ['worker'],
+              env: [{ name: 'TOKEN', valueFrom: { secretKeyRef: { name: 'worker-secret', key: 'token' } } }],
+            },
+          },
+        ],
+      },
+    })
+
+    expect(summary).toMatchObject({
+      shape: 'DAG · main · 2 tasks',
+      serviceAccount: 'migrator',
+      retry: 'worker: 2 retries · OnError · 5s backoff',
+      deadline: '600s',
+      parallelism: '3 maximum',
+      secrets: ['template-registry', 'worker-secret', 'workflow-registry'],
+      imagePullSecrets: ['template-registry', 'workflow-registry'],
+      units: [{ name: 'worker', type: 'Container', image: 'example/worker:v3', command: 'worker' }],
+    })
+  })
+
+  it('uses the stored WorkflowTemplate snapshot for a retained Workflow run', () => {
+    const run = {
+      spec: { workflowTemplateRef: { name: 'current-definition' } },
+      status: {
+        storedWorkflowTemplateSpec: {
+          entrypoint: 'main',
+          templates: [{ name: 'main', container: { image: 'example/job:old', command: ['old-command'] } }],
+        },
+      },
+    }
+    const current = executionDefinitionSummary('WorkflowTemplate', {
+      spec: { entrypoint: 'main', templates: [{ name: 'main', container: { image: 'example/job:new', command: ['new-command'] } }] },
+    })
+    const stored = executionDefinitionSummary('Workflow', run)
+
+    expect(stored?.units[0]).toMatchObject({ image: 'example/job:old', command: 'old-command' })
+    expect(executionDefinitionFingerprint(stored)).not.toBe(executionDefinitionFingerprint(current))
+  })
+
+  it('does not report drift for an equivalent stored template snapshot', () => {
+    const current = executionDefinitionSummary('WorkflowTemplate', {
+      spec: { entrypoint: 'main', templates: [{ name: 'main', container: { name: 'job', image: 'example/job:v1', resources: { limits: { cpu: '1000m' } } } }] },
+    })
+    const stored = executionDefinitionSummary('Workflow', {
+      status: {
+        storedWorkflowTemplateSpec: {
+          entrypoint: 'main',
+          workflowTemplateRef: { name: 'definition' },
+          templates: [{ name: 'main', container: { name: 'job', image: 'example/job:v1', resources: { limits: { cpu: '1' } } } }],
+        },
+      },
+    })
+
+    expect(executionDefinitionFingerprint(stored)).toBe(executionDefinitionFingerprint(current))
+  })
+
+  it('reads a ScaledJob embedded Job target', () => {
+    const summary = executionDefinitionSummary('ScaledJob', {
+      spec: {
+        jobTargetRef: {
+          backoffLimit: 2,
+          activeDeadlineSeconds: 90,
+          template: { spec: { serviceAccountName: 'worker', containers: [{ name: 'worker', image: 'example/worker:v4' }] } },
+        },
+      },
+    })
+
+    expect(summary).toMatchObject({
+      shape: 'Pod · 1 container',
+      serviceAccount: 'worker',
+      retry: 'Backoff limit 2 · restart Never',
+      deadline: '90s',
+      units: [{ image: 'example/worker:v4' }],
+    })
+  })
+
+  it('summarizes init and multiple application containers', () => {
+    const summary = executionDefinitionSummary('Job', {
+      spec: {
+        template: {
+          spec: {
+            initContainers: [{ name: 'prepare', image: 'example/prepare:v1' }],
+            containers: [{ name: 'worker', image: 'example/worker:v1' }, { name: 'sidecar', image: 'example/sidecar:v1' }],
+          },
+        },
+      },
+    })
+
+    expect(summary).toMatchObject({
+      shape: 'Pod · 2 containers · 1 init',
+      units: [
+        { name: 'prepare', type: 'Init container' },
+        { name: 'worker', type: 'Container' },
+        { name: 'sidecar', type: 'Container' },
+      ],
+    })
+  })
+
+  it('summarizes an inline CronWorkflow steps entrypoint', () => {
+    const summary = executionDefinitionSummary('CronWorkflow', {
+      spec: {
+        workflowSpec: {
+          entrypoint: 'main',
+          templates: [
+            { name: 'main', steps: [[{ name: 'first', template: 'run' }, { name: 'second', template: 'run' }], [{ name: 'third', template: 'run' }]] },
+            { name: 'run', script: { image: 'example/script:v1', command: ['sh'], source: 'echo done' } },
+          ],
+        },
+      },
+    })
+
+    expect(summary).toMatchObject({
+      shape: 'Steps · main · 3 steps in 2 groups',
+      units: [{ name: 'run', type: 'Script', image: 'example/script:v1', command: 'sh' }],
+    })
+  })
+
+  it('summarizes a container set entrypoint', () => {
+    const summary = executionDefinitionSummary('WorkflowTemplate', {
+      spec: {
+        entrypoint: 'main',
+        templates: [{
+          name: 'main',
+          containerSet: {
+            containers: [
+              { name: 'first', image: 'example/first:v1' },
+              { name: 'second', image: 'example/second:v1', command: ['second'] },
+            ],
+          },
+        }],
+      },
+    })
+
+    expect(summary).toMatchObject({
+      shape: 'Container set · main · 2 containers',
+      units: [
+        { name: 'first', type: 'Container', image: 'example/first:v1' },
+        { name: 'second', type: 'Container', image: 'example/second:v1', command: 'second' },
+      ],
+    })
+  })
+})

package/src/components/execution/execution-definition.ts

@@ -0,0 +1,245 @@
+import { formatCPUString, formatMemoryString } from '@skyhook-io/k8s-ui/utils/format'
+
+export interface ExecutionUnitSummary {
+  name: string
+  type: string
+  image?: string
+  command?: string
+  requests?: string
+  limits?: string
+}
+
+export interface ExecutionDefinitionSummary {
+  shape: string
+  units: ExecutionUnitSummary[]
+  externalTemplates: string[]
+  configMaps: string[]
+  secrets: string[]
+  imagePullSecrets: string[]
+  serviceAccount: string
+  retry: string
+  deadline?: string
+  parallelism?: string
+}
+
+export function executionDefinitionSummary(kind: string, resource: any): ExecutionDefinitionSummary | null {
+  if (!resource) return null
+  switch (kind.toLowerCase()) {
+    case 'job':
+    case 'jobs':
+      return kubernetesJobSummary(resource.spec ?? {})
+    case 'cronjob':
+    case 'cronjobs':
+      return kubernetesJobSummary(resource.spec?.jobTemplate?.spec ?? {})
+    case 'scaledjob':
+    case 'scaledjobs':
+      return kubernetesJobSummary(resource.spec?.jobTargetRef ?? {})
+    case 'cronworkflow':
+    case 'cronworkflows':
+      return argoWorkflowSummary(resource.spec?.workflowSpec ?? {})
+    case 'workflowtemplate':
+    case 'workflowtemplates':
+    case 'clusterworkflowtemplate':
+    case 'clusterworkflowtemplates':
+      return argoWorkflowSummary(resource.spec ?? {})
+    case 'workflow':
+    case 'workflows':
+      return argoWorkflowSummary(resource.status?.storedWorkflowTemplateSpec ?? resource.spec ?? {})
+    default:
+      return null
+  }
+}
+
+export function executionDefinitionFingerprint(summary: ExecutionDefinitionSummary | null): string {
+  if (!summary) return ''
+  return JSON.stringify(summary)
+}
+
+function kubernetesJobSummary(jobSpec: any): ExecutionDefinitionSummary {
+  const podSpec = jobSpec.template?.spec ?? {}
+  const containers = Array.isArray(podSpec.containers) ? podSpec.containers : []
+  const initContainers = Array.isArray(podSpec.initContainers) ? podSpec.initContainers : []
+  const units = [
+    ...initContainers.map((container: any) => containerSummary(container, 'Init container')),
+    ...containers.map((container: any) => containerSummary(container, 'Container')),
+  ]
+  const dependencies = podDependencies(podSpec, [...initContainers, ...containers])
+  const shapeParts = [`${containers.length} ${containers.length === 1 ? 'container' : 'containers'}`]
+  if (initContainers.length > 0) shapeParts.push(`${initContainers.length} init`)
+  const parallelism = Number(jobSpec.parallelism ?? 1)
+  const completions = Number(jobSpec.completions ?? 1)
+  const completionMode = jobSpec.completionMode || 'NonIndexed'
+  return {
+    shape: `Pod · ${shapeParts.join(' · ')}`,
+    units,
+    externalTemplates: [],
+    configMaps: dependencies.configMaps,
+    secrets: dependencies.secrets,
+    imagePullSecrets: pullSecretNames(podSpec),
+    serviceAccount: podSpec.serviceAccountName || 'default',
+    retry: `Backoff limit ${jobSpec.backoffLimit ?? 6} · restart ${podSpec.restartPolicy || 'Never'}`,
+    ...(jobSpec.activeDeadlineSeconds != null ? { deadline: `${jobSpec.activeDeadlineSeconds}s` } : {}),
+    parallelism: `${parallelism} parallel · ${completions} ${completions === 1 ? 'completion' : 'completions'} · ${completionMode}`,
+  }
+}
+
+function argoWorkflowSummary(spec: any): ExecutionDefinitionSummary {
+  const templates = Array.isArray(spec.templates) ? spec.templates : []
+  const entrypoint = templates.find((template: any) => template?.name === spec.entrypoint)
+  const units = templates.flatMap((template: any) => argoTemplateUnits(template))
+  const dependencies = podDependencies(spec, unitsSourceContainers(templates))
+  for (const template of templates) {
+    const templateDependencies = podDependencies(template, [])
+    dependencies.configMaps.push(...templateDependencies.configMaps)
+    dependencies.secrets.push(...templateDependencies.secrets)
+  }
+  const imagePullSecrets = unique([
+    ...pullSecretNames(spec),
+    ...templates.flatMap((template: any) => pullSecretNames(template)),
+  ])
+  const retries = templates
+    .filter((template: any) => template?.retryStrategy != null)
+    .map((template: any) => formatArgoRetry(template.name || 'template', template.retryStrategy))
+  if (spec.retryStrategy != null) retries.unshift(formatArgoRetry('Workflow', spec.retryStrategy))
+  if (spec.templateDefaults?.retryStrategy != null) retries.unshift(formatArgoRetry('Defaults', spec.templateDefaults.retryStrategy))
+  return {
+    shape: entrypoint
+      ? argoTemplateShape(entrypoint)
+      : spec.workflowTemplateRef?.name
+        ? `${spec.workflowTemplateRef.clusterScope ? 'ClusterWorkflowTemplate' : 'WorkflowTemplate'} · ${spec.workflowTemplateRef.name}`
+        : templates.length > 0
+          ? `${templates.length} defined ${templates.length === 1 ? 'template' : 'templates'}`
+          : 'Inline workflow',
+    units,
+    externalTemplates: argoExternalTemplateRefs(spec, templates),
+    configMaps: unique(dependencies.configMaps),
+    secrets: unique(dependencies.secrets),
+    imagePullSecrets,
+    serviceAccount: spec.serviceAccountName || 'default',
+    retry: retries.length > 0 ? retries.join(' · ') : 'Not configured',
+    ...(spec.activeDeadlineSeconds != null ? { deadline: `${spec.activeDeadlineSeconds}s` } : {}),
+    ...(spec.parallelism != null ? { parallelism: `${spec.parallelism} maximum` } : argoShapePolicy(entrypoint)),
+  }
+}
+
+function pullSecretNames(podSpec: any): string[] {
+  return unique((podSpec?.imagePullSecrets ?? []).flatMap((secret: any) => secret?.name ? [String(secret.name)] : []))
+}
+
+function argoTemplateShape(template: any): string {
+  const name = template.name || 'entrypoint'
+  if (template.dag) {
+    const tasks = Array.isArray(template.dag.tasks) ? template.dag.tasks.length : 0
+    return `DAG · ${name} · ${tasks} ${tasks === 1 ? 'task' : 'tasks'}`
+  }
+  if (template.steps) {
+    const groups = Array.isArray(template.steps) ? template.steps.length : 0
+    const steps = Array.isArray(template.steps) ? template.steps.reduce((sum: number, group: any) => sum + (Array.isArray(group) ? group.length : 0), 0) : 0
+    return `Steps · ${name} · ${steps} ${steps === 1 ? 'step' : 'steps'} in ${groups} ${groups === 1 ? 'group' : 'groups'}`
+  }
+  if (template.containerSet) {
+    const containers = Array.isArray(template.containerSet.containers) ? template.containerSet.containers.length : 0
+    return `Container set · ${name} · ${containers} ${containers === 1 ? 'container' : 'containers'}`
+  }
+  if (template.script) return `Script · ${name}`
+  if (template.container) return `Container · ${name}`
+  if (template.resource) return `Resource · ${name} · ${template.resource.action || 'operation'}`
+  if (template.suspend != null) return `Suspend · ${name}`
+  if (template.http) return `HTTP · ${name}`
+  return `Template · ${name}`
+}
+
+function argoTemplateUnits(template: any): ExecutionUnitSummary[] {
+  if (template.container) return [containerSummary({ ...template.container, resources: template.container.resources ?? template.resources }, 'Container', template.name)]
+  if (template.script) return [containerSummary({ ...template.script, resources: template.script.resources ?? template.resources }, 'Script', template.name)]
+  if (template.containerSet?.containers) {
+    return template.containerSet.containers.map((container: any) => containerSummary(container, 'Container', `${template.name}/${container.name}`))
+  }
+  return []
+}
+
+function argoExternalTemplateRefs(spec: any, templates: any[]): string[] {
+  const refs: string[] = []
+  if (templates.length === 0 && spec.workflowTemplateRef?.name) refs.push(`${spec.workflowTemplateRef.clusterScope ? 'ClusterWorkflowTemplate' : 'WorkflowTemplate'}/${spec.workflowTemplateRef.name}`)
+  for (const template of templates) {
+    const tasks = Array.isArray(template?.dag?.tasks) ? template.dag.tasks : []
+    const steps = Array.isArray(template?.steps) ? template.steps.flatMap((group: any) => Array.isArray(group) ? group : []) : []
+    for (const item of [...tasks, ...steps]) {
+      if (item?.templateRef?.name) refs.push(`${item.templateRef.clusterScope ? 'ClusterWorkflowTemplate' : 'WorkflowTemplate'}/${item.templateRef.name}`)
+    }
+  }
+  return unique(refs)
+}
+
+function unitsSourceContainers(templates: any[]): any[] {
+  return templates.flatMap((template) => {
+    if (template?.container) return [template.container]
+    if (template?.script) return [template.script]
+    return Array.isArray(template?.containerSet?.containers) ? template.containerSet.containers : []
+  })
+}
+
+function containerSummary(container: any, type: string, fallbackName?: string): ExecutionUnitSummary {
+  const command = [...(Array.isArray(container.command) ? container.command : []), ...(Array.isArray(container.args) ? container.args : [])]
+  const requests = formatResources(container.resources?.requests)
+  const limits = formatResources(container.resources?.limits)
+  return {
+    name: container.name || fallbackName || type,
+    type,
+    ...(container.image ? { image: String(container.image) } : {}),
+    ...(command.length > 0 ? { command: command.map(String).join(' ') } : {}),
+    ...(requests && requests !== '-' ? { requests } : {}),
+    ...(limits && limits !== '-' ? { limits } : {}),
+  }
+}
+
+function podDependencies(podSpec: any, containers: any[]): { configMaps: string[]; secrets: string[] } {
+  const configMaps: string[] = []
+  const secrets: string[] = []
+  for (const pullSecret of podSpec?.imagePullSecrets ?? []) {
+    if (pullSecret?.name) secrets.push(pullSecret.name)
+  }
+  for (const container of containers) {
+    for (const source of container?.envFrom ?? []) {
+      if (source?.configMapRef?.name) configMaps.push(source.configMapRef.name)
+      if (source?.secretRef?.name) secrets.push(source.secretRef.name)
+    }
+    for (const variable of container?.env ?? []) {
+      if (variable?.valueFrom?.configMapKeyRef?.name) configMaps.push(variable.valueFrom.configMapKeyRef.name)
+      if (variable?.valueFrom?.secretKeyRef?.name) secrets.push(variable.valueFrom.secretKeyRef.name)
+    }
+  }
+  for (const volume of podSpec?.volumes ?? []) {
+    if (volume?.configMap?.name) configMaps.push(volume.configMap.name)
+    if (volume?.secret?.secretName) secrets.push(volume.secret.secretName)
+    for (const source of volume?.projected?.sources ?? []) {
+      if (source?.configMap?.name) configMaps.push(source.configMap.name)
+      if (source?.secret?.name) secrets.push(source.secret.name)
+    }
+  }
+  return { configMaps: unique(configMaps), secrets: unique(secrets) }
+}
+
+function formatArgoRetry(name: string, retry: any): string {
+  if (retry && Object.keys(retry).length === 0) return `${name}: until completion`
+  const limit = retry?.limit != null ? `${retry.limit} retries` : 'controller limit'
+  const policy = retry?.retryPolicy || 'OnFailure'
+  const backoff = retry?.backoff?.duration ? ` · ${retry.backoff.duration} backoff` : ''
+  return `${name}: ${limit} · ${policy}${backoff}`
+}
+
+function argoShapePolicy(entrypoint: any): { parallelism?: string } {
+  if (entrypoint?.dag?.failFast != null) return { parallelism: `DAG fail-fast ${entrypoint.dag.failFast ? 'on' : 'off'}` }
+  return {}
+}
+
+function unique(values: string[]): string[] {
+  return [...new Set(values)].sort((a, b) => a.localeCompare(b))
+}
+
+function formatResources(resources: any): string | undefined {
+  const parts = []
+  if (resources?.cpu) parts.push(`CPU ${formatCPUString(String(resources.cpu)).replace(/^1 cores$/, '1 core')}`)
+  if (resources?.memory) parts.push(`memory ${formatMemoryString(String(resources.memory))}`)
+  return parts.length > 0 ? parts.join(' · ') : undefined
+}

package/src/components/gitops/ArgoResourceDiffLoader.tsx

@@ -0,0 +1,23 @@
+import { ArgoResourceDiff } from '@skyhook-io/k8s-ui'
+import type { GitOpsInsightRef } from '@skyhook-io/k8s-ui'
+import { useArgoResourceDiff } from '../../api/client'
+
+interface ArgoResourceDiffLoaderProps {
+  appNamespace: string
+  appName: string
+  resourceRef: GitOpsInsightRef
+}
+
+// Host wrapper: fetches the Argo CD resource diff and hands the data to the
+// pure k8s-ui presentation component. Mirrors the data-in-web / render-in-
+// k8s-ui split the resource renderers use for their host-wired data.
+export function ArgoResourceDiffLoader({ appNamespace, appName, resourceRef }: ArgoResourceDiffLoaderProps) {
+  const { data, isLoading, error } = useArgoResourceDiff(appNamespace, appName, resourceRef)
+  return (
+    <ArgoResourceDiff
+      diff={data ?? null}
+      loading={isLoading}
+      error={(error as Error | null)?.message ?? null}
+    />
+  )
+}