@skyhook-io/radar-app 1.17.0 → 1.17.1

package/src/integrations/resourceHosts.tsx

@@ -0,0 +1,119 @@
+import { useMemo } from 'react'
+import { useLocation } from 'react-router-dom'
+import { PaneLoader, type WorkloadExtraTab } from '@skyhook-io/k8s-ui'
+import { useRadarFeature } from '../api/client'
+import type { RenderDiagnoseAction } from '../context/DiagnoseCustomization'
+import { apiVersionToGroup } from '../utils/navigation'
+import type { SelectedResource } from '../types'
+import { cnpgResourceHost } from '../components/cnpg/host'
+import {
+  composeDetailSlots, composeResourceHosts, hostsForResource, hostSupport, resourceHostForSlot,
+  type DetailSlots, type HostResource, type HostFeatures, type HostKind, type KindListProps,
+  type ResourceHost,
+} from './resourceHost'
+import { RayJobRenderer } from '../components/resources/renderers/RayJobRenderer'
+import { JobRenderer, JobSetRenderer } from '../components/resources/renderers/JobAdmissionRenderers'
+import { RayClusterRenderer } from '../components/resources/renderers/RayClusterRenderer'
+import { RayServiceRenderer } from '../components/resources/renderers/RayServiceRenderer'
+import { KueueWorkloadRenderer } from '../components/resources/renderers/KueueWorkloadRenderer'
+import { PodRenderer } from '../components/resources/renderers/PodRenderer'
+import { KarpenterNodePoolRenderer } from '../components/resources/renderers/KarpenterNodePoolRenderer'
+import { NodeRenderer } from '../components/resources/renderers/NodeRenderer'
+import { ServiceRenderer } from '../components/resources/renderers/ServiceRenderer'
+import { WorkloadRenderer } from '../components/resources/renderers/WorkloadRenderer'
+import { CompositeRenderer } from '../components/resources/CompositeRenderer'
+import { ServiceAccountRenderer } from '../components/resources/renderers/ServiceAccountRenderer'
+import { RoleRenderer } from '../components/resources/renderers/RoleRenderer'
+import { RoleBindingRenderer } from '../components/resources/renderers/RoleBindingRenderer'
+import { NamespaceRenderer } from '../components/resources/renderers/NamespaceRenderer'
+import { CAPIClusterRenderer } from '../components/resources/renderers/CAPIClusterRenderer'
+import { HPARenderer } from '../components/resources/renderers/HPARenderer'
+import { PVCRenderer } from '../components/resources/renderers/PVCRenderer'
+import { RolloutRenderer } from '../components/resources/renderers/RolloutRenderer'
+import { KyvernoPolicyCoverage } from '../components/resources/renderers/KyvernoPolicyCoverage'
+import { KyvernoPolicyQueued } from '../components/resources/renderers/KyvernoPolicyQueued'
+import { VeleroBSLRenderer } from '../components/resources/renderers/VeleroBSLRenderer'
+import { VeleroBackupRenderer } from '../components/resources/renderers/VeleroBackupRenderer'
+import { VeleroRestoreRenderer } from '../components/resources/renderers/VeleroRestoreRenderer'
+
+export const resourceHosts: readonly ResourceHost[] = [
+  { id: 'kubernetes', renderers: { PodRenderer, NodeRenderer, ServiceRenderer, WorkloadRenderer, HPARenderer, PVCRenderer } },
+  { id: 'rbac', renderers: { ServiceAccountRenderer, RoleRenderer, RoleBindingRenderer, NamespaceRenderer } },
+  { id: 'batch-and-admission', renderers: { JobRenderer, JobSetRenderer, KueueWorkloadRenderer } },
+  { id: 'ray', renderers: { RayJobRenderer, RayServiceRenderer, RayClusterRenderer } },
+  { id: 'capacity', renderers: { KarpenterNodePoolRenderer } },
+  { id: 'capi', renderers: { CAPIClusterRenderer } },
+  { id: 'crossplane', renderers: { CompositeRenderer } },
+  { id: 'rollouts', renderers: { RolloutRenderer } },
+  { id: 'kyverno', renderers: { KyvernoPolicyCoverage, KyvernoPolicyQueued } },
+  { id: 'velero', renderers: { VeleroBSLRenderer, VeleroBackupRenderer, VeleroRestoreRenderer } },
+  cnpgResourceHost,
+]
+
+export const resourceRendererOverrides = composeResourceHosts(resourceHosts)
+
+export function resourceExpandedPath(resource: HostResource, context?: string, tab?: 'yaml'): string | null {
+  return resourceHostForSlot(resourceHosts, resource, 'destination')?.expandedPath?.(resource, context, tab) ?? null
+}
+
+export function resourceDetailRedirect(resource: HostResource, search: URLSearchParams): string | null {
+  return resourceHostForSlot(resourceHosts, resource, 'destination')?.detailRedirect?.(resource, search) ?? null
+}
+
+export function resourceDetailSlots(resource: HostResource, inheritedTabs?: WorkloadExtraTab[]): DetailSlots {
+  const slots = hostsForResource(resourceHosts, resource)
+    .map(host => ({ id: host.id, slots: host.detailSlots?.(resource) }))
+  return composeDetailSlots(slots, inheritedTabs)
+}
+
+export function resourceLogs(resource: HostResource, data: { apiVersion?: string } | null | undefined) {
+  const observed = { ...resource, group: data?.apiVersion ? apiVersionToGroup(data.apiVersion) : resource.group }
+  const host = resourceHostForSlot(resourceHosts, observed, 'logs')
+  return host?.logs?.(observed, data) ?? null
+}
+
+export function ResourceDrawerNavigation({ resource }: { resource: SelectedResource }) {
+  const { pathname } = useLocation()
+  return <>{resourceHosts.map(host => {
+    const navigation = host.drawerNavigation
+    if (!navigation?.ownsPath(pathname)) return null
+    const Component = navigation.Component
+    return <Component key={host.id} resource={resource} />
+  })}</>
+}
+
+export function useResourceHostFeatures(): HostFeatures {
+  // Hook order is fixed here; selected adapters mount components that own their data hooks.
+  const { support } = useRadarFeature('cnpgWorkspace')
+  return useMemo(() => ({ cnpgWorkspace: support }), [support])
+}
+
+
+export function decorateResourceDiagnose(render: RenderDiagnoseAction | undefined): RenderDiagnoseAction | undefined {
+  return resourceHosts.reduce((current, host) => host.diagnoseAction?.(current) ?? current, render)
+}
+
+
+function kindListHost(kind: Pick<HostKind, 'name' | 'group'> | null) {
+  return kind ? resourceHosts.flatMap(host => (host.kindLists ?? []).map(list => ({ host, list })))
+    .find(({ list }) => list.kind.name === kind.name && list.kind.group === kind.group) : undefined
+}
+
+export function resourceKindListMode(kind: Pick<HostKind, 'name' | 'group'> | null, features: HostFeatures, pending: boolean) {
+  const contribution = kindListHost(kind)
+  return contribution?.list.mode(hostSupport(contribution.host, features), pending) ?? 'table'
+}
+
+export function resourceKindListTitle(kind: Pick<HostKind, 'name' | 'group'>): string | null {
+  return kindListHost(kind)?.list.title ?? null
+}
+
+export function renderResourceKindList(kind: Pick<HostKind, 'name' | 'group'> | null, features: HostFeatures, pending: boolean, props: KindListProps) {
+  const contribution = kindListHost(kind)
+  if (!contribution) return null
+  const mode = contribution.list.mode(hostSupport(contribution.host, features), pending)
+  if (mode === 'wait') return <PaneLoader label="Loading…" className="flex-1" />
+  if (mode === 'table') return null
+  const Component = contribution.list.Component
+  return <Component {...props} />
+}

