@skyhook-io/radar-app 1.11.0 → 1.12.2

package/src/components/workload/WorkloadView.tsx

@@ -1869,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(() => {
@@ -1991,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
+}

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