@skyhook-io/radar-app 1.14.5 → 1.15.0

package/src/context/NavCustomization.tsx

@@ -1,15 +1,3 @@
-// Slot-based customization of Radar's top nav.
-//
-// Lets library consumers (e.g. Radar Hub) swap out the brand area, the
-// context picker, and append items on the right of the action bar —
-// without forking App.tsx or building a parallel nav.
-//
-// The `embedded` flag hides chrome that only makes sense for Radar's
-// standalone OSS binary: GitHub star link, update-from-GitHub notifier,
-// Radar's own OIDC/proxy-mode UserMenu. Consumers typically provide
-// their own auth UI via `rightExtras`.
-//
-// Default (no provider): Radar renders its standalone nav unchanged.
 import { createContext, useContext } from 'react';
 import type { ReactNode } from 'react';
 
@@ -21,11 +9,9 @@ import type { ReactNode } from 'react';
  */
 export type FleetTakeoverTarget = 'issues' | 'gitops' | 'checks' | 'certs';
 
-interface NavCustomizationBase {
-  /** Replaces Radar's Skyhook/radar logo + wordmark. */
-  brandSlot?: ReactNode;
-  /** Replaces the ContextSwitcher (kubeconfig-context picker). */
-  contextSlot?: ReactNode;
+export interface NavCustomization {
+  /** Radar Hub owns all chrome; Radar renders only the active view. */
+  embedded?: boolean;
   /**
    * When set, a "Compare across clusters" option is added to the Compare
    * button in resource action bars. The host returns the URL that should
@@ -50,8 +36,7 @@ interface NavCustomizationBase {
    * canonical surfaces rather than a second, diverging per-cluster copy:
    *   - 'issues'  → the Active Issues panel + cluster-health issues count
    *   - 'gitops'  → the GitOps controllers card
-   *   - 'checks'  → the Cluster Audit card (and any route to /audit; legacy
-   *                 `clusterChecksHref` folded in here)
+   *   - 'checks'  → the Cluster Audit card (and any route to /audit)
    *   - 'certs'   → the Certificate Health card
    *
    * View-shaped targets (issues / gitops / checks) are honored for every entry:
@@ -64,13 +49,6 @@ interface NavCustomizationBase {
    * falls back to `window.location` (a hard reload).
    */
   fleetTakeoverHref?: (target: FleetTakeoverTarget) => string | undefined;
-  /**
-   * @deprecated Superseded by `fleetTakeoverHref('checks')`. Kept so consumers
-   * still on the pre-1.7 hook keep working (App.tsx folds it into the 'checks'
-   * target) — this makes adding `fleetTakeoverHref` an additive, non-breaking
-   * change. Remove in a major release once all consumers have migrated.
-   */
-  clusterChecksHref?: () => string;
   /**
    * Optional smooth navigator for host-owned URLs. When the host takes a
    * destination over (`fleetTakeoverHref`, `crossClusterCompareHref`), Radar
@@ -82,40 +60,8 @@ interface NavCustomizationBase {
    * OSS / other hosts are unaffected.
    */
   onHostNavigate?: (url: string) => void;
-  /**
-   * Chrome level for embedded hosts. Default ('full', or omitted) renders
-   * Radar's top bar + the view-switcher. 'none' suppresses BOTH — the host
-   * drives view navigation and cluster/namespace scope from its OWN chrome, and
-   * Radar renders just the active view's content full-bleed. Radar Hub uses this
-   * to surface per-cluster views (Topology / Resources / Traffic / Cost) that
-   * don't aggregate to the fleet as native cloud destinations under one chrome,
-   * gated by a cluster picker — instead of a second, redundant in-cluster nav.
-   * Only meaningful with `embedded: true`.
-   */
-  chrome?: 'full' | 'none';
 }
 
-/**
- * Slot-based customization of Radar's top nav.
- *
- * Standalone-mode consumers pass `embedded: false` (or omit it) and may
- * optionally append items via `rightExtras`. Embedded-mode consumers must
- * supply `rightExtras` — Radar's OSS chrome (GitHub star, update notifier,
- * built-in UserMenu) is hidden, so the host app owns the right side of the
- * nav and must render its own user/auth UI there.
- */
-export type NavCustomization =
-  | (NavCustomizationBase & {
-      embedded?: false;
-      /** Appended to the right of the action bar (before the UserMenu). */
-      rightExtras?: ReactNode;
-    })
-  | (NavCustomizationBase & {
-      embedded: true;
-      /** Required in embedded mode: Radar's own UserMenu is hidden. */
-      rightExtras: ReactNode;
-    });
-
 const NavCustomizationContext = createContext<NavCustomization>({});
 
 export function NavCustomizationProvider({

package/src/context/ThemeContext.tsx

@@ -1,5 +1,5 @@
 import { createContext, useContext, useEffect, useState, ReactNode } from 'react'
-import { apiUrl, getAuthHeaders, getCredentialsMode } from '../api/config'
+import { loadPreferences, persistPreferences } from '../api/preferences'
 
 type Theme = 'dark' | 'light'
 
@@ -34,14 +34,7 @@ export function ThemeProvider({ children }: { children: ReactNode }) {
   const setTheme = (newTheme: Theme) => {
     setThemeState(newTheme)
     localStorage.setItem(THEME_STORAGE_KEY, newTheme)
-    fetch(apiUrl('/settings'), {
-      method: 'PUT',
-      credentials: getCredentialsMode(),
-      headers: { 'Content-Type': 'application/json', ...getAuthHeaders() },
-      body: JSON.stringify({ theme: newTheme }),
-    }).then((res) => {
-      if (!res.ok) console.warn('[settings] Failed to persist theme:', res.status)
-    }).catch((err) => console.warn('[settings] Failed to persist theme:', err))
+    persistPreferences({ theme: newTheme }).catch((err) => console.warn('[settings] Failed to persist theme:', err))
   }
 
   const toggleTheme = () => {
@@ -56,8 +49,7 @@ export function ThemeProvider({ children }: { children: ReactNode }) {
 
   // Sync theme from server (persisted settings survive port changes in desktop app)
   useEffect(() => {
-    fetch(apiUrl('/settings'), { credentials: getCredentialsMode(), headers: getAuthHeaders() })
-      .then((res) => res.ok ? res.json() : null)
+    loadPreferences()
       .then((data) => {
         if (data?.theme && (data.theme === 'dark' || data.theme === 'light') && data.theme !== theme) {
           setThemeState(data.theme)

package/src/hooks/useClusterLoadState.ts

@@ -21,8 +21,8 @@ interface UseClusterLoadStateResult {
 }
 
 // Tracks cluster-data warmup (deferred/partial dashboard load) once the main
-// connection is usable. Standalone / embedded-with-chrome render it in Radar's
-// topbar; chromeless hosts (Radar Hub) receive it via onClusterLoadStateChange;
+// connection is usable. Standalone renders it in Radar's topbar; Radar Hub
+// receives it via onClusterLoadStateChange;
 // a chromeless host without a callback gets a fallback row on Home.
 export function useClusterLoadState({
   namespaces,

package/src/hooks/useFavorites.ts

@@ -1,5 +1,5 @@
 import { useState, useCallback, useEffect } from 'react'
-import { apiUrl, getAuthHeaders, getCredentialsMode } from '../api/config'
+import { loadPreferences, persistPreferences } from '../api/preferences'
 
 export interface PinnedKind {
   name: string       // plural name for API calls, e.g. "pods", "deployments"
@@ -25,8 +25,7 @@ function savePinned(pinned: PinnedKind[]) {
   } catch {
     // ignore storage errors
   }
-  fetch(apiUrl('/settings'), { method: 'PUT', credentials: getCredentialsMode(), headers: { 'Content-Type': 'application/json', ...getAuthHeaders() }, body: JSON.stringify({ pinnedKinds: pinned }) })
-    .then((res) => { if (!res.ok) console.warn('[settings] Failed to persist pinned kinds:', res.status) })
+  persistPreferences({ pinnedKinds: pinned })
     .catch((err) => console.warn('[settings] Failed to persist pinned kinds:', err))
 }
 
@@ -39,8 +38,7 @@ export function usePinnedKinds() {
 
   // Sync from server (persisted settings survive port changes in desktop app)
   useEffect(() => {
-    fetch(apiUrl('/settings'), { credentials: getCredentialsMode(), headers: getAuthHeaders() })
-      .then((res) => res.ok ? res.json() : null)
+    loadPreferences()
       .then((data) => {
         if (data?.pinnedKinds?.length && loadPinned().length === 0) {
           setPinned(data.pinnedKinds)

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/auditBadges.ts

@@ -30,7 +30,7 @@ export function isBadgeWorthy(
 /**
  * buildAuditSeverityMap keys badge-worthy findings by the same resource key the
  * backend stamps onto topology nodes (`node.data.auditKey`): `group|Kind|ns|name`,
- * group following the audit convention (built-ins → their group, CRDs → "").
+ * using the resource’s actual API group.
  */
 export function buildAuditSeverityMap(
   findings: AuditFinding[] | undefined,

package/src/utils/navigation.test.ts

@@ -1,9 +1,10 @@
+import type { Topology } from '@skyhook-io/k8s-ui/types/core'
 import { afterEach, describe, expect, it } from 'vitest'
 import {
   initNavigationMap,
   resetNavigationMap,
 } from '@skyhook-io/k8s-ui/utils/navigation'
-import { relatedResourcePath, resourcePath } from './navigation'
+import { getNetworkPolicyResourceTarget, relatedResourcePath, resourcePath, withCrossViewParams } from './navigation'
 
 afterEach(resetNavigationMap)
 
@@ -43,3 +44,35 @@ describe('resource navigation paths', () => {
     ).toBe('/workload/pods/default/batch')
   })
 })
+
+
+describe('JobSet investigation navigation', () => {
+  it('preserves selected member and tab on the exact JobSet route', () => {
+    expect(relatedResourcePath({ kind: 'jobsets', namespace: 'training', name: 'wide', group: 'jobset.x-k8s.io', run: 'jobs/training/worker-240', tab: 'logs' })).toBe('/workload/jobsets/training/wide?apiGroup=jobset.x-k8s.io&run=jobs%2Ftraining%2Fworker-240&tab=logs')
+  })
+  it('leaves colliding JobSet kinds in their group-aware drawer', () => {
+    expect(relatedResourcePath({ kind: 'jobsets', namespace: 'training', name: 'wide', group: 'other.example' })).toBe('/resources/jobsets?resource=training%2Fwide&apiGroup=other.example')
+  })
+})
+
+
+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

@@ -1,5 +1,6 @@
 import { apiUrl, getAuthHeaders, getCredentialsMode } from '../api/config'
 import { apiVersionToGroup, kindToPluralWithGroup } from '@skyhook-io/k8s-ui/utils/navigation'
+import { topologyNodeResourceKind } from '@skyhook-io/k8s-ui/utils/topology-neighborhood'
 import type { SelectedResource, Topology } from '@skyhook-io/k8s-ui/types/core'
 import type { SearchHit } from '../api/client'
 
@@ -48,7 +49,7 @@ export function getNetworkPolicyResourceTarget(topology: Topology | null): { kin
 
     const group = networkPolicyGroup(node)
     const target = {
-      kind: kindToPluralWithGroup(node.kind, group ?? ''),
+      kind: kindToPluralWithGroup(topologyNodeResourceKind(node), group ?? ''),
       ...(group ? { group } : {}),
     }
     targets.set(`${target.kind}\u0000${target.group ?? ''}`, target)
@@ -67,12 +68,18 @@ export function getNetworkPolicyResourceTarget(topology: Topology | null): { kin
  * positional and WorkloadViewRoute can parse it back. '_' is safe — it's not a
  * valid DNS-1123 namespace label, so it can never collide with a real one.
  */
-export function buildWorkloadPath(resource: SelectedResource): string {
+export type ResourceNavigationTarget = SelectedResource & { run?: string; tab?: string }
+
+export function buildWorkloadPath(resource: ResourceNavigationTarget): string {
   const kind = encodeURIComponent(resource.kind)
   const namespace = encodeURIComponent(resource.namespace || '_')
   const name = encodeURIComponent(resource.name)
   const base = `/workload/${kind}/${namespace}/${name}`
-  return resource.group ? `${base}?apiGroup=${encodeURIComponent(resource.group)}` : base
+  const params = new URLSearchParams()
+  if (resource.group) params.set('apiGroup', resource.group)
+  if (resource.run) params.set('run', resource.run)
+  if (resource.tab) params.set('tab', resource.tab)
+  return params.size ? `${base}?${params}` : base
 }
 
 /**
@@ -101,9 +108,9 @@ export function resourcePath(resource: SelectedResource): string {
 
 const FULLSCREEN_RESOURCE_KINDS = new Set(['pods', 'deployments', 'statefulsets', 'daemonsets', 'jobs', 'cronjobs', 'nodes'])
 
-export function relatedResourcePath(resource: SelectedResource): string {
+export function relatedResourcePath(resource: ResourceNavigationTarget): string {
   const apiKind = kindToPluralWithGroup(resource.kind, resource.group ?? '').toLowerCase()
-  if (FULLSCREEN_RESOURCE_KINDS.has(apiKind)) {
+  if (FULLSCREEN_RESOURCE_KINDS.has(apiKind) || (apiKind === 'jobsets' && resource.group === 'jobset.x-k8s.io')) {
     return buildWorkloadPath({ ...resource, kind: apiKind })
   }
   return resourcePath(resource)
@@ -126,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/topology-selection.test.ts

@@ -37,4 +37,60 @@ describe('findSelectedTopologyNode', () => {
 
     expect(findSelectedTopologyNode(topology, selected('two.example', 'widgets'))?.id).toBe('second')
   })
+
+  it('matches a pseudo topology kind through its real Kubernetes kind', () => {
+    const knative = node('knative', 'KnativeService', 'api', 'serving.knative.dev/v1')
+    knative.data.resourceKind = 'Service'
+
+    expect(findSelectedTopologyNode(
+      { nodes: [knative], edges: [] },
+      { kind: 'services', namespace: 'default', name: 'api', group: 'serving.knative.dev' },
+    )?.id).toBe('knative')
+  })
+
+  it('keeps an omitted or explicit core Service selection on the core node', () => {
+    const core = node('core', 'Service', 'api')
+    const knative = node('knative', 'KnativeService', 'api', 'serving.knative.dev/v1')
+    knative.data.resourceKind = 'Service'
+    const topology: Topology = { nodes: [knative, core], edges: [] }
+
+    expect(findSelectedTopologyNode(topology, {
+      kind: 'services', namespace: 'default', name: 'api',
+    })?.id).toBe('core')
+    expect(findSelectedTopologyNode(topology, {
+      kind: 'services', namespace: 'default', name: 'api', group: '',
+    })?.id).toBe('core')
+  })
+
+  it('infers a typed Job group when its topology node omits apiVersion', () => {
+    const core = node('core', 'Job', 'train')
+    const volcano = node('volcano', 'Job', 'train', 'batch.volcano.sh/v1alpha1')
+    const topology: Topology = { nodes: [volcano, core], edges: [] }
+
+    expect(findSelectedTopologyNode(topology, {
+      kind: 'jobs', namespace: 'default', name: 'train', group: 'batch',
+    })?.id).toBe('core')
+    expect(findSelectedTopologyNode(topology, {
+      kind: 'jobs', namespace: 'default', name: 'train', group: 'batch.volcano.sh',
+    })?.id).toBe('volcano')
+  })
+
+  it('infers the policy group for a typed PodDisruptionBudget node', () => {
+    const pdb = node('pdb', 'PodDisruptionBudget', 'budget')
+
+    expect(findSelectedTopologyNode(
+      { nodes: [pdb], edges: [] },
+      { kind: 'poddisruptionbudgets', namespace: 'default', name: 'budget', group: 'policy' },
+    )?.id).toBe('pdb')
+  })
+
+  it('fails closed for an omitted unknown group when custom resources collide', () => {
+    const one = node('one', 'Widget', 'same', 'one.example/v1')
+    const two = node('two', 'Widget', 'same', 'two.example/v1')
+
+    expect(findSelectedTopologyNode(
+      { nodes: [one, two], edges: [] },
+      { kind: 'widgets', namespace: 'default', name: 'same' },
+    )).toBeUndefined()
+  })
 })

package/src/utils/topology-selection.ts

@@ -1,16 +1,16 @@
 import type { SelectedResource, Topology, TopologyNode } from '@skyhook-io/k8s-ui/types/core'
+import { builtinGroupForKind, canonicalResourceGroup } from '@skyhook-io/k8s-ui/utils/api-resources'
 import { apiVersionToGroup, kindToPluralWithGroup } from '@skyhook-io/k8s-ui/utils/navigation'
+import { topologyNodeResourceKind } from '@skyhook-io/k8s-ui/utils/topology-neighborhood'
 
 function topologyNodeGroup(node: TopologyNode): string | undefined {
-  const apiVersionGroup = apiVersionToGroup(node.data.apiVersion as string | undefined)
-  if (apiVersionGroup) return apiVersionGroup
+  const apiVersion = node.data.apiVersion
+  if (typeof apiVersion === 'string' && apiVersion) return apiVersionToGroup(apiVersion)
 
   const sourceGroup = node.data.sourceGroup
-  if (typeof sourceGroup === 'string' && sourceGroup) return sourceGroup
+  if (typeof sourceGroup === 'string') return sourceGroup
 
-  // Native NetworkPolicy nodes predate apiVersion in the topology payload.
-  if (node.kind === 'NetworkPolicy') return 'networking.k8s.io'
-  return undefined
+  return builtinGroupForKind(topologyNodeResourceKind(node))
 }
 
 export function findSelectedTopologyNode(
@@ -22,13 +22,13 @@ export function findSelectedTopologyNode(
   const candidates = topology?.nodes.filter(node =>
     ((node.data.namespace as string) || '') === namespace &&
     node.name === selectedResource.name &&
-    (kindToPluralWithGroup(node.kind, topologyNodeGroup(node) ?? '') === selectedKind || node.kind === selectedResource.kind),
+    (kindToPluralWithGroup(topologyNodeResourceKind(node), topologyNodeGroup(node) ?? '') === selectedKind || topologyNodeResourceKind(node) === selectedResource.kind),
   ) ?? []
 
   if (candidates.length === 0) return undefined
 
-  const selectedGroup = selectedResource.group || undefined
-  if (!selectedGroup) return candidates[0]
+  const selectedGroup = canonicalResourceGroup(selectedResource.kind, selectedResource.group)
+  if (selectedGroup === undefined) return candidates.length === 1 ? candidates[0] : undefined
 
   const groupMatch = candidates.find(node => topologyNodeGroup(node) === selectedGroup)
   if (groupMatch) return groupMatch

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' }