package/src/integrations/workspaceRoute.ts

@@ -0,0 +1,20 @@
+import type { SelectedResource } from '../types'
+
+export interface WorkspaceScreenProps {
+  namespaces: string[]
+  selectedResource: SelectedResource | null
+  onOpenResource: (resource: SelectedResource) => void
+  onCloseResource: () => void
+  onClearNamespaces: () => void
+}
+
+export interface WorkspaceRoute {
+  id: 'cnpg' | 'capacity'
+  path: string
+  label: string
+  navView: 'resources' | 'capacity'
+  namespaceScope: 'view' | 'cluster'
+  namespaceFilterTooltip?: string
+  pageTitle: (pathname: string) => string
+  contextSwitchSearch?: (pathname: string, search: URLSearchParams) => URLSearchParams
+}

package/src/integrations/workspaceRoutes.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest'
+import { workspaceContextSwitchSearch, workspaceForPath, workspaceForView } from './workspaceRoutes'
+
+describe('workspace route ownership', () => {
+  it('preserves distinct placement, scope, route parsers and title/breadcrumb labels', () => {
+    const cnpg = workspaceForPath('/cnpg/backups/db/backup%2F1')!
+    expect(cnpg.id).toBe('cnpg')
+    expect(cnpg.navView).toBe('resources')
+    expect(cnpg.namespaceScope).toBe('view')
+    expect(cnpg.pageTitle('/cnpg/backups/db/backup%2F1')).toBe('backup/1')
+    expect(cnpg.pageTitle('/cnpg/protection')).toBe('CloudNativePG Backups')
+    expect(cnpg.pageTitle('/cnpg/unknown')).toBe('CloudNativePG Clusters')
+    const capacity = workspaceForView('capacity')!
+    expect(capacity.navView).toBe('capacity')
+    expect(capacity.namespaceScope).toBe('cluster')
+    expect(capacity.pageTitle('/capacity/pools/pool%2Fone/members')).toBe('pool/one')
+    expect(capacity.pageTitle('/capacity/demand')).toBe('Capacity Demand')
+    expect(capacity.pageTitle('/capacity/activity')).toBe('Capacity Activity')
+    expect(capacity.pageTitle('/capacity/unknown')).toBe('Capacity')
+  })
+
+  it('only owns whole route prefixes inside either OSS or an embedded router basename', () => {
+    expect(workspaceForPath('/cnpg')?.id).toBe('cnpg')
+    expect(workspaceForPath('/cnpg/')).toBeDefined()
+    expect(workspaceForPath('/cnpg-other')).toBeUndefined()
+    expect(workspaceForPath('/capacity-other')).toBeUndefined()
+    expect(workspaceForPath('/workload/clusters/db/pg')).toBeUndefined()
+    // React Router supplies basename-relative locations to the application.
+    expect(workspaceForPath('/c/demo/cnpg')).toBeUndefined()
+  })
+
+  it('pins only CNPG detail context on a switch, without adopting another workspace’s query policy', () => {
+    const search = new URLSearchParams('ctx=old-cluster&tab=storage&drawer=pod&namespaces=db&ai-run=run')
+    expect(workspaceContextSwitchSearch('/cnpg/clusters/db/pg', search).toString()).toBe('ctx=old-cluster')
+    expect(workspaceContextSwitchSearch('/cnpg', search).toString()).toBe('')
+    expect(workspaceContextSwitchSearch('/capacity/pools/default', search).toString()).toBe('')
+    expect(workspaceContextSwitchSearch('/resources/pods', search).toString()).toBe('')
+    expect(search.get('tab')).toBe('storage')
+  })
+})

