@skyhook-io/radar-app 1.9.7 → 1.11.0

package/src/components/ui/DiagnosticsOverlay.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest'
+
+import { formatEnvValue, formatForGitHub } from './DiagnosticsOverlay'
+import type { DiagnosticsSnapshot } from '../../api/client'
+
+const baseSnapshot: DiagnosticsSnapshot = {
+  timestamp: '2026-08-19T10:00:00Z',
+  radarVersion: '1.9.0',
+  goVersion: 'go1.26.5',
+  goos: 'linux',
+  goarch: 'amd64',
+  uptime: '11s',
+  uptimeSec: 11,
+}
+
+const desktop: NonNullable<DiagnosticsSnapshot['desktop']> = {
+  sessionType: 'wayland',
+  desktopEnvironment: 'ubuntu:GNOME',
+  displayServer: 'wayland+x11',
+  renderOverrides: [
+    { key: 'GDK_BACKEND', value: '', set: false },
+    { key: 'WEBKIT_DISABLE_DMABUF_RENDERER', value: '1', set: true },
+    { key: 'WEBKIT_DISABLE_COMPOSITING_MODE', value: '', set: true },
+  ],
+  sandbox: [{ key: 'SNAP', value: '/snap/radar-desktop/42', set: true }],
+  webkitLibrary: 'libwebkit2gtk-4.1.so.0.13.6',
+  gpuPolicy: 'on-demand',
+}
+
+describe('formatEnvValue', () => {
+  it('separates a variable that was never set from one set to empty', () => {
+    // Only the second suppresses the desktop app's own WebKit defaults, so
+    // collapsing them would hide the cause of a rendering failure.
+    expect(formatEnvValue({ key: 'GDK_BACKEND', value: '', set: false })).toBe('(unset)')
+    expect(formatEnvValue({ key: 'GDK_BACKEND', value: '', set: true })).toBe('(empty)')
+  })
+
+  it('passes a real value through unchanged', () => {
+    expect(formatEnvValue({ key: 'GTK_THEME', value: 'Adwaita:dark', set: true })).toBe('Adwaita:dark')
+  })
+})
+
+describe('formatForGitHub desktop section', () => {
+  it('omits the section entirely when the backend reports no desktop data', () => {
+    expect(formatForGitHub(baseSnapshot, undefined, false)).not.toContain('### Desktop')
+  })
+
+  it('reports the host rendering environment', () => {
+    const md = formatForGitHub({ ...baseSnapshot, desktop }, undefined, false)
+
+    expect(md).toContain('### Desktop')
+    expect(md).toContain('Display Server: `wayland+x11`')
+    expect(md).toContain('Session Type: `wayland`')
+    expect(md).toContain('Desktop: `ubuntu:GNOME`')
+    expect(md).toContain('Webview Library: `libwebkit2gtk-4.1.so.0.13.6`')
+    expect(md).toContain('Webview GPU Policy: `on-demand`')
+    expect(md).toContain('Sandbox: `SNAP=/snap/radar-desktop/42`')
+  })
+
+  it('renders each override state distinguishably', () => {
+    const md = formatForGitHub({ ...baseSnapshot, desktop }, undefined, false)
+
+    expect(md).toContain('`GDK_BACKEND=(unset)`')
+    expect(md).toContain('`WEBKIT_DISABLE_DMABUF_RENDERER=1`')
+    expect(md).toContain('`WEBKIT_DISABLE_COMPOSITING_MODE=(empty)`')
+  })
+
+  it('degrades to placeholders rather than blanks when the host reports nothing', () => {
+    const md = formatForGitHub({ ...baseSnapshot, desktop: {} }, undefined, false)
+
+    expect(md).toContain('Display Server: `(none)`')
+    expect(md).toContain('Session Type: `(unset)`')
+    expect(md).toContain('Desktop: `(unset)`')
+  })
+})

package/src/components/ui/DiagnosticsOverlay.tsx

@@ -4,7 +4,7 @@ import { clsx } from 'clsx'
 import { TRANSITION_BACKDROP, TRANSITION_PANEL } from '../../utils/animation'
 import { openExternal } from '../../utils/navigation'
 import { useDiagnostics } from '../../api/client'
