@skyhook-io/radar-app 1.10.0 → 1.12.2

package/src/utils/navigation.ts

@@ -1,6 +1,6 @@
 import { apiUrl, getAuthHeaders, getCredentialsMode } from '../api/config'
-import { kindToPlural } from '@skyhook-io/k8s-ui/utils/navigation'
-import type { SelectedResource } from '@skyhook-io/k8s-ui/types/core'
+import { apiVersionToGroup, kindToPlural } from '@skyhook-io/k8s-ui/utils/navigation'
+import type { SelectedResource, Topology } from '@skyhook-io/k8s-ui/types/core'
 import type { SearchHit } from '../api/client'
 
 /**
@@ -17,6 +17,48 @@ export function searchHitToSelectedResource(hit: SearchHit): SelectedResource {
 export { kindToPlural, 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([
+  'NetworkPolicy',
+  'CalicoNetworkPolicy',
+  'CalicoGlobalNetworkPolicy',
+  'CalicoStagedNetworkPolicy',
+  'CalicoStagedGlobalNetworkPolicy',
+  'CalicoStagedKubernetesNetworkPolicy',
+  'CiliumNetworkPolicy',
+  'CiliumClusterwideNetworkPolicy',
+  'ClusterNetworkPolicy',
+])
+
+function networkPolicyGroup(node: Topology['nodes'][number]): string | undefined {
+  const apiVersionGroup = apiVersionToGroup(node.data.apiVersion as string | undefined)
+  if (apiVersionGroup) return apiVersionGroup
+
+  const sourceGroup = node.data.sourceGroup
+  if (typeof sourceGroup === 'string' && sourceGroup) return sourceGroup
+
+  if (node.kind === 'NetworkPolicy') return 'networking.k8s.io'
+  return undefined
+}
+
+/** Return a resource route only when the policy aggregate has one target. */
+export function getNetworkPolicyResourceTarget(topology: Topology | null): { kind: string; group?: string } | undefined {
+  const targets = new Map<string, { kind: string; group?: string }>()
+  for (const node of topology?.nodes ?? []) {
+    if (!NETWORK_POLICY_TOPOLOGY_KINDS.has(node.kind)) continue
+
+    const group = networkPolicyGroup(node)
+    const target = {
+      kind: kindToPlural(node.kind),
+      ...(group ? { group } : {}),
+    }
+    targets.set(`${target.kind}\u0000${target.group ?? ''}`, target)
+  }
+
+  if (targets.size !== 1) return undefined
+  for (const target of targets.values()) return target
+  return undefined
+}
+
 /**
  * Build a /workload/:kind/:namespace/:name URL, preserving the API group as a
  * query param so the WorkloadView can resolve CRDs with colliding kind names.

package/src/utils/network-policy-navigation.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest'
+import type { Topology, TopologyNode } from '@skyhook-io/k8s-ui/types/core'
+import { getNetworkPolicyResourceTarget } from './navigation'
+
+function node(kind: string, apiVersion?: string): TopologyNode {
+  return {
+    id: `${kind}/default/policy`,
+    kind,
+    name: 'policy',
+    status: 'healthy',
+    data: { namespace: 'default', ...(apiVersion ? { apiVersion } : {}) },
+  } as TopologyNode
+}
+
+function topology(...nodes: TopologyNode[]): Topology {
+  return { nodes, edges: [] }
+}
+
+describe('getNetworkPolicyResourceTarget', () => {
+  it('routes a Calico policy to its API group instead of the native policy list', () => {
+    expect(getNetworkPolicyResourceTarget(topology(node('CalicoNetworkPolicy', 'projectcalico.org/v3')))).toEqual({
+      kind: 'networkpolicies',
+      group: 'projectcalico.org',
+    })
+  })
+
+  it('uses the Calico policy kind when the aggregate only contains global policies', () => {
+    expect(getNetworkPolicyResourceTarget(topology(node('CalicoGlobalNetworkPolicy', 'crd.projectcalico.org/v1')))).toEqual({
+      kind: 'globalnetworkpolicies',
+      group: 'crd.projectcalico.org',
+    })
+  })
+
+  it('routes staged Kubernetes Calico policies to their exact API group', () => {
+    expect(getNetworkPolicyResourceTarget(topology(node('CalicoStagedKubernetesNetworkPolicy', 'crd.projectcalico.org/v1')))).toEqual({
+      kind: 'stagedkubernetesnetworkpolicies',
+      group: 'crd.projectcalico.org',
+    })
+  })
+
+  it('uses the generic resources view when the aggregate contains multiple policy targets', () => {
+    expect(getNetworkPolicyResourceTarget(topology(
+      node('NetworkPolicy', 'networking.k8s.io/v1'),
+      node('CalicoNetworkPolicy', 'crd.projectcalico.org/v1'),
+    ))).toBeUndefined()
+  })
+
+  it('keeps a stable route when multiple policies share one kind and group', () => {
+    expect(getNetworkPolicyResourceTarget(topology(
+      node('CalicoNetworkPolicy', 'crd.projectcalico.org/v1'),
+      node('CalicoNetworkPolicy', 'crd.projectcalico.org/v1'),
+    ))).toEqual({
+      kind: 'networkpolicies',
+      group: 'crd.projectcalico.org',
+    })
+  })
+
+  it('preserves the native NetworkPolicy API group when apiVersion is absent', () => {
+    expect(getNetworkPolicyResourceTarget(topology(node('NetworkPolicy')))).toEqual({
+      kind: 'networkpolicies',
+      group: 'networking.k8s.io',
+    })
+  })
+
+  it('returns no targeted route when topology has not identified a policy', () => {
+    expect(getNetworkPolicyResourceTarget(topology(node('Deployment')))).toBeUndefined()
+  })
+})

package/src/utils/topology-selection.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest'
+import type { SelectedResource, Topology, TopologyNode } from '@skyhook-io/k8s-ui/types/core'
+import { findSelectedTopologyNode } from './topology-selection'
+
+function node(id: string, kind: string, name: string, apiVersion?: string): TopologyNode {
+  return {
+    id,
+    kind,
+    name,
+    status: 'healthy',
+    data: { namespace: 'default', ...(apiVersion ? { apiVersion } : {}) },
+  } as TopologyNode
+}
+
+function selected(group?: string, kind = 'networkpolicies'): SelectedResource {
+  return { kind, namespace: 'default', name: 'policy', group }
+}
+
+describe('findSelectedTopologyNode', () => {
+  it('prefers the node from the selected API group when names collide', () => {
+    const native = node('native', 'NetworkPolicy', 'policy')
+    const calico = node('calico', 'CalicoNetworkPolicy', 'policy', 'projectcalico.org/v3')
+
+    expect(findSelectedTopologyNode({ nodes: [native, calico], edges: [] }, selected('projectcalico.org'))?.id).toBe('calico')
+  })
+
+  it('keeps native NetworkPolicy selection working without an apiVersion on the node', () => {
+    const native = node('native', 'NetworkPolicy', 'policy')
+
+    expect(findSelectedTopologyNode({ nodes: [native], edges: [] }, selected('networking.k8s.io'))?.id).toBe('native')
+  })
+
+  it('matches arbitrary same-name nodes by API group when both groups are present', () => {
+    const first = node('first', 'Widget', 'policy', 'one.example/v1')
+    const second = node('second', 'Widget', 'policy', 'two.example/v1')
+    const topology: Topology = { nodes: [first, second], edges: [] }
+
+    expect(findSelectedTopologyNode(topology, selected('two.example', 'widgets'))?.id).toBe('second')
+  })
+})

package/src/utils/topology-selection.ts

@@ -0,0 +1,39 @@
+import type { SelectedResource, Topology, TopologyNode } from '@skyhook-io/k8s-ui/types/core'
+import { apiVersionToGroup, kindToPlural } from '@skyhook-io/k8s-ui/utils/navigation'
+
+function topologyNodeGroup(node: TopologyNode): string | undefined {
+  const apiVersionGroup = apiVersionToGroup(node.data.apiVersion as string | undefined)
+  if (apiVersionGroup) return apiVersionGroup
+
+  const sourceGroup = node.data.sourceGroup
+  if (typeof sourceGroup === 'string' && sourceGroup) return sourceGroup
+
+  // Native NetworkPolicy nodes predate apiVersion in the topology payload.
+  if (node.kind === 'NetworkPolicy') return 'networking.k8s.io'
+  return undefined
+}
+
+export function findSelectedTopologyNode(
+  topology: Topology | null,
+  selectedResource: SelectedResource,
+): TopologyNode | undefined {
+  const namespace = selectedResource.namespace || ''
+  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),
+  ) ?? []
+
+  if (candidates.length === 0) return undefined
+
+  const selectedGroup = selectedResource.group || undefined
+  if (!selectedGroup) return candidates[0]
+
+  const groupMatch = candidates.find(node => topologyNodeGroup(node) === selectedGroup)
+  if (groupMatch) return groupMatch
+
+  // Preserve the old name/kind/ns behavior only when the topology has no group
+  // information to compare. If it does, returning no match is safer than
+  // highlighting a resource from another API group.
+  return candidates.some(node => topologyNodeGroup(node) !== undefined) ? undefined : candidates[0]
+}

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