package/src/integrations/workspaceRoutes.ts

@@ -0,0 +1,22 @@
+import { capacityWorkspaceRoute } from '../components/capacity/workspaceRoute'
+import { cnpgWorkspaceRoute } from '../components/cnpg/workspaceRoute'
+import type { WorkspaceRoute } from './workspaceRoute'
+
+export const workspaceRoutes = [cnpgWorkspaceRoute, capacityWorkspaceRoute] as const
+
+export const workspaceLabels = {
+  cnpg: cnpgWorkspaceRoute.label,
+  capacity: capacityWorkspaceRoute.label,
+} satisfies Record<WorkspaceRoute['id'], string>
+
+export function workspaceForPath(pathname: string) {
+  return workspaceRoutes.find(route => pathname === route.path || pathname.startsWith(`${route.path}/`))
+}
+
+export function workspaceForView(view: string) {
+  return workspaceRoutes.find(route => route.id === view)
+}
+
+export function workspaceContextSwitchSearch(pathname: string, search: URLSearchParams): URLSearchParams {
+  return workspaceForPath(pathname)?.contextSwitchSearch?.(pathname, search) ?? new URLSearchParams()
+}

package/src/integrations/workspaceScreens.tsx

@@ -0,0 +1,14 @@
+import type { ComponentType } from 'react'
+import { CapacityView } from '../components/capacity/CapacityView'
+import { CNPGView } from '../components/cnpg/CNPGView'
+import type { WorkspaceRoute, WorkspaceScreenProps } from './workspaceRoute'
+
+const screens: Record<WorkspaceRoute['id'], ComponentType<WorkspaceScreenProps>> = {
+  cnpg: CNPGView,
+  capacity: ({ onOpenResource }) => <CapacityView onOpenResource={onOpenResource} />,
+}
+
+export function WorkspaceScreen({ workspace, ...props }: WorkspaceScreenProps & { workspace: WorkspaceRoute }) {
+  const Component = screens[workspace.id]
+  return <Component {...props} />
+}

