openk8s 1.0.5 → 1.2.0

package/src/lib/k8s/detail-builders/pod-builder.ts

@@ -3,35 +3,60 @@ import {
   buildEnvLine, formatContainerState, formatEnvFromSource,
   formatProbe, formatValueFrom, formatVolumeSource,
 } from "../resource-parser";
+import { formatAge } from "../k8s-format";
 import type { ResourceDetailSection } from "../types";
 import type { KubernetesResource } from "../resource-parser";
 
+interface ContainerInfo {
+  record: Record<string, unknown>;
+  isInit: boolean;
+  statusEntry: Record<string, unknown> | undefined;
+}
+
+function collectContainers(spec: Record<string, unknown>, status: Record<string, unknown>): ContainerInfo[] {
+  const statusMap = new Map<string, Record<string, unknown>>();
+  for (const key of ["containerStatuses", "initContainerStatuses"] as const) {
+    for (const entry of asArray(status[key]).map(asRecord)) {
+      if (entry && asString(entry.name)) {
+        statusMap.set(asString(entry.name) ?? "", entry);
+      }
+    }
+  }
+
+  const collect = (field: string, isInit: boolean): ContainerInfo[] =>
+    asArray(spec[field])
+      .map(asRecord)
+      .filter((entry): entry is Record<string, unknown> => entry !== undefined)
+      .map((record) => {
+        const name = asString(record.name) ?? "";
+        return { record, isInit, statusEntry: statusMap.get(name) };
+      });
+
+  return [...collect("initContainers", true), ...collect("containers", false)];
+}
+
+function containerLabel(info: ContainerInfo): string {
+  const name = asString(info.record.name) ?? "container";
+  return info.isInit ? `${name} (init)` : name;
+}
+
 export function buildPodSections(resource: KubernetesResource): ResourceDetailSection[] {
   const spec = resource.spec ?? {};
   const status = resource.status ?? {};
+  const containers = collectContainers(spec, status);
 
-  const containerStatuses = new Map(
-    asArray(status.containerStatuses)
-      .map((entry) => asRecord(entry))
-      .filter((entry): entry is Record<string, unknown> => Boolean(entry && asString(entry.name)))
-      .map((entry) => [asString(entry.name) ?? "", entry]),
-  );
-
-  const containers = asArray(spec.containers)
-    .map((entry) => asRecord(entry))
-    .filter((entry): entry is Record<string, unknown> => entry !== undefined);
-
-  const containerLines = containers.map((container) => {
-    const name = asString(container.name) ?? "container";
-    const statusEntry = containerStatuses.get(name);
+  const containerLines = containers.map((info) => {
+    const name = containerLabel(info);
+    const statusEntry = info.statusEntry;
     const ready = asBoolean(statusEntry?.ready);
     const restartCount = asNumber(statusEntry?.restartCount);
 
-    return `${name}  image ${asString(container.image) ?? "-"}  ready ${ready === undefined ? "-" : ready ? "yes" : "no"}  restarts ${restartCount ?? 0}  state ${formatContainerState(statusEntry?.state)}`;
+    return `${name}  image ${asString(info.record.image) ?? "-"}  ready ${ready === undefined ? "-" : ready ? "yes" : "no"}  restarts ${restartCount ?? 0}  state ${formatContainerState(statusEntry?.state)}`;
   });
 
-  const environmentLines = containers.flatMap((container) => {
-    const containerName = asString(container.name) ?? "container";
+  const environmentLines = containers.flatMap((info) => {
+    const containerName = containerLabel(info);
+    const container = info.record;
     const envLines = asArray(container.env)
       .map((entry) => asRecord(entry))
       .filter((entry): entry is Record<string, unknown> => entry !== undefined)
@@ -78,8 +103,9 @@ export function buildPodSections(resource: KubernetesResource): ResourceDetailSe
     return [...envLines, ...envFromLines];
   });
 
-  const portLines = containers.flatMap((container) => {
-    const containerName = asString(container.name) ?? "container";
+  const portLines = containers.flatMap((info) => {
+    const containerName = containerLabel(info);
+    const container = info.record;
 
     return asArray(container.ports)
       .map((entry) => asRecord(entry))
@@ -92,8 +118,9 @@ export function buildPodSections(resource: KubernetesResource): ResourceDetailSe
       });
   });
 
-  const mountLines = containers.flatMap((container) => {
-    const containerName = asString(container.name) ?? "container";
+  const mountLines = containers.flatMap((info) => {
+    const containerName = containerLabel(info);
+    const container = info.record;
 
     return asArray(container.volumeMounts)
       .map((entry) => asRecord(entry))
@@ -105,8 +132,9 @@ export function buildPodSections(resource: KubernetesResource): ResourceDetailSe
       });
   });
 
-  const probeLines = containers.map((container) => {
-    const containerName = asString(container.name) ?? "container";
+  const probeLines = containers.map((info) => {
+    const containerName = containerLabel(info);
+    const container = info.record;
     return `${containerName}: readiness ${formatProbe(container.readinessProbe)} | liveness ${formatProbe(container.livenessProbe)} | startup ${formatProbe(container.startupProbe)}`;
   });
 
@@ -116,7 +144,7 @@ export function buildPodSections(resource: KubernetesResource): ResourceDetailSe
     .map((entry) => {
       const type = asString(entry.type) ?? "Condition";
       const conditionStatus = asString(entry.status) ?? "Unknown";
-      const transition = asString(entry.lastTransitionTime) ?? "unknown";
+      const transition = formatAge(asString(entry.lastTransitionTime));
       return `${type}: ${conditionStatus}  transitioned ${transition}`;
     });
 

package/src/lib/k8s/detail-builders/rbac-builder.ts

@@ -1,36 +1,34 @@
-import { asArray, asRecord, asString } from "../resource-parser";
+import { asArray, asRecord, asString, recordsOf } from "../resource-parser";
 import type { ResourceDetailSection } from "../types";
 import type { KubernetesResource } from "../resource-parser";
 
+function asStringOrDash(value: unknown): string {
+  return asString(value) ?? "-";
+}
+
 export function buildRoleSections(resource: KubernetesResource): ResourceDetailSection[] {
-  const raw = resource as unknown as Record<string, unknown>;
-  const rules = asArray(raw.rules)
-    .map((r) => asRecord(r))
-    .filter((r): r is Record<string, unknown> => r !== undefined)
-    .map((r) => {
-      const verbs = asArray(r.verbs).map((v) => String(v)).join(",");
-      const resources = asArray(r.resources).map((res) => String(res)).join(",");
-      const apiGroups = asArray(r.apiGroups).map((g) => String(g) || '""').join(",");
-      return `[${apiGroups}] ${resources}: ${verbs}`;
-    });
+  const raw = asRecord(resource) ?? {};
+  const rules = recordsOf(raw.rules).map((r) => {
+    const verbs = asArray(r.verbs).map(asStringOrDash).join(",");
+    const resources = asArray(r.resources).map(asStringOrDash).join(",");
+    const apiGroups = asArray(r.apiGroups).map((g) => asString(g) ?? '""').join(",");
+    return `[${apiGroups}] ${resources}: ${verbs}`;
+  });
 
   return [{ title: "Rules", lines: rules.length > 0 ? rules : ["No rules"] }];
 }
 
 export function buildRoleBindingSections(resource: KubernetesResource): ResourceDetailSection[] {
-  const raw = resource as unknown as Record<string, unknown>;
+  const raw = asRecord(resource) ?? {};
   const roleRef = asRecord(raw.roleRef);
   const refLines = roleRef
     ? [`${asString(roleRef.kind) ?? "-"} / ${asString(roleRef.name) ?? "-"}`]
     : ["No roleRef"];
 
-  const subjects = asArray(raw.subjects)
-    .map((s) => asRecord(s))
-    .filter((s): s is Record<string, unknown> => s !== undefined)
-    .map((s) => {
-      const ns = asString(s.namespace);
-      return `${asString(s.kind) ?? "-"}  ${ns ? `${ns}/` : ""}${asString(s.name) ?? "-"}`;
-    });
+  const subjects = recordsOf(raw.subjects).map((s) => {
+    const ns = asString(s.namespace);
+    return `${asString(s.kind) ?? "-"}  ${ns ? `${ns}/` : ""}${asString(s.name) ?? "-"}`;
+  });
 
   return [
     { title: "RoleRef", lines: refLines },
@@ -39,16 +37,9 @@ export function buildRoleBindingSections(resource: KubernetesResource): Resource
 }
 
 export function buildServiceAccountSections(resource: KubernetesResource): ResourceDetailSection[] {
-  const raw = resource as unknown as Record<string, unknown>;
-  const secrets = asArray(raw.secrets)
-    .map((s) => asRecord(s))
-    .filter((s): s is Record<string, unknown> => s !== undefined)
-    .map((s) => asString(s.name) ?? "-");
-
-  const imagePullSecrets = asArray(raw.imagePullSecrets)
-    .map((s) => asRecord(s))
-    .filter((s): s is Record<string, unknown> => s !== undefined)
-    .map((s) => asString(s.name) ?? "-");
+  const raw = asRecord(resource) ?? {};
+  const secrets = recordsOf(raw.secrets).map((s) => asString(s.name) ?? "-");
+  const imagePullSecrets = recordsOf(raw.imagePullSecrets).map((s) => asString(s.name) ?? "-");
 
   return [
     { title: "Secrets", lines: secrets.length > 0 ? secrets : ["None"] },

package/src/lib/k8s/k8s-format.ts

@@ -3,17 +3,22 @@ export function formatAge(value?: string | undefined): string {
     return "-";
   }
 
-  // Normalize helm-style timestamps: "2024-05-12 10:30:00.123456789 +0000 UTC"
-  // into ISO 8601: "2024-05-12T10:30:00.123+00:00"
-  // Standard ISO strings (from kubectl) pass through unchanged.
-  const normalized = value
-    .replace(/ [A-Z]+$/, "")           // strip trailing timezone name: " UTC", " EST"
-    .replace(/(\.\d{3})\d*/, "$1")     // truncate sub-millisecond digits
-    .replace(" ", "T")                 // first space → T (date/time separator)
-    .replace(" ", "")                  // second space (before offset) → removed
+  // Standard ISO strings (from kubectl) pass through unchanged (sub-ms digits are truncated).
+  // Helm-style timestamps ("2024-05-12 10:30:00.123456789 +0000 UTC") are normalized to ISO 8601.
+  const isHelmFormat = value.includes(" ");
+  const strippedTz = value.replace(/ [A-Z]+$/, ""); // strip trailing timezone name: " UTC", " EST"
+  const hasNumericOffset = /[+-]\d{4}$/.test(strippedTz);
+  const normalized = strippedTz
+    .replace(/(\.\d{3})\d*/, "$1") // truncate sub-millisecond digits
+    .replace(" ", "T") // first space → T (date/time separator)
+    .replace(" ", "") // second space (before offset, if any) → removed
     .replace(/([+-]\d{2})(\d{2})$/, "$1:$2"); // +0000 → +00:00
 
-  const created = new Date(normalized);
+  // Helm timestamps are UTC. If a helm-format value lacked a numeric offset,
+  // append Z so it parses as UTC rather than the host's local timezone.
+  const iso = isHelmFormat && !hasNumericOffset ? `${normalized}Z` : normalized;
+
+  const created = new Date(iso);
 
   if (Number.isNaN(created.valueOf())) {
     return "-";

package/src/lib/k8s/resource-detail-builder.ts

@@ -1,6 +1,6 @@
 import type { ResourceDetail, ResourceKind } from "./types";
 import { isPodKind } from "./resource-parser";
-import type { KubernetesResource, KubernetesMetadata } from "./resource-parser";
+import type { KubernetesResource } from "./resource-parser";
 
 export { type KubernetesMetadata, type KubernetesResource } from "./resource-parser";
 
@@ -8,9 +8,9 @@ import { buildOverviewSection, buildPortForward } from "./detail-builders/overvi
 import { buildPodSections } from "./detail-builders/pod-builder";
 import { buildHpaSections, buildCronJobSections } from "./detail-builders/hpa-cronjob-builder";
 import { buildNodeSections } from "./detail-builders/node-builder";
-import { buildEventSections } from "./detail-builders/event-builder";
+import { buildEventObjectSections } from "./detail-builders/event-builder";
 import { buildRoleSections, buildRoleBindingSections, buildServiceAccountSections } from "./detail-builders/rbac-builder";
-import { flattenSections, extractContainerNames } from "./resource-parser";
+import { extractContainerNames } from "./resource-parser";
 
 export function buildResourceDetail(options: BuildResourceDetailOptions): ResourceDetail {
   const kindName = options.resource.kind ?? options.resourceKind?.name ?? "unknown";
@@ -28,7 +28,7 @@ export function buildResourceDetail(options: BuildResourceDetailOptions): Resour
   } else if (normalizedKind === "node") {
     additionalSections = buildNodeSections(options.resource);
   } else if (normalizedKind === "event" || normalizedKind === "events") {
-    additionalSections = buildEventSections(options.resource);
+    additionalSections = buildEventObjectSections(options.resource);
   } else if (normalizedKind === "role" || normalizedKind === "clusterrole") {
     additionalSections = buildRoleSections(options.resource);
   } else if (normalizedKind === "rolebinding" || normalizedKind === "clusterrolebinding") {
@@ -47,10 +47,8 @@ export function buildResourceDetail(options: BuildResourceDetailOptions): Resour
       name: options.resource.metadata?.name ?? "unknown",
       namespace: options.resource.metadata?.namespace,
     },
-    summaryLines: flattenSections(summarySections),
     summarySections,
     yaml: options.yaml,
-    describe: options.describe,
     replicas: overview.replicas,
     portForwards: portForward.length > 0 ? portForward : undefined,
     containers: containers && containers.length > 0 ? containers : undefined,
@@ -61,5 +59,4 @@ export interface BuildResourceDetailOptions {
   resourceKind?: ResourceKind | undefined;
   resource: KubernetesResource;
   yaml: string;
-  describe?: string | undefined;
 }

package/src/lib/k8s/resource-parser.ts

@@ -19,12 +19,17 @@ export function asRecord(value: unknown): Record<string, unknown> | undefined {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
 }
 
+/**
+ * Returns the value if it is a non-empty string, otherwise undefined.
+ * Note: an explicitly-empty string is treated as absent — callers that need
+ * to preserve empty strings should read the field directly.
+ */
 export function asString(value: unknown): string | undefined {
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 
 export function asNumber(value: unknown): number | undefined {
-  return typeof value === "number" ? value : undefined;
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
 
 export function asBoolean(value: unknown): boolean | undefined {
@@ -35,6 +40,16 @@ export function asArray(value: unknown): unknown[] {
   return Array.isArray(value) ? value : [];
 }
 
+/**
+ * Returns the records (objects) within an array, dropping non-object entries.
+ * Convenience for the common `asArray(x).map(asRecord).filter(isRecord)` pattern.
+ */
+export function recordsOf(value: unknown): Record<string, unknown>[] {
+  return asArray(value)
+    .map(asRecord)
+    .filter((entry): entry is Record<string, unknown> => entry !== undefined);
+}
+
 export function summarizeLabels(labels?: Record<string, string> | undefined): string {
   const pairs = Object.entries(labels ?? {});
 
@@ -150,7 +165,7 @@ export function formatContainerState(value: unknown): string {
   const state = asRecord(value);
 
   if (!state) {
-    return "waiting";
+    return "unknown";
   }
 
   if (state.running) {

package/src/lib/k8s/types.ts

@@ -1,8 +1,8 @@
 export type PaneId = "clusters" | "resources" | "inspector";
 
-export type OverlayId = "cluster-switcher" | "namespace-switcher" | "delete-confirm" | "port-forward" | "logs" | "scale" | "container-picker" | "helm-rollback";
+export type OverlayId = "cluster-switcher" | "namespace-switcher" | "delete-confirm" | "port-forward" | "port-forward-list" | "logs" | "scale" | "container-picker" | "helm-rollback" | "notification-history" | "help";
 
-export type InspectorTab = "summary" | "yaml" | "events" | "describe";
+export type InspectorTab = "summary" | "yaml";
 
 export type LoadStatus = "idle" | "loading" | "ready" | "error";
 
@@ -68,14 +68,13 @@ export interface ResourceDetailSection {
 
 export interface ResourceDetail {
   ref: ResourceRef;
-  summaryLines: string[];
   summarySections: ResourceDetailSection[];
   yaml: string;
-  describe?: string | undefined;
   replicas?: number | undefined;
   portForwards?: ResourcePortForward[] | undefined;
   containers?: string[] | undefined;
   helmChart?: string | undefined;
+  helmValues?: string | undefined;
 }
 
 export interface EventItem {
@@ -105,10 +104,18 @@ export interface AppError {
 
 export type NotificationTone = "info" | "success" | "warning" | "danger";
 
+export interface NotificationAction {
+  id: string;
+  label: string;
+}
+
 export interface Notification {
   id: string;
   tone: NotificationTone;
   message: string;
+  persistent: boolean;
+  createdAt: number;
+  actions: NotificationAction[];
 }
 
 export interface PodMetricEntry {
@@ -158,6 +165,7 @@ export interface AppState {
   revealedSecretValues: Record<string, string>;
   activePortForwards: ActivePortForward[];
   notifications: Notification[];
+  notificationHistory: Notification[];
   podMetrics: Record<string, { cpu: string; memory: string }>;
   nodeMetrics: Record<string, { cpu: string; memory: string; cpuPct: number; memPct: number }>;
   helmRollbackRevision: string;

package/src/lib/kubectl/__tests__/metrics-utils.test.ts

@@ -35,12 +35,21 @@ describe("parseMemBytes", () => {
   test("Ki", () => expect(parseMemBytes("512Ki")).toBe(512 * 1024));
   test("Mi", () => expect(parseMemBytes("256Mi")).toBe(256 * 1024 ** 2));
   test("Gi", () => expect(parseMemBytes("2Gi")).toBe(2 * 1024 ** 3));
+  test("Ti", () => expect(parseMemBytes("1Ti")).toBe(1024 ** 4));
+  test("Pi", () => expect(parseMemBytes("1Pi")).toBe(1024 ** 5));
+  test("Ei", () => expect(parseMemBytes("1Ei")).toBe(1024 ** 6));
   test("K (decimal)", () => expect(parseMemBytes("1000K")).toBe(1000 * 1000));
   test("M (decimal)", () => expect(parseMemBytes("10M")).toBe(10 * 1000 ** 2));
   test("G (decimal)", () => expect(parseMemBytes("1G")).toBe(1000 ** 3));
+  test("T (decimal)", () => expect(parseMemBytes("1T")).toBe(1000 ** 4));
+  test("P (decimal)", () => expect(parseMemBytes("1P")).toBe(1000 ** 5));
+  test("E (decimal)", () => expect(parseMemBytes("1E")).toBe(1000 ** 6));
   test("plain bytes", () => expect(parseMemBytes("1024")).toBe(1024));
   test("empty string", () => expect(parseMemBytes("")).toBe(0));
   test("invalid", () => expect(parseMemBytes("abc")).toBe(0));
+  test("does not match K before Ki (order-dependent regression guard)", () => {
+    expect(parseMemBytes("100Ki")).toBe(100 * 1024);
+  });
 });
 
 // ── formatCpu ────────────────────────────────────────────────────────────────

package/src/lib/kubectl/kubectl-helpers.ts

@@ -1,4 +1,5 @@
 import { formatAge } from "../k8s/k8s-format";
+import { asRecord, asString } from "../k8s/resource-parser";
 import type { ResourceKind, ResourceRef } from "../k8s/types";
 import type { GenericListItem } from "./kubectl-types";
 
@@ -6,6 +7,12 @@ export function normalizeKind(kind: string): string {
   return kind.trim().toLowerCase();
 }
 
+export const HELM_RELEASE_KIND = "helmreleases";
+
+export function isHelmRelease(ref: { kind: string } | undefined): ref is { kind: string } {
+  return ref !== undefined && normalizeKind(ref.kind) === HELM_RELEASE_KIND;
+}
+
 export function normalizeResourceTarget(ref: ResourceRef): string {
   const kind = normalizeKind(ref.kind);
   return `${kind}/${ref.name}`;
@@ -77,8 +84,8 @@ export function supportsScale(ref: ResourceRef): boolean {
   return ["deployment", "deployments", "statefulset", "statefulsets", "replicaset", "replicasets"].includes(kind);
 }
 
-export function parseKubectlError(stderr: string, args: string[]): Error {
-  const message = stderr.trim() || `kubectl ${args.join(" ")} failed`;
+export function parseKubectlError(stderr: string, args: string[], command = "kubectl"): Error {
+  const message = stderr.trim() || `${command} ${args.join(" ")} failed`;
   return new Error(message);
 }
 
@@ -114,9 +121,7 @@ export function resourceStatus(resource: GenericListItem): string {
   }
 
   if (kind === "rolebinding" || kind === "clusterrolebinding") {
-    const subjects = Array.isArray((resource as unknown as Record<string, unknown>).subjects)
-      ? ((resource as unknown as Record<string, unknown>).subjects as unknown[])
-      : [];
+    const subjects = Array.isArray(resource.subjects) ? resource.subjects : [];
     return `${subjects.length} subjects`;
   }
 
@@ -164,9 +169,9 @@ export function resourceSummary(resource: GenericListItem): string {
   }
 
   if (kind === "node") {
-    const nodeInfo = (status.nodeInfo ?? {}) as Record<string, unknown>;
-    const kubeletVersion = typeof nodeInfo.kubeletVersion === "string" ? nodeInfo.kubeletVersion : "";
-    const labels = (resource as unknown as { metadata?: { labels?: Record<string, string> } }).metadata?.labels ?? {};
+    const nodeInfo = asRecord(status.nodeInfo) ?? {};
+    const kubeletVersion = asString(nodeInfo.kubeletVersion) ?? "";
+    const labels = resource.metadata?.labels ?? {};
     const roles = Object.keys(labels)
       .filter((k) => k.startsWith("node-role.kubernetes.io/"))
       .map((k) => k.replace("node-role.kubernetes.io/", ""))
@@ -175,14 +180,14 @@ export function resourceSummary(resource: GenericListItem): string {
   }
 
   if (kind === "role" || kind === "clusterrole") {
-    const rules = (resource as unknown as { rules?: unknown[] }).rules ?? [];
+    const rules = Array.isArray(resource.rules) ? resource.rules : [];
     return `${rules.length} rules`;
   }
 
   if (kind === "rolebinding" || kind === "clusterrolebinding") {
-    const roleRef = (resource as unknown as { roleRef?: Record<string, unknown> }).roleRef;
+    const roleRef = resource.roleRef;
     if (roleRef) {
-      return `\u2192 ${roleRef.kind ?? ""}/${roleRef.name ?? ""}`;
+      return `\u2192 ${asString(roleRef.kind) ?? ""}/${asString(roleRef.name) ?? ""}`;
     }
     return "";
   }