@skyhook-io/radar-app 1.8.3 → 1.8.6

package/src/RadarApp.tsx

@@ -25,6 +25,7 @@ import { ThemeProvider } from './context/ThemeContext';
 import { ToastProvider, showApiError, showApiSuccess } from './components/ui/Toast';
 import { setApiBase, setBasename } from './api/config';
 import { NavCustomizationProvider } from './context/NavCustomization';
+import { FilterLocationBridge } from './filter/FilterLocationBridge';
 import type { NavCustomization } from './context/NavCustomization';
 
 // Declare the shape of mutation meta here — inlined rather than in a
@@ -153,7 +154,9 @@ export function RadarApp({
       <QueryClientProvider client={client}>
         <ToastProvider>
           <NavCustomizationProvider value={navSlots}>
-            <App manageDocumentTitle={manageDocumentTitle} documentTitleSuffix={documentTitleSuffix} />
+            <FilterLocationBridge>
+              <App manageDocumentTitle={manageDocumentTitle} documentTitleSuffix={documentTitleSuffix} />
+            </FilterLocationBridge>
           </NavCustomizationProvider>
         </ToastProvider>
       </QueryClientProvider>

package/src/api/client.metrics.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it } from 'vitest'
+import {
+  ApiError,
+  getVisibleLiveMetrics,
+  isMetricsUnavailableError,
+  isLiveMetricsUnavailable,
+  normalizeNodeMetricsHistory,
+  normalizePodMetricsHistory,
+  shouldFetchLiveMetrics,
+} from './client'
+
+describe('metrics unavailable classification', () => {
+  it('only treats metrics-shaped API failures as metrics unavailable', () => {
+    expect(isMetricsUnavailableError(new ApiError('Node metrics not found (metrics-server may not be installed)', 404))).toBe(true)
+    expect(isMetricsUnavailableError(new ApiError('the server could not find the requested resource (get nodes.metrics.k8s.io)', 500))).toBe(true)
+    expect(isMetricsUnavailableError(new ApiError('failed to get node metrics: the server could not find the requested resource', 500))).toBe(true)
+    expect(isMetricsUnavailableError(new ApiError('the server is currently unable to handle the request (get nodes.metrics.k8s.io)', 500))).toBe(true)
+    expect(isMetricsUnavailableError(new ApiError('the server could not find the requested resource', 500))).toBe(false)
+    expect(isMetricsUnavailableError(new ApiError('no access to nodes', 403))).toBe(false)
+    expect(isMetricsUnavailableError(new ApiError('metrics-server forbidden', 500))).toBe(false)
+    expect(isMetricsUnavailableError(new ApiError('database unavailable', 500))).toBe(false)
+  })
+
+  it('uses the server-owned unavailable flag for history responses', () => {
+    const podHistory = normalizePodMetricsHistory({
+      namespace: 'default',
+      name: 'api',
+      containers: [],
+      metricsUnavailable: true,
+      collectionError: 'the server could not find the requested resource (get pods.metrics.k8s.io)',
+      rawCollectionError: 'the server could not find the requested resource',
+      metricsUnavailableDiagnosis: 'The v1beta1.metrics.k8s.io APIService is not registered. Install metrics-server or restore that APIService.',
+    })
+    expect(podHistory.collectionError).toBeUndefined()
+    expect(podHistory.rawCollectionError).toBeUndefined()
+    expect(podHistory.metricsUnavailable).toBe(true)
+    expect(podHistory.metricsUnavailableReason).toBe('the server could not find the requested resource')
+    expect(podHistory.metricsUnavailableDiagnosis).toBe('The v1beta1.metrics.k8s.io APIService is not registered. Install metrics-server or restore that APIService.')
+
+    const nodeHistory = normalizeNodeMetricsHistory({
+      name: 'kind-worker',
+      dataPoints: [],
+      metricsUnavailable: true,
+      collectionError: 'Node metrics not found (metrics-server may not be installed)',
+      rawCollectionError: 'the server could not find the requested resource',
+      metricsUnavailableDiagnosis: 'The v1beta1.metrics.k8s.io APIService is not Available (FailedDiscoveryCheck). Check the metrics-server Service, endpoints, and API aggregation/TLS configuration.',
+    })
+    expect(nodeHistory.collectionError).toBeUndefined()
+    expect(nodeHistory.rawCollectionError).toBeUndefined()
+    expect(nodeHistory.metricsUnavailable).toBe(true)
+    expect(nodeHistory.metricsUnavailableReason).toBe('the server could not find the requested resource')
+    expect(nodeHistory.metricsUnavailableDiagnosis).toBe('The v1beta1.metrics.k8s.io APIService is not Available (FailedDiscoveryCheck). Check the metrics-server Service, endpoints, and API aggregation/TLS configuration.')
+  })
+
+  it('does not infer history unavailability from collection-error copy', () => {
+    const history = normalizeNodeMetricsHistory({
+      name: 'kind-worker',
+      dataPoints: [],
+      collectionError: 'Node metrics not found (metrics-server may not be installed)',
+      rawCollectionError: 'the server could not find the requested resource',
+    })
+    expect(history.collectionError).toBe('Node metrics not found (metrics-server may not be installed)')
+    expect(history.rawCollectionError).toBe('the server could not find the requested resource')
+    expect(history.metricsUnavailable).toBeUndefined()
+    expect(history.metricsUnavailableReason).toBeUndefined()
+  })
+
+  it('keeps non-metrics collection errors visible', () => {
+    const history = normalizeNodeMetricsHistory({
+      name: 'kind-worker',
+      dataPoints: [],
+      collectionError: 'forbidden: no access to nodes',
+    })
+    expect(history.collectionError).toBe('forbidden: no access to nodes')
+    expect(history.metricsUnavailable).toBeUndefined()
+  })
+
+  it('keeps generic not-found collection errors visible without a metrics API signal', () => {
+    const history = normalizeNodeMetricsHistory({
+      name: 'kind-worker',
+      dataPoints: [],
+      collectionError: 'the server could not find the requested resource',
+    })
+    expect(history.collectionError).toBe('the server could not find the requested resource')
+    expect(history.metricsUnavailable).toBeUndefined()
+  })
+
+  it('waits for history classification before live metrics fetches', () => {
+    expect(shouldFetchLiveMetrics(false, false)).toBe(false)
+    expect(shouldFetchLiveMetrics(true, false)).toBe(true)
+    expect(shouldFetchLiveMetrics(true, true)).toBe(false)
+  })
+
+  it('does not expose cached live metrics while the live query is disabled', () => {
+    const cachedMetrics = { usage: { cpu: '10m', memory: '20Mi' } }
+    expect(getVisibleLiveMetrics(false, false, cachedMetrics)).toBeUndefined()
+    expect(getVisibleLiveMetrics(true, true, cachedMetrics)).toBeUndefined()
+    expect(getVisibleLiveMetrics(true, false, cachedMetrics)).toBe(cachedMetrics)
+  })
+
+  it('treats null live metrics as unavailable only after live fetch is enabled', () => {
+    expect(isLiveMetricsUnavailable(false, null)).toBe(false)
+    expect(isLiveMetricsUnavailable(true, null)).toBe(true)
+    expect(isLiveMetricsUnavailable(true, undefined)).toBe(false)
+  })
+})

package/src/api/client.ts

@@ -17,6 +17,7 @@ import type {
   HelmValues,
   ManifestDiff,
   NotesDiff,
+  HooksDiff,
   ResourceDiff,
   UpgradeInfo,
   BatchUpgradeInfo,
@@ -35,6 +36,15 @@ import type { GitOpsOperationResponse } from '../types/gitops'
 import { getApiBase, getAuthHeaders, getCredentialsMode, getBasename, routePath } from './config'
 import { pluralToKind } from '../utils/navigation'
 
+// Auto-refresh cadences (ms) — named constants for each polled hook's
+// refetchInterval below, so the poll rate reads clearly at each call site.
+const DASHBOARD_REFRESH_INTERVAL_MS = 30_000
+const AUDIT_REFRESH_INTERVAL_MS = 60_000
+const ISSUES_REFRESH_INTERVAL_MS = 30_000
+const COST_REFRESH_INTERVAL_MS = 60_000
+const CHANGES_REFRESH_INTERVAL_MS = 60_000
+const APPLICATIONS_REFRESH_INTERVAL_MS = 60_000
+
 // Wrapper around fetch that always includes credentials (for session cookies)
 // and handles 401 responses globally. Merges caller-provided headers with
 // auth headers from the config module so library consumers (Radar Hub) can
@@ -93,6 +103,47 @@ export function isForbiddenError(error: unknown): boolean {
   return error instanceof ApiError && error.status === 403
 }
 
+const METRICS_API_GROUP_TOKENS = ['metrics', 'k8s', 'io'] as const
+
+function mentionsMetricsAPIGroup(message: string): boolean {
+  const tokens = message.split(/[^a-z0-9]+/).filter(Boolean)
+  return tokens.some((token, index) => (
+    token === METRICS_API_GROUP_TOKENS[0] &&
+    tokens[index + 1] === METRICS_API_GROUP_TOKENS[1] &&
+    tokens[index + 2] === METRICS_API_GROUP_TOKENS[2]
+  ))
+}
+
+function hasMetricsUnavailablePhrase(message: string): boolean {
+  return (
+    message.includes('may not be installed') ||
+    message.includes('not found') ||
+    message.includes('could not find the requested resource') ||
+    message.includes('no matches for kind') ||
+    message.includes('no resource matches') ||
+    message.includes('no metrics known') ||
+    message.includes('not available') ||
+    message.includes('unable to fetch metrics') ||
+    message.includes('currently unable to handle the request')
+  )
+}
+
+export function isMetricsUnavailableError(error: unknown): boolean {
+  if (!(error instanceof ApiError)) return false
+  if (error.status !== 404 && error.status !== 500) return false
+  return [error.message, error.data?.error].some((message) => {
+    if (typeof message !== 'string') return false
+    const normalized = message.toLowerCase()
+    const hasMetricsSignal = (
+      normalized.includes('metrics-server') ||
+      mentionsMetricsAPIGroup(normalized) ||
+      normalized.includes('pod metrics') ||
+      normalized.includes('node metrics')
+    )
+    return hasMetricsSignal && hasMetricsUnavailablePhrase(normalized)
+  })
+}
+
 export async function fetchJSON<T>(path: string, signal?: AbortSignal): Promise<T> {
   const response = await apiFetch(`${getApiBase()}${path}`, signal ? { signal } : undefined)
   if (!response.ok) {
@@ -326,7 +377,7 @@ export function useDashboard(namespaces: string[] = []) {
     queryKey: ['dashboard', namespaces],
     queryFn: () => fetchJSON(`/dashboard${params}`),
     staleTime: 15000, // 15 seconds
-    refetchInterval: 30000, // Refresh every 30 seconds
+    refetchInterval: DASHBOARD_REFRESH_INTERVAL_MS,
   })
 }
 
@@ -337,7 +388,7 @@ export function useAudit(namespaces: string[] = []) {
     queryKey: ['audit', namespaces],
     queryFn: () => fetchJSON(`/audit${params}`),
     staleTime: 30000,
-    refetchInterval: 60000,
+    refetchInterval: AUDIT_REFRESH_INTERVAL_MS,
     placeholderData: (prev) => prev,
   })
 }