package/src/utils/drawer-trail.ts

@@ -0,0 +1,35 @@
+import type { SelectedResource } from '../types'
+
+// Drawer identity in the URL: kind:group:namespace:name, chained with "~" for
+// the in-drawer trail (last entry is the one shown). Kubernetes names and API
+// groups cannot contain ":" or "~", and the group is mandatory: CRD kinds
+// collide across groups (CloudNativePG's Cluster and Backup with CAPI,
+// KubeBlocks and Velero kinds).
+export function encodeDrawerRef(r: SelectedResource): string {
+  return [r.kind, r.group ?? '', r.namespace ?? '', r.name].join(':')
+}
+
+export function decodeDrawerRef(s: string): SelectedResource | null {
+  const parts = s.split(':')
+  if (parts.length !== 4 || !parts[0] || !parts[3]) return null
+  return { kind: parts[0], group: parts[1], namespace: parts[2], name: parts[3] }
+}
+
+export function decodeDrawerTrail(param: string | null): SelectedResource[] {
+  if (!param) return []
+  return param.split('~').map(decodeDrawerRef).filter((r): r is SelectedResource => r !== null)
+}
+
+export function encodeDrawerTrail(trail: SelectedResource[]): string {
+  return trail.map(encodeDrawerRef).join('~')
+}
+
+export function sameSelectedResource(a: SelectedResource | null | undefined, b: SelectedResource | null | undefined): boolean {
+  if (!a || !b) return false
+  return (
+    a.kind.toLowerCase() === b.kind.toLowerCase() &&
+    (a.group ?? '') === (b.group ?? '') &&
+    (a.namespace ?? '') === (b.namespace ?? '') &&
+    a.name === b.name
+  )
+}

package/src/utils/kindFilterStore.test.ts

