@skyhook-io/radar-app 1.10.0 → 1.12.2

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

@@ -0,0 +1,115 @@
+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)`')
+  })
+})
+
+describe('formatForGitHub kubeconfig section', () => {
+  it('reports combined source counts and ignored ambient configuration', () => {
+    const md = formatForGitHub({
+      ...baseSnapshot,
+      kubeconfig: {
+        mode: 'multi-source',
+        fileCount: 3,
+        directoryFileCount: 2,
+        contextCount: 7,
+        enrichedFromShell: true,
+        kubeconfigEnvIgnored: true,
+        kubeconfigEnvIgnoredReason: 'directories-only configuration',
+        currentContextUsesExec: false,
+      },
+    }, undefined, false)
+
+    expect(md).toContain('Mode: `multi-source` | Files: 3 | Directory Files: 2 | Contexts (after source resolution): 7')
+    expect(md).toContain('KUBECONFIG Captured From Shell: Yes | Ignored: Yes — directories-only configuration')
+  })
+
+  it('omits directory counts for environment path lists', () => {
+    const md = formatForGitHub({
+      ...baseSnapshot,
+      kubeconfig: {
+        mode: 'multi-env',
+        fileCount: 2,
+        directoryFileCount: 0,
+        contextCount: 4,
+        enrichedFromShell: false,
+        kubeconfigEnvIgnored: false,
+        kubeconfigEnvIgnoredReason: '',
+        currentContextUsesExec: true,
+      },
+    }, undefined, false)
+
+    expect(md).toContain('Mode: `multi-env` | Files: 2 | Contexts (after source resolution): 4')
+    expect(md).not.toContain('Directory Files:')
+  })
+})

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 && (
@@ -170,10 +171,10 @@ function Section({ title, children, warn }: { title: string; children: React.Rea
 
 function Row({ label, value, warn }: { label: string; value: React.ReactNode; warn?: boolean }) {
   return (
-    <div className="flex items-baseline justify-between gap-4 text-xs">
+    <div className="flex items-start justify-between gap-4 text-xs">
       <span className="text-theme-text-secondary shrink-0">{label}</span>
       <span className={clsx(
-        'text-right truncate',
+        'min-w-0 text-right break-words',
         warn ? 'text-yellow-400' : 'text-theme-text-primary'
       )}>{value}</span>
     </div>
@@ -218,11 +219,19 @@ function KubeconfigSection({ data }: { data: DiagnosticsSnapshot }) {
   const present = k.execPluginsPresent ?? []
   const hasMissing = missing.length > 0
   return (
-    <Section title="Kubeconfig" warn={hasMissing}>
+    <Section title="Kubeconfig" warn={hasMissing || k.kubeconfigEnvIgnored}>
       <Row label="Mode" value={k.mode || '(not initialized)'} />
       <Row label="Files Loaded" value={k.fileCount} />
-      <Row label="Contexts (post-merge)" value={k.contextCount} />
-      <Row label="Enriched From Shell" value={k.enrichedFromShell ? 'Yes' : 'No'} />
+      {(k.mode === 'multi-dir' || k.mode === 'multi-source') && (
+        <Row label="Directory Files Loaded" value={k.directoryFileCount} />
+      )}
+      <Row label="Contexts (after source resolution)" value={k.contextCount} />
+      <Row label="KUBECONFIG Captured From Shell" value={k.enrichedFromShell ? 'Yes' : 'No'} />
+      <Row
+        label="KUBECONFIG Ignored"
+        value={k.kubeconfigEnvIgnored ? `Yes — ${k.kubeconfigEnvIgnoredReason}` : 'No'}
+        warn={k.kubeconfigEnvIgnored}
+      />
       <Row
         label="Current Context Uses Exec"
         value={k.currentContextUsesExec ? 'Yes' : 'No'}
@@ -529,6 +538,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 +618,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(``)
@@ -601,7 +639,11 @@ function formatForGitHub(data: DiagnosticsSnapshot, frontendPerf?: K8sUIPerfSnap
   if (data.kubeconfig) {
     const k = data.kubeconfig
     lines.push(`### Kubeconfig`)