@@ -368,7 +419,7 @@ export function useIssues(namespaces: string[] = []) {
     queryKey: ['issues', namespaces],
     queryFn: () => fetchJSON(`/issues${params}`),
     staleTime: 30000,
-    refetchInterval: 30000,
+    refetchInterval: ISSUES_REFRESH_INTERVAL_MS,
   })
 }
 
@@ -516,7 +567,7 @@ export function useOpenCostSummary() {
   return useQuery<OpenCostSummary>({
     queryKey: ['opencost-summary'],
     queryFn: () => fetchJSON('/opencost/summary'),
-    refetchInterval: 60000, // Refresh every minute
+    refetchInterval: COST_REFRESH_INTERVAL_MS,
     staleTime: 30000,
     placeholderData: (prev) => prev, // Keep previous data visible during refetch
   })
@@ -954,7 +1005,7 @@ export function useApplications(namespaces: string[]) {
     queryKey: ['applications', namespaces],
     queryFn: () => fetchJSON(`/applications${queryString ? `?${queryString}` : ''}`),
     staleTime: 30_000,
-    refetchInterval: 60_000,
+    refetchInterval: APPLICATIONS_REFRESH_INTERVAL_MS,
   })
 }
 
@@ -1113,7 +1164,7 @@ export function useChanges(options: UseChangesOptions = {}) {
     queryKey: ['changes', namespaces, kind, timeRange, filter, includeK8sEvents, includeManaged, includeDeleted, limit],
     queryFn: () => fetchJSON(`/changes${queryString ? `?${queryString}` : ''}`),
     staleTime: 5000, // Consider data stale after 5 seconds to ensure fresh data on navigation
-    refetchInterval: 60000, // SSE handles real-time updates; this is a fallback
+    refetchInterval: CHANGES_REFRESH_INTERVAL_MS, // SSE handles real-time updates; this is a fallback
     enabled,
   })
 }
