@skyhook-io/k8s-ui 1.5.13 → 1.6.1

package/src/utils/format.ts

@@ -175,6 +175,34 @@ export function formatCPUMillicores(millicores: number): string {
   return formatCoresValue(cores)
 }
 
+// =============================================================================
+// Time Formatting
+// =============================================================================
+
+export function formatCompactAge(value?: string): string {
+  if (!value) return ''
+  const time = Date.parse(value)
+  if (!Number.isFinite(time)) return ''
+  const seconds = Math.max(0, Math.floor((Date.now() - time) / 1000))
+  if (seconds < 60) return `${seconds}s`
+  const minutes = Math.floor(seconds / 60)
+  if (minutes < 60) return `${minutes}m`
+  const hours = Math.floor(minutes / 60)
+  if (hours < 24) return `${hours}h`
+  return `${Math.floor(hours / 24)}d`
+}
+
+export function formatRelativeAgeTime(value?: string, fallback = '-'): string {
+  if (!value) return fallback
+  const time = Date.parse(value)
+  if (!Number.isFinite(time)) return value
+  const diff = Date.now() - time
+  if (diff < 0) return new Date(time).toLocaleString()
+  const compact = formatCompactAge(value)
+  if (!compact) return fallback
+  return compact === '0s' ? 'just now' : `${compact} ago`
+}
+
 /**
  * Format memory MiB to human-readable string.
  * Used by dashboard API which returns memory in MiB.

package/src/utils/gitops-owner.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect } from 'vitest'
+
+import type { Relationships } from '../types/core'
+
+import { gitOpsOwnerFromRelationships } from './gitops-owner'
+
+describe('gitOpsOwnerFromRelationships', () => {
+  it('returns null when relationships is undefined', () => {
+    expect(gitOpsOwnerFromRelationships(undefined)).toBeNull()
+  })
+
+  it('returns null when managedBy is absent', () => {
+    expect(gitOpsOwnerFromRelationships({})).toBeNull()
+  })
+
+  it('returns null when managedBy is empty', () => {
+    expect(gitOpsOwnerFromRelationships({ managedBy: [] })).toBeNull()
+  })
+
+  it('maps an ArgoCD Application ref', () => {
+    const rel: Relationships = {
+      managedBy: [{ kind: 'Application', group: 'argoproj.io', namespace: 'argocd', name: 'storefront' }],
+    }
+    expect(gitOpsOwnerFromRelationships(rel)).toEqual({
+      tool: 'argocd',
+      kind: 'applications',
+      namespace: 'argocd',
+      name: 'storefront',
+    })
+  })
+
+  it('maps a Flux Kustomization ref', () => {
+    const rel: Relationships = {
+      managedBy: [{ kind: 'Kustomization', group: 'kustomize.toolkit.fluxcd.io', namespace: 'flux-system', name: 'prod-apps' }],
+    }
+    expect(gitOpsOwnerFromRelationships(rel)).toEqual({
+      tool: 'fluxcd',
+      kind: 'kustomizations',
+      namespace: 'flux-system',
+      name: 'prod-apps',
+    })
+  })
+
+  it('maps a Flux HelmRelease ref', () => {
+    const rel: Relationships = {
+      managedBy: [{ kind: 'HelmRelease', group: 'helm.toolkit.fluxcd.io', namespace: 'flux-system', name: 'cert-manager' }],
+    }
+    expect(gitOpsOwnerFromRelationships(rel)).toEqual({
+      tool: 'fluxcd',
+      kind: 'helmreleases',
+      namespace: 'flux-system',
+      name: 'cert-manager',
+    })
+  })
+
+  it('disambiguates Flux HelmRelease from native Helm via API group', () => {
+    // A native Helm release would not carry the helm.toolkit.fluxcd.io group;
+    // server-side SynthesizeManagedBy only assigns that group for Flux.
+    const rel: Relationships = {
+      managedBy: [{ kind: 'HelmRelease', group: 'helm.sh', namespace: 'default', name: 'native-helm' }],
+    }
+    expect(gitOpsOwnerFromRelationships(rel)).toBeNull()
+  })
+
+  it('returns null for native K8s owners (no GitOps chip)', () => {
+    const rel: Relationships = {
+      managedBy: [{ kind: 'Deployment', namespace: 'prod', name: 'web' }],
+    }
+    expect(gitOpsOwnerFromRelationships(rel)).toBeNull()
+  })
+
+  it('returns null for an unrecognized manager kind', () => {
+    const rel: Relationships = {
+      managedBy: [{ kind: 'CustomController', group: 'example.com', namespace: 'prod', name: 'thing' }],
+    }
+    expect(gitOpsOwnerFromRelationships(rel)).toBeNull()
+  })
+
+  it('only considers the first managedBy entry', () => {
+    // The server emits the topmost meaningful manager first; if there are
+    // multiple, downstream chips intentionally only render the primary.
+    const rel: Relationships = {
+      managedBy: [
+        { kind: 'Application', group: 'argoproj.io', namespace: 'argocd', name: 'primary' },
+        { kind: 'Kustomization', group: 'kustomize.toolkit.fluxcd.io', namespace: 'flux-system', name: 'secondary' },
+      ],
+    }
+    expect(gitOpsOwnerFromRelationships(rel)).toEqual({
+      tool: 'argocd',
+      kind: 'applications',
+      namespace: 'argocd',
+      name: 'primary',
+    })
+  })
+})

package/src/utils/gitops-owner.ts

@@ -0,0 +1,55 @@
+// Map a resource's server-side `Relationships.managedBy` to a navigable
+// GitOps owner ref, used by the drawer to render the "Managed by <app>" chip.
+//
+// The detection (label/annotation parsing, Argo tracking-id decoding, Flux
+// label inspection, Helm release annotation, owner-chain walk) lives server-
+// side in pkg/topology.SynthesizeManagedBy. This file is now a thin mapper
+// from the structured ref into the discriminated union the chip + router need.
+
+import type { Relationships, ResourceRef } from '../types/core'
+
+// GitOpsOwnerRef is a discriminated union — the tool determines which kind is
+// valid. Modeling it this way prevents callers (and consumers of the returned
+// type) from constructing `{ tool: 'argo', kind: 'helmreleases' }` which would
+// route to a non-existent page.
+export type GitOpsOwnerRef =
+  | { tool: 'argocd'; kind: 'applications'; namespace: string; name: string }
+  | { tool: 'fluxcd'; kind: 'kustomizations' | 'helmreleases'; namespace: string; name: string }
+
+// Vocabulary mirrors `pkg/gitops/tree.Tool` so the wire labels match end-to-end.
+export type GitOpsOwnerTool = GitOpsOwnerRef['tool']
+
+// API groups for GitOps manager kinds. Used to disambiguate Flux HelmRelease
+// from a future native-Helm kind, etc.
+const ARGO_APPLICATION_GROUP = 'argoproj.io'
+const FLUX_KUSTOMIZE_GROUP = 'kustomize.toolkit.fluxcd.io'
+const FLUX_HELM_GROUP = 'helm.toolkit.fluxcd.io'
+
+// gitOpsOwnerFromRelationships reads relationships.managedBy[0] and maps it to
+// a GitOpsOwnerRef when the manager is a GitOps controller. Returns null when
+// the manager is a native K8s owner (Deployment, ReplicaSet, etc.), a plain
+// Helm release, or when no manager is reported.
+//
+// Old radar binaries (pre-T2) emit no managedBy field; this returns null in
+// that case and the drawer silently skips the chip — natural pressure to
+// upgrade rather than carry a label-parsing fallback in the client.
+export function gitOpsOwnerFromRelationships(
+  rel: Relationships | undefined | null,
+): GitOpsOwnerRef | null {
+  const refs = rel?.managedBy
+  if (!refs || refs.length === 0) return null
+  return refToGitOpsOwner(refs[0])
+}
+
+function refToGitOpsOwner(ref: ResourceRef): GitOpsOwnerRef | null {
+  switch (true) {
+    case ref.kind === 'Application' && ref.group === ARGO_APPLICATION_GROUP:
+      return { tool: 'argocd', kind: 'applications', namespace: ref.namespace, name: ref.name }
+    case ref.kind === 'Kustomization' && ref.group === FLUX_KUSTOMIZE_GROUP:
+      return { tool: 'fluxcd', kind: 'kustomizations', namespace: ref.namespace, name: ref.name }
+    case ref.kind === 'HelmRelease' && ref.group === FLUX_HELM_GROUP:
+      return { tool: 'fluxcd', kind: 'helmreleases', namespace: ref.namespace, name: ref.name }
+    default:
+      return null
+  }
+}

package/src/utils/gitops-route.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest'
+import { gitOpsRouteForOwner, gitOpsRouteForResource } from './gitops-route'
+
+describe('gitOpsRouteForOwner', () => {
+  it('routes to detail URL for Argo with known namespace', () => {
+    expect(gitOpsRouteForOwner({ tool: 'argocd', kind: 'applications', namespace: 'argocd', name: 'guestbook' }))
+      .toBe('/gitops/detail/applications/argocd/guestbook')
+  })
+  it('routes to fleet when Argo namespace is unknown (bare instance label)', () => {
+    expect(gitOpsRouteForOwner({ tool: 'argocd', kind: 'applications', namespace: '', name: 'guestbook' }))
+      .toBe('/gitops')
+  })
+  it('routes Flux Kustomization owners with their namespace', () => {
+    expect(gitOpsRouteForOwner({ tool: 'fluxcd', kind: 'kustomizations', namespace: 'flux-system', name: 'podinfo' }))
+      .toBe('/gitops/detail/kustomizations/flux-system/podinfo')
+  })
+  it('routes Flux HelmRelease owners', () => {
+    expect(gitOpsRouteForOwner({ tool: 'fluxcd', kind: 'helmreleases', namespace: 'flux-system', name: 'podinfo' }))
+      .toBe('/gitops/detail/helmreleases/flux-system/podinfo')
+  })
+  it('encodes path components', () => {
+    expect(gitOpsRouteForOwner({ tool: 'fluxcd', kind: 'kustomizations', namespace: 'has space', name: 'a/b' }))
+      .toBe('/gitops/detail/kustomizations/has%20space/a%2Fb')
+  })
+})
+
+describe('gitOpsRouteForResource', () => {
+  const mk = (api: string, kind: string, ns = 'x', name = 'y') => ({
+    apiVersion: api, kind, metadata: { namespace: ns, name },
+  })
+
+  it('routes Argo CRs (Application/ApplicationSet/AppProject)', () => {
+    expect(gitOpsRouteForResource(mk('argoproj.io/v1alpha1', 'Application', 'argocd', 'app')))
+      .toBe('/gitops/detail/applications/argocd/app')
+    expect(gitOpsRouteForResource(mk('argoproj.io/v1alpha1', 'ApplicationSet', 'argocd', 'set')))
+      .toBe('/gitops/detail/applicationsets/argocd/set')
+    expect(gitOpsRouteForResource(mk('argoproj.io/v1alpha1', 'AppProject', 'argocd', 'proj')))
+      .toBe('/gitops/detail/appprojects/argocd/proj')
+  })
+
+  it('routes Flux reconcilers (Kustomization/HelmRelease)', () => {
+    expect(gitOpsRouteForResource(mk('kustomize.toolkit.fluxcd.io/v1', 'Kustomization', 'flux-system', 'k')))
+      .toBe('/gitops/detail/kustomizations/flux-system/k')
+    expect(gitOpsRouteForResource(mk('helm.toolkit.fluxcd.io/v2', 'HelmRelease', 'flux-system', 'hr')))
+      .toBe('/gitops/detail/helmreleases/flux-system/hr')
+  })
+
+  // Source CRs are *not* portals — the resource drawer renders them better.
+  // If this ever flips, also update pkg/gitops/tree/graph.go classifyGitOpsKind
+  // and web/src/components/gitops/GitOpsView.tsx isGitOpsDetailRef.
+  it('returns null for Flux source CRs (drawer-only)', () => {
+    expect(gitOpsRouteForResource(mk('source.toolkit.fluxcd.io/v1', 'GitRepository'))).toBeNull()
+    expect(gitOpsRouteForResource(mk('source.toolkit.fluxcd.io/v1', 'HelmRepository'))).toBeNull()
+    expect(gitOpsRouteForResource(mk('source.toolkit.fluxcd.io/v1beta2', 'OCIRepository'))).toBeNull()
+    expect(gitOpsRouteForResource(mk('source.toolkit.fluxcd.io/v1beta2', 'Bucket'))).toBeNull()
+    expect(gitOpsRouteForResource(mk('source.toolkit.fluxcd.io/v1', 'HelmChart'))).toBeNull()
+  })
+
+  it('returns null for ordinary K8s resources', () => {
+    expect(gitOpsRouteForResource(mk('apps/v1', 'Deployment'))).toBeNull()
+    expect(gitOpsRouteForResource(mk('v1', 'Service'))).toBeNull()
+    expect(gitOpsRouteForResource(mk('v1', 'Pod'))).toBeNull()
+  })
+
+  it('returns null on malformed input', () => {
+    expect(gitOpsRouteForResource(null)).toBeNull()
+    expect(gitOpsRouteForResource(undefined)).toBeNull()
+    expect(gitOpsRouteForResource({})).toBeNull()
+    expect(gitOpsRouteForResource({ kind: 'Application' })).toBeNull() // no apiVersion → no group
+  })
+
+  it('distinguishes name collisions by group', () => {
+    // Knative Service vs core Service — not a portal kind, but pins behavior.
+    expect(gitOpsRouteForResource(mk('serving.knative.dev/v1', 'Service'))).toBeNull()
+    // A hypothetical "Application" CR in another group must not portal.
+    expect(gitOpsRouteForResource(mk('example.com/v1', 'Application'))).toBeNull()
+  })
+})

package/src/utils/gitops-route.ts

@@ -0,0 +1,104 @@
+// Routes to the GitOps detail page (in fleet view if the lookup is ambiguous).
+//
+// Two distinct entry points:
+//
+//   gitOpsRouteForOwner(owner)
+//     For "Managed by <app>" affordances: an ordinary K8s resource carries
+//     GitOps ownership labels/annotations and we want to navigate to its
+//     owning GitOps CR. Wraps the detect→navigate split: detectGitOpsOwner
+//     gives us a typed ref, this helper turns the ref into a URL.
+//
+//   gitOpsRouteForResource(resource)
+//     For "Open in GitOps" affordances on the GitOps CR itself
+//     (Application, ApplicationSet, AppProject, Kustomization, HelmRelease).
+//     Source CRs (GitRepository/HelmRepository/OCIRepository/Bucket/HelmChart)
+//     return null — they're not portal kinds; the standard resource drawer
+//     renders them better.
+//
+// Keep the portal catalog in sync with:
+//   - pkg/gitops/tree/graph.go        (Go classifier)
+//   - web/src/components/gitops/GitOpsView.tsx isGitOpsDetailRef
+// If a kind is added or removed here, update those too.
+
+import type { GitOpsOwnerRef } from './gitops-owner'
+
+export interface GitOpsResource {
+  apiVersion?: string
+  kind?: string
+  metadata?: { namespace?: string; name?: string }
+}
+
+// gitOpsRouteForOwner turns a detected GitOps owner ref into a navigable URL.
+// When the owner namespace is unknown (Argo apps detected only by the bare
+// app.kubernetes.io/instance label), routes to the GitOps fleet view so the
+// user can locate the app rather than landing on a 404'd detail URL.
+export function gitOpsRouteForOwner(owner: GitOpsOwnerRef): string {
+  if (owner.tool === 'argocd' && !owner.namespace) {
+    return '/gitops'
+  }
+  return gitOpsDetailUrl(owner.kind, owner.namespace, owner.name)
+}
+
+// gitOpsRouteForResource returns the GitOps detail URL for a portal-kind
+// resource, or null when the resource isn't itself a GitOps CR that has its
+// own detail page. Callers should fall back to the standard resource drawer
+// on null.
+export function gitOpsRouteForResource(resource: GitOpsResource | null | undefined): string | null {
+  if (!resource) return null
+  const kind = resource.kind?.toLowerCase()
+  const group = apiGroup(resource.apiVersion)
+  const ns = resource.metadata?.namespace ?? ''
+  const name = resource.metadata?.name ?? ''
+  if (!kind || !name) return null
+
+  const plural = portalPluralFor(kind, group)
+  if (!plural) return null
+  return gitOpsDetailUrl(plural, ns, name)
+}
+
+function portalPluralFor(kindLower: string, group: string): string | null {
+  if (group === 'argoproj.io') {
+    if (kindLower === 'application') return 'applications'
+    if (kindLower === 'applicationset') return 'applicationsets'
+    if (kindLower === 'appproject') return 'appprojects'
+    return null
+  }
+  if (group === 'kustomize.toolkit.fluxcd.io' && kindLower === 'kustomization') return 'kustomizations'
+  if (group === 'helm.toolkit.fluxcd.io' && kindLower === 'helmrelease') return 'helmreleases'
+  return null
+}
+
+function apiGroup(apiVersion: string | undefined): string {
+  if (!apiVersion) return ''
+  const slash = apiVersion.indexOf('/')
+  return slash < 0 ? '' : apiVersion.slice(0, slash)
+}
+
+function gitOpsDetailUrl(kindPlural: string, namespace: string, name: string): string {
+  const ns = encodeURIComponent(namespace || '_')
+  return `/gitops/detail/${encodeURIComponent(kindPlural)}/${ns}/${encodeURIComponent(name)}`
+}
+
+// gitOpsRouteForKind is a kind-only variant for callers that only have
+// (kind, namespace, name) — e.g. Audit findings, which today don't carry the
+// apiGroup of the resource they subject. Matches by kind alone, accepting the
+// (very small) risk of routing a CRD named "Application" or "Kustomization"
+// from a non-GitOps group to a "not found" GitOps detail page. When/if those
+// callers grow apiGroup access, prefer gitOpsRouteForResource.
+export function gitOpsRouteForKind(kind: string, namespace: string, name: string): string | null {
+  if (!kind || !name) return null
+  switch (kind) {
+    case 'Application':
+      return gitOpsDetailUrl('applications', namespace, name)
+    case 'ApplicationSet':
+      return gitOpsDetailUrl('applicationsets', namespace, name)
+    case 'AppProject':
+      return gitOpsDetailUrl('appprojects', namespace, name)
+    case 'Kustomization':
+      return gitOpsDetailUrl('kustomizations', namespace, name)
+    case 'HelmRelease':
+      return gitOpsDetailUrl('helmreleases', namespace, name)
+    default:
+      return null
+  }
+}

package/src/utils/helm-status.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest'
+import { isHelmReleaseActionable } from './badge-colors'
+
+// Pin the membership set so adding a new Helm status becomes a
+// deliberate decision here.
+
+describe('isHelmReleaseActionable', () => {
+  it('returns true for `failed`', () => {
+    expect(isHelmReleaseActionable('failed')).toBe(true)
+  })
+
+  it('is case-insensitive (matches Helm SDK serialisation variants)', () => {
+    expect(isHelmReleaseActionable('FAILED')).toBe(true)
+    expect(isHelmReleaseActionable('Failed')).toBe(true)
+  })
+
+  it('returns FALSE for the pending-* in-flight statuses', () => {
+    // These are Helm's NORMAL in-flight states during every
+    // routine install/upgrade/rollback. If we treated them as
+    // actionable, every routine install would briefly attach an
+    // alarming chevron + tooltip to its own row. Until we have
+    // release age available client-side to distinguish
+    // "transient" from "stuck > N min", we give up the
+    // stuck-controller signpost rather than alarm the common case.
+    expect(isHelmReleaseActionable('pending-install')).toBe(false)
+    expect(isHelmReleaseActionable('pending-upgrade')).toBe(false)
+    expect(isHelmReleaseActionable('pending-rollback')).toBe(false)
+  })
+
+  it('returns false for the success / normal statuses', () => {
+    expect(isHelmReleaseActionable('deployed')).toBe(false)
+    expect(isHelmReleaseActionable('superseded')).toBe(false)
+    expect(isHelmReleaseActionable('uninstalled')).toBe(false)
+  })
+
+  it('returns false for `uninstalling` (in-progress, not stuck)', () => {
+    expect(isHelmReleaseActionable('uninstalling')).toBe(false)
+  })
+
+  it('returns false for null / undefined / empty', () => {
+    expect(isHelmReleaseActionable(null)).toBe(false)
+    expect(isHelmReleaseActionable(undefined)).toBe(false)
+    expect(isHelmReleaseActionable('')).toBe(false)
+  })
+
+  it('returns false for unknown strings (defensive)', () => {
+    expect(isHelmReleaseActionable('mystery-status')).toBe(false)
+    expect(isHelmReleaseActionable('error')).toBe(false) // Helm uses 'failed', not 'error'
+  })
+})

package/src/utils/index.ts

@@ -14,3 +14,5 @@ export * from './k8s-errors'
 export * from './parse-go-time'
 export * from './view-transition'
 export * from './validators'
+export * from './gitops-owner'
+export * from './gitops-route'

package/src/utils/navigation.ts

@@ -142,3 +142,17 @@ export function refToSelectedResource(ref: ResourceRef): SelectedResource {
     group: ref.group,
   }
 }
+
+/**
+ * Extract the API group from an apiVersion string.
+ * Returns '' for core resources (e.g. "v1") and for missing/empty input.
+ * Examples:
+ *   "v1"                          → ""
+ *   "apps/v1"                     → "apps"
+ *   "cluster.x-k8s.io/v1beta1"    → "cluster.x-k8s.io"
+ */
+export function apiVersionToGroup(apiVersion?: string | null): string {
+  if (!apiVersion) return ''
+  const i = apiVersion.indexOf('/')
+  return i === -1 ? '' : apiVersion.slice(0, i)
+}