@@ -0,0 +1,147 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { createKindFilterStore } from './kindFilterStore'
+
+const storage = new Map<string, string>()
+vi.stubGlobal('localStorage', {
+  getItem: (k: string) => storage.get(k) ?? null,
+  setItem: (k: string, v: string) => void storage.set(k, v),
+  removeItem: (k: string) => void storage.delete(k),
+  get length() { return storage.size },
+  key: (i: number) => [...storage.keys()][i] ?? null,
+})
+afterEach(() => {
+  storage.clear()
+  vi.stubGlobal('sessionStorage', undefined)
+})
+
+function fakeSessionStorage() {
+  const items = new Map<string, string>()
+  return {
+    getItem: (k: string) => items.get(k) ?? null,
+    setItem: (k: string, v: string) => void items.set(k, v),
+    get length() { return items.size },
+    key: (i: number) => [...items.keys()][i] ?? null,
+  }
+}
+
+describe('createKindFilterStore', () => {
+  it('keeps each cluster and each API group apart', () => {
+    const a = createKindFilterStore('/api|ctx-a')
+    const b = createKindFilterStore('/api|ctx-b')
+    a.set('services', '', 'filters=type%3AClusterIP')
+    a.set('services', 'serving.knative.dev', 'problems=failed')
+
+    expect(a.get('services', '')).toBe('filters=type%3AClusterIP')
+    expect(a.get('services', 'serving.knative.dev')).toBe('problems=failed')
+    expect(b.get('services', '')).toBeUndefined()
+  })
+
+  it('removes the entry when the filters are cleared', () => {
+    const store = createKindFilterStore('/api|ctx')
+    store.set('pods', '', 'problems=failed')
+    store.set('pods', '', '')
+
+    expect(store.get('pods', '')).toBeUndefined()
+    expect(storage.size).toBe(0)
+  })
+
+  it('remembers the last Resources list per cluster, with its API group only', () => {
+    const a = createKindFilterStore('/api|ctx-a')
+    a.recordLastKind('/resources/services', '?apiGroup=serving.knative.dev&filters=x&namespaces=n')
+    a.recordLastKind('/resources', '')
+    a.recordLastKind('/helm', '')
+
+    expect(a.lastKind()).toBe('/resources/services?apiGroup=serving.knative.dev')
+    expect(createKindFilterStore('/api|ctx-b').lastKind()).toBeUndefined()
+
+    a.recordLastKind('/resources/pods/', '?problems=failed')
+    expect(a.lastKind()).toBe('/resources/pods')
+  })
+
+  it('keeps a tab on its own filters while another tab saves different ones', () => {
+    const tabA = createKindFilterStore('/api|ctx')
+    const tabB = createKindFilterStore('/api|ctx')
+    tabA.set('pods', '', 'filters=namespace%3Aa')
+    tabB.set('pods', '', 'filters=namespace%3Ab')
+
+    expect(tabA.get('pods', '')).toBe('filters=namespace%3Aa')
+    expect(createKindFilterStore('/api|ctx').get('pods', '')).toBe('filters=namespace%3Ab')
+
+    tabA.set('pods', '', '')
+    tabB.set('pods', '', 'filters=namespace%3Ac')
+    expect(tabA.get('pods', '')).toBeUndefined()
+  })
+
+  it('keeps what a tab restored when another tab saves later', () => {
+    createKindFilterStore('/api|ctx').set('pods', '', 'filters=namespace%3Aa')
+    const tabA = createKindFilterStore('/api|ctx')
+    expect(tabA.get('pods', '')).toBe('filters=namespace%3Aa')
+    expect(tabA.get('services', '')).toBeUndefined()
+
+    const tabB = createKindFilterStore('/api|ctx')
+    tabB.set('pods', '', 'filters=namespace%3Ab')
+    tabB.set('services', '', 'filters=type%3AClusterIP')
+
+    expect(tabA.get('pods', '')).toBe('filters=namespace%3Aa')
+    expect(tabA.get('services', '')).toBeUndefined()
+  })
+
+  it('clears one column on every kind of the cluster, in the tab and in storage', () => {
+    const tab = createKindFilterStore('/api|ctx')
+    tab.set('pods', '', 'filters=namespace%3Aa%7Cstatus%3ARunning&problems=failed')
+    tab.set('services', '', 'filters=namespace%3Aexclude%3Ab')
+    tab.set('deployments', '', 'problems=failed')
+    // Another tab saved this kind; this tab never read it.
+    createKindFilterStore('/api|ctx').set('configmaps', '', 'filters=namespace%3Ac')
+    const otherCluster = createKindFilterStore('/api|ctx:2')
+    otherCluster.set('pods', '', 'filters=namespace%3Aa')
+
+    tab.clearColumn('namespace')
+
+    expect(tab.get('pods', '')).toBe('filters=status%3ARunning&problems=failed')
+    expect(tab.get('services', '')).toBeUndefined()
+    expect(tab.get('deployments', '')).toBe('problems=failed')
+    expect(tab.get('configmaps', '')).toBeUndefined()
+    const fresh = createKindFilterStore('/api|ctx')
+    expect(fresh.get('pods', '')).toBe('filters=status%3ARunning&problems=failed')
+    expect(fresh.get('services', '')).toBeUndefined()
+    expect(fresh.get('configmaps', '')).toBeUndefined()
+    expect(createKindFilterStore('/api|ctx:2').get('pods', '')).toBe('filters=namespace%3Aa')
+  })
+
+  it("keeps the tab's own filters on reload and in a duplicated tab; a new tab starts from the last saved", () => {
+    const tabA = fakeSessionStorage()
+    vi.stubGlobal('sessionStorage', tabA)
+    createKindFilterStore('/api|ctx').set('pods', '', 'filters=namespace%3Aa')
+
+    // Tab B saves a newer choice.
+    vi.stubGlobal('sessionStorage', fakeSessionStorage())
+    createKindFilterStore('/api|ctx').set('pods', '', 'filters=namespace%3Ab')
+
+    vi.stubGlobal('sessionStorage', tabA)
+    expect(createKindFilterStore('/api|ctx').get('pods', '')).toBe('filters=namespace%3Aa')
+
+    const duplicate = fakeSessionStorage()
+    for (let i = 0; i < tabA.length; i++) duplicate.setItem(tabA.key(i)!, tabA.getItem(tabA.key(i)!)!)
+    vi.stubGlobal('sessionStorage', duplicate)
+    expect(createKindFilterStore('/api|ctx').get('pods', '')).toBe('filters=namespace%3Aa')
+
+    vi.stubGlobal('sessionStorage', fakeSessionStorage())
+    expect(createKindFilterStore('/api|ctx').get('pods', '')).toBe('filters=namespace%3Ab')
+  })
+
+  it('remembers filters in the tab only when storage is unavailable', () => {
+    vi.stubGlobal('localStorage', {
+      getItem: () => { throw new Error('denied') },
+      setItem: () => { throw new Error('denied') },
+      removeItem: () => { throw new Error('denied') },
+    })
+    const store = createKindFilterStore('/api|ctx')
+    store.set('pods', '', 'problems=failed')
+    store.recordLastKind('/resources/pods', '')
+
+    expect(store.get('pods', '')).toBe('problems=failed')
+    expect(createKindFilterStore('/api|ctx').get('pods', '')).toBeUndefined()
+    expect(store.lastKind()).toBeUndefined()
+  })
+})

