@skyhook-io/radar-app 1.12.2 → 1.12.3

package/src/components/home/RadarVersionLine.test.tsx

@@ -0,0 +1,145 @@
+import { renderToString } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import type { VersionInfo } from '../../api/client'
+import { RadarVersionLine } from './RadarVersionLine'
+
+const version: VersionInfo = {
+  currentVersion: '1.2.3',
+  latestVersion: '1.3.0',
+  updateAvailable: true,
+  installMethod: 'direct',
+  releaseUrl: 'https://github.com/skyhook-io/radar/releases/tag/v1.3.0',
+}
+
+describe('RadarVersionLine', () => {
+  it('shows the running version without an upgrade affordance when up to date', () => {
+    const html = renderToString(
+      <RadarVersionLine version={{ ...version, latestVersion: '1.2.3', updateAvailable: false }} />,
+    )
+    expect(html).toContain('Radar')
+    expect(html).toContain('v1.2.3')
+    expect(html).not.toContain('available')
+  })
+
+  it('shows patch upgrades with the quiet treatment', () => {
+    const html = renderToString(
+      <RadarVersionLine version={{ ...version, latestVersion: '1.2.4' }} />,
+    )
+    expect(html).toContain('v1.2.3')
+    expect(html).toContain('v1.2.4')
+    expect(html).toContain('available')
+    expect(html).toContain('text-accent-text hover:text-accent')
+  })
+
+  it('makes minor upgrades more prominent', () => {
+    const html = renderToString(<RadarVersionLine version={version} />)
+    expect(html).toContain('font-medium text-accent hover:text-accent-light')
+    expect(html).not.toContain('minor releases behind')
+  })
+
+  it('uses warning emphasis and explains when an installation is three minor releases behind', () => {
+    const html = renderToString(
+      <RadarVersionLine version={{ ...version, currentVersion: '1.0.9', latestVersion: '1.3.0' }} />,
+    )
+    expect(html).toContain('font-medium text-warning-text hover:opacity-80')
+    expect(html).toContain('This installation is 3 minor releases behind')
+  })
+
+  it('uses warning emphasis for a major upgrade', () => {
+    const html = renderToString(
+      <RadarVersionLine version={{ ...version, currentVersion: '0.12.0', latestVersion: '1.3.0' }} />,
+    )
+    expect(html).toContain('font-medium text-warning-text hover:opacity-80')
+    expect(html).toContain('A major Radar upgrade is available')
+  })
+
+  it('does not claim manager discovery has failed while it is loading', () => {
+    const html = renderToString(<RadarVersionLine version={version} managerLoading />)
+    expect(html).toContain('v1.3.0')
+    expect(html).toContain('available')
+    expect(html).toContain('lucide-circle-arrow-up')
+    expect(html).toContain('Checking how this installation is managed')
+    expect(html).not.toContain('could not be confirmed')
+    expect(html).not.toContain('<a')
+    expect(html).not.toContain('<button')
+    expect(html).toContain('class="sr-only"')
+    expect(html).not.toContain('aria-label=')
+  })
+
+  it('opens actionable upgrade instructions when the installation manager is unknown', () => {
+    const html = renderToString(<RadarVersionLine version={version} />)
+    expect(html).toContain('https://radarhq.io/docs/configuration/in-cluster')
+    expect(html).not.toContain('#upgrading')
+    expect(html).toContain('Open the in-cluster upgrade instructions')
+    expect(html).not.toContain(version.releaseUrl)
+    expect(html).toContain('font-medium text-accent hover:text-accent-light')
+  })
+
+  it('keeps the visible upgrade label in the accessible name', () => {
+    const html = renderToString(<RadarVersionLine version={version} />)
+    expect(html).toContain('aria-label="v1.3.0 available —')
+  })
+
+  it('deep-links exact Helm ownership when the host supports it', () => {
+    const html = renderToString(
+      <RadarVersionLine
+        version={version}
+        manager={{ ownership: 'helm', namespace: 'radar-system', release: 'radar' }}
+        onNavigateToHelmRelease={() => {}}
+      />,
+    )
+    expect(html).toContain('Managed by Helm release radar-system/radar')
+    expect(html).toContain('Open the release to upgrade')
+  })
+
+  it('describes the docs fallback when a Helm navigation callback is unavailable', () => {
+    const html = renderToString(
+      <RadarVersionLine
+        version={version}
+        manager={{ ownership: 'helm', namespace: 'radar-system', release: 'radar' }}
+      />,
+    )
+    expect(html).toContain('https://radarhq.io/docs/configuration/in-cluster')
+    expect(html).toContain('Managed by Helm release radar-system/radar')
+    expect(html).toContain('Open the in-cluster upgrade instructions')
+    expect(html).not.toContain('Open the release to upgrade')
+  })
+
+  it('deep-links verified GitOps ownership', () => {
+    const controllerRef = { group: 'kustomize.toolkit.fluxcd.io', kind: 'Kustomization', namespace: 'flux-system', name: 'radar' }
+    const verified = renderToString(
+      <RadarVersionLine
+        version={version}
+        manager={{ ownership: 'gitops', controller: 'Kustomization flux-system/radar', controllerRef }}
+        onNavigateToGitOps={() => {}}
+      />,
+    )
+    expect(verified).toContain('Managed by Kustomization flux-system/radar')
+    expect(verified).toContain('Open it to upgrade through GitOps')
+
+    const suspected = renderToString(
+      <RadarVersionLine
+        version={version}
+        manager={{ ownership: 'gitops', controller: 'Kustomization flux-system/radar' }}
+        onNavigateToGitOps={() => {}}
+      />,
+    )
+    expect(suspected).toContain('appears to be managed through GitOps (Kustomization flux-system/radar)')
+    expect(suspected).toContain('Open the upgrade instructions')
+    expect(suspected).not.toContain('Managed by Kustomization')
+  })
+
+  it('describes the docs fallback when a GitOps navigation callback is unavailable', () => {
+    const controllerRef = { group: 'kustomize.toolkit.fluxcd.io', kind: 'Kustomization', namespace: 'flux-system', name: 'radar' }
+    const html = renderToString(
+      <RadarVersionLine
+        version={version}
+        manager={{ ownership: 'gitops', controller: 'Kustomization flux-system/radar', controllerRef }}
+      />,
+    )
+    expect(html).toContain('https://radarhq.io/docs/configuration/in-cluster')
+    expect(html).toContain('Managed by Kustomization flux-system/radar')
+    expect(html).toContain('Open the in-cluster upgrade instructions and apply the change through GitOps')
+    expect(html).not.toContain('Open it to upgrade through GitOps')
+  })
+})