package/src/utils/resource-hierarchy.ts

@@ -13,6 +13,7 @@
 
 import type { TimelineEvent, Topology } from '../types/core'
 import { isWorkloadKind } from '../types/core'
+import { apiVersionToGroup } from './navigation'
 
 /**
  * Resource lane representing a single resource and its timeline events.
@@ -21,6 +22,12 @@ import { isWorkloadKind } from '../types/core'
 export interface ResourceLane {
   id: string
   kind: string
+  /**
+   * API group for the resource (e.g. "cluster.x-k8s.io"). Empty for core
+   * resources. Needed to disambiguate CRDs whose kind collides with another
+   * (e.g. CAPI Cluster vs CNPG Cluster) when the lane is clicked.
+   */
+  group?: string
   namespace: string
   name: string
   events: TimelineEvent[]
@@ -179,6 +186,25 @@ export function buildResourceHierarchy(options: HierarchyOptions): ResourceLane[
   const { events, topology, rootResource, groupByApp = true } = options
   const laneMap = new Map<string, ResourceLane>()
 
+  // API group lookup by lane ID (kind/namespace/name) sourced from topology nodes.
+  // Lanes built from events (which carry apiVersion) take precedence over this fallback,
+  // but parent lanes that exist only as edge endpoints still need a group.
+  const topoGroupByLaneId = new Map<string, string>()
+  if (topology?.nodes) {
+    for (const node of topology.nodes) {
+      const laneId = nodeIdToLaneId(node.id)
+      if (!laneId) continue
+      const apiVersion = node.data?.apiVersion as string | undefined
+      const group = apiVersionToGroup(apiVersion)
+      if (group) topoGroupByLaneId.set(laneId, group)
+    }
+  }
+  const resolveGroup = (laneId: string, event?: TimelineEvent): string => {
+    const fromEvent = apiVersionToGroup(event?.apiVersion)
+    if (fromEvent) return fromEvent
+    return topoGroupByLaneId.get(laneId) ?? ''
+  }
+
   // Track events that should be attached to their owner instead of their own lane
   const eventsToAttach: { event: TimelineEvent; ownerLaneId: string }[] = []
 
@@ -192,19 +218,28 @@ export function buildResourceHierarchy(options: HierarchyOptions): ResourceLane[
     }
 
     const laneId = `${event.kind}/${event.namespace}/${event.name}`
-    if (!laneMap.has(laneId)) {
+    const existing = laneMap.get(laneId)
+    if (!existing) {
       laneMap.set(laneId, {
         id: laneId,
         kind: event.kind,
+        group: resolveGroup(laneId, event),
         namespace: event.namespace,
         name: event.name,
-        events: [],
+        events: [event],
         isWorkload: isWorkloadKind(event.kind),
         children: [],
         childEventCount: 0,
       })
+    } else {
+      // Stored events may lack apiVersion; upgrade the lane's group from any
+      // later event that carries it.
+      if (!existing.group) {
+        const fromEvent = apiVersionToGroup(event.apiVersion)
+        if (fromEvent) existing.group = fromEvent
+      }
+      existing.events.push(event)
     }
-    laneMap.get(laneId)!.events.push(event)
   }
 
   // Attach K8s Events to their owner lanes
@@ -218,6 +253,7 @@ export function buildResourceHierarchy(options: HierarchyOptions): ResourceLane[
       laneMap.set(ownerLaneId, {
         id: ownerLaneId,
         kind: parts[0],
+        group: resolveGroup(ownerLaneId),
         namespace: parts[1],
         name: parts.slice(2).join('/'),
         events: [event],
@@ -242,6 +278,7 @@ export function buildResourceHierarchy(options: HierarchyOptions): ResourceLane[
         laneMap.set(ownerLaneId, {
           id: ownerLaneId,
           kind: eventWithOwner.owner.kind,
+          group: resolveGroup(ownerLaneId),
           namespace: lane.namespace,
           name: eventWithOwner.owner.name,
           events: [],
@@ -277,6 +314,7 @@ export function buildResourceHierarchy(options: HierarchyOptions): ResourceLane[
             laneMap.set(sourceLaneId, {
               id: sourceLaneId,
               kind: parts[0],
+              group: resolveGroup(sourceLaneId),
               namespace: parts[1],
               name: parts.slice(2).join('/'),
               events: [],
@@ -304,6 +342,7 @@ export function buildResourceHierarchy(options: HierarchyOptions): ResourceLane[
               laneMap.set(sourceLaneId, {
                 id: sourceLaneId,
                 kind: parts[0],
+                group: resolveGroup(sourceLaneId),
                 namespace: parts[1],
                 name: parts.slice(2).join('/'),
                 events: [],
@@ -323,6 +362,7 @@ export function buildResourceHierarchy(options: HierarchyOptions): ResourceLane[
               laneMap.set(targetLaneId, {
                 id: targetLaneId,
                 kind: parts[0],
+                group: resolveGroup(targetLaneId),
                 namespace: parts[1],
                 name: parts.slice(2).join('/'),
                 events: [],
@@ -342,6 +382,7 @@ export function buildResourceHierarchy(options: HierarchyOptions): ResourceLane[
               laneMap.set(targetLaneId, {
                 id: targetLaneId,
                 kind: parts[0],
+                group: resolveGroup(targetLaneId),
                 namespace: parts[1],
                 name: parts.slice(2).join('/'),
                 events: [],
@@ -361,6 +402,7 @@ export function buildResourceHierarchy(options: HierarchyOptions): ResourceLane[
               laneMap.set(sourceLaneId, {
                 id: sourceLaneId,
                 kind: parts[0],
+                group: resolveGroup(sourceLaneId),
                 namespace: parts[1],
                 name: parts.slice(2).join('/'),
                 events: [],
@@ -382,6 +424,7 @@ export function buildResourceHierarchy(options: HierarchyOptions): ResourceLane[
             laneMap.set(targetLaneId, {
               id: targetLaneId,
               kind: parts[0],
+              group: resolveGroup(targetLaneId),
               namespace: parts[1],
               name: parts.slice(2).join('/'),
               events: [],
@@ -582,6 +625,7 @@ export function buildResourceHierarchy(options: HierarchyOptions): ResourceLane[
     const placeholderLane: ResourceLane = {
       id: rootLaneId,
       kind: rootResource.kind,
+      group: resolveGroup(rootLaneId),
       namespace: rootResource.namespace,
       name: rootResource.name,
       events: [],