@skyhook-io/k8s-ui 1.14.2 → 1.14.4

package/src/utils/log-export.test.ts

@@ -0,0 +1,225 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  LOG_EXPORT_FORMATS,
+  previewLogExport,
+  serializeLogEntries,
+  type ExportableLogEntry,
+  type LogExportFormat,
+} from './log-export'
+
+const ESC = '\u001b'
+
+const entry = (over: Partial<ExportableLogEntry> = {}): ExportableLogEntry => ({
+  timestamp: '2024-01-20T10:30:00.123456789Z',
+  content: 'connection refused',
+  container: 'app',
+  pod: 'api-7d9f',
+  ...over,
+})
+
+const opts = (over: Partial<{ format: LogExportFormat; showTimestamps: boolean; showPodName: boolean }> = {}) => ({
+  format: 'txt' as LogExportFormat,
+  showTimestamps: true,
+  showPodName: true,
+  ...over,
+})
+
+describe('serializeLogEntries — text', () => {
+  it('emits the raw RFC3339 timestamp rather than any display format', () => {
+    const { content } = serializeLogEntries([entry()], opts({ showPodName: false }))
+    expect(content).toBe('2024-01-20T10:30:00.123456789Z connection refused')
+  })
+
+  it('omits timestamps when the viewer has them hidden', () => {
+    const { content } = serializeLogEntries([entry()], opts({ showTimestamps: false, showPodName: false }))
+    expect(content).toBe('connection refused')
+  })
+
+  it('attributes pod and container when pod names are shown', () => {
+    const { content } = serializeLogEntries([entry()], opts({ showTimestamps: false }))
+    expect(content).toBe('[api-7d9f/app] connection refused')
+  })
+
+  it('falls back to the pod alone when no container is known', () => {
+    const { content } = serializeLogEntries([entry({ container: undefined })], opts({ showTimestamps: false }))
+    expect(content).toBe('[api-7d9f] connection refused')
+  })
+
+  it('drops pod attribution for entries with no pod, even when the toggle is on', () => {
+    const { content } = serializeLogEntries([entry({ pod: undefined })], opts({ showTimestamps: false }))
+    expect(content).toBe('connection refused')
+  })
+
+  it('skips an empty timestamp instead of emitting a leading space', () => {
+    const { content } = serializeLogEntries([entry({ timestamp: '' })], opts({ showPodName: false }))
+    expect(content).toBe('connection refused')
+  })
+
+  it('strips ANSI escapes', () => {
+    const { content } = serializeLogEntries(
+      [entry({ content: `${ESC}[31mconnection refused${ESC}[0m` })],
+      opts({ showTimestamps: false, showPodName: false }),
+    )
+    expect(content).toBe('connection refused')
+  })
+
+  it('preserves raw JSON content rather than any collapsed rendering', () => {
+    const json = '{"level":"error","msg":"connection refused","stack":"a\\nb"}'
+    const { content } = serializeLogEntries([entry({ content: json })], opts({ showTimestamps: false, showPodName: false }))
+    expect(content).toBe(json)
+  })
+
+  it('joins entries with newlines and returns empty for no entries', () => {
+    const { content } = serializeLogEntries(
+      [entry({ content: 'first' }), entry({ content: 'second' })],
+      opts({ showTimestamps: false, showPodName: false }),
+    )
+    expect(content).toBe('first\nsecond')
+    expect(serializeLogEntries([], opts()).content).toBe('')
+  })
+})
+
+describe('serializeLogEntries — structured formats', () => {
+  it('keeps the timestamp field in JSON even when the display toggle is off', () => {
+    const { content, mime, extension } = serializeLogEntries(
+      [entry()],
+      opts({ format: 'json', showTimestamps: false }),
+    )
+    expect(JSON.parse(content)).toEqual([{
+      timestamp: '2024-01-20T10:30:00.123456789Z',
+      pod: 'api-7d9f',
+      container: 'app',
+      content: 'connection refused',
+    }])
+    expect(mime).toBe('application/json;charset=utf-8')
+    expect(extension).toBe('json')
+  })
+
+  it('keeps the pod key in JSON even when pod attribution is off, since the display toggle is not a schema', () => {
+    const { content } = serializeLogEntries([entry()], opts({ format: 'json', showPodName: false }))
+    expect(Object.keys(JSON.parse(content)[0])).toEqual(['timestamp', 'pod', 'container', 'content'])
+  })
+
+  it('omits the pod key only for entries that genuinely have no pod', () => {
+    const { content } = serializeLogEntries([entry({ pod: undefined })], opts({ format: 'json' }))
+    expect(Object.keys(JSON.parse(content)[0])).toEqual(['timestamp', 'container', 'content'])
+  })
+
+  it('strips ANSI from structured content too', () => {
+    const { content } = serializeLogEntries(
+      [entry({ content: `${ESC}[31mboom${ESC}[0m` })],
+      opts({ format: 'json' }),
+    )
+    expect(JSON.parse(content)[0].content).toBe('boom')
+  })
+
+  it('writes a CSV header matching the columns it emits', () => {
+    const { content, mime } = serializeLogEntries([entry()], opts({ format: 'csv' }))
+    expect(content.split('\n')).toEqual([
+      'timestamp,pod,container,content',
+      '"2024-01-20T10:30:00.123456789Z","api-7d9f","app","connection refused"',
+    ])
+    expect(mime).toBe('text/csv;charset=utf-8')
+  })
+
+  it('keeps the CSV pod column when pod attribution is off but the data has pods', () => {
+    const { content } = serializeLogEntries([entry()], opts({ format: 'csv', showPodName: false }))
+    expect(content.split('\n')[0]).toBe('timestamp,pod,container,content')
+  })
+
+  it('drops the CSV pod column only when no entry has a pod', () => {
+    const { content } = serializeLogEntries([entry({ pod: undefined })], opts({ format: 'csv' }))
+    expect(content.split('\n')).toEqual([
+      'timestamp,container,content',
+      '"2024-01-20T10:30:00.123456789Z","app","connection refused"',
+    ])
+  })
+
+  it('keeps the column count aligned when only some entries carry a pod', () => {
+    const { content } = serializeLogEntries(
+      [entry({ pod: undefined }), entry()],
+      opts({ format: 'csv' }),
+    )
+    const [header, ...rows] = content.split('\n')
+    expect(header.split(',').length).toBe(4)
+    for (const row of rows) expect(row.split('","').length).toBe(4)
+  })
+
+  it('neutralizes cells a spreadsheet would evaluate as a formula', () => {
+    const { content } = serializeLogEntries(
+      [entry({ content: '=cmd|\' /c calc\'!A1' }), entry({ content: '+1' }), entry({ content: '-rf /' }), entry({ content: '@SUM(A1)' })],
+      opts({ format: 'csv', showPodName: false }),
+    )
+    const cells = content.split('\n').slice(1).map(r => r.split(',').pop())
+    expect(cells).toEqual([
+      '"\'=cmd|\' /c calc\'!A1"',
+      '"\'+1"',
+      '"\'-rf /"',
+      '"\'@SUM(A1)"',
+    ])
+  })
+
+  it('leaves ordinary content unprefixed', () => {
+    const { content } = serializeLogEntries([entry()], opts({ format: 'csv', showPodName: false }))
+    expect(content).toContain('"connection refused"')
+  })
+
+  it('doubles quotes inside a CSV cell', () => {
+    const { content } = serializeLogEntries(
+      [entry({ content: 'said "hello"', pod: undefined })],
+      opts({ format: 'csv' }),
+    )
+    expect(content.split('\n')[1]).toBe('"2024-01-20T10:30:00.123456789Z","app","said ""hello"""')
+  })
+
+  it('emits a header-only CSV and an empty JSON array for no entries', () => {
+    expect(serializeLogEntries([], opts({ format: 'csv' })).content).toBe('timestamp,container,content')
+    expect(serializeLogEntries([], opts({ format: 'json' })).content).toBe('[]')
+  })
+
+  it('declares a charset so non-ASCII content survives a spreadsheet import', () => {
+    for (const format of LOG_EXPORT_FORMATS) {
+      expect(serializeLogEntries([], opts({ format })).mime).toContain('charset=utf-8')
+    }
+  })
+})
+
+describe('previewLogExport', () => {
+  it('shows the first two lines of a text export', () => {
+    expect(previewLogExport(
+      [entry({ content: 'first' }), entry({ content: 'second' }), entry({ content: 'third' })],
+      opts({ showTimestamps: false, showPodName: false }),
+    )).toEqual(['first', 'second'])
+  })
+
+  it('shows one compact object for JSON, not the pretty-printed array', () => {
+    const [line, ...rest] = previewLogExport([entry()], opts({ format: 'json' }))
+    expect(rest).toEqual([])
+    expect(line).toBe('{"timestamp":"2024-01-20T10:30:00.123456789Z","pod":"api-7d9f","container":"app","content":"connection refused"}')
+  })
+
+  it('shows the CSV header alongside a row so the columns are legible', () => {
+    expect(previewLogExport([entry()], opts({ format: 'csv' }))).toEqual([
+      'timestamp,pod,container,content',
+      '"2024-01-20T10:30:00.123456789Z","api-7d9f","app","connection refused"',
+    ])
+  })
+
+  it('previews exactly what the payload contains', () => {
+    for (const format of ['txt', 'json', 'csv'] as LogExportFormat[]) {
+      const o = opts({ format })
+      const preview = previewLogExport([entry()], o)
+      const { content } = serializeLogEntries([entry()], o)
+      for (const line of preview) {
+        // JSON pretty-prints across lines, so compare on the field values instead.
+        if (format === 'json') expect(JSON.parse(content)[0]).toEqual(JSON.parse(line))
+        else expect(content.split('\n')).toContain(line)
+      }
+    }
+  })
+
+  it('returns nothing when there is nothing to export', () => {
+    expect(previewLogExport([], opts())).toEqual([])
+  })
+})

