@skyhook-io/radar-app 0.2.2 → 0.3.1

package/src/components/dock/BottomDock.tsx

@@ -1,4 +1,4 @@
-import { BottomDock as K8sBottomDock, DockTab, useDock } from '@skyhook-io/k8s-ui'
+import { BottomDock as K8sBottomDock, DockTab, useDock, Input } from '@skyhook-io/k8s-ui'
 import { TerminalTab } from './TerminalTab'
 import { LogsTab } from './LogsTab'
 import { WorkloadLogsTab } from './WorkloadLogsTab'
@@ -70,8 +70,7 @@ function TrafficFlowSearchHeader() {
     <div className="flex-1 flex items-center ml-2">
       <div className="relative">
         <Search className="absolute left-1.5 top-1/2 -translate-y-1/2 w-3 h-3 text-theme-text-tertiary" />
-        <input
-          type="text"
+        <Input
           value={search}
           onChange={e => setSearch(e.target.value)}
           placeholder="Filter flows..."

package/src/components/dock/DockContext.tsx

@@ -2,6 +2,7 @@
 export {
   DockProvider,
   useDock,
+  useDockReservedHeight,
   useOpenTerminal,
   useOpenLogs,
   useOpenWorkloadLogs,

package/src/components/dock/TerminalTab.tsx

@@ -19,7 +19,7 @@ export function TerminalTab({ namespace, podName, containerName, containers, isA
     const response = await fetch(apiUrl(`/pods/${namespace}/${podName}/debug`), {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ targetContainer, image: 'busybox:latest' }),
+      body: JSON.stringify({ targetContainer }),
     })
     if (!response.ok) {
       const err = await response.json().catch(() => ({ error: 'Unknown error' }))

package/src/components/dock/WorkloadLogsTab.tsx

@@ -1,4 +1,5 @@
 import { WorkloadLogsViewer } from '../logs/WorkloadLogsViewer'
+import { ScheduledWorkloadLogsViewer } from '../logs/ScheduledWorkloadLogsViewer'
 
 interface WorkloadLogsTabProps {
   namespace: string
@@ -11,13 +12,28 @@ export function WorkloadLogsTab({
   workloadKind,
   workloadName,
 }: WorkloadLogsTabProps) {
+  const normalizedKind = workloadKind.toLowerCase()
+  const isScheduled = normalizedKind === 'cronjob' || normalizedKind === 'cronjobs' ||
+    normalizedKind === 'cronworkflow' || normalizedKind === 'cronworkflows' ||
+    normalizedKind === 'workflowtemplate' || normalizedKind === 'workflowtemplates' ||
+    normalizedKind === 'clusterworkflowtemplate' || normalizedKind === 'clusterworkflowtemplates' ||
+    normalizedKind === 'scaledjob' || normalizedKind === 'scaledjobs'
+
   return (
     <div className="h-full">
-      <WorkloadLogsViewer
-        kind={workloadKind}
-        namespace={namespace}
-        name={workloadName}
-      />
+      {isScheduled ? (
+        <ScheduledWorkloadLogsViewer
+          kind={workloadKind}
+          namespace={namespace}
+          name={workloadName}
+        />
+      ) : (
+        <WorkloadLogsViewer
+          kind={workloadKind}
+          namespace={namespace}
+          name={workloadName}
+        />
+      )}
     </div>
   )
 }

package/src/components/dock/index.ts

@@ -1,2 +1,2 @@
-export { DockProvider, useDock, useOpenTerminal, useOpenLogs, useOpenWorkloadLogs, useOpenNodeTerminal, useOpenLocalTerminal } from './DockContext'
+export { DockProvider, useDock, useDockReservedHeight, useOpenTerminal, useOpenLogs, useOpenWorkloadLogs, useOpenNodeTerminal, useOpenLocalTerminal } from './DockContext'
 export { BottomDock } from './BottomDock'

package/src/components/execution/BatchExecutionView.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, it } from 'vitest'
+import type { WorkflowExecutionActivity } from '@skyhook-io/k8s-ui/utils/workflow-execution'
+import { activityPreviewItems, effectiveDefinitionResource, isDirectRunKind, retentionHistoryCopy, runMessageNeedsDisclosure, workflowDefinitionParameters, workflowDefinitionTarget, workflowRunArguments } from './BatchExecutionView'
+
+function activity(id: string, tone: WorkflowExecutionActivity['tone'] = 'success'): WorkflowExecutionActivity {
+  return { id, at: '2026-01-01T00:00:00Z', label: id, tone }
+}
+
+describe('activityPreviewItems', () => {
+  it('keeps a stable chronological prefix so expansion only appends activity', () => {
+    const items = [
+      activity('workflow-started', 'info'),
+      ...Array.from({ length: 14 }, (_, index) => activity(`node-${index}`)),
+      activity('workflow-finished'),
+    ]
+
+    expect(activityPreviewItems(items)).toEqual(items.slice(0, 8))
+  })
+
+  it('keeps large failed histories capped while preserving chronological prefix ordering', () => {
+    const items = Array.from({ length: 500 }, (_, index) => activity(`event-${index}`, index === 499 ? 'danger' : 'success'))
+
+    expect(activityPreviewItems(items)).toEqual(items.slice(0, 8))
+  })
+})
+
+describe('retentionHistoryCopy', () => {
+  it('puts configured history limits beside runs and calls out a reached phase limit', () => {
+    const resource = { spec: { successfulJobsHistoryLimit: 1, failedJobsHistoryLimit: 3 } }
+
+    expect(retentionHistoryCopy('CronJob', resource, { succeeded: 1, failed: 0 })).toBe(
+      'Keeps latest 1 succeeded / latest 3 failed. Success limit reached.',
+    )
+  })
+
+  it('uses controller defaults for scheduled workflows', () => {
+    expect(retentionHistoryCopy('CronWorkflow', { spec: {} }, { succeeded: 1, failed: 1 })).toBe(
+      'Keeps latest 3 succeeded / latest 1 failed. Failure limit reached.',
+    )
+  })
+
+  it('does not invent limits for ScaledJobs that do not configure them', () => {
+    expect(retentionHistoryCopy('ScaledJob', { spec: {} }, { succeeded: 4, failed: 2 })).toBeNull()
+  })
+
+  it('does not show retention settings for template-level histories', () => {
+    expect(retentionHistoryCopy('WorkflowTemplate', { spec: {} }, { succeeded: 4, failed: 2 })).toBeNull()
+  })
+})
+
+describe('runMessageNeedsDisclosure', () => {
+  it('keeps short successful messages inline', () => {
+    expect(runMessageNeedsDisclosure('Reached expected number of succeeded pods')).toBe(false)
+  })
+
+  it('keeps short failures inline and discloses multiline or long messages', () => {
+    expect(runMessageNeedsDisclosure('permission denied')).toBe(false)
+    expect(runMessageNeedsDisclosure('first line\nsecond line')).toBe(true)
+    expect(runMessageNeedsDisclosure('x'.repeat(141))).toBe(true)
+  })
+})
+
+describe('workflow parameters', () => {
+  const definition = {
+    spec: {
+      arguments: {
+        parameters: [
+          { name: 'region', value: 'us-east-1', description: 'Deployment region' },
+          { name: 'mode' },
+        ],
+      },
+    },
+  }
+
+  it('reads the input contract from workflow definitions', () => {
+    expect(workflowDefinitionParameters('WorkflowTemplate', definition)).toEqual(definition.spec.arguments.parameters)
+    expect(workflowDefinitionParameters('Workflow', definition)).toEqual([])
+  })
+
+  it('shows only selected-run arguments that differ from definition defaults', () => {
+    const run = {
+      spec: {
+        arguments: {
+          parameters: [
+            { name: 'region', value: 'eu-west-1' },
+            { name: 'mode', value: 'safe' },
+            { name: 'unchanged', value: 'same' },
+          ],
+        },
+      },
+    }
+    const definitionWithUnchanged = {
+      spec: {
+        arguments: {
+          parameters: [...definition.spec.arguments.parameters, { name: 'unchanged', value: 'same' }],
+        },
+      },
+    }
+
+    expect(workflowRunArguments(run, 'WorkflowTemplate', definitionWithUnchanged).map((parameter) => parameter.name)).toEqual(['region', 'mode'])
+    expect(workflowRunArguments(run, 'Workflow', run)).toHaveLength(3)
+  })
+})
+
+describe('referenced CronWorkflow definitions', () => {
+  const cronWorkflow = {
+    metadata: { namespace: 'jobs' },
+    spec: {
+      workflowSpec: {
+        workflowTemplateRef: { name: 'shared' },
+        arguments: { parameters: [{ name: 'region', value: 'eu' }] },
+      },
+    },
+  }
+
+  it('fetches the referenced namespaced definition', () => {
+    expect(workflowDefinitionTarget('CronWorkflow', cronWorkflow)).toEqual({
+      kind: 'workflowtemplates',
+      namespace: 'jobs',
+      name: 'shared',
+      group: 'argoproj.io',
+    })
+  })
+
+  it('combines referenced execution details with CronWorkflow overrides', () => {
+    const referenced = {
+      spec: {
+        entrypoint: 'main',
+        serviceAccountName: 'base-account',
+        arguments: { parameters: [{ name: 'region', value: 'us', description: 'Target region' }, { name: 'mode', value: 'safe' }] },
+        templates: [{ name: 'main', container: { image: 'example/shared:v1' } }],
+      },
+    }
+
+    const effective = effectiveDefinitionResource('CronWorkflow', cronWorkflow, referenced)
+
+    expect(effective.spec.workflowSpec).toMatchObject({
+      entrypoint: 'main',
+      serviceAccountName: 'base-account',
+      templates: referenced.spec.templates,
+      arguments: {
+        parameters: [
+          { name: 'region', value: 'eu', description: 'Target region' },
+          { name: 'mode', value: 'safe' },
+        ],
+      },
+    })
+  })
+
+  it('replaces valueFrom when a schedule supplies a concrete value', () => {
+    const referenced = {
+      spec: {
+        arguments: { parameters: [{ name: 'region', valueFrom: { configMapKeyRef: { name: 'defaults', key: 'region' } } }] },
+      },
+    }
+
+    const effective = effectiveDefinitionResource('CronWorkflow', cronWorkflow, referenced)
+
+    expect(effective.spec.workflowSpec.arguments.parameters[0]).toEqual({ name: 'region', value: 'eu' })
+  })
+})
+
+describe('direct run identity', () => {
+  it('suppresses captured configuration only when the workload is the run itself', () => {
+    expect(isDirectRunKind('Job', 'jobs')).toBe(true)
+    expect(isDirectRunKind('Workflow', 'workflows')).toBe(true)
+    expect(isDirectRunKind('CronJob', 'jobs')).toBe(false)
+    expect(isDirectRunKind('WorkflowTemplate', 'workflows')).toBe(false)
+  })
+})