@skyhook-io/radar-app 1.11.0 → 1.12.3

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

package/src/utils/navigation.test.ts

@@ -0,0 +1,45 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import {
+  initNavigationMap,
+  resetNavigationMap,
+} from '@skyhook-io/k8s-ui/utils/navigation'
+import { relatedResourcePath, resourcePath } from './navigation'
+
+afterEach(resetNavigationMap)
+
+describe('resource navigation paths', () => {
+  it('routes the native PodGroup by its scheduling API group', () => {
+    initNavigationMap([
+      {
+        group: 'scheduling.k8s.io',
+        version: 'v1beta1',
+        kind: 'PodGroup',
+        name: 'podgroups',
+        namespaced: true,
+        isCrd: false,
+        verbs: ['get', 'list'],
+      },
+    ])
+
+    expect(
+      resourcePath({
+        kind: 'PodGroup',
+        group: 'scheduling.k8s.io',
+        namespace: 'default',
+        name: 'batch',
+      }),
+    ).toBe(
+      '/resources/podgroups?resource=default%2Fbatch&apiGroup=scheduling.k8s.io',
+    )
+  })
+
+  it('preserves Radar virtual PodGroup navigation without an API group', () => {
+    expect(
+      relatedResourcePath({
+        kind: 'PodGroup',
+        namespace: 'default',
+        name: 'batch',
+      }),
+    ).toBe('/workload/pods/default/batch')
+  })
+})

package/src/utils/navigation.ts

@@ -1,5 +1,5 @@
 import { apiUrl, getAuthHeaders, getCredentialsMode } from '../api/config'
-import { apiVersionToGroup, kindToPlural } from '@skyhook-io/k8s-ui/utils/navigation'
+import { apiVersionToGroup, kindToPluralWithGroup } from '@skyhook-io/k8s-ui/utils/navigation'
 import type { SelectedResource, Topology } from '@skyhook-io/k8s-ui/types/core'
 import type { SearchHit } from '../api/client'
 
@@ -14,7 +14,7 @@ export function searchHitToSelectedResource(hit: SearchHit): SelectedResource {
 }
 
 // Re-export shared navigation utilities from @skyhook-io/k8s-ui.