package/src/components/home/RadarVersionLine.tsx

@@ -0,0 +1,137 @@
+import { ArrowUpCircle } from 'lucide-react'
+import { gitOpsRouteForResource } from '@skyhook-io/k8s-ui'
+import type { CloudConnectSelf, VersionInfo } from '../../api/client'
+import {
+  getVersionUpdateStatus,
+  IN_CLUSTER_UPGRADE_URL,
+  type VersionUpdateTier,
+} from '../../utils/version'
+import { Tooltip } from '../ui/Tooltip'
+
+interface RadarVersionLineProps {
+  version: VersionInfo
+  manager?: CloudConnectSelf
+  managerLoading?: boolean
+  onNavigateToHelmRelease?: (namespace: string, release: string) => void
+  onNavigateToGitOps?: (path: string) => void
+}
+
+function displayVersion(version: string): string {
+  return version === 'dev' || version.startsWith('v') ? version : `v${version}`
+}
+
+export function RadarVersionLine({
+  version,
+  manager,
+  managerLoading = false,
+  onNavigateToHelmRelease,
+  onNavigateToGitOps,
+}: RadarVersionLineProps) {
+  const latestVersion = version.latestVersion
+  const updateStatus = getVersionUpdateStatus(version.currentVersion, latestVersion)
+  const showUpgrade = version.updateAvailable && !!latestVersion && updateStatus.tier !== 'none'
+
+  if (!showUpgrade) {
+    return <span>Radar <span className="font-mono">{displayVersion(version.currentVersion)}</span></span>
+  }
+
+  const controller = manager?.controllerRef
+  const gitOpsPath = controller
+    ? gitOpsRouteForResource({
+        apiVersion: controller.group ? `${controller.group}/v1` : undefined,
+        kind: controller.kind,
+        metadata: { namespace: controller.namespace, name: controller.name },
+      })
+    : null
+
+  let detail = managerLoading
+    ? 'Checking how this installation is managed.'
+    : 'The installation manager could not be confirmed. Open the in-cluster upgrade instructions.'
+  let onClick: (() => void) | undefined
+  const actionClassName = `inline-flex items-center gap-1 transition-colors ${upgradeActionClassName(updateStatus.tier)}`
+
+  if (manager?.ownership === 'helm' && manager.namespace && manager.release) {
+    if (onNavigateToHelmRelease) {
+      detail = `Managed by Helm release ${manager.namespace}/${manager.release}. Open the release to upgrade.`
+      onClick = () => onNavigateToHelmRelease(manager.namespace!, manager.release!)
+    } else {
+      detail = `Managed by Helm release ${manager.namespace}/${manager.release}. Open the in-cluster upgrade instructions.`
+    }
+  } else if (controller && gitOpsPath) {
+    const objectName = `${controller.namespace ? `${controller.namespace}/` : ''}${controller.name}`
+    if (onNavigateToGitOps) {
+      detail = `Managed by ${controller.kind} ${objectName}. Open it to upgrade through GitOps.`
+      onClick = () => onNavigateToGitOps(gitOpsPath)
+    } else {
+      detail = `Managed by ${controller.kind} ${objectName}. Open the in-cluster upgrade instructions and apply the change through GitOps.`
+    }
+  } else if (manager?.ownership === 'gitops') {
+    detail = manager.controller
+      ? `This installation appears to be managed through GitOps (${manager.controller}). Open the upgrade instructions and apply the change through its source of truth.`
+      : 'This installation appears to be managed through GitOps. Open the upgrade instructions and apply the change through its source of truth.'
+  }
+
+  const ageDetail = updateAgeDetail(updateStatus)
+  const accessibleLabel = `${displayVersion(latestVersion)} available${ageDetail ? `. ${ageDetail}` : ''} — ${detail}`
+  const action = managerLoading ? (
+    <span className={actionClassName}>
+      <UpgradeLabel version={latestVersion} />
+      <span className="sr-only">{detail}</span>
+    </span>
+  ) : onClick ? (
+    <button
+      type="button"
+      className={actionClassName}
+      onClick={onClick}
+      aria-label={accessibleLabel}
+    >
+      <UpgradeLabel version={latestVersion} />
+    </button>
+  ) : (
+    <a
+      href={IN_CLUSTER_UPGRADE_URL}
+      target="_blank"
+      rel="noreferrer"
+      className={actionClassName}
+      aria-label={accessibleLabel}
+    >
+      <UpgradeLabel version={latestVersion} />
+    </a>
+  )
+
+  return (
+    <span className="inline-flex flex-wrap items-center gap-x-1">
+      <span>Radar <span className="font-mono">{displayVersion(version.currentVersion)}</span></span>
+      <span className="inline-flex items-center gap-1">
+        <span aria-hidden>·</span>
+        <Tooltip
+          content={accessibleLabel}
+          className="!whitespace-normal !max-w-sm"
+        >
+          {action}
+        </Tooltip>
+      </span>
+    </span>
+  )
+}
+
+function upgradeActionClassName(tier: VersionUpdateTier): string {
+  if (tier === 'patch') return 'text-accent-text hover:text-accent'
+  if (tier === 'minor') return 'font-medium text-accent hover:text-accent-light'
+  return 'font-medium text-warning-text hover:opacity-80'
+}
+
+function updateAgeDetail(status: ReturnType<typeof getVersionUpdateStatus>): string | undefined {
+  if (status.majorVersionBehind) return 'A major Radar upgrade is available.'
+  if (status.tier !== 'stale' || !status.minorVersionsBehind) return undefined
+  return `This installation is ${status.minorVersionsBehind} minor releases behind.`
+}
+
+function UpgradeLabel({ version }: { version: string }) {
+  return (
+    <>
+      <ArrowUpCircle className="h-3.5 w-3.5 shrink-0" aria-hidden />
+      <span><span className="font-mono">{displayVersion(version)}</span> available</span>
+    </>
+  )
+}