package/src/utils/kindFilterStore.ts

@@ -0,0 +1,91 @@
+import { kindFiltersFromSearch, kindFiltersToSearch } from '../components/resources/resource-utils'
+import { RESOURCE_LIST_PATH } from './navigation'
+import { createTabStorage } from './tabStorage'
+
+const FILTERS_PREFIX = 'radar-filters:'
+const LAST_KIND_PREFIX = 'radar-last-kind:'
+
+/**
+ * Per-cluster Resources filters (one query string per kind) and the last
+ * Resources kind, kept in localStorage so they survive reloads and new tabs.
+ * Storage can be unavailable (private mode, blocked site data): every access
+ * degrades to "nothing remembered".
+ *
+ * Filters are read from the tab's own copy first (sessionStorage: kept on
+ * reload, copied to a duplicated tab), so a tab keeps showing what happened
+ * in it while another tab saves different filters; localStorage only seeds a
+ * kind the first time the tab reads it.
+ */
+export function createKindFilterStore(cluster: string) {
+  const filtersKey = (plural: string, group: string) => `${FILTERS_PREFIX}${cluster}:${plural}/${group}`
+  const lastKindKey = LAST_KIND_PREFIX + cluster
+  const tab = createTabStorage()
+
+  return {
+    get(plural: string, group: string): string | undefined {
+      const key = filtersKey(plural, group)
+      const own = tab.get(key)
+      if (own !== undefined) return own || undefined
+      let saved: string | undefined
+      try {
+        saved = localStorage.getItem(key) ?? undefined
+      } catch { /* unavailable: nothing saved */ }
+      // What the tab was given is now the tab's own, whatever other tabs save later.
+      tab.set(key, saved ?? '')
+      return saved
+    },
+    /** An empty search removes the entry. */
+    set(plural: string, group: string, search: string) {
+      tab.set(filtersKey(plural, group), search)
+      try {
+        if (search) localStorage.setItem(filtersKey(plural, group), search)
+        else localStorage.removeItem(filtersKey(plural, group))
+      } catch { /* ignore */ }
+    },
+    /** Removes one column's filter from every kind of this cluster, in the tab and in localStorage. */
+    clearColumn(column: string) {
+      const withoutColumn = (search: string) => {
+        const filters = kindFiltersFromSearch(search)
+        delete filters.columnFilters[column]
+        delete filters.columnFilterExcludes[column]
+        return kindFiltersToSearch(filters)
+      }
+      const prefix = `${FILTERS_PREFIX}${cluster}:`
+      // The rest is `<plural>/<group>`, never a colon: guards against a context named `<cluster>:…`.
+      const ofCluster = (key: string | null): key is string => !!key?.startsWith(prefix) && !key.slice(prefix.length).includes(':')
+      for (const key of tab.keys().filter(ofCluster)) tab.set(key, withoutColumn(tab.get(key) ?? ''))
+      try {
+        const keys: string[] = []
+        for (let i = 0; i < localStorage.length; i++) {
+          const key = localStorage.key(i)
+          if (ofCluster(key)) keys.push(key)
+        }
+        for (const key of keys) {
+          const next = withoutColumn(localStorage.getItem(key) ?? '')
+          if (next) localStorage.setItem(key, next)
+          else localStorage.removeItem(key)
+        }
+      } catch { /* ignore */ }
+    },
+    /** The last Resources list path (`/resources/<plural>[?apiGroup=…]`). */
+    lastKind(): string | undefined {
+      try {
+        return localStorage.getItem(lastKindKey) ?? undefined
+      } catch {
+        return undefined
+      }
+    },
+    /** Records a location; only a Resources list path counts. */
+    recordLastKind(pathname: string, search: string) {
+      const path = pathname.replace(/\/+$/, '')
+      if (!RESOURCE_LIST_PATH.test(path)) return
+      const group = new URLSearchParams(search).get('apiGroup')
+      const value = group ? `${path}?${new URLSearchParams({ apiGroup: group })}` : path
+      try {
+        localStorage.setItem(lastKindKey, value)
+      } catch { /* ignore */ }
+    },
+  }
+}
+
+export type KindFilterStore = ReturnType<typeof createKindFilterStore>