-export { kindToPlural, pluralToKind, refToSelectedResource, apiVersionToGroup } from '@skyhook-io/k8s-ui/utils/navigation'
+export { kindToPlural, kindToPluralWithGroup, pluralToKind, refToSelectedResource, apiVersionToGroup } from '@skyhook-io/k8s-ui/utils/navigation'
 export type { NavigateToResource } from '@skyhook-io/k8s-ui/utils/navigation'
 
 const NETWORK_POLICY_TOPOLOGY_KINDS = new Set([
@@ -48,7 +48,7 @@ export function getNetworkPolicyResourceTarget(topology: Topology | null): { kin
 
     const group = networkPolicyGroup(node)
     const target = {
-      kind: kindToPlural(node.kind),
+      kind: kindToPluralWithGroup(node.kind, group ?? ''),
       ...(group ? { group } : {}),
     }
     targets.set(`${target.kind}\u0000${target.group ?? ''}`, target)
@@ -96,13 +96,13 @@ export function resourcePath(resource: SelectedResource): string {
   }
   if (resource.group) params.set('apiGroup', resource.group)
   const query = params.toString()
-  return `/resources/${kindToPlural(resource.kind)}${query ? `?${query}` : ''}`
+  return `/resources/${kindToPluralWithGroup(resource.kind, resource.group ?? '')}${query ? `?${query}` : ''}`
 }
 
 const FULLSCREEN_RESOURCE_KINDS = new Set(['pods', 'deployments', 'statefulsets', 'daemonsets', 'jobs', 'cronjobs', 'nodes'])
 
 export function relatedResourcePath(resource: SelectedResource): string {
-  const apiKind = kindToPlural(resource.kind).toLowerCase()
+  const apiKind = kindToPluralWithGroup(resource.kind, resource.group ?? '').toLowerCase()
   if (FULLSCREEN_RESOURCE_KINDS.has(apiKind)) {
     return buildWorkloadPath({ ...resource, kind: apiKind })
   }

package/src/utils/topology-selection.ts

@@ -1,5 +1,5 @@
 import type { SelectedResource, Topology, TopologyNode } from '@skyhook-io/k8s-ui/types/core'
-import { apiVersionToGroup, kindToPlural } from '@skyhook-io/k8s-ui/utils/navigation'
+import { apiVersionToGroup, kindToPluralWithGroup } from '@skyhook-io/k8s-ui/utils/navigation'
 
 function topologyNodeGroup(node: TopologyNode): string | undefined {
   const apiVersionGroup = apiVersionToGroup(node.data.apiVersion as string | undefined)
@@ -18,10 +18,11 @@ export function findSelectedTopologyNode(
   selectedResource: SelectedResource,
 ): TopologyNode | undefined {
   const namespace = selectedResource.namespace || ''
+  const selectedKind = kindToPluralWithGroup(selectedResource.kind, selectedResource.group ?? '')
   const candidates = topology?.nodes.filter(node =>
     ((node.data.namespace as string) || '') === namespace &&
     node.name === selectedResource.name &&
-    (kindToPlural(node.kind) === selectedResource.kind || node.kind === selectedResource.kind),
+    (kindToPluralWithGroup(node.kind, topologyNodeGroup(node) ?? '') === selectedKind || node.kind === selectedResource.kind),
   ) ?? []
 
   if (candidates.length === 0) return undefined

package/src/utils/version.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+import {
+  getVersionUpdateStatus,
+  IN_CLUSTER_UPGRADE_URL,
+  parseMajorMinor,
+  versionUpdateURL,
+} from './version'
+
+describe('Radar version helpers', () => {
+  it('parses major and minor versions with an optional v prefix', () => {
+    expect(parseMajorMinor('v1.12.3')).toEqual({ major: 1, minor: 12 })
+    expect(parseMajorMinor('dev')).toBeNull()
+  })
+
+  it('grades available updates by distance from the latest release', () => {
+    expect(getVersionUpdateStatus('1.12.0', '1.12.1')).toEqual({ tier: 'patch' })
+    expect(getVersionUpdateStatus('1.11.4', '1.12.1')).toEqual({ tier: 'minor', minorVersionsBehind: 1 })
+    expect(getVersionUpdateStatus('1.10.4', '1.12.1')).toEqual({ tier: 'minor', minorVersionsBehind: 2 })
+    expect(getVersionUpdateStatus('1.9.4', '1.12.1')).toEqual({ tier: 'stale', minorVersionsBehind: 3 })
+    expect(getVersionUpdateStatus('0.12.4', '1.12.1')).toEqual({ tier: 'stale', majorVersionBehind: true })
+    expect(getVersionUpdateStatus('1.12.1-rc.1', '1.12.1')).toEqual({ tier: 'patch' })
+  })
+
+  it('does not flag invalid, current, or newer local builds', () => {
+    expect(getVersionUpdateStatus('dev', '1.12.1')).toEqual({ tier: 'none' })
+    expect(getVersionUpdateStatus('1.12.1', '1.12.1')).toEqual({ tier: 'none' })
+    expect(getVersionUpdateStatus('1.13.0', '1.12.1')).toEqual({ tier: 'none' })
+    expect(getVersionUpdateStatus('2.0.0', '1.12.1')).toEqual({ tier: 'none' })
+  })
+
+  it('routes in-cluster upgrades to instructions instead of release notes', () => {
+    const releaseURL = 'https://github.com/skyhook-io/radar/releases/tag/v1.2.4'
+    expect(versionUpdateURL('in-cluster', releaseURL)).toBe(IN_CLUSTER_UPGRADE_URL)
+    expect(versionUpdateURL('local', releaseURL)).toBe(releaseURL)
+    expect(versionUpdateURL('cloud', releaseURL)).toBeUndefined()
+  })
+})

package/src/utils/version.ts

@@ -0,0 +1,56 @@
+import type { DeploymentMode } from '../types'
+
+export interface MajorMinorVersion {
+  major: number
+  minor: number
+}
+
+export type VersionUpdateTier = 'none' | 'patch' | 'minor' | 'stale'
+
+export interface VersionUpdateStatus {
+  tier: VersionUpdateTier
+  minorVersionsBehind?: number
+  majorVersionBehind?: boolean
+}
+
+export const IN_CLUSTER_UPGRADE_URL = 'https://radarhq.io/docs/configuration/in-cluster'
+
+export function versionUpdateURL(deploymentMode: DeploymentMode, releaseURL?: string): string | undefined {
+  if (deploymentMode === 'cloud') return undefined
+  return deploymentMode === 'in-cluster' ? IN_CLUSTER_UPGRADE_URL : releaseURL
+}
+
+export function parseMajorMinor(version: string): MajorMinorVersion | null {
+  const match = /^v?(\d+)\.(\d+)/.exec(version.trim())
+  if (!match) return null
+  return { major: Number(match[1]), minor: Number(match[2]) }
+}
+
+function parseVersion(version: string): [major: number, minor: number, patch: number, prerelease: boolean] | null {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version.trim())
+  if (!match) return null
+  return [Number(match[1]), Number(match[2]), Number(match[3]), !!match[4]]
+}
+
+export function getVersionUpdateStatus(current: string, latest?: string): VersionUpdateStatus {
+  if (!latest) return { tier: 'none' }
+
+  const currentVersion = parseVersion(current)
+  const latestVersion = parseVersion(latest)
+  if (!currentVersion || !latestVersion) return { tier: 'none' }
+
+  const [currentMajor, currentMinor, currentPatch, currentPrerelease] = currentVersion
+  const [latestMajor, latestMinor, latestPatch, latestPrerelease] = latestVersion
+
+  if (latestMajor < currentMajor) return { tier: 'none' }
+  if (latestMajor > currentMajor) return { tier: 'stale', majorVersionBehind: true }
+
+  const minorVersionsBehind = latestMinor - currentMinor
+  if (minorVersionsBehind >= 3) return { tier: 'stale', minorVersionsBehind }
+  if (minorVersionsBehind > 0) return { tier: 'minor', minorVersionsBehind }
+  if (minorVersionsBehind < 0 || latestPatch < currentPatch) return { tier: 'none' }
+  if (latestPatch === currentPatch) {
+    return currentPrerelease && !latestPrerelease ? { tier: 'patch' } : { tier: 'none' }
+  }
+  return { tier: 'patch' }
+}

package/src/utils/wails-clipboard.test.ts

@@ -0,0 +1,109 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { copyText } from '@skyhook-io/k8s-ui/utils/clipboard'
+
+import { installWailsClipboardShim } from './wails-clipboard'
+
+function focusedMonacoEditor(text: string) {
+  return {
+    hasTextFocus: () => true,
+    getSelection: () => ({}),
+    getModel: () => ({ getValueInRange: () => text }),
+    pushUndoStop: vi.fn(),
+    executeEdits: vi.fn(),
+  }
+}
+
+function setupDom({ monacoEditor = null as unknown, nativeCopyResult = true, insecureOrigin = false } = {}) {
+  const origExecCommand = vi.fn(() => nativeCopyResult)
+  const textarea = {
+    value: '',
+    style: {} as CSSStyleDeclaration,
+    setAttribute: vi.fn(),
+    select: vi.fn(),
+    setSelectionRange: vi.fn(),
+    remove: vi.fn(),
+  }
+  const doc = {
+    execCommand: origExecCommand as Document['execCommand'],
+    addEventListener: vi.fn(),
+    createElement: vi.fn(() => textarea),
+    body: { appendChild: vi.fn() },
+    activeElement: null,
+  }
+  const win = { __radarMonacoEditor: monacoEditor, getSelection: () => null }
+  // navigator.clipboard is a secure-context-only API — absent entirely on plain HTTP.
+  const writeText = vi.fn(() => Promise.resolve())
+  const nav = {
+    clipboard: insecureOrigin ? undefined : { writeText, readText: vi.fn(() => Promise.resolve('')) },
+  }
+  vi.stubGlobal('document', doc)
+  vi.stubGlobal('window', win)
+  vi.stubGlobal('navigator', nav)
+  installWailsClipboardShim()
+  return { doc, writeText, origExecCommand, textarea }
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+})
+
+describe('installWailsClipboardShim execCommand patch', () => {
+  it('delegates copy to the native command when Monaco is not focused', () => {
+    const { doc, writeText, origExecCommand } = setupDom()
+
+    expect(doc.execCommand('copy')).toBe(true)
+
+    expect(origExecCommand).toHaveBeenCalledWith('copy', undefined, undefined)
+    expect(writeText).not.toHaveBeenCalled()
+  })
+
+  it('reports the native command failing instead of fabricating success', () => {
+    const { doc } = setupDom({ nativeCopyResult: false })
+
+    expect(doc.execCommand('copy')).toBe(false)
+  })
+
+  it('hijacks copy for Monaco virtual selections, which the native command cannot see', () => {
+    const editor = focusedMonacoEditor('monaco-selection')
+    const { doc, writeText, origExecCommand } = setupDom({ monacoEditor: editor })
+
+    expect(doc.execCommand('copy')).toBe(true)
+
+    expect(writeText).toHaveBeenCalledWith('monaco-selection')
+    expect(origExecCommand).not.toHaveBeenCalled()
+  })
+
+  it('hijacks cut for Monaco and deletes the selection', () => {
+    const editor = focusedMonacoEditor('monaco-selection')
+    const { doc, writeText } = setupDom({ monacoEditor: editor })
+
+    expect(doc.execCommand('cut')).toBe(true)
+
+    expect(writeText).toHaveBeenCalledWith('monaco-selection')
+    expect(editor.executeEdits).toHaveBeenCalledOnce()
+  })
+
+  it('delegates unrelated commands untouched', () => {
+    const { doc, origExecCommand } = setupDom()
+
+    doc.execCommand('insertText', false, 'x')
+
+    expect(origExecCommand).toHaveBeenCalledWith('insertText', false, 'x')
+  })
+
+  it('lets copyText reach the native command through the patch when the Clipboard API is unavailable', async () => {
+    const { doc, origExecCommand, textarea } = setupDom({ insecureOrigin: true })
+
+    await expect(copyText('busybox', undefined, doc as unknown as Document)).resolves.toBe(true)
+
+    expect(textarea.value).toBe('busybox')
+    expect(origExecCommand).toHaveBeenCalledWith('copy', undefined, undefined)
+  })
+
+  it('surfaces copyText failure when the native command fails under the patch', async () => {
+    const { doc } = setupDom({ nativeCopyResult: false, insecureOrigin: true })
+
+    await expect(copyText('busybox', undefined, doc as unknown as Document)).resolves.toBe(false)
+  })
+})

package/src/utils/wails-clipboard.ts

@@ -0,0 +1,127 @@
+// === 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()
+}
+
+export function installWailsClipboardShim(): void {
+  const _origExecCommand = document.execCommand.bind(document)
+
+  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').
+  //
+  // Only Monaco needs the copy/cut hijack: its virtual selection is invisible
+  // to the native command. Every other caller (notably the hidden-textarea
+  // fallback in @skyhook-io/k8s-ui's copyText, which is how copy works at all
+  // on insecure origins where navigator.clipboard doesn't exist) must reach
+  // the native command and see its real return value — hijacking those routes
+  // them back into the async Clipboard API and fabricates success.
+  document.execCommand = function (command: string, showUI?: boolean, value?: string) {
+    if (command === 'copy' || command === 'cut') {
+      const monaco = getMonacoSelection()
+      if (!monaco) return _origExecCommand(command, showUI, value)
+      navigator.clipboard.writeText(monaco.text).catch((err) => { console.warn('[Radar] Clipboard write failed:', err) })
+      if (command === 'cut') deleteMonacoSelection(monaco.editor)
+      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
+}