-import type { DiagnosticsSnapshot, DiagMetricsSourceHealth, DiagDropRecord, DiagErrorEntry, DiagCacheSyncStatus, DiagInformerSyncStatus, DiagSyncPhase, DiagSampleWindow } from '../../api/client'
+import type { DiagnosticsSnapshot, DiagEnvVar, DiagMetricsSourceHealth, DiagDropRecord, DiagErrorEntry, DiagCacheSyncStatus, DiagInformerSyncStatus, DiagSyncPhase, DiagSampleWindow } from '../../api/client'
 import { getK8sUIPerfSnapshot, type K8sUIPerfSnapshot } from '@skyhook-io/k8s-ui'
 
 interface DiagnosticsOverlayProps {
@@ -119,6 +119,7 @@ export function DiagnosticsOverlay({ onClose, isOpen = true }: DiagnosticsOverla
               <PermissionsSection data={data} />
               <APIDiscoverySection data={data} />
               <PerfSection data={data} />
+              <DesktopSection data={data} />
               <RuntimeSection data={data} />
               <ConfigSection data={data} />
               {data.errors && data.errors.length > 0 && (
@@ -529,6 +530,35 @@ function formatFrontendUs(w: { count: number; last: number; p50: number; p95: nu
   return `last ${fmt(w.last)} · p50 ${fmt(w.p50)} · p95 ${fmt(w.p95)} · max ${fmt(w.max)} (n=${w.count})`
 }
 
+// An override present but empty is not the same as one that was never set —
+// merely existing is enough to suppress the desktop app's WebKit defaults.
+export function formatEnvValue(v: DiagEnvVar): string {
+  if (!v.set) return '(unset)'
+  return v.value === '' ? '(empty)' : v.value
+}
+
+function DesktopSection({ data }: { data: DiagnosticsSnapshot }) {
+  if (!data.desktop) return null
+  const d = data.desktop
+  const overrides = d.renderOverrides ?? []
+  const sandbox = d.sandbox ?? []
+  return (
+    <Section title="Desktop">
+      {d.displayServer && <Row label="Display Server" value={d.displayServer} />}
+      <Row label="Session Type" value={d.sessionType || '(unset)'} />
+      <Row label="Desktop Environment" value={d.desktopEnvironment || '(unset)'} />
+      {d.webkitLibrary && <Row label="Webview Library" value={d.webkitLibrary} />}
+      {d.gpuPolicy && <Row label="Webview GPU Policy" value={d.gpuPolicy} />}
+      {overrides.map((v) => (
+        <Row key={v.key} label={v.key} value={formatEnvValue(v)} />
+      ))}
+      {sandbox.map((v) => (
+        <Row key={v.key} label={`Sandbox: ${v.key}`} value={v.value} />
+      ))}
+    </Section>
+  )
+}
+
 function RuntimeSection({ data }: { data: DiagnosticsSnapshot }) {
   if (!data.runtime) return null
   const rt = data.runtime
@@ -580,7 +610,7 @@ function CopyButton({ label, onClick, copied }: { label: string; onClick: () =>
 
 // --- GitHub-friendly formatting ---
 
-function formatForGitHub(data: DiagnosticsSnapshot, frontendPerf?: K8sUIPerfSnapshot, includeRawJson = true): string {
+export function formatForGitHub(data: DiagnosticsSnapshot, frontendPerf?: K8sUIPerfSnapshot, includeRawJson = true): string {
   const lines: string[] = []
   lines.push(`## Radar Diagnostics`)
   lines.push(``)
@@ -758,6 +788,21 @@ function formatForGitHub(data: DiagnosticsSnapshot, frontendPerf?: K8sUIPerfSnap
     lines.push(``)
   }
 
+  if (data.desktop) {
+    const d = data.desktop
+    lines.push(`### Desktop`)
+    lines.push(`- Display Server: \`${d.displayServer || '(none)'}\` | Session Type: \`${d.sessionType || '(unset)'}\` | Desktop: \`${d.desktopEnvironment || '(unset)'}\``)
+    if (d.webkitLibrary) lines.push(`- Webview Library: \`${d.webkitLibrary}\``)
+    if (d.gpuPolicy) lines.push(`- Webview GPU Policy: \`${d.gpuPolicy}\``)
+    if (d.renderOverrides && d.renderOverrides.length > 0) {
+      lines.push(`- Render Overrides: ${d.renderOverrides.map((v) => `\`${v.key}=${formatEnvValue(v)}\``).join(' ')}`)
+    }
+    if (d.sandbox && d.sandbox.length > 0) {
+      lines.push(`- Sandbox: ${d.sandbox.map((v) => `\`${v.key}=${v.value}\``).join(' ')}`)
+    }
+    lines.push(``)
+  }
+
   if (data.runtime) {
     const rt = data.runtime
     lines.push(`### Runtime`)

package/src/components/workload/WorkloadView.tsx

@@ -22,6 +22,7 @@ import {
   gitOpsOwnerFromRelationships,
   getGitOpsResourceStatus,
   isDiagnoseKind,
+  isRolloutKind,
 } from '@skyhook-io/k8s-ui'
 import type { ServicePortRenderProps } from '@skyhook-io/k8s-ui/components/resources/renderers/ServiceRenderer'
 import type { SelectedResource, ResourceRef, Relationships } from '../../types'
@@ -46,6 +47,8 @@ import {
   useRestartWorkload,
   useWorkloadRevisions,
   useRollbackWorkload,
+  useRolloutAction,
+  useRolloutCapabilities,
   useWorkloadPods,
   useFluxReconcile,
   useFluxSyncWithSource,
@@ -109,6 +112,20 @@ import { RoleBindingRenderer } from '../resources/renderers/RoleBindingRenderer'
 import { NamespaceRenderer } from '../resources/renderers/NamespaceRenderer'
 import { HPARenderer } from '../resources/renderers/HPARenderer'
 import { PVCRenderer } from '../resources/renderers/PVCRenderer'
+import { RolloutRenderer } from '../resources/renderers/RolloutRenderer'
+import { KyvernoPolicyCoverage } from '../resources/renderers/KyvernoPolicyCoverage'
+import { KyvernoPolicyQueued } from '../resources/renderers/KyvernoPolicyQueued'
+import { CNPGObjectStoreRenderer } from '../resources/renderers/CNPGObjectStoreRenderer'
+import { VeleroBSLRenderer } from '../resources/renderers/VeleroBSLRenderer'
+import { VeleroBackupRenderer } from '../resources/renderers/VeleroBackupRenderer'
+import { VeleroRestoreRenderer } from '../resources/renderers/VeleroRestoreRenderer'
+import { CNPGClusterRenderer } from '../resources/renderers/CNPGClusterRenderer'
+import { CNPGImageCatalogRenderer } from '../resources/renderers/CNPGImageCatalogRenderer'
+import {
+  CNPGDatabaseRenderer,
+  CNPGPublicationRenderer,
+  CNPGSubscriptionRenderer,
+} from '../resources/renderers/CNPGDeclarativeRenderer'
 import { CreateResourceDialog } from '../shared/CreateResourceDialog'
 import { cleanYamlForDuplicate } from '../../utils/skeleton-yaml'
 import { useDesktopDownload } from '../../hooks/useDesktopDownload'
@@ -141,6 +158,18 @@ const rendererOverrides: RendererOverrides = {
   NamespaceRenderer,
   HPARenderer,
   PVCRenderer,
+  RolloutRenderer,
+  KyvernoPolicyCoverage,
+  KyvernoPolicyQueued,
+  CNPGObjectStoreRenderer,
+  VeleroBSLRenderer,
+  VeleroBackupRenderer,
+  VeleroRestoreRenderer,
+  CNPGClusterRenderer,
+  CNPGDatabaseRenderer,
+  CNPGPublicationRenderer,
+  CNPGSubscriptionRenderer,
+  CNPGImageCatalogRenderer,
 }
 
 // ============================================================================
@@ -269,11 +298,19 @@ function useActionsBarProps(
   const deleteMutation = useDeleteResource()
   const restartWorkloadMutation = useRestartWorkload()
   const rollbackMutation = useRollbackWorkload()
+  const rolloutActionMutation = useRolloutAction()
   const triggerCronJobMutation = useTriggerCronJob()
   const suspendCronJobMutation = useSuspendCronJob()
   const resumeCronJobMutation = useResumeCronJob()
 
-  const isRollbackKind = ['deployments', 'statefulsets', 'daemonsets'].includes(kind.toLowerCase())
+  const isRollbackKind = ['deployments', 'statefulsets', 'daemonsets', 'rollouts'].includes(kind.toLowerCase())
+  const isRollout = isRolloutKind(kind)
+  const { data: rolloutCapabilities } = useRolloutCapabilities(namespace, name, isRollout)
+  // Restart and Rollback are the generic workload buttons, so a Rollout has to
+  // withhold the callback the way promote-full does. Permissive until the probe
+  // answers — withholding while it loads would flicker the shared buttons.
+  const rolloutAllows = (verb: 'restart' | 'rollback') =>
+    !isRollout || !rolloutCapabilities || rolloutCapabilities[verb]
   const {
     data: revisionsList,
     isLoading: revisionsLoading,
@@ -339,17 +376,28 @@ function useActionsBarProps(
     cascadeDependents: cascadePreview?.dependents,
     cascadeLoading,
     cascadeRootResolved: cascadeError ? false : cascadePreview?.rootResolved,
-    onRestart: (params: Parameters<typeof restartWorkloadMutation.mutate>[0]) =>
-      restartWorkloadMutation.mutate(params),
+    onRestart: rolloutAllows('restart')
+      ? (params: Parameters<typeof restartWorkloadMutation.mutate>[0]) =>
+          restartWorkloadMutation.mutate(params)
+      : undefined,
     isRestarting: restartWorkloadMutation.isPending,
     revisions: revisionsList,
     revisionsLoading,
     revisionsError: revisionsError ?? null,
-    onRollback: (
-      params: Parameters<typeof rollbackMutation.mutate>[0],
-      callbacks?: { onSuccess?: () => void },
-    ) => rollbackMutation.mutate(params, { onSuccess: callbacks?.onSuccess }),
+    onRollback: rolloutAllows('rollback')
+      ? (
+          params: Parameters<typeof rollbackMutation.mutate>[0],
+          callbacks?: { onSuccess?: () => void },
+        ) => rollbackMutation.mutate(params, { onSuccess: callbacks?.onSuccess })
+      : undefined,
     isRollingBack: rollbackMutation.isPending,
+    // Absent when promote-full is denied — the dialog reads the callback's
+    // presence as the permission signal and hides the option.
+    // mutateAsync, not mutate: the revision dialog awaits this before closing.
+    onRolloutPromoteFull: rolloutCapabilities?.promoteFull
+      ? (params: { namespace: string; name: string }) =>
+          rolloutActionMutation.mutateAsync({ action: 'promote-full', ...params })
+      : undefined,
     onTriggerCronJob: (params: Parameters<typeof triggerCronJobMutation.mutate>[0]) =>
       triggerCronJobMutation.mutate(params),
     isTriggeringCronJob: triggerCronJobMutation.isPending,

package/src/utils/navigation.ts

@@ -1,6 +1,6 @@
 import { apiUrl, getAuthHeaders, getCredentialsMode } from '../api/config'
-import { kindToPlural } from '@skyhook-io/k8s-ui/utils/navigation'
-import type { SelectedResource } from '@skyhook-io/k8s-ui/types/core'
+import { apiVersionToGroup, kindToPlural } from '@skyhook-io/k8s-ui/utils/navigation'
+import type { SelectedResource, Topology } from '@skyhook-io/k8s-ui/types/core'
 import type { SearchHit } from '../api/client'
 
 /**
@@ -17,6 +17,48 @@ export function searchHitToSelectedResource(hit: SearchHit): SelectedResource {
 export { kindToPlural, pluralToKind, refToSelectedResource, apiVersionToGroup } from '@skyhook-io/k8s-ui/utils/navigation'
 export type { NavigateToResource } from '@skyhook-io/k8s-ui/utils/navigation'
 
+const NETWORK_POLICY_TOPOLOGY_KINDS = new Set([
+  'NetworkPolicy',
+  'CalicoNetworkPolicy',
+  'CalicoGlobalNetworkPolicy',
+  'CalicoStagedNetworkPolicy',
+  'CalicoStagedGlobalNetworkPolicy',
+  'CalicoStagedKubernetesNetworkPolicy',
+  'CiliumNetworkPolicy',
+  'CiliumClusterwideNetworkPolicy',
+  'ClusterNetworkPolicy',
+])
+
+function networkPolicyGroup(node: Topology['nodes'][number]): string | undefined {
+  const apiVersionGroup = apiVersionToGroup(node.data.apiVersion as string | undefined)
+  if (apiVersionGroup) return apiVersionGroup
+
+  const sourceGroup = node.data.sourceGroup
+  if (typeof sourceGroup === 'string' && sourceGroup) return sourceGroup
+
+  if (node.kind === 'NetworkPolicy') return 'networking.k8s.io'
+  return undefined
+}
+
+/** Return a resource route only when the policy aggregate has one target. */
+export function getNetworkPolicyResourceTarget(topology: Topology | null): { kind: string; group?: string } | undefined {
+  const targets = new Map<string, { kind: string; group?: string }>()
+  for (const node of topology?.nodes ?? []) {
+    if (!NETWORK_POLICY_TOPOLOGY_KINDS.has(node.kind)) continue
+
+    const group = networkPolicyGroup(node)
+    const target = {
+      kind: kindToPlural(node.kind),
+      ...(group ? { group } : {}),
+    }
+    targets.set(`${target.kind}\u0000${target.group ?? ''}`, target)
+  }
+
+  if (targets.size !== 1) return undefined
+  for (const target of targets.values()) return target
+  return undefined
+}
+
 /**
  * Build a /workload/:kind/:namespace/:name URL, preserving the API group as a
  * query param so the WorkloadView can resolve CRDs with colliding kind names.

package/src/utils/network-policy-navigation.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest'
+import type { Topology, TopologyNode } from '@skyhook-io/k8s-ui/types/core'
+import { getNetworkPolicyResourceTarget } from './navigation'
+
+function node(kind: string, apiVersion?: string): TopologyNode {
+  return {
+    id: `${kind}/default/policy`,
+    kind,
+    name: 'policy',
+    status: 'healthy',
+    data: { namespace: 'default', ...(apiVersion ? { apiVersion } : {}) },
+  } as TopologyNode
+}
+
+function topology(...nodes: TopologyNode[]): Topology {
+  return { nodes, edges: [] }
+}
+
+describe('getNetworkPolicyResourceTarget', () => {
+  it('routes a Calico policy to its API group instead of the native policy list', () => {
+    expect(getNetworkPolicyResourceTarget(topology(node('CalicoNetworkPolicy', 'projectcalico.org/v3')))).toEqual({
+      kind: 'networkpolicies',
+      group: 'projectcalico.org',
+    })
+  })
+
+  it('uses the Calico policy kind when the aggregate only contains global policies', () => {
+    expect(getNetworkPolicyResourceTarget(topology(node('CalicoGlobalNetworkPolicy', 'crd.projectcalico.org/v1')))).toEqual({
+      kind: 'globalnetworkpolicies',
+      group: 'crd.projectcalico.org',
+    })
+  })
+
+  it('routes staged Kubernetes Calico policies to their exact API group', () => {
+    expect(getNetworkPolicyResourceTarget(topology(node('CalicoStagedKubernetesNetworkPolicy', 'crd.projectcalico.org/v1')))).toEqual({
+      kind: 'stagedkubernetesnetworkpolicies',
+      group: 'crd.projectcalico.org',
+    })
+  })
+
+  it('uses the generic resources view when the aggregate contains multiple policy targets', () => {
+    expect(getNetworkPolicyResourceTarget(topology(
+      node('NetworkPolicy', 'networking.k8s.io/v1'),
+      node('CalicoNetworkPolicy', 'crd.projectcalico.org/v1'),
+    ))).toBeUndefined()
+  })
+
+  it('keeps a stable route when multiple policies share one kind and group', () => {
+    expect(getNetworkPolicyResourceTarget(topology(
+      node('CalicoNetworkPolicy', 'crd.projectcalico.org/v1'),
+      node('CalicoNetworkPolicy', 'crd.projectcalico.org/v1'),
+    ))).toEqual({
+      kind: 'networkpolicies',
+      group: 'crd.projectcalico.org',
+    })
+  })
+
+  it('preserves the native NetworkPolicy API group when apiVersion is absent', () => {
+    expect(getNetworkPolicyResourceTarget(topology(node('NetworkPolicy')))).toEqual({
+      kind: 'networkpolicies',
+      group: 'networking.k8s.io',
+    })
+  })
+
+  it('returns no targeted route when topology has not identified a policy', () => {
+    expect(getNetworkPolicyResourceTarget(topology(node('Deployment')))).toBeUndefined()
+  })
+})

package/src/utils/topology-selection.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest'
+import type { SelectedResource, Topology, TopologyNode } from '@skyhook-io/k8s-ui/types/core'
+import { findSelectedTopologyNode } from './topology-selection'
+
+function node(id: string, kind: string, name: string, apiVersion?: string): TopologyNode {
+  return {
+    id,
+    kind,
+    name,
+    status: 'healthy',
+    data: { namespace: 'default', ...(apiVersion ? { apiVersion } : {}) },
+  } as TopologyNode
+}
+
+function selected(group?: string, kind = 'networkpolicies'): SelectedResource {
+  return { kind, namespace: 'default', name: 'policy', group }
+}
+
+describe('findSelectedTopologyNode', () => {
+  it('prefers the node from the selected API group when names collide', () => {
+    const native = node('native', 'NetworkPolicy', 'policy')
+    const calico = node('calico', 'CalicoNetworkPolicy', 'policy', 'projectcalico.org/v3')
+
+    expect(findSelectedTopologyNode({ nodes: [native, calico], edges: [] }, selected('projectcalico.org'))?.id).toBe('calico')
+  })
+
+  it('keeps native NetworkPolicy selection working without an apiVersion on the node', () => {
+    const native = node('native', 'NetworkPolicy', 'policy')
+
+    expect(findSelectedTopologyNode({ nodes: [native], edges: [] }, selected('networking.k8s.io'))?.id).toBe('native')
+  })
+
+  it('matches arbitrary same-name nodes by API group when both groups are present', () => {
+    const first = node('first', 'Widget', 'policy', 'one.example/v1')
+    const second = node('second', 'Widget', 'policy', 'two.example/v1')
+    const topology: Topology = { nodes: [first, second], edges: [] }
+
+    expect(findSelectedTopologyNode(topology, selected('two.example', 'widgets'))?.id).toBe('second')
+  })
+})

package/src/utils/topology-selection.ts

@@ -0,0 +1,39 @@
+import type { SelectedResource, Topology, TopologyNode } from '@skyhook-io/k8s-ui/types/core'
+import { apiVersionToGroup, kindToPlural } from '@skyhook-io/k8s-ui/utils/navigation'
+
+function topologyNodeGroup(node: TopologyNode): string | undefined {
+  const apiVersionGroup = apiVersionToGroup(node.data.apiVersion as string | undefined)
+  if (apiVersionGroup) return apiVersionGroup
+
+  const sourceGroup = node.data.sourceGroup
+  if (typeof sourceGroup === 'string' && sourceGroup) return sourceGroup
+
+  // Native NetworkPolicy nodes predate apiVersion in the topology payload.
+  if (node.kind === 'NetworkPolicy') return 'networking.k8s.io'
+  return undefined
+}
+
+export function findSelectedTopologyNode(
+  topology: Topology | null,
+  selectedResource: SelectedResource,
+): TopologyNode | undefined {
+  const namespace = selectedResource.namespace || ''
+  const candidates = topology?.nodes.filter(node =>
+    ((node.data.namespace as string) || '') === namespace &&
+    node.name === selectedResource.name &&
+    (kindToPlural(node.kind) === selectedResource.kind || node.kind === selectedResource.kind),
+  ) ?? []
+
+  if (candidates.length === 0) return undefined
+
+  const selectedGroup = selectedResource.group || undefined
+  if (!selectedGroup) return candidates[0]
+
+  const groupMatch = candidates.find(node => topologyNodeGroup(node) === selectedGroup)
+  if (groupMatch) return groupMatch
+
+  // Preserve the old name/kind/ns behavior only when the topology has no group
+  // information to compare. If it does, returning no match is safer than
+  // highlighting a resource from another API group.
+  return candidates.some(node => topologyNodeGroup(node) !== undefined) ? undefined : candidates[0]
+}