-    lines.push(`- Mode: \`${k.mode || '(not initialized)'}\` | Files: ${k.fileCount} | Contexts (post-merge): ${k.contextCount} | Enriched From Shell: ${k.enrichedFromShell ? 'Yes' : 'No'}`)
+    const directoryFiles = k.mode === 'multi-dir' || k.mode === 'multi-source'
+      ? ` | Directory Files: ${k.directoryFileCount}`
+      : ''
+    lines.push(`- Mode: \`${k.mode || '(not initialized)'}\` | Files: ${k.fileCount}${directoryFiles} | Contexts (after source resolution): ${k.contextCount}`)
+    lines.push(`- KUBECONFIG Captured From Shell: ${k.enrichedFromShell ? 'Yes' : 'No'} | Ignored: ${k.kubeconfigEnvIgnored ? `Yes — ${k.kubeconfigEnvIgnoredReason}` : 'No'}`)
     lines.push(`- Current Context Uses Exec: ${k.currentContextUsesExec ? 'Yes' : 'No'}`)
     if (k.execPluginsPresent && k.execPluginsPresent.length > 0) {
       lines.push(`- Exec Plugins on PATH: \`${k.execPluginsPresent.join('`, `')}\``)
@@ -758,6 +800,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/ui/command-items.ts

@@ -8,7 +8,7 @@ import {
   Activity,
   Sun,
   Stethoscope,
-  DollarSign,
+  Coins,
   Gauge,
   ShieldCheck,
   GitBranch,
@@ -19,15 +19,7 @@ import {
 import { useNamespaces, useContexts } from "../../api/client";
 import { CORE_RESOURCES, useAPIResources } from "../../api/apiResources";
 import { getResourceIcon } from "../../utils/resource-icons";
-import { parseContextName } from "../../utils/context-name";
-
-// Drop the disambiguating " (source)" suffix the context list appends, so the
-// GKE/EKS/AKS parser sees the bare context name (mirrors the cluster picker).
-function stripSourceSuffix(name: string, source?: string): string {
-  if (!source) return name;
-  const escaped = source.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return name.replace(new RegExp(`\\s+\\(${escaped}(?:\\s+#\\d+)?\\)$`), "");
-}
+import { parseContextForSwitcher, parseContextName } from "../../utils/context-name";
 
 export type MainView =
   | "home"
@@ -151,7 +143,7 @@ const VIEW_ENTRIES: {
   { view: "traffic", label: "Live Traffic", icon: Activity, shortcut: "g f" },
   { view: "checks", label: "Checks", icon: ShieldCheck, shortcut: "g u" },
   { view: "capacity", label: "Capacity", icon: Gauge, shortcut: "g p" },
-  { view: "cost", label: "Cost", icon: DollarSign, shortcut: "g c" },
+  { view: "cost", label: "Cost", icon: Coins, shortcut: "g c" },
 ];
 
 // The static command-palette items (Views, Resource Kinds, Contexts,
@@ -204,9 +196,7 @@ export function useCommandItems(cb: CommandItemCallbacks): CommandItem[] {
       // it. Count display names so genuine duplicates (same cluster name from
       // different kubeconfig sources) stay distinguishable; unique ones stay clean.
       const parsedCtx = contexts.map((ctx) => {
-        const parsed = parseContextName(
-          stripSourceSuffix(ctx.name, ctx.source),
-        );
+        const parsed = parseContextForSwitcher(ctx);
         const fromCluster = ctx.cluster ? parseContextName(ctx.cluster) : null;
         const meta = [
           parsed.provider ?? fromCluster?.provider,

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,
@@ -1821,7 +1869,7 @@ function DiagnoseTabContent({
   // this is a safety confirm, not an authz check.
   const [pendingRunPath, setPendingRunPath] = useState<string | null>(null)
   const requestInClusterRun = useCallback((path: string) => {
-    if (inClusterConsentGiven(inClusterCap?.cluster)) runInClusterTest(path)
+    if (inClusterConsentGiven(inClusterCap?.clusterKey)) runInClusterTest(path)
     else setPendingRunPath(path)
   }, [inClusterCap, runInClusterTest])
   const confirmInClusterRun = useCallback(() => {
@@ -1943,6 +1991,7 @@ function DiagnoseTabContent({
       <InClusterConsentDialog
         open={pendingRunPath !== null}
         cluster={inClusterCap?.cluster}
+        clusterKey={inClusterCap?.clusterKey}
         namespace={inClusterCap?.namespace ?? namespace}
         requests={consentRequests}
         untestedCount={consentUntestedCount}

package/src/main.tsx

@@ -2,6 +2,7 @@ import React from 'react'
 import ReactDOM from 'react-dom/client'
 import { RadarApp } from './RadarApp'
 import { openExternal } from './utils/navigation'
+import { installWailsClipboardShim } from './utils/wails-clipboard'
 import './index.css'
 
 // Intercept external link clicks in the Wails desktop app.
@@ -17,120 +18,9 @@ window.addEventListener('click', (e: MouseEvent) => {
   openExternal(href)
 })
 
-// === Wails Desktop Clipboard ===
-//
-// Background: The desktop app uses a RedirectHandler that navigates the Wails
-// webview from wails:// to http://localhost:<port>. After the redirect,
-// window.runtime (Wails JS API) is no longer available. Clipboard operations
-// must use navigator.clipboard and DOM events instead.
-//
-// What works and why:
-//   Cmd+C / Cmd+X: Handled in keydown listener below. The Edit menu registers
-//     these accelerators with nil callbacks (native responder chain), but WKWebView
-//     does NOT dispatch a DOM copy/cut event from the native copy: selector.
-//     The keydown event DOES reach JS, so we intercept it here.
-//   Cmd+V: Handled by menu.go's explicit WindowExecJS callback which reads
-//     navigator.clipboard.readText() and dispatches a synthetic paste event.
-//   Right-click Copy/Cut (Monaco): Monaco calls document.execCommand('copy'/'cut'),
-//     intercepted by the monkey-patch below.
-//   Right-click Paste (Monaco): Not supported — Monaco calls navigator.clipboard
-//     .readText() directly (not execCommand), and WKWebView blocks readText() from
-//     page JS context. Use Cmd+V instead.
-
-// Read selected text from Monaco if it has focus. Monaco uses virtual selection
-// (not DOM selection), so window.getSelection() doesn't work — we access the
-// editor instance exposed by YamlEditor.tsx.
-function getMonacoSelection(): { text: string; editor: any } | null {
-  const editor = (window as any).__radarMonacoEditor
-  if (!editor?.hasTextFocus?.()) return null
-  const sel = editor.getSelection()
-  const model = editor.getModel()
-  if (!sel || !model) return null
-  const text = model.getValueInRange(sel)
-  if (!text) return null
-  return { text, editor }
-}
-
-function getSelectedText(): { text: string; monaco: { text: string; editor: any } | null } {
-  const monaco = getMonacoSelection()
-  if (monaco) return { text: monaco.text, monaco }
-  const sel = window.getSelection()
-  const text = sel ? sel.toString() : ''
-  return { text, monaco: null }
-}
-
-function deleteMonacoSelection(editor: any): void {
-  editor.pushUndoStop()
-  editor.executeEdits('cut', [{ range: editor.getSelection(), text: '' }])
-  editor.pushUndoStop()
-}
-
-function handleCopyOrCut(isCut: boolean): void {
-  const { text, monaco } = getSelectedText()
-  if (!text) return
-  navigator.clipboard.writeText(text).catch((err) => { console.warn('[Radar] Clipboard write failed:', err) })
-  if (isCut) {
-    if (monaco) {
-      deleteMonacoSelection(monaco.editor)
-    } else {
-      _origExecCommand('delete')
-    }
-  }
-}
-
-// Cmd+C/X: the menu's nil callback does NOT dispatch a DOM copy event.
-document.addEventListener('keydown', (e) => {
-  if (!(e.metaKey || e.ctrlKey)) return
-  if (e.key !== 'c' && e.key !== 'x') return
-  handleCopyOrCut(e.key === 'x')
-}, true)
-
-// Intercept copy/cut DOM events to handle Monaco's virtual selection.
-// These fire from right-click -> Copy in some contexts. When a real
-// ClipboardEvent is available, we write directly to e.clipboardData
-// (synchronous, more reliable than the async clipboard API).
-document.addEventListener('copy', (e: ClipboardEvent) => {
-  const result = getMonacoSelection()
-  if (result && e.clipboardData) {
-    e.preventDefault()
-    e.clipboardData.setData('text/plain', result.text)
-  }
-}, true)
-
-document.addEventListener('cut', (e: ClipboardEvent) => {
-  const result = getMonacoSelection()
-  if (result && e.clipboardData) {
-    e.preventDefault()
-    e.clipboardData.setData('text/plain', result.text)
-    deleteMonacoSelection(result.editor)
-  }
-}, true)
-
-// Monkey-patch document.execCommand for Wails WebView compatibility.
-// Handles copy/cut from Monaco's right-click context menu, and paste from
-// any context that calls execCommand('paste').
-const _origExecCommand = document.execCommand.bind(document)
-document.execCommand = function (command: string, showUI?: boolean, value?: string) {
-  if (command === 'copy' || command === 'cut') {
-    handleCopyOrCut(command === 'cut')
-    return true
-  }
-  if (command === 'paste') {
-    navigator.clipboard.readText().then((text) => {
-      if (!text) return
-      const el = document.activeElement || document.body
-      try {
-        const dt = new DataTransfer()
-        dt.setData('text/plain', text)
-        const ev = new ClipboardEvent('paste', { clipboardData: dt, bubbles: true, cancelable: true })
-        if (!el.dispatchEvent(ev)) return
-      } catch { /* ClipboardEvent dispatch failed, fall back to insertText */ }
-      _origExecCommand('insertText', false, text)
-    }).catch((err) => { console.warn('[Radar] Paste failed:', err) })
-    return true
-  }
-  return _origExecCommand(command, showUI, value)
-} as typeof document.execCommand
+// Wails desktop clipboard shim — see web/src/utils/wails-clipboard.ts for the
+// full WKWebView background and what each interception exists for.
+installWailsClipboardShim()
 
 // Mouse back/forward button navigation (button 3 = back, button 4 = forward).
 // Uses 'mouseup' in capture phase to intercept before the browser's native handler.

package/src/utils/context-name.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'vitest'
+
+import type { ContextInfo } from '../types'
+import { parseContextForSwitcher, visibleContextQualifier } from './context-name'
+
+function context(name: string, originalName?: string): ContextInfo {
+  return {
+    name,
+    originalName,
+    cluster: 'cluster',
+    user: 'user',
+    namespace: '',
+    isCurrent: false,
+    source: 'eks',
+  }
+}
+
+describe('parseContextForSwitcher', () => {
+  it('preserves provider parsing while separating a backend qualifier', () => {
+    const originalName = 'arn:aws:eks:us-east-1:123456789012:cluster/prod'
+    const parsed = parseContextForSwitcher(context(`${originalName} (eks)`, originalName))
+
+    expect(parsed.provider).toBe('EKS')
+    expect(parsed.clusterName).toBe('prod')
+    expect(parsed.region).toBe('us-east-1')
+    expect(parsed.nameQualifier).toBe('(eks)')
+  })
+
+  it('keeps a qualifier after its colliding sibling disappears', () => {
+    const parsed = parseContextForSwitcher(context('prod (secondary)', 'prod'))
+
+    expect(parsed.raw).toBe('prod')
+    expect(parsed.nameQualifier).toBe('(secondary)')
+  })
+
+  it('does not reinterpret a natural parenthesized name', () => {
+    const parsed = parseContextForSwitcher(context('prod (config)', 'prod (config)'))
+
+    expect(parsed.raw).toBe('prod (config)')
+    expect(parsed.nameQualifier).toBeUndefined()
+  })
+
+  it('uses the visible name for direct single-file contexts', () => {
+    const parsed = parseContextForSwitcher(context('local'))
+
+    expect(parsed.raw).toBe('local')
+    expect(parsed.nameQualifier).toBeUndefined()
+  })
+})
+
+describe('visibleContextQualifier', () => {
+  it('suppresses a qualifier repeated by the visible source label', () => {
+    expect(visibleContextQualifier('(secondary)', 'secondary', true)).toBeUndefined()
+  })
+
+  it('retains qualifiers that distinguish identical source labels', () => {
+    expect(visibleContextQualifier('(secondary #2)', 'secondary', true)).toBe('(secondary #2)')
+  })
+
+  it('retains the qualifier when the source label is hidden', () => {
+    expect(visibleContextQualifier('(secondary)', 'secondary', false)).toBe('(secondary)')
+  })
+})

package/src/utils/context-name.ts

@@ -1,2 +1,24 @@
+import { parseContextName } from '@skyhook-io/k8s-ui/utils/context-name'
+import type { ContextInfo } from '../types'
+
 // Re-export from the shared @skyhook-io/k8s-ui package.
 export * from '@skyhook-io/k8s-ui/utils/context-name'
+
+export function parseContextForSwitcher(context: ContextInfo) {
+  const raw = context.originalName || context.name
+  const nameQualifier = context.originalName && context.name !== context.originalName
+    ? context.name.slice(context.originalName.length).trim() || undefined
+    : undefined
+  return {
+    ...parseContextName(raw),
+    nameQualifier,
+  }
+}
+
+export function visibleContextQualifier(
+  qualifier: string | undefined,
+  source: string | undefined,
+  sourceLabelVisible: boolean,
+) {
+  return sourceLabelVisible && qualifier === `(${source})` ? undefined : qualifier
+}