@@ -1243,25 +1294,44 @@ export interface NodeMetrics {
   }
 }
 
+async function fetchMetricsOrNull<T>(path: string): Promise<T | null> {
+  try {
+    return await fetchJSON<T>(path)
+  } catch (error) {
+    if (isMetricsUnavailableError(error)) return null
+    throw error
+  }
+}
+
+function retryMetricsQuery(failureCount: number, error: unknown): boolean {
+  return !isMetricsUnavailableError(error) && failureCount < 1
+}
+
 // Fetch metrics for a specific pod
-export function usePodMetrics(namespace: string, podName: string) {
-  return useQuery<PodMetrics>({
+export function usePodMetrics(namespace: string, podName: string, options?: { enabled?: boolean }) {
+  return useQuery<PodMetrics | null>({
     queryKey: ['pod-metrics', namespace, podName],
-    queryFn: () => fetchJSON(`/metrics/pods/${namespace}/${podName}`),
-    enabled: Boolean(namespace && podName),
-    staleTime: 15000, // Metrics are fresh for 15 seconds
-    refetchInterval: 30000, // Refresh every 30 seconds
+    queryFn: () => fetchMetricsOrNull<PodMetrics>(`/metrics/pods/${namespace}/${podName}`),
+    enabled: Boolean(namespace && podName) && (options?.enabled ?? true),
+    staleTime: 15000,
+    refetchInterval: 30000,
+    refetchOnMount: 'always',
+    refetchOnReconnect: 'always',
+    retry: retryMetricsQuery,
   })
 }
 
 // Fetch metrics for a specific node
-export function useNodeMetrics(nodeName: string) {
-  return useQuery<NodeMetrics>({
+export function useNodeMetrics(nodeName: string, options?: { enabled?: boolean }) {
+  return useQuery<NodeMetrics | null>({
     queryKey: ['node-metrics', nodeName],
-    queryFn: () => fetchJSON(`/metrics/nodes/${nodeName}`),
-    enabled: Boolean(nodeName),
+    queryFn: () => fetchMetricsOrNull<NodeMetrics>(`/metrics/nodes/${nodeName}`),
+    enabled: Boolean(nodeName) && (options?.enabled ?? true),
     staleTime: 15000,
     refetchInterval: 30000,
+    refetchOnMount: 'always',
+    refetchOnReconnect: 'always',
+    retry: retryMetricsQuery,
   })
 }
 
@@ -1285,19 +1355,57 @@ export interface PodMetricsHistory {
   name: string
   containers: ContainerMetricsHistory[]
   collectionError?: string
+  rawCollectionError?: string
+  metricsUnavailableDiagnosis?: string
+  metricsUnavailable?: boolean
+  metricsUnavailableReason?: string
 }
 
 export interface NodeMetricsHistory {
   name: string
   dataPoints: MetricsDataPoint[]
   collectionError?: string
+  rawCollectionError?: string
+  metricsUnavailableDiagnosis?: string
+  metricsUnavailable?: boolean
+  metricsUnavailableReason?: string
+}
+
+function withoutCollectionError<T extends { collectionError?: string; rawCollectionError?: string }>(history: T): T {
+  const next = { ...history }
+  delete next.collectionError
+  delete next.rawCollectionError
+  return next
+}
+
+export function normalizePodMetricsHistory(history: PodMetricsHistory): PodMetricsHistory {
+  if (history.metricsUnavailable !== true) return history
+  return { ...withoutCollectionError(history), metricsUnavailable: true, metricsUnavailableReason: history.rawCollectionError || history.collectionError }
+}
+
+export function normalizeNodeMetricsHistory(history: NodeMetricsHistory): NodeMetricsHistory {
+  if (history.metricsUnavailable !== true) return history
+  return { ...withoutCollectionError(history), metricsUnavailable: true, metricsUnavailableReason: history.rawCollectionError || history.collectionError }
+}
+
+export function shouldFetchLiveMetrics(historySettled: boolean, metricsUnavailable: boolean): boolean {
+  return historySettled && !metricsUnavailable
+}
+
+export function isLiveMetricsUnavailable(liveMetricsEnabled: boolean, metrics: unknown): boolean {
+  return liveMetricsEnabled && metrics === null
+}
+
+export function getVisibleLiveMetrics<T>(liveMetricsEnabled: boolean, metricsUnavailable: boolean, metrics: T | null | undefined): T | undefined {
+  if (!liveMetricsEnabled || metricsUnavailable) return undefined
+  return metrics ?? undefined
 }
 
 // Fetch historical metrics for a pod (last ~1 hour)
 export function usePodMetricsHistory(namespace: string, podName: string) {
   return useQuery<PodMetricsHistory>({
     queryKey: ['pod-metrics-history', namespace, podName],
-    queryFn: () => fetchJSON(`/metrics/pods/${namespace}/${podName}/history`),
+    queryFn: async () => normalizePodMetricsHistory(await fetchJSON<PodMetricsHistory>(`/metrics/pods/${namespace}/${podName}/history`)),
     enabled: Boolean(namespace && podName),
     staleTime: 25000, // Slightly less than poll interval
     refetchInterval: 30000, // Match the backend poll interval
@@ -1308,7 +1416,7 @@ export function usePodMetricsHistory(namespace: string, podName: string) {
 export function useNodeMetricsHistory(nodeName: string) {
   return useQuery<NodeMetricsHistory>({
     queryKey: ['node-metrics-history', nodeName],
-    queryFn: () => fetchJSON(`/metrics/nodes/${nodeName}/history`),
+    queryFn: async () => normalizeNodeMetricsHistory(await fetchJSON<NodeMetricsHistory>(`/metrics/nodes/${nodeName}/history`)),
     enabled: Boolean(nodeName),
     staleTime: 25000,
     refetchInterval: 30000,
@@ -1545,9 +1653,12 @@ export function useAutoPromConnect(): void {
     const timeout = window.setTimeout(() => {
       // Direct apiFetch (not via the usePrometheusConnect mutation) so the
       // meta-driven toast handler stays silent — the user didn't click anything.
-      apiFetch(`${getApiBase()}/prometheus/connect`, { method: 'POST' })
-        .then(resp => {
+      apiFetch(`${getApiBase()}/prometheus/connect?optional=true`, { method: 'POST' })
+        .then(async resp => {
           if (!resp.ok) throw new Error(`HTTP ${resp.status}`)
+          const nextStatus = await resp.json() as PrometheusStatus
+          queryClient.setQueryData(['prometheus-status'], nextStatus)
+          if (!nextStatus.connected) throw new Error(nextStatus.error || 'Prometheus unavailable')
           queryClient.invalidateQueries({ queryKey: ['prometheus-status'] })
         })
         .catch(() => {
@@ -2452,6 +2563,22 @@ export function useHelmNotesDiff(
   })
 }
 
+export function useHelmHooksDiff(
+  namespace: string,
+  name: string,
+  revision1: number,
+  revision2: number,
+  enabled = true,
+) {
+  return useQuery<HooksDiff>({
+    queryKey: ['helm-hooks-diff', namespace, name, revision1, revision2],
+    queryFn: () =>
+      fetchJSON(`/helm/releases/${namespace}/${name}/hooks/diff?revision1=${revision1}&revision2=${revision2}`),
+    enabled: Boolean(namespace && name && revision1 > 0 && revision2 > 0 && revision1 !== revision2 && enabled),
+    staleTime: 60000,
+  })
+}
+
 export function useHelmResourceDiff(
   namespace: string,
   name: string,

package/src/components/ConnectionErrorView.tsx

@@ -254,7 +254,7 @@ export function ConnectionErrorView({ connection, onRetry, isRetrying }: Connect
 
           {connection.error && (
             <div className="w-full bg-theme-elevated border border-theme-border rounded-lg p-3 mb-6 overflow-auto max-h-32">
-              <code className="text-xs text-red-400 font-mono whitespace-pre-wrap break-all">
+              <code className="text-xs text-red-400 font-mono whitespace-pre-wrap break-words">
                 {connection.error}
               </code>
             </div>

package/src/components/ContextSwitcher.tsx

@@ -14,6 +14,8 @@ import { parseContextName, type ParsedContextName } from '../utils/context-name'
 
 interface ContextSwitcherProps {
   className?: string
+  variant?: 'chip' | 'segment'
+  label?: string
 }
 
 export interface ContextSwitcherHandle {
@@ -24,7 +26,7 @@ interface ParsedContext extends ParsedContextName {
   context: ContextInfo
 }
 
-export const ContextSwitcher = forwardRef<ContextSwitcherHandle, ContextSwitcherProps>(({ className = '' }, ref) => {
+export const ContextSwitcher = forwardRef<ContextSwitcherHandle, ContextSwitcherProps>(({ className = '', variant, label }, ref) => {
   const [showConfirm, setShowConfirm] = useState(false)
   const [pendingSwitch, setPendingSwitch] = useState<ParsedContext | null>(null)
   const [sessionCounts, setSessionCounts] = useState<SessionCounts | null>(null)
@@ -191,6 +193,8 @@ export const ContextSwitcher = forwardRef<ContextSwitcherHandle, ContextSwitcher
       <ClusterSwitcher
         ref={ref}
         className={className}
+        variant={variant}
+        label={label}
         currentId={currentId}
         currentName={currentRaw}
         currentSourceLabel={currentSourceLabel}