package/src/utils/navigation.test.ts

@@ -4,7 +4,7 @@ import {
   initNavigationMap,
   resetNavigationMap,
 } from '@skyhook-io/k8s-ui/utils/navigation'
-import { getNetworkPolicyResourceTarget, relatedResourcePath, resourcePath, withCrossViewParams } from './navigation'
+import { getNetworkPolicyResourceTarget, relatedResourcePath, resourcePath, withCrossViewParams, writeViewParams } from './navigation'
 
 afterEach(resetNavigationMap)
 
@@ -76,3 +76,15 @@ describe('withCrossViewParams', () => {
     expect(withCrossViewParams('/helm', '')).toBe('/helm')
   })
 })
+
+describe('writeViewParams', () => {
+  it('keeps topology mode and grouping only on topology', () => {
+    const topology = new URLSearchParams('namespace=old&apiGroup=example.com')
+    writeViewParams(topology, [], { mode: 'traffic', grouping: 'app' })
+    expect(topology.toString()).toBe('apiGroup=example.com&mode=traffic&group=app')
+
+    const issues = new URLSearchParams('mode=traffic&group=app&kind=Widget&apiGroup=example.com&resource=ns%2Fw')
+    writeViewParams(issues, ['ns'], null)
+    expect(issues.toString()).toBe('kind=Widget&apiGroup=example.com&resource=ns%2Fw&namespaces=ns')
+  })
+})

package/src/utils/navigation.ts

@@ -1,7 +1,7 @@
 import { apiUrl, getAuthHeaders, getCredentialsMode } from '../api/config'
 import { apiVersionToGroup, kindToPluralWithGroup } from '@skyhook-io/k8s-ui/utils/navigation'
 import { topologyNodeResourceKind } from '@skyhook-io/k8s-ui/utils/topology-neighborhood'
