@skyhook-io/k8s-ui 1.8.0 → 1.8.2

package/src/utils/applications.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { compareVersions, appGroupLagMessage, matchWorkloadAcrossInstances, foldAppGroups, identityEnvInferred, type AppGroupFoldEntry } from './applications'
+import { compareVersions, appGroupingExplainer, APP_IDENTITY_ANNOTATION, appGroupLagMessage, matchWorkloadAcrossInstances, foldAppGroups, identityEnvInferred, type AppGroupFoldEntry } from './applications'
 
 describe('compareVersions', () => {
   it('orders semver', () => {
@@ -205,3 +205,40 @@ describe('foldAppGroups', () => {
     expect(grouped.map((r) => r.kind)).toEqual(['group'])
   })
 })
+
+describe('appGroupingExplainer', () => {
+  it('declared origins fold across clusters with no fix needed', () => {
+    for (const source of ['explicit', 'argo-path', 'argo-appset', 'flux-source']) {
+      const e = appGroupingExplainer({ key: 'k', env: 'prod', confidence: 'high', evidence: '', source })
+      expect(e.folds).toBe(true)
+      expect(e.fix).toBeUndefined()
+    }
+  })
+
+  it('NAME sources stay per-cluster and tell the user how to fold', () => {
+    for (const source of ['label', 'name-stem', 'namespace', undefined]) {
+      const e = appGroupingExplainer({ key: 'k', env: 'prod', confidence: 'high', evidence: '', source })
+      expect(e.folds).toBe(false)
+      expect(e.fix).toContain(APP_IDENTITY_ANNOTATION)
+    }
+  })
+})
+
+describe('foldAppGroups pathKey disambiguation', () => {
+  const fleetEntry = (key: string, env: string, pathKey: string): AppGroupFoldEntry => ({
+    row: { key, name: 'billing', identity: { key: 'billing', env, confidence: 'high', evidence: 'e', portable: true, source: 'argo-path', pathKey } },
+    health: 'healthy', versions: [], ready: 1, desired: 1, kinds: { Deployment: 1 }, classComposition: [{ cls: 'service', count: 1 }],
+  })
+  const opts = { localScope: (e: AppGroupFoldEntry) => e.row.key }
+
+  it('folds same-name portable rows that share a pathKey', () => {
+    const rows = foldAppGroups([fleetEntry('cl-a', 'dev', 'apps/billing'), fleetEntry('cl-b', 'prod', 'apps/billing')], new Set(), false, opts)
+    expect(rows.filter((r) => r.kind === 'group').length).toBe(1)
+  })
+
+  it('does NOT fold same-name portable rows with different pathKeys (two teams, two paths)', () => {
+    const rows = foldAppGroups([fleetEntry('cl-a', 'dev', 'teamA/billing'), fleetEntry('cl-b', 'prod', 'teamB/billing')], new Set(), false, opts)
+    expect(rows.filter((r) => r.kind === 'group').length).toBe(0)
+    expect(rows.filter((r) => r.kind === 'instance').length).toBe(2)
+  })
+})

package/src/utils/applications.ts

@@ -53,6 +53,63 @@ export interface AppIdentity {
   evidence: string
   /** True when the key is backed by declared upstream identity and can group across clusters. */
   portable?: boolean
+  /** Machine-readable provenance tier (radar applications_identity.go):
+   *  explicit | argo-path | argo-appset | flux-source (declared origins, portable)
+   *  · label | name-stem | namespace (NAMEs, per-cluster). */
+  source?: string
+  /** Declared source-path stem (argo-path / flux-source only). The display `key`
+   *  is the name stem; this disambiguates same-name/different-path apps in the
+   *  portable cross-cluster fold. */
+  pathKey?: string
+}
+
+/** The user-set annotation that forces cross-cluster grouping — the canonical
+ *  answer to "how do I make this fold?" for non-GitOps apps. */
+export const APP_IDENTITY_ANNOTATION = 'app.skyhook.io/app'
+
+/** Whether a Source is a declared cross-cluster origin (mirrors the hub's
+ *  isDeclaredPortableSource). NAMEs collide across clusters and stay per-cluster. */
+export function isDeclaredAppSource(source?: string): boolean {
+  return source === 'explicit' || source === 'argo-path' || source === 'argo-appset' || source === 'flux-source'
+}
+
+/** A short label for how an app's identity was determined, by Source — the
+ *  plain-language "grouped by …" phrase shown in the identity tooltip. */
+export function appSourceLabel(source?: string): string {
+  switch (source) {
+    case 'explicit':
+      return `the ${APP_IDENTITY_ANNOTATION} annotation`
+    case 'argo-path':
+      return 'its Argo CD source path'
+    case 'argo-appset':
+      return 'its ApplicationSet (env fan-out)'
+    case 'flux-source':
+      return 'its Flux source'
+    case 'addon':
+      return 'a shared add-on name + chart/image'
+    case 'label':
+      return 'the app.kubernetes.io/name label'
+    case 'name-stem':
+      return 'a shared name + image'
+    case 'namespace':
+      return 'a shared namespace + image'
+    default:
+      return 'its workload grouping'
+  }
+}
+
+/** The explainer for "why isn't this grouped across clusters, and how do I fix
+ *  it?" — drives the per-cluster row hint. `folds` is true when the identity is a
+ *  declared origin (folds cross-cluster); otherwise `fix` says what to add. */
+export function appGroupingExplainer(identity?: AppIdentity): { folds: boolean; how: string; fix?: string } {
+  const folds = isDeclaredAppSource(identity?.source)
+  return {
+    folds,
+    how: `Grouped by ${appSourceLabel(identity?.source)}.`,
+    fix: folds
+      ? undefined
+      : `This app only has a per-cluster name, which can't prove two clusters run the same app. To fold it across clusters, set ${APP_IDENTITY_ANNOTATION} on its workloads in each cluster (same value), or deploy it via Argo CD / Flux with the environment in the source path.`,
+  }
 }
 
 export interface AppRow {
@@ -474,6 +531,12 @@ export interface FoldAppGroupsOptions<T extends AppGroupFoldEntry> {
    *  should include the cluster id so local name/repo evidence cannot merge
    *  unrelated clusters. Portable identities ignore the scope. */
   localScope?: (entry: T) => string | undefined
+  /** Per-member env slices for the env ladder. A fleet member spans several
+   *  per-cluster envs, so the host supplies them (cluster-coverage derived,
+   *  authoritative) rather than the single `identity.env` — which the hub can
+   *  stale when it joins the same overlay key across clusters. Defaults to the
+   *  member's single identity env. */
+  envsOf?: (entry: T) => Array<{ env: string; health: AppHealth }>
 }
 
 export function foldAppGroups<T extends AppGroupFoldEntry>(
@@ -489,7 +552,10 @@ export function foldAppGroups<T extends AppGroupFoldEntry>(
     if (!id) return null
     const scope = options.localScope?.(e)
     if (!scope) return id.key
-    return id.portable ? `portable:${id.key}` : `local:${scope}:${id.key}`
+    // A declared-PATH identity displays its name stem as the key but carries the
+    // path stem in pathKey; two different apps can share a name while declaring
+    // different paths, so disambiguate the portable cross-cluster fold by pathKey.
+    return id.portable ? `portable:${id.key}${id.pathKey ? `:${id.pathKey}` : ''}` : `local:${scope}:${id.key}`
   }
   const byGroup = new Map<string, T[]>()
   for (const e of entries) {
@@ -518,15 +584,20 @@ export function foldAppGroups<T extends AppGroupFoldEntry>(
     let desired = 0
     let health: AppHealth = 'unknown'
     for (const m of members) {
-      const env = m.row.identity!.env
       const v = newest(m)
-      const cur = cellMap.get(env)
-      if (!cur) {
-        cellMap.set(env, { env, health: m.health, version: v, count: 1, firstKey: m.row.key })
-      } else {
-        cur.count++
-        if ((HEALTH_RANK[m.health] ?? 0) > (HEALTH_RANK[cur.health] ?? 0)) cur.health = m.health
-        if (v && (!cur.version || compareVersions(v, cur.version) === 1)) cur.version = v
+      // A fleet member spans several per-cluster envs; the host supplies them so
+      // the ladder reflects every env, not just the member's (possibly stale)
+      // single identity env. Default: the one identity env.
+      const slices = options.envsOf?.(m) ?? [{ env: m.row.identity!.env, health: m.health }]
+      for (const slice of slices) {
+        const cur = cellMap.get(slice.env)
+        if (!cur) {
+          cellMap.set(slice.env, { env: slice.env, health: slice.health, version: v, count: 1, firstKey: m.row.key })
+        } else {
+          cur.count++
+          if ((HEALTH_RANK[slice.health] ?? 0) > (HEALTH_RANK[cur.health] ?? 0)) cur.health = slice.health
+          if (v && (!cur.version || compareVersions(v, cur.version) === 1)) cur.version = v
+        }
       }
       if ((HEALTH_RANK[m.health] ?? 0) > (HEALTH_RANK[health] ?? 0)) health = m.health
       ready += m.ready
@@ -672,3 +743,127 @@ export function newestTag(versions: string[]): string | undefined {
   }
   return best
 }
+
+// -----------------------------------------------------------------------------
+// Applications list entry model — the per-row shape the shared list core renders.
+// Discriminated on `variant` so the OSS single-cluster row and the Cloud fleet
+// row (one row spanning several clusters) carry their own fields with no loose
+// optional-superset overlap. The base carries everything the facet rail, fold,
+// counts, and sort read; the variant arms carry only what their instance-row
+// renderer needs. Both arms satisfy AppGroupFoldEntry, so foldAppGroups is shared.
+// -----------------------------------------------------------------------------
+
+export interface AppEntryBase {
+  row: AppRow
+  health: AppHealth
+  versions: string[]
+  kinds: Record<string, number>
+  workloadClass: AppWorkloadClass
+  /** Distinct contained classes — the inclusive facet-matching set. */
+  classSet: AppWorkloadClass[]
+  classComposition: { cls: AppWorkloadClass; count: number }[]
+  category: AppCategory
+  ready: number
+  desired: number
+  /** ready/desired as a fraction for sorting; -1 when nothing is desired. */
+  readyRatio: number
+  source: AppSource
+}
+
+export interface SingleAppEntry extends AppEntryBase {
+  variant: 'single'
+  namespace: string
+  namespaces: string[]
+  env: string
+  envInferred: boolean
+}
+
+/** One environment instance within a fleet row (env name + worst health across
+ *  its clusters + whether the env was inferred from the namespace). */
+export interface EnvSlice {
+  env: string
+  health: AppHealth
+  inferred: boolean
+}
+
+/** A cluster this fleet row's app runs in. */
+export interface AppClusterRef {
+  id: string
+  name: string
+  health: AppHealth
+}
+
+export interface FleetAppEntry extends AppEntryBase {
+  variant: 'fleet'
+  envs: EnvSlice[]
+  clusters: AppClusterRef[]
+  /** True when the app runs different versions across its clusters/envs. */
+  versionSkew: boolean
+}
+
+export type AppEntry = SingleAppEntry | FleetAppEntry
+
+/** Build a single-cluster list entry from a wire row. The env is resolved via
+ *  the server's identity classification (authoritative) with a namespace
+ *  heuristic fallback for plain rows. */
+export function buildSingleAppEntry(row: AppRow, discoveredEnvs?: ReadonlySet<string>): SingleAppEntry {
+  const kinds: Record<string, number> = {}
+  let ready = 0
+  let desired = 0
+  for (const wl of row.workloads || []) {
+    kinds[wl.kind] = (kinds[wl.kind] ?? 0) + 1
+    ready += wl.ready ?? 0
+    desired += wl.desired ?? 0
+  }
+  const namespace = namespaceOf(row)
+  // The server's identity classification carries the authoritative env (label/
+  // declared/discovered); plain rows fall back to the trio + discovered-token
+  // namespace heuristic.
+  const resolved = resolveEnv(undefined, namespace, discoveredEnvs)
+  const env = row.identity?.env ?? resolved.env
+  const inferred = row.identity ? identityEnvInferred(row.identity) : resolved.inferred
+  return {
+    variant: 'single',
+    row,
+    health: healthOf(row.health),
+    versions: Array.from(new Set((row.versions || []).filter(Boolean))),
+    namespace,
+    namespaces: namespacesOf(row),
+    env,
+    envInferred: inferred,
+    kinds,
+    workloadClass: workloadClassOf(row.workload_class),
+    classSet: classSetOf(row),
+    classComposition: classCompositionOf(row),
+    category: categoryOf(row.category),
+    ready,
+    desired,
+    readyRatio: desired > 0 ? ready / desired : -1,
+    source: sourceOf(row.tier),
+  }
+}
+
+/** The text an entry matches free-text search against — name, key, namespace,
+ *  source/class/category labels, versions, env, workload kinds + identity. Pure
+ *  and exported so the list core and tests share one definition. */
+export function searchTextForEntry(e: AppEntry): string {
+  const workloadText = (e.row.workloads || []).flatMap((wl) => [wl.kind, wl.namespace, wl.name, wl.version])
+  const envParts = e.variant === 'single' ? [e.env || 'unlabeled'] : e.envs.map((s) => s.env || 'unlabeled')
+  const nsParts = e.variant === 'single' ? [e.namespace] : e.clusters.map((c) => c.name)
+  return [
+    e.row.name,
+    e.row.key,
+    ...nsParts,
+    SOURCE_META[e.source].label,
+    CLASS_META[e.workloadClass].label,
+    ...e.classSet.map((c) => CLASS_META[c].label),
+    CATEGORY_META[e.category].label,
+    ...e.versions,
+    ...envParts,
+    ...Object.keys(e.kinds),
+    ...workloadText,
+  ]
+    .filter(Boolean)
+    .join(' ')
+    .toLowerCase()
+}

package/src/utils/platform.ts

@@ -0,0 +1,4 @@
+/** True when running on a macOS / iOS platform (drives ⌘ vs Ctrl conventions). */
+export function isMac(): boolean {
+  return typeof navigator !== 'undefined' && /Mac|iPhone|iPad/.test(navigator.platform)
+}