@skyhook-io/k8s-ui 1.8.13 → 1.8.15

package/src/components/workload/WorkloadView.tsx

@@ -43,7 +43,11 @@ import { buildResourceHierarchy, getAllEventsFromHierarchy, isProblematicEvent,
 import { TimelineSwimlanes, type TimeWindow } from '../timeline/TimelineSwimlanes'
 import { TimelineList } from '../timeline/TimelineList'
 import { ResourceActionsBar } from '../shared/ResourceActionsBar'
-import { EditableYamlView, SaveSuccessAnimation } from '../shared/EditableYamlView'
+import {
+  EditableYamlView,
+  SaveSuccessAnimation,
+  type EditableYamlViewProps,
+} from '../shared/EditableYamlView'
 import { ResourceRendererDispatch, getResourceStatus, diagnoseHealthHint, type DiagnoseHealthHint, type RendererOverrides } from '../shared/ResourceRendererDispatch'
 import type { ScalerDiagnosis } from '../resources/renderers/WorkloadRenderer'
 import { DetailShell, type DetailShellTab } from '../shared/DetailShell'
@@ -188,11 +192,19 @@ interface WorkloadViewProps {
 
   // ── Mutations ────────────────────────────────────────────────────────────
   /** Update a resource from YAML */
-  onUpdateResource?: (params: { kind: string; namespace: string; name: string; yaml: string }) => Promise<void>
+  onUpdateResource?: EditableYamlViewProps['onSave']
   /** Whether the resource is being updated */
   isUpdatingResource?: boolean
   /** Error message from the last update attempt */
   updateResourceError?: string | null
+  /** Preview a resource update against Kubernetes before saving. */
+  onPreviewResource?: EditableYamlViewProps['onPreview']
+  /** Whether the resource preview is being prepared. */
+  isPreviewingResource?: boolean
+  /** Error message from the last preview attempt. */
+  previewResourceError?: string | null
+  /** Load cluster schemas for YAML validation and completion. */
+  yamlSchemaLoader?: EditableYamlViewProps['schemaLoader']
 
   // ── Tab state (optional URL sync) ────────────────────────────────────────
   /** Controlled active tab. If not provided, managed internally. */
@@ -360,6 +372,10 @@ export function WorkloadView({
   onUpdateResource,
   isUpdatingResource,
   updateResourceError,
+  onPreviewResource,
+  isPreviewingResource,
+  previewResourceError,
+  yamlSchemaLoader,
   // Tab state
   activeTab: controlledTab,
   onTabChange,
@@ -572,6 +588,7 @@ export function WorkloadView({
         namespace,
         name,
         yaml,
+        force: true,
       })
       setTimeout(() => refetch(), 1000)
     } catch {
@@ -806,6 +823,10 @@ export function WorkloadView({
               onSave={onUpdateResource}
               isSaving={isUpdatingResource}
               saveError={updateResourceError}
+              onPreview={onPreviewResource}
+              isPreviewing={isPreviewingResource}
+              previewError={previewResourceError}
+              schemaLoader={yamlSchemaLoader}
               onDuplicate={onDuplicate}
               onDownload={onDownload}
             />
@@ -1099,6 +1120,10 @@ export function WorkloadView({
                   onSave={onUpdateResource}
                   isSaving={isUpdatingResource}
                   saveError={updateResourceError}
+                  onPreview={onPreviewResource}
+                  isPreviewing={isPreviewingResource}
+                  previewError={previewResourceError}
+                  schemaLoader={yamlSchemaLoader}
                   onDuplicate={onDuplicate}
                   onDownload={onDownload}
                 />

package/src/monaco-deep.d.ts

@@ -0,0 +1,5 @@
+declare module 'monaco-editor/esm/vs/editor/editor.api' {
+  export * from 'monaco-editor'
+}
+
+declare module 'monaco-editor/esm/vs/basic-languages/yaml/yaml.contribution'

package/src/types/core.ts

@@ -74,11 +74,19 @@ export interface Capabilities {
   // doesn't crash against an older backend that hasn't shipped the field yet —
   // consumers should default to { mode: 'local' } when absent.
   deployment?: Deployment
+  // Optional because Radar Hub can embed a newer frontend against an older
+  // in-cluster Radar agent. Features require an explicit server advertisement.
+  features?: FeatureCapabilities
   resources?: ResourcePermissions // Per-resource-type permissions
   authEnabled?: boolean   // Auth is enabled on the backend
   username?: string       // Authenticated user's username (when auth enabled)
 }
 
+export interface FeatureCapabilities {
+  yamlReview?: boolean
+  yamlSchemas?: boolean
+}
+
 // DeploymentMode is the closed set of topologies Radar can run in.
 // `local` is a developer's machine with a kubeconfig (most OSS use).
 // `in-cluster` is a Radar pod inside the cluster, no kubeconfig.

package/src/utils/yaml.test.ts

@@ -1,6 +1,11 @@
 import { describe, it, expect } from 'vitest'
 import { parse as yamlParse } from 'yaml'
-import { cleanResourceForYaml, resourceToYaml } from './yaml'
+import {
+  cleanResourceForYaml,
+  normalizeYamlForReview,
+  resourceToYaml,
+  splitYamlDocuments,
+} from './yaml'
 
 function makePod() {
   return {
@@ -82,7 +87,11 @@ describe('cleanResourceForYaml', () => {
   })
 
   it('handles metadata present but null', () => {
-    const cleaned = cleanResourceForYaml({ kind: 'Pod', metadata: null, spec: {} })
+    const cleaned = cleanResourceForYaml({
+      kind: 'Pod',
+      metadata: null,
+      spec: {},
+    })
     expect(cleaned).toEqual({ kind: 'Pod', metadata: null, spec: {} })
   })
 })
@@ -99,3 +108,92 @@ describe('resourceToYaml', () => {
     expect(yamlParse(yaml)).toEqual(cleaned)
   })
 })
+
+describe('splitYamlDocuments', () => {
+  it('uses the server document boundaries and drops empty segments', () => {
+    expect(
+      splitYamlDocuments(`apiVersion: v1
+kind: ConfigMap
+---
+
+---
+apiVersion: v1
+kind: Service
+`),
+    ).toEqual([
+      {
+        content: 'apiVersion: v1\nkind: ConfigMap',
+        startLine: 1,
+        schemaIndex: 0,
+      },
+      {
+        content: 'apiVersion: v1\nkind: Service',
+        startLine: 5,
+        schemaIndex: 2,
+      },
+    ])
+  })
+})
+
+describe('normalizeYamlForReview', () => {
+  it('strips server noise while preserving admitted defaults', () => {
+    const normalized = normalizeYamlForReview(`apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: api
+  resourceVersion: "42"
+spec:
+  replicas: 2
+status:
+  availableReplicas: 2
+`)
+    expect(normalized).not.toContain('resourceVersion')
+    expect(normalized).not.toContain('status:')
+    expect(normalized).toContain('replicas: 2')
+  })
+
+  it('masks Secret payloads and annotations on every document', () => {
+    const normalized = normalizeYamlForReview(`apiVersion: v1
+kind: Secret
+metadata:
+  name: credentials
+  annotations:
+    token: annotation-secret
+data:
+  password: c2VjcmV0
+`)
+    expect(normalized).not.toContain('annotation-secret')
+    expect(normalized).not.toContain('c2VjcmV0')
+    expect(normalized).toContain('<redacted:unchanged>')
+    expect(normalized).toContain('password:')
+  })
+
+  it('preserves server-issued differential markers while masking malformed Secret fields', () => {
+    const normalized = normalizeYamlForReview(`apiVersion: v1
+kind: Secret
+metadata:
+  name: credentials
+  annotations: annotation-secret
+data:
+  changed: <redacted:after>
+  raw: c2VjcmV0
+stringData: plain-secret
+`)
+    expect(normalized).toContain('<redacted:after>')
+    expect(normalized).toContain('<redacted:unchanged>')
+    expect(normalized).not.toContain('annotation-secret')
+    expect(normalized).not.toContain('c2VjcmV0')
+    expect(normalized).not.toContain('plain-secret')
+  })
+
+  it('never returns an unparseable Secret draft verbatim', () => {
+    const normalized = normalizeYamlForReview(`apiVersion: v1
+kind: Secret
+data:
+  password: c2VjcmV0
+broken: [
+`)
+    expect(normalized).toBe('# YAML could not be normalized safely for review.\n')
+    expect(normalized).not.toContain('c2VjcmV0')
+  })
+})

package/src/utils/yaml.ts

@@ -1,4 +1,4 @@
-import { stringify as yamlStringify } from 'yaml'
+import { parseAllDocuments, stringify as yamlStringify } from 'yaml'
 
 const SERVER_GENERATED_METADATA = [
   'managedFields',
@@ -8,6 +8,40 @@ const SERVER_GENERATED_METADATA = [
   'generation',
 ] as const
 
+export interface YamlDocumentSource {
+  content: string
+  startLine: number
+  schemaIndex: number
+}
+
+export function splitYamlDocuments(content: string): YamlDocumentSource[] {
+  const documents: YamlDocumentSource[] = []
+  let lines: string[] = []
+  let startLine = 1
+  let schemaIndex = 0
+  let sawSeparator = false
+
+  const append = () => {
+    const document = lines.join('\n').trim()
+    if (document) documents.push({ content: document, startLine, schemaIndex })
+    return document !== ''
+  }
+
+  content.split('\n').forEach((line, index) => {
+    if (/^---(?:[ \t]+#.*|[ \t]*)\r?$/.test(line)) {
+      const hadContent = append()
+      if (sawSeparator || hadContent) schemaIndex += 1
+      sawSeparator = true
+      lines = []
+      startLine = index + 1
+      return
+    }
+    lines.push(line)
+  })
+  append()
+  return documents
+}
+
 export function cleanResourceForYaml<T = any>(data: T): T {
   if (!data || typeof data !== 'object') return data
   const cleaned = structuredClone(data) as any
@@ -24,3 +58,54 @@ export function resourceToYaml(data: any): string {
   if (!data) return ''
   return yamlStringify(cleanResourceForYaml(data), { lineWidth: 0, indent: 2 })
 }
+
+export function normalizeYamlForReview(content: string): string {
+  try {
+    const documents = parseAllDocuments(content)
+    if (documents.some((document) => document.errors.length > 0)) {
+      return '# YAML could not be normalized safely for review.\n'
+    }
+    return (
+      documents
+        .map((document) => {
+          const value = document.toJS({ maxAliasCount: 100 })
+          const cleaned = cleanResourceForYaml(value) as Record<string, any>
+          if (typeof cleaned?.kind === 'string' && cleaned.kind.toLowerCase() === 'secret') {
+            for (const field of ['data', 'stringData', 'binaryData']) {
+              if (cleaned[field] === undefined) continue
+              if (
+                !cleaned[field] ||
+                typeof cleaned[field] !== 'object' ||
+                Array.isArray(cleaned[field])
+              ) {
+                cleaned[field] = safeSecretReviewMarker(cleaned[field])
+                continue
+              }
+              for (const key of Object.keys(cleaned[field])) {
+                cleaned[field][key] = safeSecretReviewMarker(cleaned[field][key])
+              }
+            }
+            const annotations = cleaned.metadata?.annotations
+            if (annotations && typeof annotations === 'object' && !Array.isArray(annotations)) {
+              for (const key of Object.keys(annotations)) {
+                annotations[key] = safeSecretReviewMarker(annotations[key])
+              }
+            } else if (annotations !== undefined) {
+              cleaned.metadata.annotations = safeSecretReviewMarker(annotations)
+            }
+          }
+          return yamlStringify(cleaned, { lineWidth: 0, indent: 2 }).trimEnd()
+        })
+        .join('\n---\n') + '\n'
+    )
+  } catch {
+    return '# YAML could not be normalized safely for review.\n'
+  }
+}
+
+function safeSecretReviewMarker(value: unknown) {
+  if (typeof value === 'string' && /^<redacted:(unchanged|before|after)>$/.test(value)) {
+    return value
+  }
+  return '<redacted:unchanged>'
+}