@skyhook-io/k8s-ui 1.16.1 → 1.16.3

package/src/components/dock/BottomDock.tsx

@@ -4,6 +4,7 @@ import { X, ChevronDown, ChevronUp, Terminal, FileText, Trash2, Layers, Maximize
 import { clsx } from 'clsx'
 import { useDock, DockTab } from './DockContext'
 import { useRegisterShortcuts } from '../../hooks/useKeyboardShortcuts'
+import { Tooltip } from '../ui/Tooltip'
 
 const MIN_HEIGHT = 200
 const MAX_HEIGHT_RATIO = 0.7
@@ -224,7 +225,13 @@ function TabButton({
       onClick={onSelect}
     >
       <Icon className="w-3.5 h-3.5" />
-      <span className="truncate max-w-[120px]">{tab.title}</span>
+      {tab.titleTooltip ? (
+        <Tooltip content={tab.titleTooltip} wrapperClassName="min-w-0">
+          <span className="block truncate max-w-[120px]">{tab.title}</span>
+        </Tooltip>
+      ) : (
+        <span className="truncate max-w-[120px]">{tab.title}</span>
+      )}
       <button
         onClick={(e) => {
           e.stopPropagation()

package/src/components/dock/DockContext.tsx

@@ -6,6 +6,7 @@ export interface DockTab {
   id: string
   type: DockTabType
   title: string
+  titleTooltip?: string
   // Common app context (optional — app-specific, used by tab content components)
   orgId?: string
   clusterId?: string
@@ -22,6 +23,7 @@ export interface DockTab {
   nodeName?: string
   // Local terminal props
   initialCommand?: string
+  localTerminalContext?: string
 }
 
 export interface DockContextValue {
@@ -33,6 +35,7 @@ export interface DockContextValue {
   isMaximized: boolean
   isResizing: boolean
   addTab: (tab: Omit<DockTab, 'id'>) => string
+  setTabTitle: (id: string, title: string, titleTooltip?: string) => void
   removeTab: (id: string) => void
   setActiveTab: (id: string) => void
   toggleExpanded: () => void
@@ -118,6 +121,10 @@ export function DockProvider({ children }: { children: ReactNode }) {
     })
   }, [activeTabId])
 
+  const setTabTitle = useCallback((id: string, title: string, titleTooltip?: string) => {
+    setTabs(prev => prev.map(tab => tab.id === id ? { ...tab, title, titleTooltip } : tab))
+  }, [])
+
   const setActiveTab = useCallback((id: string) => {
     setActiveTabId(id)
   }, [])
@@ -142,6 +149,7 @@ export function DockProvider({ children }: { children: ReactNode }) {
       isMaximized,
       isResizing,
       addTab,
+      setTabTitle,
       removeTab,
       setActiveTab,
       toggleExpanded,

package/src/components/dock/LocalTerminalTab.test.tsx

@@ -0,0 +1,189 @@
+// @vitest-environment jsdom
+import { act, StrictMode } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+import { LocalTerminalTab, type LocalTerminalTabProps } from './LocalTerminalTab'
+import { TerminalTab } from './TerminalTab'
+
+vi.mock('@xterm/xterm', () => ({
+  Terminal: class {
+    rows = 24
+    cols = 80
+    loadAddon() {}
+    open() {}
+    resize() {}
+    focus() {}
+    dispose() {}
+    write() {}
+    onData() {}
+  },
+}))
+vi.mock('@xterm/addon-fit', () => ({ FitAddon: class { proposeDimensions() { return { rows: 24, cols: 80 } } } }))
+vi.mock('@xterm/addon-web-links', () => ({ WebLinksAddon: class {} }))
+vi.mock('./terminalClipboard', () => ({ setupTerminalClipboard: () => () => {}, copyTerminalSelection: vi.fn() }))
+vi.mock('./TerminalClipboardToolbar', () => ({ TerminalClipboardToolbar: () => null }))
+vi.mock('./useMultilinePasteConfirm', () => ({ useMultilinePasteConfirm: () => ({ confirmPaste: vi.fn(), pasteDialog: null }) }))
+Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true })
+
+class Socket {
+  static OPEN = 1
+  static instances: Socket[] = []
+  readyState = 1
+  onopen?: () => void
+  onclose?: () => void
+  onmessage?: (event: { data: string }) => void
+  send = vi.fn()
+  close() { this.readyState = 3; this.onclose?.() }
+  constructor() { Socket.instances.push(this) }
+  session(context: string) {
+    this.onmessage?.({ data: JSON.stringify({ type: 'session', context, kubeconfigIsolated: true }) })
+  }
+}
+let root: Root
+let element: HTMLDivElement
+beforeEach(() => {
+  Socket.instances = []
+  vi.stubGlobal('WebSocket', Socket)
+  vi.stubGlobal('ResizeObserver', class { observe() {} disconnect() {} })
+  vi.stubGlobal('requestAnimationFrame', () => 0)
+  element = document.createElement('div')
+  document.body.appendChild(element)
+  root = createRoot(element)
+})
+afterEach(async () => {
+  await act(async () => root.unmount())
+  element.remove()
+  vi.unstubAllGlobals()
+  vi.useRealTimers()
+})
+async function render(props: Partial<LocalTerminalTabProps> = {}, strict = false) {
+  await act(async () => {
+    const terminal = <LocalTerminalTab createSession={async () => ({ wsUrl: 'ws://localhost' })} {...props} />
+    root.render(strict ? <StrictMode>{terminal}</StrictMode> : terminal)
+  })
+}
+
+it('reports the current session, clears metadata on reconnect, and ignores old socket messages', async () => {
+  const firstCallback = vi.fn()
+  await render({ onSessionInfo: firstCallback })
+  expect(firstCallback).toHaveBeenCalledWith(null)
+  const old = Socket.instances[0]
+  await act(async () => { old.onopen?.(); old.session('production') })
+  expect(firstCallback).toHaveBeenLastCalledWith({ context: 'production', kubeconfigIsolated: true })
+  const currentCallback = vi.fn()
+  await render({ onSessionInfo: currentCallback })
+  await act(async () => old.close())
+  await act(async () => element.querySelector<HTMLButtonElement>('button')!.click())
+  expect(currentCallback).toHaveBeenLastCalledWith(null)
+  const current = Socket.instances[1]
+  await act(async () => { current.onopen?.(); current.session('staging'); old.session('production') })
+  expect(currentCallback).toHaveBeenLastCalledWith({ context: 'staging', kubeconfigIsolated: true })
+  expect(currentCallback).toHaveBeenCalledTimes(2)
+})
+
+it('does not open an obsolete session when Strict Mode creations resolve out of order', async () => {
+  let resolveOld!: (value: { wsUrl: string }) => void
+  const pending = new Promise<{ wsUrl: string }>(resolve => { resolveOld = resolve })
+  const createSession = vi.fn().mockReturnValueOnce(pending).mockResolvedValueOnce({ wsUrl: 'ws://localhost/current' })
+  const onSessionInfo = vi.fn()
+  await render({ createSession, onSessionInfo }, true)
+  expect(createSession).toHaveBeenCalledTimes(2)
+  expect(Socket.instances).toHaveLength(1)
+  await act(async () => resolveOld({ wsUrl: 'ws://localhost/obsolete' }))
+  expect(Socket.instances).toHaveLength(1)
+  await act(async () => Socket.instances[0].session('current'))
+  expect(onSessionInfo).toHaveBeenLastCalledWith({ context: 'current', kubeconfigIsolated: true })
+})
+
+it('sends the initial command once and does not replay it on reconnect', async () => {
+  vi.useFakeTimers()
+  await render({ initialCommand: 'aws sso login' })
+  const first = Socket.instances[0]
+  await act(async () => first.onopen?.())
+  expect(first.send).not.toHaveBeenCalledWith(JSON.stringify({ type: 'input', data: 'aws sso login\n' }))
+  await act(async () => vi.advanceTimersByTime(300))
+  const inputs = () => Socket.instances.flatMap(socket => socket.send.mock.calls.map(([data]) => JSON.parse(data))).filter(message => message.type === 'input')
+  expect(inputs()).toEqual([{ type: 'input', data: 'aws sso login\n' }])
+
+  await act(async () => first.close())
+  await act(async () => element.querySelector<HTMLButtonElement>('button')!.click())
+  await act(async () => Socket.instances[1].onopen?.())
+  await act(async () => vi.advanceTimersByTime(300))
+  expect(inputs()).toEqual([{ type: 'input', data: 'aws sso login\n' }])
+})
+
+it('keeps an unsent initial command available when the first connection closes before delivery', async () => {
+  vi.useFakeTimers()
+  await render({ initialCommand: 'gcloud auth login' })
+  const first = Socket.instances[0]
+  await act(async () => first.onopen?.())
+  await act(async () => vi.advanceTimersByTime(100))
+  await act(async () => first.close())
+  await act(async () => element.querySelector<HTMLButtonElement>('button')!.click())
+  const second = Socket.instances[1]
+  await act(async () => second.onopen?.())
+  await act(async () => vi.advanceTimersByTime(200))
+  const input = JSON.stringify({ type: 'input', data: 'gcloud auth login\n' })
+  expect(first.send).not.toHaveBeenCalledWith(input)
+  expect(second.send).not.toHaveBeenCalledWith(input)
+  await act(async () => vi.advanceTimersByTime(100))
+  expect(second.send.mock.calls.filter(([data]) => JSON.parse(data).type === 'input')).toEqual([[input]])
+})
+
+it('sends the initial command independently in each terminal tab', async () => {
+  vi.useFakeTimers()
+  await act(async () => {
+    root.render(<>
+      <LocalTerminalTab createSession={async () => ({ wsUrl: 'ws://localhost/first' })} initialCommand="aws sso login" />
+      <LocalTerminalTab createSession={async () => ({ wsUrl: 'ws://localhost/second' })} initialCommand="aws sso login" />
+    </>)
+  })
+  expect(Socket.instances).toHaveLength(2)
+  await act(async () => Socket.instances.forEach(socket => socket.onopen?.()))
+  await act(async () => vi.advanceTimersByTime(300))
+  const input = JSON.stringify({ type: 'input', data: 'aws sso login\n' })
+  for (const socket of Socket.instances) {
+    expect(socket.send.mock.calls.filter(([data]) => JSON.parse(data).type === 'input')).toEqual([[input]])
+  }
+})
+
+it('keeps a blocked reconnect intact until the host permits it', async () => {
+  vi.useFakeTimers()
+  let allowed = true
+  const createSession = vi.fn(async () => ({ wsUrl: 'ws://localhost' }))
+  const onSessionInfo = vi.fn()
+  await render({ createSession, canConnect: () => allowed, initialCommand: 'auth-command', onSessionInfo })
+  await act(async () => Socket.instances[0].onopen?.())
+  await act(async () => vi.advanceTimersByTime(300))
+  await act(async () => Socket.instances[0].close())
+  const terminal = element.querySelector('div.absolute')
+  expect(terminal).not.toBeNull()
+  const metadataCalls = onSessionInfo.mock.calls.length
+  allowed = false
+  await act(async () => element.querySelector<HTMLButtonElement>('button')!.click())
+  expect(createSession).toHaveBeenCalledTimes(1)
+  expect(onSessionInfo).toHaveBeenCalledTimes(metadataCalls)
+  expect(element.contains(terminal)).toBe(true)
+  allowed = true
+  await act(async () => element.querySelector<HTMLButtonElement>('button')!.click())
+  await act(async () => Socket.instances[1].onopen?.())
+  await act(async () => vi.advanceTimersByTime(300))
+  expect(createSession).toHaveBeenCalledTimes(2)
+  expect(Socket.instances.flatMap(s => s.send.mock.calls).filter(([data]) => JSON.parse(data).type === 'input')).toHaveLength(1)
+})
+
+it.each(['local', 'pod'])('allows Retry after a %s terminal creation error', async kind => {
+  const createSession = vi.fn()
+    .mockRejectedValueOnce(new Error('creation failed'))
+    .mockResolvedValueOnce({ wsUrl: 'ws://localhost' })
+  await act(async () => root.render(kind === 'local'
+    ? <LocalTerminalTab createSession={createSession} />
+    : <TerminalTab namespace="default" podName="pod" containerName="app" containers={['app']} createSession={createSession} />))
+  expect(element.textContent).toContain('creation failed')
+  const retry = [...element.querySelectorAll('button')].find(button => button.textContent?.trim() === 'Retry')!
+  await act(async () => retry.click())
+  expect(createSession).toHaveBeenCalledTimes(2)
+  expect(Socket.instances).toHaveLength(1)
+  await act(async () => Socket.instances[0].onopen?.())
+  expect(element.textContent).not.toContain('creation failed')
+})

package/src/components/dock/LocalTerminalTab.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useLayoutEffect, useRef, useCallback, useState } from 'react'
+import { useEffect, useLayoutEffect, useRef, useCallback, useState, type ReactNode } from 'react'
 import { Terminal as XTerm } from '@xterm/xterm'
 import { FitAddon } from '@xterm/addon-fit'
 import { WebLinksAddon } from '@xterm/addon-web-links'
@@ -9,31 +9,52 @@ import { setupTerminalClipboard, copyTerminalSelection } from './terminalClipboa
 import { TerminalClipboardToolbar } from './TerminalClipboardToolbar'
 import { useMultilinePasteConfirm } from './useMultilinePasteConfirm'
 
+export interface LocalTerminalSessionInfo {
+  context: string
+  kubeconfigIsolated: boolean
+}
+
 export interface LocalTerminalTabProps {
   isActive?: boolean
   /** Returns the WebSocket URL for the local terminal session */
   createSession: () => Promise<{ wsUrl: string }>
-  /** Command to auto-execute after the terminal connects */
+  /** Command to send once per mounted terminal after a connection opens */
   initialCommand?: string
+  canConnect?: () => boolean
+  onConnectionError?: () => void
+  onSessionInfo?: (info: LocalTerminalSessionInfo | null) => void
+  toolbarExtra?: ReactNode
 }
 
 export function LocalTerminalTab({
   isActive = true,
   createSession,
   initialCommand,
+  canConnect,
+  onConnectionError,
+  onSessionInfo,
+  toolbarExtra,
 }: LocalTerminalTabProps) {
   const terminalRef = useRef<HTMLDivElement>(null)
   const xtermRef = useRef<XTerm | null>(null)
   const fitAddonRef = useRef<FitAddon | null>(null)
   const wsRef = useRef<WebSocket | null>(null)
   const cleanupRef = useRef<(() => void) | undefined>(undefined)
-  const cancelledRef = useRef(false)
+  const connectionAttemptRef = useRef(0)
+  const initialCommandSentRef = useRef(false)
   const createSessionRef = useRef(createSession)
+  const onSessionInfoRef = useRef(onSessionInfo)
+  const canConnectRef = useRef(canConnect)
+  const onConnectionErrorRef = useRef(onConnectionError)
   useLayoutEffect(() => { createSessionRef.current = createSession }, [createSession])
+  useLayoutEffect(() => { onSessionInfoRef.current = onSessionInfo }, [onSessionInfo])
+  useLayoutEffect(() => { canConnectRef.current = canConnect }, [canConnect])
+  useLayoutEffect(() => { onConnectionErrorRef.current = onConnectionError }, [onConnectionError])
   const [isConnected, setIsConnected] = useState(false)
   const [isConnecting, setIsConnecting] = useState(true)
   const [error, setError] = useState<string | null>(null)
   const [hasSelection, setHasSelection] = useState(false)
+  const connectAllowed = canConnect?.() !== false
   const { confirmPaste, pasteDialog } = useMultilinePasteConfirm()
 
   const handleCopy = useCallback(() => {
@@ -43,7 +64,13 @@ export function LocalTerminalTab({
   const connect = useCallback(() => {
     if (!terminalRef.current) return
 
-    cancelledRef.current = false
+    if (canConnectRef.current && !canConnectRef.current()) {
+      setIsConnecting(false)
+      return
+    }
+
+    const attempt = ++connectionAttemptRef.current
+    onSessionInfoRef.current?.(null)
     setIsConnecting(true)
     setError(null)
 
@@ -145,34 +172,39 @@ export function LocalTerminalTab({
 
     createSessionRef.current()
       .then(({ wsUrl }) => {
-        if (cancelledRef.current) return
+        if (attempt !== connectionAttemptRef.current) return
         const ws = new WebSocket(wsUrl)
         wsRef.current = ws
 
         ws.onopen = () => {
+          if (attempt !== connectionAttemptRef.current) return
           setIsConnected(true)
           setIsConnecting(false)
           doFit(ws)
           xterm.focus()
-          if (initialCommand) {
+          if (initialCommand && !initialCommandSentRef.current) {
             // Small delay to let the shell prompt initialize
             setTimeout(() => {
-              if (ws.readyState === WebSocket.OPEN) {
+              if (attempt === connectionAttemptRef.current && !initialCommandSentRef.current && ws.readyState === WebSocket.OPEN) {
                 ws.send(JSON.stringify({ type: 'input', data: initialCommand + '\n' }))
+                initialCommandSentRef.current = true
               }
             }, 300)
           }
         }
 
         ws.onmessage = (event) => {
-          let msg: Record<string, string> | null = null
+          if (attempt !== connectionAttemptRef.current) return
+          let msg: { type: 'output' | 'error' | 'exit'; data?: string } | ({ type: 'session' } & LocalTerminalSessionInfo)
           try {
-            msg = JSON.parse(event.data as string) as Record<string, string>
+            msg = JSON.parse(event.data as string)
           } catch {
             xterm.write(event.data as string)
             return
           }
-          if (msg.type === 'output' && msg.data) {
+          if (msg.type === 'session') {
+            onSessionInfoRef.current?.({ context: msg.context, kubeconfigIsolated: msg.kubeconfigIsolated })
+          } else if (msg.type === 'output' && msg.data) {
             xterm.write(msg.data)
           } else if (msg.type === 'exit') {
             xterm.write('\r\n\x1b[2m[Process exited]\x1b[0m\r\n')
@@ -183,12 +215,15 @@ export function LocalTerminalTab({
         }
 
         ws.onerror = () => {
+          if (attempt !== connectionAttemptRef.current) return
+          onConnectionErrorRef.current?.()
           setError((prev) => prev || 'Connection error')
           setIsConnected(false)
           setIsConnecting(false)
         }
 
         ws.onclose = () => {
+          if (attempt !== connectionAttemptRef.current) return
           setIsConnected(false)
           setIsConnecting(false)
           xterm.write('\r\n\x1b[31mConnection closed\x1b[0m\r\n')
@@ -201,6 +236,7 @@ export function LocalTerminalTab({
         })
       })
       .catch((err) => {
+        if (attempt !== connectionAttemptRef.current) return
         setError(err instanceof Error ? err.message : 'Failed to connect')
         setIsConnecting(false)
       })
@@ -209,7 +245,7 @@ export function LocalTerminalTab({
   useEffect(() => {
     connect()
     return () => {
-      cancelledRef.current = true
+      connectionAttemptRef.current++
       cleanupRef.current?.()
       wsRef.current?.close()
       xtermRef.current?.dispose()
@@ -232,16 +268,18 @@ export function LocalTerminalTab({
         <span
           title={isConnected ? 'Connected' : isConnecting ? 'Connecting...' : 'Disconnected'}
           className={clsx(
-            'w-2 h-2 rounded-full',
+            'w-2 h-2 shrink-0 rounded-full',
             isConnected ? 'bg-green-500' : isConnecting ? 'bg-yellow-500 animate-pulse' : 'bg-red-500'
           )}
         />
-        <span className="text-xs text-theme-text-tertiary">Local Terminal</span>
+        <span className="shrink-0 text-xs text-theme-text-tertiary">Local Terminal</span>
+        {toolbarExtra}
 
         {!isConnected && !isConnecting && (
           <button
             onClick={connect}
-            className="flex items-center gap-1 px-2 py-0.5 text-xs text-theme-text-tertiary hover:text-theme-text-primary hover:bg-theme-elevated rounded"
+            disabled={!connectAllowed}
+            className="shrink-0 whitespace-nowrap flex items-center gap-1 px-2 py-0.5 text-xs text-theme-text-tertiary enabled:hover:text-theme-text-primary enabled:hover:bg-theme-elevated disabled:opacity-50 disabled:cursor-not-allowed rounded"
           >
             <RefreshCw className="w-3 h-3" />
             Reconnect
@@ -252,20 +290,20 @@ export function LocalTerminalTab({
       </div>
 
       {/* Terminal or error */}
-      {error ? (
+      <div ref={terminalRef} className="absolute top-8 left-0 right-0 bottom-0 bg-[#0f172a] [&_.xterm-viewport]:!bg-[#0f172a]" />
+      {error && (
         <div key="error" className="absolute top-8 left-0 right-0 bottom-0 flex flex-col items-center justify-center p-4 text-center bg-slate-900">
           <div className="text-red-400 mb-2 text-sm">Failed to connect</div>
           <div className="text-xs text-theme-text-disabled mb-3">{error}</div>
           <button
             onClick={connect}
-            className="flex items-center gap-2 px-3 py-1.5 btn-brand text-xs rounded"
+            disabled={!connectAllowed}
+            className="flex items-center gap-2 px-3 py-1.5 btn-brand text-xs rounded disabled:opacity-50 disabled:cursor-not-allowed"
           >
             <RefreshCw className="w-3 h-3" />
             Retry
           </button>
         </div>
-      ) : (
-        <div key="terminal" ref={terminalRef} className="absolute top-8 left-0 right-0 bottom-0 bg-[#0f172a] [&_.xterm-viewport]:!bg-[#0f172a]" />
       )}
       {pasteDialog}
     </div>

package/src/components/dock/TerminalTab.tsx

@@ -298,8 +298,8 @@ export function TerminalTab({
         {!error && <TerminalClipboardToolbar hasSelection={hasSelection} onCopy={handleCopy} />}
       </div>
 
-      {/* Terminal or error — key forces xterm canvas unmount/remount on toggle */}
-      {error ? (
+      <div ref={terminalRef} className="absolute top-8 left-0 right-0 bottom-0 bg-[#0f172a] [&_.xterm-viewport]:!bg-[#0f172a]" />
+      {error && (
         <div key="error" className="absolute top-8 left-0 right-0 bottom-0 flex flex-col items-center justify-center p-4 text-center bg-slate-900">
           {errorType === 'shell_not_found' ? (
             <>
@@ -347,8 +347,6 @@ export function TerminalTab({
             </>
           )}
         </div>
-      ) : (
-        <div key="terminal" ref={terminalRef} className="absolute top-8 left-0 right-0 bottom-0 bg-[#0f172a] [&_.xterm-viewport]:!bg-[#0f172a]" />
       )}
       {pasteDialog}
     </div>

package/src/components/issues/IssuesView.tsx

@@ -403,7 +403,16 @@ export function IssueRow({
 function Diagnosis({ issue, source }: { issue: Issue; source?: IssueDiagnosisSource }) {
   const crash =
     issue.restart_count || issue.last_terminated_reason
-      ? [issue.restart_count ? `${issue.restart_count} restart${issue.restart_count === 1 ? '' : 's'}` : null, issue.last_terminated_reason ? `last exit: ${issue.last_terminated_reason}` : null]
+      ? [
+          issue.restart_count ? `${issue.restart_count} restart${issue.restart_count === 1 ? '' : 's'}` : null,
+          issue.last_terminated_reason ? `last exit: ${issue.last_terminated_reason}` : null,
+          issue.restart_loop?.workload_pods && issue.restart_loop.workload_pods > 1
+            ? `${issue.restart_loop.looping_pods} of ${issue.restart_loop.workload_pods} pods looping`
+            : null,
+          issue.restart_loop?.startup_probe_failure ? 'startup probe failures seen' : null,
+          issue.restart_loop?.liveness_probe_failure ? 'liveness probe failures seen' : null,
+          issue.restart_loop?.readiness_probe_failure ? 'readiness probe failures seen' : null,
+        ]
           .filter(Boolean)
           .join(' · ')
       : null;

package/src/components/issues/types.ts

@@ -230,6 +230,9 @@ export interface Issue {
   // Pod crash context carried from the representative member.
   restart_count?: number;
   last_terminated_reason?: string;
+  /** Evidence for a container in an active restart loop (crashloop issues).
+   *  Probe failures are observations alongside the restarts, not a cause. */
+  restart_loop?: IssueRestartLoop;
 
   /**
    * Best-effort timing evidence from K8s-native signals. Absent when Radar has
@@ -360,3 +363,24 @@ export function issueMessageParts(issue: Issue): { headline: string; detail: str
   if (normalized && normalized !== raw) return { headline: normalized, detail: raw };
   return { headline: raw, detail: '' };
 }
+
+export interface IssueProbeFailure {
+  last_seen: string;
+  message?: string;
+}
+
+export interface IssueRestartLoop {
+  container: string;
+  sidecar?: boolean;
+  restart_count: number;
+  last_exit_code: number;
+  last_reason?: string;
+  last_finished_at?: string;
+  last_started_at?: string;
+  looping_pods?: number;
+  workload_pods?: number;
+  severity_reason?: string;
+  liveness_probe_failure?: IssueProbeFailure;
+  readiness_probe_failure?: IssueProbeFailure;
+  startup_probe_failure?: IssueProbeFailure;
+}

package/src/components/logs/LogCore.theme.test.tsx

@@ -0,0 +1,77 @@
+// @vitest-environment jsdom
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { LogCore } from './LogCore'
+
+Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true })
+
+let root: Root
+let element: HTMLDivElement
+beforeEach(() => {
+  localStorage.clear()
+  element = document.createElement('div')
+  document.body.appendChild(element)
+  root = createRoot(element)
+})
+afterEach(async () => {
+  await act(async () => root.unmount())
+  element.remove()
+})
+
+const noop = () => {}
+async function render(props: { forceDark?: boolean; defaultDark?: boolean }) {
+  await act(async () =>
+    root.render(
+      <LogCore
+        entries={[]}
+        isLoading={false}
+        isStreaming={false}
+        onStopStream={noop}
+        onRefresh={noop}
+        onDownload={noop}
+        {...props}
+      />,
+    ),
+  )
+}
+const toggle = () => element.querySelector<HTMLButtonElement>('button[aria-label^="Switch log viewer"]')
+
+describe('LogCore theme', () => {
+  it('defaults to dark when no theme hint is given', async () => {
+    await render({})
+    expect(toggle()?.getAttribute('aria-label')).toBe('Switch log viewer to light mode')
+  })
+
+  it('follows defaultDark and keeps the toggle available', async () => {
+    await render({ defaultDark: false })
+    expect(toggle()?.getAttribute('aria-label')).toBe('Switch log viewer to dark mode')
+    await render({ defaultDark: true })
+    expect(toggle()?.getAttribute('aria-label')).toBe('Switch log viewer to light mode')
+  })
+
+  it('prefers the saved toggle choice over defaultDark', async () => {
+    localStorage.setItem('radar-logs-dark', 'true')
+    await render({ defaultDark: false })
+    expect(toggle()?.getAttribute('aria-label')).toBe('Switch log viewer to light mode')
+  })
+
+  it('returns to the saved choice when a forceDark pin is lifted', async () => {
+    localStorage.setItem('radar-logs-dark', 'false')
+    await render({ forceDark: true, defaultDark: false })
+    expect(toggle()).toBeNull()
+    await render({ defaultDark: false })
+    expect(toggle()?.getAttribute('aria-label')).toBe('Switch log viewer to dark mode')
+  })
+
+  it('ignores a saved value that is not a palette choice', async () => {
+    localStorage.setItem('radar-logs-dark', 'garbage')
+    await render({ defaultDark: false })
+    expect(toggle()?.getAttribute('aria-label')).toBe('Switch log viewer to dark mode')
+  })
+
+  it('hides the toggle when forceDark is set', async () => {
+    await render({ forceDark: true, defaultDark: false })
+    expect(toggle()).toBeNull()
+  })
+})

package/src/components/logs/LogCore.tsx

@@ -67,6 +67,12 @@ interface LogCoreProps {
    * the viewer manages its own palette via localStorage and the Sun/Moon button.
    */
   forceDark?: boolean
+  /**
+   * Palette to use when the user hasn't picked one with the Sun/Moon toggle
+   * (e.g. the host app's theme). Unlike `forceDark`, the toggle stays visible.
+   * Defaults to dark.
+   */
+  defaultDark?: boolean
 }
 
 interface LevelOption {
@@ -143,12 +149,14 @@ export function LogCore({
   emptyCommand,
   errorMessage,
   forceDark,
+  defaultDark = true,
 }: LogCoreProps) {
   const virtuosoRef = useRef<VirtuosoHandle>(null)
   const [atBottom, setAtBottom] = useState(true)
   const themeLocked = typeof forceDark === 'boolean'
   // Seed isDark: forceDark prop wins; else localStorage['radar-logs-dark'];
-  // else default dark. See log-palette.ts for why the viewer is palette-driven
+  // else defaultDark (the host app's theme, dark if not given). See
+  // log-palette.ts for why the viewer is palette-driven
   // instead of theme-token-driven.
   const [isDark, setIsDark] = useState<boolean>(() => {
     if (typeof forceDark === 'boolean') return forceDark
@@ -157,13 +165,26 @@ export function LogCore({
       if (v === 'false') return false
       if (v === 'true') return true
     } catch {}
-    return true
+    return defaultDark
   })
   useEffect(() => {
     if (typeof forceDark === 'boolean') {
       setIsDark(forceDark)
     }
   }, [forceDark])
+  // Re-resolve whenever the host's hint changes, including when a forceDark pin
+  // is lifted: the user's saved pick wins, otherwise the host default.
+  useEffect(() => {
+    if (typeof forceDark === 'boolean') return
+    try {
+      const v = localStorage.getItem('radar-logs-dark')
+      if (v === 'true' || v === 'false') {
+        setIsDark(v === 'true')
+        return
+      }
+    } catch {}
+    setIsDark(defaultDark)
+  }, [defaultDark, forceDark])
   const palette = useMemo(() => getLogPalette(isDark), [isDark])
   const toggleDark = useCallback(() => {
     if (themeLocked) return