package/src/utils/log-export.ts

@@ -0,0 +1,149 @@
+/**
+ * Serialization for the log viewer's export popover.
+ *
+ * Copy and download share this module so the two can never disagree about what
+ * a line looks like — the popover's preview is rendered from the same functions
+ * that produce the payload.
+ */
+
+import { stripAnsi } from './log-format'
+
+export type LogExportFormat = 'txt' | 'json' | 'csv'
+
+export interface ExportableLogEntry {
+  timestamp: string
+  content: string
+  container?: string
+  pod?: string
+}
+
+export interface LogExportOptions {
+  format: LogExportFormat
+  /**
+   * Mirrors the viewer's timestamp toggle, and applies to `txt` only. JSON and
+   * CSV always carry the timestamp: there it is a named field a reader can
+   * ignore, not the visual noise the toggle exists to suppress.
+   */
+  showTimestamps: boolean
+  /**
+   * Mirrors the viewer's pod attribution, and — like `showTimestamps` — applies
+   * to `txt` only. JSON and CSV carry `pod` whenever the entry has one: a
+   * display preference must not silently strip the column that makes a
+   * multi-pod export attributable.
+   */
+  showPodName: boolean
+}
+
+export interface LogExportPayload {
+  content: string
+  mime: string
+  extension: LogExportFormat
+}
+
+// Charset is explicit: log content is arbitrary UTF-8, and Excel on Windows
+// falls back to a legacy code page without it.
+const MIME: Record<LogExportFormat, string> = {
+  txt: 'text/plain;charset=utf-8',
+  json: 'application/json;charset=utf-8',
+  csv: 'text/csv;charset=utf-8',
+}
+
+/** Display order for the format picker. */
+export const LOG_EXPORT_FORMATS: readonly LogExportFormat[] = ['txt', 'json', 'csv']
+
+export const LOG_EXPORT_FORMAT_LABELS: Record<LogExportFormat, string> = {
+  txt: 'Text',
+  json: 'JSON',
+  csv: 'CSV',
+}
+
+/**
+ * One entry as the viewer would read it back: timestamps raw rather than in the
+ * display format, since an exported line is correlated against other systems
+ * long after the screen that produced it is gone.
+ */
+function textLine(entry: ExportableLogEntry, { showTimestamps, showPodName }: LogExportOptions): string {
+  const parts: string[] = []
+  if (showTimestamps && entry.timestamp) parts.push(entry.timestamp)
+  if (showPodName && entry.pod) parts.push(entry.container ? `[${entry.pod}/${entry.container}]` : `[${entry.pod}]`)
+  parts.push(stripAnsi(entry.content))
+  return parts.join(' ')
+}
+
+function jsonEntry(entry: ExportableLogEntry): Record<string, string> {
+  return {
+    timestamp: entry.timestamp,
+    ...(entry.pod ? { pod: entry.pod } : {}),
+    ...(entry.container ? { container: entry.container } : {}),
+    content: stripAnsi(entry.content),
+  }
+}
+
+/** Columns follow the data, not a display toggle, so a row can never carry a field the header doesn't name. */
+function csvColumns(entries: readonly ExportableLogEntry[]): string[] {
+  return entries.some(e => e.pod)
+    ? ['timestamp', 'pod', 'container', 'content']
+    : ['timestamp', 'container', 'content']
+}
+
+// A cell opening with one of these is a formula to Excel and Sheets, and quoting
+// does not stop it — the quotes are stripped before evaluation. Log content is
+// whatever a pod chose to print, so the leading apostrophe (which spreadsheets
+// consume on import) is the difference between a CSV and an execution vector.
+const SPREADSHEET_FORMULA_START = /^[=+\-@\t\r]/
+
+function csvCell(value: string): string {
+  const escaped = (SPREADSHEET_FORMULA_START.test(value) ? `'${value}` : value).replace(/"/g, '""')
+  return `"${escaped}"`
+}
+
+function csvRow(entry: ExportableLogEntry, columns: readonly string[]): string {
+  const cells = [
+    entry.timestamp,
+    ...(columns.includes('pod') ? [entry.pod ?? ''] : []),
+    entry.container ?? '',
+    stripAnsi(entry.content),
+  ]
+  return cells.map(csvCell).join(',')
+}
+
+export function serializeLogEntries(
+  entries: readonly ExportableLogEntry[],
+  opts: LogExportOptions,
+): LogExportPayload {
+  const base = { mime: MIME[opts.format], extension: opts.format }
+  switch (opts.format) {
+    case 'json':
+      return { ...base, content: JSON.stringify(entries.map(jsonEntry), null, 2) }
+    case 'csv': {
+      const columns = csvColumns(entries)
+      return { ...base, content: [columns.join(','), ...entries.map(e => csvRow(e, columns))].join('\n') }
+    }
+    default:
+      return { ...base, content: entries.map(e => textLine(e, opts)).join('\n') }
+  }
+}
+
+/**
+ * Up to two representative lines for the popover's preview box. This is the only
+ * thing telling the user which fields their export carries, so it renders the
+ * shape of the real output rather than a description of it: for CSV that means
+ * the header alongside a row, and for JSON a single compact entry rather than
+ * the pretty-printed array the payload actually uses.
+ */
+export function previewLogExport(
+  entries: readonly ExportableLogEntry[],
+  opts: LogExportOptions,
+): string[] {
+  if (entries.length === 0) return []
+  switch (opts.format) {
+    case 'json':
+      return [JSON.stringify(jsonEntry(entries[0]))]
+    case 'csv': {
+      const columns = csvColumns(entries)
+      return [columns.join(','), csvRow(entries[0], columns)]
+    }
+    default:
+      return entries.slice(0, 2).map(e => textLine(e, opts))
+  }
+}

package/src/utils/navigation.test.ts

@@ -326,3 +326,13 @@ describe('lane identity helpers', () => {
     expect(parseLaneId('bogus')).toBeNull()
   })
 })
+
+describe('pluralToKind on absent input', () => {
+  // A saved investigation can carry an empty kind. This runs over every row of
+  // the run list, so throwing here took the whole investigations panel down and
+  // made every other run unopenable — one bad row, no panel.
+  test('returns the empty string instead of throwing', () => {
+    expect(() => pluralToKind('')).not.toThrow()
+    expect(pluralToKind('')).toBe('')
+  })
+})

package/src/utils/navigation.ts

@@ -147,6 +147,10 @@ export function kindToPluralWithGroup(kind: string, group: string): string {
  * singular PascalCase form for internal logic (health checks, badge colors, hierarchy matching).
  */
 export function pluralToKind(plural: string): string {
+  // A saved investigation can carry an empty kind, and this runs over every
+  // row of the run list — indexing [0] of "" threw and took the whole panel
+  // down with it, making every other run unopenable.
+  if (!plural) return plural
   const lower = plural.toLowerCase()
   const pluralToKindMap = getPluralToKind()