-import type { SelectedResource, Topology } from '@skyhook-io/k8s-ui/types/core'
+import type { GroupingMode, SelectedResource, Topology, TopologyMode } from '@skyhook-io/k8s-ui/types/core'
 import type { SearchHit } from '../api/client'
 
 /**
@@ -137,7 +137,44 @@ export function openExternal(url: string): void {
 // setMainView's cross-view params. A navigation whose search omits
 // ?namespaces= reads as an empty pick to App's URL sync, which clears the
 // user's namespace scope.
-const CROSS_VIEW_PARAMS = ['namespaces', 'ai-run'] as const
+export const CROSS_VIEW_PARAMS = ['namespaces', 'ai-run'] as const
+
+/** A Resources list route (`/resources/<plural>`), as opposed to bare `/resources` or a detail page. */
+export const RESOURCE_LIST_PATH = /^\/resources\/[^/]+$/
+
+/**
+ * Writes App's view state into the query string. Topology's `mode` and
+ * `group` are dropped on every other view, so no other view can use those
+ * names for params of its own.
+ */
+export function writeViewParams(
+  params: URLSearchParams,
+  namespaces: string[],
+  topology: { mode: TopologyMode; grouping: GroupingMode } | null,
+): void {
+  if (namespaces.length > 0) {
+    params.set('namespaces', namespaces.join(','))
+  } else {
+    params.delete('namespaces')
+  }
+  // Legacy single-namespace param
+  params.delete('namespace')
+  if (!topology) {
+    params.delete('mode')
+    params.delete('group')
+    return
+  }
+  if (topology.mode !== 'resources') {
+    params.set('mode', topology.mode)
+  } else {
+    params.delete('mode')
+  }
+  if (topology.grouping !== 'none' && (namespaces.length === 0 || topology.grouping !== 'namespace')) {
+    params.set('group', topology.grouping)
+  } else {
+    params.delete('group')
+  }
+}
 
 /** Carries the current cross-view params onto an in-app path that doesn't set them itself. */
 export function withCrossViewParams(path: string, currentSearch: string): string {

package/src/utils/page-links.ts

@@ -0,0 +1,21 @@
+/**
+ * The label for "← back" on the page a push lands on: the title of the page
+ * being left, which Radar keeps in the document title.
+ */
+export function currentPageLabel(): string {
+  return document.title.replace(/\s*·\s*Radar$/, '') || 'previous page'
+}
+
+/**
+ * Radar's Issues page narrowed to one subject (it has no link to a single issue).
+ * The subject travels as `resource=ns/name`, never `namespace=`: App reads a bare
+ * `namespace` as the view filter, and a URL without `namespaces` clears it.
+ */
+export function issuesPathForSubject(subject: { kind: string; group?: string; namespace: string; name: string }, viewNamespaces?: string | null): string {
+  const params = new URLSearchParams()
+  if (viewNamespaces) params.set('namespaces', viewNamespaces)
+  params.set('kind', subject.kind)
+  if (subject.group) params.set('apiGroup', subject.group)
+  params.set('resource', subject.namespace ? `${subject.namespace}/${subject.name}` : subject.name)
+  return `/issues?${params}`
+}

package/src/utils/tabStorage.ts

@@ -0,0 +1,40 @@
+/**
+ * Per-tab strings in sessionStorage: they survive a reload and are copied
+ * when the tab is duplicated, while a tab opened from scratch starts empty.
+ * Without sessionStorage (private mode, blocked site data) they live in
+ * memory, so a reload forgets them.
+ */
+export function createTabStorage() {
+  let session: Storage | undefined
+  try {
+    session = sessionStorage
+    session.getItem('')
+  } catch {
+    session = undefined
+  }
+  const memory = new Map<string, string>()
+
+  return {
+    get(key: string): string | undefined {
+      return session ? session.getItem(key) ?? undefined : memory.get(key)
+    },
+    set(key: string, value: string) {
+      if (!session) {
+        memory.set(key, value)
+        return
+      }
+      try {
+        session.setItem(key, value)
+      } catch { /* over quota: keep the previous value */ }
+    },
+    keys(): string[] {
+      if (!session) return [...memory.keys()]
+      const keys: string[] = []
+      for (let i = 0; i < session.length; i++) {
+        const key = session.key(i)
+        if (key !== null) keys.push(key)
+      }
+      return keys
+    },
+  }
+}