@skyhook-io/radar-app 1.8.0 → 1.8.2

package/src/components/ui/ShortcutHelpOverlay.tsx

@@ -29,7 +29,7 @@ const VIEW_LABELS: Record<string, string> = {
   timeline: 'Timeline',
   helm: 'Helm',
   gitops: 'GitOps',
-  traffic: 'Traffic',
+  traffic: 'Live Traffic',
 }
 
 type ShortcutEntry = { description: string; keys: string[] }

package/src/components/ui/command-items.ts

@@ -91,7 +91,7 @@ const VIEW_ENTRIES: { view: MainView; label: string; icon: React.ComponentType<{
   { view: 'timeline', label: 'Timeline', icon: Clock, shortcut: 'g l' },
   { view: 'helm', label: 'Helm', icon: Package, shortcut: 'g m' },
   { view: 'gitops', label: 'GitOps', icon: GitBranch, shortcut: 'g o' },
-  { view: 'traffic', label: 'Traffic', icon: Activity, shortcut: 'g f' },
+  { view: 'traffic', label: 'Live Traffic', icon: Activity, shortcut: 'g f' },
   { view: 'checks', label: 'Checks', icon: ShieldCheck, shortcut: 'g u' },
   { view: 'cost', label: 'Cost', icon: DollarSign, shortcut: 'g c' },
 ]

package/src/components/workload/WorkloadView.tsx

@@ -199,45 +199,45 @@ function useActionsBarProps(kind: string, namespace: string, name: string) {
     renderPortForward: ({ type, namespace: ns, name: n, className }: { type: 'pod' | 'service'; namespace: string; name: string; className?: string }) => (
       <PortForwardButton type={type} namespace={ns} name={n} className={className} />
     ),
-    onDelete: (params: any, callbacks?: any) => deleteMutation.mutate(params, { onSuccess: callbacks?.onSuccess }),
+    onDelete: (params: Parameters<typeof deleteMutation.mutate>[0], callbacks?: { onSuccess?: () => void }) => deleteMutation.mutate(params, { onSuccess: callbacks?.onSuccess }),
     isDeleting: deleteMutation.isPending,
     cascadeDependents: cascadePreview?.dependents,
     cascadeLoading,
-    onRestart: (params: any) => restartWorkloadMutation.mutate(params),
+    onRestart: (params: Parameters<typeof restartWorkloadMutation.mutate>[0]) => restartWorkloadMutation.mutate(params),
     isRestarting: restartWorkloadMutation.isPending,
     revisions: revisionsList,
     revisionsLoading,
     revisionsError: revisionsError ?? null,
-    onRollback: (params: any, callbacks?: any) => rollbackMutation.mutate(params, { onSuccess: callbacks?.onSuccess }),
+    onRollback: (params: Parameters<typeof rollbackMutation.mutate>[0], callbacks?: { onSuccess?: () => void }) => rollbackMutation.mutate(params, { onSuccess: callbacks?.onSuccess }),
     isRollingBack: rollbackMutation.isPending,
-    onTriggerCronJob: (params: any) => triggerCronJobMutation.mutate(params),
+    onTriggerCronJob: (params: Parameters<typeof triggerCronJobMutation.mutate>[0]) => triggerCronJobMutation.mutate(params),
     isTriggeringCronJob: triggerCronJobMutation.isPending,
-    onSuspendCronJob: (params: any) => suspendCronJobMutation.mutate(params),
+    onSuspendCronJob: (params: Parameters<typeof suspendCronJobMutation.mutate>[0]) => suspendCronJobMutation.mutate(params),
     isSuspendingCronJob: suspendCronJobMutation.isPending,
-    onResumeCronJob: (params: any) => resumeCronJobMutation.mutate(params),
+    onResumeCronJob: (params: Parameters<typeof resumeCronJobMutation.mutate>[0]) => resumeCronJobMutation.mutate(params),
     isResumingCronJob: resumeCronJobMutation.isPending,
-    onFluxReconcile: (params: any) => fluxReconcileMutation.mutate(params),
+    onFluxReconcile: (params: Parameters<typeof fluxReconcileMutation.mutate>[0]) => fluxReconcileMutation.mutate(params),
     isFluxReconciling: fluxReconcileMutation.isPending,
-    onFluxSyncWithSource: (params: any) => fluxSyncWithSourceMutation.mutate(params),
+    onFluxSyncWithSource: (params: Parameters<typeof fluxSyncWithSourceMutation.mutate>[0]) => fluxSyncWithSourceMutation.mutate(params),
     isFluxSyncing: fluxSyncWithSourceMutation.isPending,
-    onFluxSuspend: (params: any) => fluxSuspendMutation.mutate(params),
+    onFluxSuspend: (params: Parameters<typeof fluxSuspendMutation.mutate>[0]) => fluxSuspendMutation.mutate(params),
     isFluxSuspending: fluxSuspendMutation.isPending,
-    onFluxResume: (params: any) => fluxResumeMutation.mutate(params),
+    onFluxResume: (params: Parameters<typeof fluxResumeMutation.mutate>[0]) => fluxResumeMutation.mutate(params),
     isFluxResuming: fluxResumeMutation.isPending,
-    onArgoSync: (params: any) => argoSyncMutation.mutate(params),
+    onArgoSync: (params: Parameters<typeof argoSyncMutation.mutate>[0]) => argoSyncMutation.mutate(params),
     isArgoSyncing: argoSyncMutation.isPending,
-    onArgoRefresh: (params: any) => argoRefreshMutation.mutate(params),
+    onArgoRefresh: (params: Parameters<typeof argoRefreshMutation.mutate>[0]) => argoRefreshMutation.mutate(params),
     isArgoRefreshing: argoRefreshMutation.isPending,
-    onArgoSuspend: (params: any) => argoSuspendMutation.mutate(params),
+    onArgoSuspend: (params: Parameters<typeof argoSuspendMutation.mutate>[0]) => argoSuspendMutation.mutate(params),
     isArgoSuspending: argoSuspendMutation.isPending,
-    onArgoResume: (params: any) => argoResumeMutation.mutate(params),
+    onArgoResume: (params: Parameters<typeof argoResumeMutation.mutate>[0]) => argoResumeMutation.mutate(params),
     isArgoResuming: argoResumeMutation.isPending,
     canNodeWrite,
-    onCordonNode: (params: any) => cordonMutation.mutate(params),
+    onCordonNode: (params: Parameters<typeof cordonMutation.mutate>[0]) => cordonMutation.mutate(params),
     isCordoningNode: cordonMutation.isPending,
-    onUncordonNode: (params: any) => uncordonMutation.mutate(params),
+    onUncordonNode: (params: Parameters<typeof uncordonMutation.mutate>[0]) => uncordonMutation.mutate(params),
     isUncordoningNode: uncordonMutation.isPending,
-    onDrainNode: (params: any) => drainMutation.mutate(params),
+    onDrainNode: (params: Parameters<typeof drainMutation.mutate>[0]) => drainMutation.mutate(params),
     isDrainingNode: drainMutation.isPending,
   }
 }

