@skyhook-io/radar-app 1.14.6 → 1.15.0

package/src/components/whats-new/check-whats-new.test.ts

@@ -0,0 +1,65 @@
+import { spawnSync } from 'node:child_process'
+import { mkdtempSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { describe, expect, it } from 'vitest'
+
+// scripts/check-whats-new.sh gates every minor release on having notes; these
+// pin what counts as an entry, against catalogs written to a temp dir.
+const script = join(__dirname, '..', '..', '..', '..', 'scripts', 'check-whats-new.sh')
+
+function check(version: string, catalog: string) {
+  const file = join(mkdtempSync(join(tmpdir(), 'whats-new-')), 'releaseNotes.ts')
+  writeFileSync(file, catalog)
+  return spawnSync('bash', [script, version], { env: { ...process.env, WHATS_NEW_CATALOG: file }, encoding: 'utf8' }).status
+}
+
+const empty = `export const RELEASE_NOTES: ReleaseNotes[] = []\n`
+const withEntry = (entry: string, before = '') => `${before}export const RELEASE_NOTES: ReleaseNotes[] = [\n${entry}\n]\n\nexport function after() {}\n`
+
+describe('check-whats-new.sh', () => {
+  it('lets patches and prereleases through without notes', () => {
+    expect(check('v1.15.1', empty)).toBe(0)
+    expect(check('v1.15.0-rc.1', empty)).toBe(0)
+  })
+
+  it('refuses a minor or major release without notes, including one with build metadata', () => {
+    expect(check('v1.15.0', empty)).toBe(1)
+    expect(check('v2.0.0', empty)).toBe(1)
+    expect(check('v1.15.0+build.1', empty)).toBe(1)
+  })
+
+  it('refuses a version that is not vX.Y.Z', () => {
+    expect(check('v1.15', empty)).toBe(1)
+    expect(check('latest', empty)).toBe(1)
+  })
+
+  it('accepts a real entry, wherever version sits in it', () => {
+    const entry = `  {\n    releaseUrl: 'https://github.com/skyhook-io/radar/releases/tag/v1.15.0', version: 'v1.15.0',\n    highlights: [],\n  },`
+    expect(check('v1.15.0', withEntry(entry))).toBe(0)
+    expect(check('1.15.0+build.1', withEntry(entry))).toBe(0)
+  })
+
+  it('does not count comments, objects outside the catalog, or look-alike properties', () => {
+    const decoys = `// { version: 'v1.16.0' },\n/* { version: 'v1.17.0' } */\nconst draft = { version: 'v1.18.0' }\n`
+    const catalog = withEntry(`  // { version: 'v1.20.0' },\n  { notversion: 'v1.19.0' },`, decoys)
+    for (const v of ['v1.16.0', 'v1.17.0', 'v1.18.0', 'v1.19.0', 'v1.20.0']) expect(check(v, catalog), v).toBe(1)
+  })
+
+  it('ignores an object after an empty catalog, even with a semicolon', () => {
+    expect(check('v1.15.0', `export const RELEASE_NOTES: ReleaseNotes[] = [];\nconst draft = { version: 'v1.15.0' };\n`)).toBe(1)
+  })
+
+  it('does not count the words "version:" inside another entry\'s text', () => {
+    const entry = `  {\n    version: 'v1.14.0',\n    improvements: ["Set version: 'v1.15.0' in your configuration"],\n  },`
+    expect(check('v1.15.0', withEntry(entry))).toBe(1)
+  })
+
+  it('accepts a value on the line after its key, quoted keys, and space before the colon', () => {
+    expect(check('v1.15.0', withEntry(`  {\n    version:\n      'v1.15.0',\n  },`))).toBe(0)
+    expect(check('v1.15.0', withEntry(`  { version: "v1.15.0" },`))).toBe(0)
+    expect(check('v1.15.0', withEntry(`  { "version": "v1.15.0" },`))).toBe(0)
+    expect(check('v1.15.0', withEntry(`  { version : 'v1.15.0' },`))).toBe(0)
+    expect(check('v1.15.0', withEntry(`  {\n    "version" :\n      "v1.15.0",\n  },`))).toBe(0)
+  })
+})

package/src/components/whats-new/releaseNotes.ts

@@ -0,0 +1,121 @@
+import type { LucideIcon } from 'lucide-react'
+import { Bot, GitCompareArrows, Layers, Network, Scale } from 'lucide-react'
+import { compareVersions } from '../../utils/version'
+
+export interface ReleaseHighlight {
+  id: string
+  icon: LucideIcon
+  title: string
+  description: string
+  /** In-app route the highlight's call to action opens. */
+  path?: string
+  cta?: string
+  /** Icon tile color, so the cards read apart at a glance. The lead card always uses the accent. */
+  tone?: HighlightTone
+}
+
+export type HighlightTone = 'violet' | 'teal' | 'emerald' | 'indigo'
+
+export interface ReleaseNotes {
+  version: string
+  /** The first highlight leads the dialog at full width. */
+  highlights: ReleaseHighlight[]
+  improvements: string[]
+  releaseUrl: string
+}
+
+// One entry per release that has something to announce. A version without its
+// own entry shows the newest entry at or below it, so a patch upgrade (or one
+// that skips the release with notes) still gets them. Every minor and major
+// release must have its own entry: scripts/check-whats-new.sh refuses to
+// release one without it.
+export const RELEASE_NOTES: ReleaseNotes[] = [
+  {
+    version: 'v1.15.0',
+    releaseUrl: 'https://github.com/skyhook-io/radar/releases/tag/v1.15.0',
+    highlights: [
+      {
+        id: 'ai-investigations',
+        icon: Bot,
+        title: 'AI investigations that show their work',
+        // No link: the investigations workspace redirects home when this run
+        // mode can't host local agents.
+        description: 'A clear verdict and the story of what broke, with the charts, logs and config behind it placed where the agent cites them. Now also runs on OpenCode, including AWS Bedrock.',
+      },
+      {
+        id: 'gitops-manifest-diff',
+        icon: GitCompareArrows,
+        title: 'Full manifest diffs for Argo CD resources',
+        description: 'Compare the Git-rendered and live manifest of a drifted Argo CD resource, side by side or unified.',
+        tone: 'violet',
+        path: '/gitops',
+        cta: 'Open GitOps',
+      },
+      {
+        id: 'rightsizing-risks-first',
+        icon: Scale,
+        title: 'Rightsizing and cost data in MCP',
+        description: 'Agents get new optimized tools. Risks (OOM, limit conflicts and throttling) lead before cost-saving, in the UI as well.',
+        tone: 'emerald',
+        path: '/cost/rightsizing',
+        cta: 'Open Rightsizing',
+      },
+      {
+        id: 'batch-ai-workloads',
+        icon: Layers,
+        title: 'Deeper batch + AI/ML workloads support',
+        description: 'Dedicated pages for Kueue, JobSet and Ray resources, and Job and JobSet details now show why a queued job has no Pods.',
+        tone: 'teal',
+      },
+      {
+        id: 'rollout-traffic-topology',
+        icon: Network,
+        title: 'Canary and blue-green in Topology',
+        description: 'See canary and stable Pods, which Services route to each side, and the canary traffic weight.',
+        tone: 'indigo',
+        path: '/topology',
+        cta: 'Open Topology',
+      },
+    ],
+    improvements: [
+      // The grid fills row by row: pair lines of similar length.
+      'Resource tables remember your sort for each kind',
+      'Install Helm charts from OCI registries',
+      'Checks flag expired and expiring TLS certificates',
+      'Radar Desktop keeps your preferences across restarts',
+      'Issues show where a failing Pod differs from its template',
+      'PVC details say why usage data is unavailable',
+      'Issues catch Strimzi connector and admission webhook failures',
+      'Bind the web UI to a specific IP with --listen-address',
+    ],
+  },
+]
+
+export function releaseNotesFor(
+  version: string | undefined,
+  catalog: ReleaseNotes[] = RELEASE_NOTES,
+): ReleaseNotes | undefined {
+  if (!version) return undefined
+  const normalized = version.startsWith('v') ? version : `v${version}`
+  return catalog.find(notes => notes.version === normalized)
+}
+
+/** The release line a catalog entry covers, e.g. v1.15 for v1.15.0: its patches show the same notes. */
+export function releaseLine(version: string): string {
+  return version.replace(/^(v\d+\.\d+)\.\d+$/, '$1')
+}
+
+/** The newest notes for a release at or below `version` — what that version's user has access to. */
+export function latestReleaseNotesFor(
+  version: string | undefined,
+  catalog: ReleaseNotes[] = RELEASE_NOTES,
+): ReleaseNotes | undefined {
+  if (!version) return undefined
+  let latest: ReleaseNotes | undefined
+  for (const notes of catalog) {
+    const atOrBelow = compareVersions(notes.version, version)
+    if (atOrBelow === null || atOrBelow > 0) continue
+    if (!latest || (compareVersions(notes.version, latest.version) ?? 0) > 0) latest = notes
+  }
+  return latest
+}

package/src/components/workload/WorkloadView.tsx

@@ -1,3 +1,5 @@
+import { RayJobRenderer } from '../resources/renderers/RayJobRenderer'
+import { JobRenderer, JobSetRenderer } from '../resources/renderers/JobAdmissionRenderers'
 import { RayClusterRenderer } from '../resources/renderers/RayClusterRenderer'
 import { RayServiceRenderer } from '../resources/renderers/RayServiceRenderer'
 import { KueueWorkloadRenderer } from '../resources/renderers/KueueWorkloadRenderer'
@@ -171,6 +173,9 @@ export function supportsBatchExecution(kind: string, apiKind: string, group?: st
 
 // Stable reference — web renderer wrappers inject platform hooks internally
 const rendererOverrides: RendererOverrides = {
+  RayJobRenderer,
+  JobRenderer,
+  JobSetRenderer,
   RayServiceRenderer,
   RayClusterRenderer,
   KueueWorkloadRenderer,
@@ -607,6 +612,11 @@ export function WorkloadView({
   const refetchResourceAndRuns = useCallback(async () => {
     await Promise.all([
       refetchResource(),
+      ...(apiKind === 'rayjobs' && effectiveGroup === 'ray.io' ? [
+        queryClient.refetchQueries({ queryKey: ['resource', 'jobs', namespace, name, 'batch'], type: 'active' }),
+        ...(resource?.spec?.clusterSelector?.['ray.io/cluster'] ? [queryClient.refetchQueries({ queryKey: ['resource', 'rayclusters', namespace, resource.spec.clusterSelector['ray.io/cluster'], 'ray.io'], type: 'active' })] : []),
+      ] : []),
+      queryClient.refetchQueries({ queryKey: ['kueue-admission', effectiveGroup, apiKind, namespace, name], type: 'active' }),
       queryClient.refetchQueries({
         queryKey: ['workload-runs', apiKind, namespace, name],
       }),
@@ -615,7 +625,7 @@ export function WorkloadView({
         ...(apiKind === 'rayclusters' ? { type: 'active' as const } : {}),
       }),
     ])
-  }, [apiKind, name, namespace, queryClient, refetchResource])
+  }, [apiKind, effectiveGroup, name, namespace, queryClient, refetchResource, resource?.spec?.clusterSelector])
   const podWorkloadOwner = useMemo(
     () => podWorkloadOwnerFromRelationships(apiKind, namespace, relationships, resource),
     [apiKind, namespace, relationships, resource],

package/src/k8s-ui-exports.test.ts

@@ -0,0 +1,73 @@
+/// <reference types="node" />
+import { describe, expect, test } from 'vitest'
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+// Radar's own build aliases @skyhook-io/k8s-ui to its source, so a deep
+// import that the package's `exports` map can't serve still builds here and
+// only fails in a consumer that installs the published packages (Radar Hub).
+// This resolves every deep import the way Node and bundlers do: the most
+// specific matching key wins, and an array target resolves to its first entry
+// without falling back when that file doesn't exist.
+
+const here = dirname(fileURLToPath(import.meta.url))
+const k8sUiRoot = resolve(here, '../../packages/k8s-ui')
+const exportsMap: Record<string, string | string[]> = JSON.parse(
+  readFileSync(join(k8sUiRoot, 'package.json'), 'utf8'),
+).exports
+
+function resolveExport(subpath: string): string | undefined {
+  const key = `./${subpath}`
+  let target = exportsMap[key]
+  let star: string | undefined
+  if (target === undefined) {
+    let best = ''
+    for (const pattern of Object.keys(exportsMap)) {
+      const i = pattern.indexOf('*')
+      if (i < 0) continue
+      const prefix = pattern.slice(0, i)
+      const suffix = pattern.slice(i + 1)
+      if (key.startsWith(prefix) && key.endsWith(suffix) && key.length >= prefix.length + suffix.length && prefix.length > best.length) {
+        best = prefix
+        target = exportsMap[pattern]
+        star = key.slice(prefix.length, key.length - suffix.length)
+      }
+    }
+  }
+  if (target === undefined) return undefined
+  const first = Array.isArray(target) ? target[0] : target
+  return join(k8sUiRoot, star === undefined ? first : first.split('*').join(star))
+}
+
+// Everything radar-app publishes that can import from k8s-ui, stylesheets
+// included (vitest doesn't load CSS, so these are read from disk).
+function sourceFiles(dir: string): string[] {
+  return readdirSync(dir).flatMap((name) => {
+    const path = join(dir, name)
+    if (statSync(path).isDirectory()) return sourceFiles(path)
+    return /\.(ts|tsx|css)$/.test(name) && !/\.test\.(ts|tsx)$/.test(name) ? [path] : []
+  })
+}
+
+describe('@skyhook-io/k8s-ui deep imports', () => {
+  const imports = new Set<string>()
+  for (const file of sourceFiles(here)) {
+    // Any quoted specifier: `from` imports, side-effect and dynamic imports,
+    // and stylesheet @imports all resolve through the same map.
+    for (const m of readFileSync(file, 'utf8').matchAll(/['"]@skyhook-io\/k8s-ui\/([^'"]+)['"]/g)) {
+      imports.add(m[1])
+    }
+  }
+
+  test('finds the deep imports it checks, stylesheets included', () => {
+    expect(imports.size).toBeGreaterThan(10)
+    expect(imports).toContain('theme/variables.css')
+  })
+
+  test.each([...imports].sort())('%s resolves through the published exports map', (subpath) => {
+    const file = resolveExport(subpath)
+    expect(file, `no exports entry serves "@skyhook-io/k8s-ui/${subpath}"`).toBeDefined()
+    expect(existsSync(file!), `"@skyhook-io/k8s-ui/${subpath}" resolves to missing ${file}`).toBe(true)
+  })
+})

package/src/utils/navigation.test.ts

@@ -4,7 +4,7 @@ import {
   initNavigationMap,
   resetNavigationMap,
 } from '@skyhook-io/k8s-ui/utils/navigation'
-import { getNetworkPolicyResourceTarget, relatedResourcePath, resourcePath } from './navigation'
+import { getNetworkPolicyResourceTarget, relatedResourcePath, resourcePath, withCrossViewParams } from './navigation'
 
 afterEach(resetNavigationMap)
 
@@ -60,3 +60,19 @@ it('uses the Kubernetes kind for a Calico aggregate target', () => {
   expect(getNetworkPolicyResourceTarget({nodes: [{id: 'policy', kind: 'CalicoNetworkPolicy', name: 'allow', status: 'healthy', data: {apiVersion: 'crd.projectcalico.org/v1', resourceKind: 'NetworkPolicy'}}], edges: []} as unknown as Topology))
     .toEqual({kind: 'networkpolicies', group: 'crd.projectcalico.org'})
 })
+
+describe('withCrossViewParams', () => {
+  it('carries the namespace pick and open investigation onto a bare path', () => {
+    expect(withCrossViewParams('/gitops/argo/argocd/app', '?namespaces=a,b&ai-run=r1&tab=yaml'))
+      .toBe('/gitops/argo/argocd/app?namespaces=a%2Cb&ai-run=r1')
+  })
+
+  it('keeps what the path sets itself, and its hash', () => {
+    expect(withCrossViewParams('/resources/pods?namespaces=x#top', '?namespaces=a&ai-run=r1'))
+      .toBe('/resources/pods?namespaces=x&ai-run=r1#top')
+  })
+
+  it('leaves the path alone when nothing is scoped', () => {
+    expect(withCrossViewParams('/helm', '')).toBe('/helm')
+  })
+})

package/src/utils/navigation.ts

@@ -133,3 +133,19 @@ export function openExternal(url: string): void {
       window.open(url, '_blank')
     })
 }
+
+// setMainView's cross-view params. A navigation whose search omits
+// ?namespaces= reads as an empty pick to App's URL sync, which clears the
+// user's namespace scope.
+const CROSS_VIEW_PARAMS = ['namespaces', 'ai-run'] as const
+
+/** Carries the current cross-view params onto an in-app path that doesn't set them itself. */
+export function withCrossViewParams(path: string, currentSearch: string): string {
+  const destination = new URL(path, 'http://radar.invalid')
+  const current = new URLSearchParams(currentSearch)
+  for (const key of CROSS_VIEW_PARAMS) {
+    const value = current.get(key)
+    if (value && !destination.searchParams.has(key)) destination.searchParams.set(key, value)
+  }
+  return `${destination.pathname}${destination.search}${destination.hash}`
+}

package/src/utils/version.ts

@@ -32,6 +32,17 @@ function parseVersion(version: string): [major: number, minor: number, patch: nu
   return [Number(match[1]), Number(match[2]), Number(match[3]), !!match[4]]
 }
 
+/** Semver order (a prerelease sorts before its release); null when either side isn't a version. */
+export function compareVersions(a: string, b: string): number | null {
+  const x = parseVersion(a)
+  const y = parseVersion(b)
+  if (!x || !y) return null
+  for (let i = 0; i < 3; i++) {
+    if (x[i] !== y[i]) return (x[i] as number) - (y[i] as number)
+  }
+  return Number(y[3]) - Number(x[3])
+}
+
 export function getVersionUpdateStatus(current: string, latest?: string): VersionUpdateStatus {
   if (!latest) return { tier: 'none' }