package/src/components/resources/PodFilesystemModal.tsx

@@ -1,4 +1,4 @@
-import { useState, useRef, useEffect, useMemo, useCallback } from 'react'
+import { createElement, useState, useRef, useEffect, useMemo, useCallback } from 'react'
 import { createPortal } from 'react-dom'
 import { X, File, Link2, ChevronRight, AlertTriangle, Loader2, Search, Download, FolderOpen } from 'lucide-react'
 import { PaneLoader, Input } from '@skyhook-io/k8s-ui'
@@ -7,6 +7,9 @@ import type { FileNode } from '../../types'
 import { formatBytes } from '../../utils/format'
 import { downloadBlob, filterTree } from './file-browser-utils'
 import { apiUrl, getAuthHeaders, getCredentialsMode } from '../../api/config'
+import { isDesktopApp } from '../../utils/desktop-download'
+import { openFile, openFolder } from '../../utils/desktop-open-folder'
+import { useToast } from '../ui/Toast'
 import { Tooltip } from '../ui/Tooltip'
 
 interface PodFilesystem {
@@ -35,6 +38,36 @@ async function fetchPodFiles(
   return response.json()
 }
 
+/**
+ * Desktop only: has the backend write the pod file straight to disk. The browser
+ * route would hand the whole file to the webview only to have it hand every byte
+ * back to be saved, which is what puts a large file out of reach there.
+ * Returns the path it was saved to.
+ */
+async function savePodFileToDisk(
+  namespace: string,
+  podName: string,
+  container: string,
+  filePath: string,
+): Promise<string> {
+  const params = new URLSearchParams()
+  params.set('container', container)
+  params.set('path', filePath)
+
+  const response = await fetch(apiUrl(`/pods/${namespace}/${podName}/files/save?${params.toString()}`), {
+    method: 'POST',
+    credentials: getCredentialsMode(),
+    headers: getAuthHeaders(),
+  })
+  if (response.status === 204) throw new Error('cancelled')
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: 'Save failed' }))
+    throw new Error(error.error || `HTTP ${response.status}`)
+  }
+  const body = await response.json()
+  return body.path
+}
+
 interface PodFilesystemModalProps {
   open: boolean
   onClose: () => void
@@ -309,6 +342,7 @@ interface PodFileTreeNodeProps {
 
 function PodFileTreeNode({ node, namespace, podName, container, onNavigate }: PodFileTreeNodeProps) {
   const [downloading, setDownloading] = useState(false)
+  const { showSuccess, showError } = useToast()
   const isDir = node.type === 'dir'
   const isSymlink = node.type === 'symlink'
   const isDownloadable = !isDir // files and symlinks can be downloaded
@@ -319,6 +353,21 @@ function PodFileTreeNode({ node, namespace, podName, container, onNavigate }: Po
 
     setDownloading(true)
     try {
+      if (await isDesktopApp()) {
+        const savedPath = await savePodFileToDisk(namespace, podName, container, node.path)
+        showSuccess(
+          'File saved',
+          savedPath,
+          {
+            label: 'Show in Finder',
+            icon: createElement(FolderOpen, { className: 'w-3.5 h-3.5' }),
+            onClick: () => openFolder(savedPath),
+          },
+          () => openFile(savedPath),
+        )
+        return
+      }
+
       const params = new URLSearchParams()
       params.set('container', container)
       params.set('path', node.path)
@@ -335,7 +384,10 @@ function PodFileTreeNode({ node, namespace, podName, container, onNavigate }: Po
       const blob = await response.blob()
       await downloadBlob(blob, node.name)
     } catch (err) {
-      console.error('Download failed:', err)
+      const message = err instanceof Error ? err.message : String(err)
+      if (message !== 'cancelled') {
+        showError(`Could not download ${node.name}`, message)
+      }
     } finally {
       setDownloading(false)
     }

package/src/components/resources/ResourcesView.tsx

@@ -16,10 +16,12 @@ import {
   ResourcesView as BaseResourcesView,
   CORE_RESOURCES,
   intersectWorkloadWrites,
+  hasCuratedColumns,
+  sanitizePrinterTable,
 } from '@skyhook-io/k8s-ui'
-import type { Capabilities, ResourceQueryResult, WorkloadWritePermissions } from '@skyhook-io/k8s-ui'
+import type { Capabilities, PrinterTable, ResourceQueryResult, WorkloadWritePermissions } from '@skyhook-io/k8s-ui'
 import type { SelectedResource } from '../../types'
-import { kindToPlural, type NavigateToResource } from '../../utils/navigation'
+import { apiVersionToGroup, kindToPluralWithGroup, type NavigateToResource } from '../../utils/navigation'
 import { CreateResourceDialog } from '../shared/CreateResourceDialog'
 import { getSkeletonYaml } from '../../utils/skeleton-yaml'
 
@@ -229,12 +231,19 @@ export function ResourcesView({ namespaces, selectedResource, onResourceClick, o
   // Fetch full data only for the selected kind
   const selectedKindQuery = useQuery({
     queryKey: ['resources', selectedKind?.name, isSelectedCrd ? selectedKind?.group : '', namespaces],
-    queryFn: async () => {
-      if (!selectedKind) return []
+    queryFn: async (): Promise<{ items: any[]; printerTable: PrinterTable | null }> => {
+      if (!selectedKind) return { items: [], printerTable: null }
       const params = new URLSearchParams()
       if (namespaces.length > 0) params.set('namespaces', namespacesParam)
       if (isSelectedCrd && selectedKind.group) params.set('group', selectedKind.group)
       if (selectedKindSummaryServed) params.set('include', 'summary')
+      // Only CRDs can declare printer columns, and a curated kind discards the
+      // result — so table mode is requested from exactly the kinds that can use
+      // it. Resolving a table costs the server a CRD read per request; doing
+      // that for a kind whose columns are hand-curated is pure waste.
+      const wantsTable = isSelectedCrd && !!selectedKind.group &&
+        !hasCuratedColumns(selectedKind.name, selectedKind.group)
+      if (wantsTable) params.set('table', '1')
       const startedAt = performance.now()
       debugNamespaceLog('resources:selected-kind-fetch-start', {
         kind: selectedKind.name,
@@ -258,7 +267,19 @@ export function ResourcesView({ namespaces, selectedResource, onResourceClick, o
         const errorData = await res.json().catch(() => ({ error: `HTTP ${res.status}` }))
         throw new ApiError(errorData.error || `Failed to fetch ${selectedKind.name}`, res.status, errorData)
       }
-      return res.json()
+      const body = await res.json()
+      // Both branches are current shapes, not a guess at a legacy one: a Radar
+      // backend that predates `table` ignores the parameter and answers with
+      // the bare array. @skyhook-io/radar-app is versioned independently of the
+      // backend it points at, so a consumer can pair a new frontend with an
+      // older Radar — and reading that array as a missing envelope would render
+      // every CRD list empty. Items and columns still come from one response,
+      // so a row can never render against another fetch's cells.
+      if (!wantsTable || Array.isArray(body)) return { items: body as any[], printerTable: null }
+      return {
+        items: Array.isArray(body?.items) ? body.items as any[] : [],
+        printerTable: sanitizePrinterTable(body),
+      }
     },
     enabled: !!selectedKind && !selectedKindQueryBlocked,
     staleTime: 30000,
@@ -275,13 +296,13 @@ export function ResourcesView({ namespaces, selectedResource, onResourceClick, o
     return {
       resourceName: selectedKind.name,
       group: selectedKind.group,
-      data: selectedKindQueryBlocked ? [] : selectedKindQuery.data as any[] | undefined,
+      data: selectedKindQueryBlocked ? [] : selectedKindQuery.data?.items,
       isLoading: waitingForGuardCount || selectedKindQuery.isLoading,
       error: selectedKindQueryBlocked ? undefined : selectedKindQuery.error,
       refetch: selectedKindQuery.refetch,
       dataUpdatedAt: selectedKindQuery.dataUpdatedAt,
     }
-  }, [selectedKind, selectedKindQueryBlocked, waitingForGuardCount, selectedKindQuery.data, selectedKindQuery.isLoading, selectedKindQuery.error, selectedKindQuery.refetch, selectedKindQuery.dataUpdatedAt])
+  }, [selectedKind, selectedKindQueryBlocked, waitingForGuardCount, selectedKindQuery.data?.items, selectedKindQuery.isLoading, selectedKindQuery.error, selectedKindQuery.refetch, selectedKindQuery.dataUpdatedAt])
 
   // Metrics
   const { data: topPodMetrics } = useTopPodMetrics({ enabled: topPodMetricsEnabled, namespaces })
@@ -352,6 +373,7 @@ export function ResourcesView({ namespaces, selectedResource, onResourceClick, o
       resourceReasons={countsData?.reasons}
       resourceUnavailable={countsData?.unavailable}
       selectedKindQuery={selectedKindQueryResult}
+      printerTable={selectedKindQueryBlocked ? null : selectedKindQuery.data?.printerTable ?? null}
       connectionState={connection.state}
       largeListGuard={largeListGuard}
       onSelectedKindChange={setSelectedKind}
@@ -394,7 +416,8 @@ export function ResourcesView({ namespaces, selectedResource, onResourceClick, o
       initialYaml={createDialogYaml}
       title={createDialogTitle}
       onCreated={(result) => {
-        onResourceClick?.({ kind: kindToPlural(result.kind), namespace: result.namespace, name: result.name, group: '' })
+        const group = apiVersionToGroup(result.apiVersion)
+        onResourceClick?.({ kind: kindToPluralWithGroup(result.kind, group), namespace: result.namespace, name: result.name, group })
       }}
     />
     </>

package/src/components/resources/renderers/WorkloadRenderer.tsx

@@ -4,8 +4,8 @@ import { useScaleWorkload, fetchJSON } from '../../../api/client'
 import { useRBACSubject } from '../../../api/rbac'
 import { usePolicyResource } from '../../../api/policy'
 import { useQueries, useQueryClient } from '@tanstack/react-query'
-import { kindToPlural } from '@skyhook-io/k8s-ui/utils/navigation'
-import type { Relationships, ResourceRef, ResourceWithRelationships } from '../../../types'
+import { kindToPlural, kindToPluralWithGroup } from '@skyhook-io/k8s-ui/utils/navigation'
+import type { Relationships, ResourceRef, ResourceWithRelationships, WorkloadPodInfo } from '../../../types'
 import type { ScalerDiagnosis } from '@skyhook-io/k8s-ui/components/resources/renderers/WorkloadRenderer'
 
 // Map plural lowercase kind to singular PascalCase for ownerReferences matching
@@ -26,9 +26,10 @@ interface WorkloadRendererProps {
   onNavigate?: (ref: ResourceRef) => void
   relationships?: Relationships
   scaleBlockedBy?: ResourceRef[]
+  workloadPods?: WorkloadPodInfo[]
 }
 
-export function WorkloadRenderer({ kind, data, onNavigate, scaleBlockedBy }: WorkloadRendererProps) {
+export function WorkloadRenderer({ kind, data, onNavigate, scaleBlockedBy, workloadPods }: WorkloadRendererProps) {
   const navigate = useNavigate()
   const queryClient = useQueryClient()
   const scaleMutation = useScaleWorkload()
@@ -54,13 +55,19 @@ export function WorkloadRenderer({ kind, data, onNavigate, scaleBlockedBy }: Wor
   })
   const hpaQueries = useQueries({
     queries: hpaRefs.map(ref => ({
-      queryKey: ['resource', kindToPlural(ref.kind), ref.namespace, ref.name, ref.group],
+      queryKey: [
+        'resource',
+        kindToPluralWithGroup(ref.kind, ref.group ?? ''),
+        ref.namespace,
+        ref.name,
+        ref.group,
+      ],
       queryFn: () => {
         const ns = ref.namespace || '_'
         const params = new URLSearchParams()
         if (ref.group) params.set('group', ref.group)
         const query = params.toString()
-        return fetchJSON<ResourceWithRelationships<any>>(`/resources/${kindToPlural(ref.kind)}/${ns}/${ref.name}${query ? `?${query}` : ''}`)
+        return fetchJSON<ResourceWithRelationships<any>>(`/resources/${kindToPluralWithGroup(ref.kind, ref.group ?? '')}/${ns}/${ref.name}${query ? `?${query}` : ''}`)
       },
       enabled: Boolean(ref.kind && ref.name),
       staleTime: 10000,
@@ -90,6 +97,7 @@ export function WorkloadRenderer({ kind, data, onNavigate, scaleBlockedBy }: Wor
       policyLoading={policyLoading}
       policyError={policyError as Error | null}
       scaleBlockedBy={scaleBlockedBy}
+      workloadPods={workloadPods}
       scalerDiagnostics={scalerDiagnostics}
       onScale={async (replicas) => {
         await scaleMutation.mutateAsync({

package/src/components/settings/SettingsDialog.tsx

@@ -12,7 +12,7 @@ import { useAnimatedUnmount } from '../../hooks/useAnimatedUnmount'
 import { TRANSITION_BACKDROP, TRANSITION_PANEL } from '../../utils/animation'
 import { apiUrl, getAuthHeaders, getCredentialsMode, routePath } from '../../api/config'
 import {
-  useCloudRole, useVersionCheck, useClusterInfo, usePrometheusStatus, useArgoStatus,
+  useCloudRole, useVersionCheck, useClusterInfo, usePrometheusStatus, useArgoStatus, useCapabilities,
 } from '../../api/client'
 import { useCapabilitiesContext } from '../../contexts/CapabilitiesContext'
 import { Input, SelectMenu } from '@skyhook-io/k8s-ui'
@@ -21,6 +21,7 @@ import { AISettingsSection, type AIDraft } from '../diagnose/AISettings'
 import { MyPermissionsContent } from './MyPermissionsDialog'
 import { useDiagnose } from '../diagnose/DiagnoseContext'
 import { currencyOptionsForValue } from './currency-options'
+import { versionUpdateURL } from '../../utils/version'
 
 // The loopback URL an MCP client is told to connect to. Shared by the overview
 // row and the MCP section: both must carry the base path, or the URL they
@@ -45,6 +46,7 @@ interface Config {
   argoCdUrl?: string
   argoCdInsecureTls?: boolean
   mcp?: boolean | null
+  restoreLastDesktopContext?: boolean | null
 }
 
 interface ConfigResponse {
@@ -102,6 +104,7 @@ function normalizeStartup(c: Config) {
     historyLimit: c.historyLimit ?? null,
     mcp: c.mcp ?? true,
     opencostCurrency: c.opencostCurrency?.trim().toUpperCase() ?? '',
+    restoreLastDesktopContext: c.restoreLastDesktopContext ?? true,
   }
 }
 
@@ -159,7 +162,8 @@ export function SettingsDialog({
   const clusterDirty =
     edN.kubeconfig !== svN.kubeconfig ||
     edN.kubeconfigDirs !== svN.kubeconfigDirs ||
-    edN.namespace !== svN.namespace
+    edN.namespace !== svN.namespace ||
+    edN.restoreLastDesktopContext !== svN.restoreLastDesktopContext
   const serverDirty =
     edN.port !== svN.port || edN.noBrowser !== svN.noBrowser || edN.browser !== svN.browser
   const mcpDirty = edN.mcp !== svN.mcp
@@ -504,6 +508,7 @@ export function SettingsDialog({
                 <ClusterSection
                   config={editedConfig}
                   effectiveConfig={configData?.effective}
+                  isDesktop={isDesktop}
                   onChange={updateConfigField}
                 />
               </div>
@@ -907,6 +912,8 @@ function OverviewPanel({ active, onNavigate }: { active: boolean; onNavigate: (s
   const { data: cluster } = useClusterInfo()
   const { data: prom } = usePrometheusStatus()
   const { data: argo } = useArgoStatus(active)
+  const { data: capabilitiesData } = useCapabilities()
+  const deploymentMode = capabilitiesData ? (capabilitiesData.deployment?.mode ?? 'local') : undefined
   const { data: version } = useVersionCheck()
   const capabilities = useCapabilitiesContext()
   const diag = useDiagnose()
@@ -963,9 +970,9 @@ function OverviewPanel({ active, onNavigate }: { active: boolean; onNavigate: (s
 
   return (
     <div className="space-y-4">
-      {version?.updateAvailable && (
+      {version?.updateAvailable && deploymentMode !== undefined && deploymentMode !== 'cloud' && (
         <a
-          href={version.releaseUrl}
+          href={versionUpdateURL(deploymentMode, version.releaseUrl)}
           target="_blank"
           rel="noreferrer"
           className="flex items-center gap-2 px-3 py-2 text-xs rounded-md border border-skyhook-500/30 bg-skyhook-500/10 hover:bg-skyhook-500/15 transition-colors"
@@ -1052,10 +1059,12 @@ function AIUnavailableNotice() {
 function ClusterSection({
   config,
   effectiveConfig,
+  isDesktop,
   onChange,
 }: {
   config: Config
   effectiveConfig?: Config
+  isDesktop: boolean
   onChange: <K extends keyof Config>(field: K, value: Config[K]) => void
 }) {
   const kubeconfigDirs = effectiveConfig ? (effectiveConfig.kubeconfigDirs ?? []) : config.kubeconfigDirs
@@ -1087,6 +1096,14 @@ function ClusterSection({
         placeholder="All namespaces"
         onChange={(v) => onChange('namespace', v || undefined)}
       />
+      {isDesktop && (
+        <ConfigToggle
+          label="Reopen on the last used cluster"
+          description="Come back to the cluster you were working in. Turn off to use your kubeconfig's current context on the next Desktop start."
+          value={config.restoreLastDesktopContext ?? true}
+          onChange={(v) => onChange('restoreLastDesktopContext', v ? undefined : false)}
+        />
+      )}
     </>
   )
 }

package/src/components/ui/ErrorBoundary.test.tsx

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest'
+
+import { ErrorBoundary } from './ErrorBoundary'
+
+// Navigating re-renders this boundary rather than remounting it, so a boundary
+// that only latched would keep the fallback on screen for the rest of the
+// session. These drive the lifecycle hooks directly - a caught error needs a
+// real render loop, which the SSR-string tests used elsewhere here cannot give.
+const caught = (resetKey: string) => ({
+  hasError: true,
+  error: new Error("Cannot read properties of undefined (reading 'nodeCount')"),
+  resetKey,
+})
+
+describe('ErrorBoundary reset', () => {
+  it('clears a caught error when resetKey changes', () => {
+    expect(ErrorBoundary.getDerivedStateFromProps({ children: null, resetKey: '/topology' }, caught('/'))).toEqual({
+      hasError: false,
+      error: null,
+      resetKey: '/topology',
+    })
+  })
+
+  it('clears it when only a later path segment changes', () => {
+    // The view is just the first path segment, so /resources/pods and
+    // /resources/services are the same view. Resetting per view would leave a
+    // crash under /resources trapping the user as they switch kinds.
+    const next = ErrorBoundary.getDerivedStateFromProps(
+      { children: null, resetKey: '/resources/services' },
+      caught('/resources/pods'),
+    )
+    expect(next?.hasError).toBe(false)
+  })
+
+  it('clears it when only the query changes', () => {
+    // Selection rides in the query, so a path-only key would strand a crash on
+    // the view that produced it.
+    const next = ErrorBoundary.getDerivedStateFromProps(
+      { children: null, resetKey: '/resources/pods?resource=kube-system/coredns' },
+      caught('/resources/pods'),
+    )
+    expect(next?.hasError).toBe(false)
+  })
+
+  it('holds the error while resetKey is unchanged', () => {
+    expect(ErrorBoundary.getDerivedStateFromProps({ children: null, resetKey: '/' }, caught('/'))).toBeNull()
+  })
+
+  it('records the error', () => {
+    expect(ErrorBoundary.getDerivedStateFromError(new Error('boom'))).toEqual({
+      hasError: true,
+      error: new Error('boom'),
+    })
+  })
+})