package/src/context/ConnectionContext.tsx

@@ -62,6 +62,22 @@ export function ConnectionProvider({ children }: { children: ReactNode }) {
   // Track if SSE has started delivering connection_state events
   // Once SSE is active, it becomes the authoritative source for connection state
   const sseActiveRef = useRef(false)
+  // Track whether we've reached 'connected' at least once. Distinguishes the
+  // initial connect (bootstrap queries already fetched while 'connecting') from
+  // a reconnect after a drop (cache may be stale across the gap).
+  const hasConnectedRef = useRef(false)
+  // Whether the QueryClient already held data when this provider mounted. A host
+  // can share one client across cluster-scoped RadarApp mounts (see RadarApp's
+  // `queryClient` prop); that client may carry another cluster's data under
+  // identical keys, so a warm-at-mount cache must be fully refreshed on first
+  // connect. A cold cache (standalone, or a per-cluster remount) takes the cheap
+  // error-only path. Snapshot synchronously before this provider's own query
+  // registers — ConnectionProvider is the outermost provider, so a fresh client
+  // is genuinely empty here.
+  const cacheWarmAtMountRef = useRef<boolean | null>(null)
+  if (cacheWarmAtMountRef.current === null) {
+    cacheWarmAtMountRef.current = queryClient.getQueryCache().getAll().length > 0
+  }
 
   // Fetch initial connection status
   // Poll while connecting to get progress updates (SSE not established yet)
@@ -143,9 +159,20 @@ export function ConnectionProvider({ children }: { children: ReactNode }) {
       return status
     })
 
-    // If we just connected, invalidate queries to fetch fresh data
     if (status.state === 'connected') {
-      queryClient.invalidateQueries()
+      const firstConnect = !hasConnectedRef.current
+      hasConnectedRef.current = true
+      // A reconnect after a drop (cache stale across the gap), or a first connect
+      // onto a client that already carried data at mount (shared across clusters),
+      // refreshes the whole cache. A clean first connect only needs to recover the
+      // bootstrap queries that 503'd while the cluster was still 'connecting'
+      // (status === 'error'); the rest already fetched fresh during 'connecting',
+      // so re-fetching the whole cache there would double-load every endpoint.
+      if (!firstConnect || cacheWarmAtMountRef.current) {
+        queryClient.invalidateQueries()
+      } else {
+        queryClient.invalidateQueries({ predicate: (q) => q.state.status === 'error' })
+      }
     }
   }, [queryClient])
 

package/src/main.tsx

@@ -130,7 +130,7 @@ document.execCommand = function (command: string, showUI?: boolean, value?: stri
         dt.setData('text/plain', text)
         const ev = new ClipboardEvent('paste', { clipboardData: dt, bubbles: true, cancelable: true })
         if (!el.dispatchEvent(ev)) return
-      } catch (_e) { /* ClipboardEvent dispatch failed, fall back to insertText */ }
+      } catch { /* ClipboardEvent dispatch failed, fall back to insertText */ }
       _origExecCommand('insertText', false, text)
     }).catch((err) => { console.warn('[Radar] Paste failed:', err) })
     return true