openk8s 1.0.4 → 1.1.0

package/src/app/use-footer-hints.ts

@@ -1,16 +1,19 @@
 import { useMemo } from "react";
 
-import { GLYPHS, KEY_HINT, TEXT_MUTED, TEXT_SUBTLE } from "./theme";
-import type { AppState, ActivePortForward, ResourceDetail, ResourceRef } from "../lib/k8s/types";
+import { GLYPHS } from "./theme";
+import { FOOTER_PADDING, HINT_CELL_OVERHEAD } from "./constants";
+import type { ActivePortForward, PaneId, ResourceDetail, ResourceListItem, ResourceRef } from "../lib/k8s/types";
+import { isHelmRelease } from "../lib/kubectl/kubectl-helpers";
 import { KubectlService } from "../lib/kubectl/kubectl-service";
 
 export function useFooterHints(
   filterMode: boolean,
-  state: AppState,
+  activePane: PaneId,
   activeResourceRef: ResourceRef | undefined,
   activeDetail: ResourceDetail | undefined,
   selectedResourcePortForwards: ActivePortForward[],
-  deleteTargets: { length: number },
+  activePortForwardsCount: number,
+  deleteTargets: ReadonlyArray<ResourceListItem>,
   kubectl: KubectlService,
 ): [string, string][] {
   return useMemo((): [string, string][] => {
@@ -22,12 +25,12 @@ export function useFooterHints(
       ];
     }
 
-    const isHelm = activeResourceRef?.kind.toLowerCase() === "helmreleases";
+    const isHelm = isHelmRelease(activeResourceRef);
     const hasResource = Boolean(activeResourceRef);
     const hasPortForwards =
       (activeDetail?.portForwards?.length ?? 0) > 0 || selectedResourcePortForwards.length > 0;
 
-    if (state.activePane === "clusters") {
+    if (activePane === "clusters") {
       return [
         [GLYPHS.tab, "panes"],
         ["↑↓", "kinds"],
@@ -35,7 +38,7 @@ export function useFooterHints(
       ];
     }
 
-    if (state.activePane === "inspector") {
+    if (activePane === "inspector") {
       return [
         [GLYPHS.tab, "panes"],
         ["←", "back"],
@@ -48,17 +51,17 @@ export function useFooterHints(
       ["↑↓", "navigate"],
       ["/", "filter"],
       ["R", "refresh"],
+      ["⇧N", "history"],
+      ...(activePortForwardsCount > 0 ? [["⇧F", "forwards"] as [string, string]] : []),
+      ["?", "help"],
     ];
 
     if (!hasResource) return hints;
 
     if (isHelm) {
-      hints.push(
-        ["E", "edit values"],
-        ...(deleteTargets.length > 0 ? [["D", "delete"] as [string, string]] : []),
-        ["B", "rollback"],
-        ["U", "upgrade"],
-      );
+      hints.push(["E", "edit values"]);
+      if (deleteTargets.length > 0) hints.push(["D", "delete"]);
+      hints.push(["B", "rollback"], ["U", "upgrade"]);
     } else {
       hints.push(["L", "logs"], ["E", "edit"], ["X", "shell"]);
       if (hasPortForwards) hints.push(["F", "forward"]);
@@ -70,11 +73,13 @@ export function useFooterHints(
     return hints;
   }, [
     filterMode,
-    state.activePane,
+    activePane,
     activeResourceRef,
     activeDetail,
     selectedResourcePortForwards,
+    activePortForwardsCount,
     deleteTargets,
+    kubectl,
   ]);
 }
 
@@ -83,14 +88,14 @@ export function useFooterHintRows(
   terminalWidth: number,
 ): { footerHintsRow1: [string, string][]; footerHintsRow2: [string, string][] } {
   return useMemo(() => {
-    const innerWidth = terminalWidth - 4;
+    const innerWidth = terminalWidth - FOOTER_PADDING;
     const row1: [string, string][] = [];
     const row2: [string, string][] = [];
     let used1 = 0;
     let used2 = 0;
 
     for (const [key, label] of footerHints) {
-      const w = key.length + label.length + 3;
+      const w = key.length + label.length + HINT_CELL_OVERHEAD;
       const gap1 = row1.length === 0 ? 0 : 2;
       const gap2 = row2.length === 0 ? 0 : 2;
       if (used1 + gap1 + w <= innerWidth) {

package/src/app/utils.ts

@@ -52,11 +52,6 @@ export interface ResourcePreviewOptions {
   resource?: ResourceListItem | undefined;
 }
 
-export interface CurrentKindLabelOptions {
-  resourceKinds: ResourceKind[];
-  selectedKind: string;
-}
-
 export interface PortForwardIdOptions {
   context: string;
   namespace: string;
@@ -185,10 +180,6 @@ export function kindDescription(kind: ResourceKind): string {
   return `${scope}${shortNames}`;
 }
 
-export function currentKindLabel(options: CurrentKindLabelOptions): string {
-  return options.resourceKinds.find((kind) => kind.name === options.selectedKind)?.name ?? options.selectedKind;
-}
-
 export function resourcePreview(options: ResourcePreviewOptions): string[] {
   if (!options.resource) {
     return ["Select a resource to inspect it."];
@@ -263,6 +254,7 @@ export function selectedRef(options: SelectedRefOptions): ResourceRef | undefine
 const EKS_ARN_RE = /^arn:aws:eks:[^:]+:\d{12}:cluster\/(.+)$/;
 
 export function truncate(s: string, maxLen: number): string {
+  if (maxLen <= 0) return s.length > 0 ? "\u2026" : s;
   if (s.length <= maxLen) return s;
   return s.slice(0, maxLen - 1) + "\u2026";
 }

package/src/assets/tree-sitter/yaml/highlights.scm

@@ -0,0 +1,79 @@
+(boolean_scalar) @boolean
+
+(null_scalar) @constant.builtin
+
+[
+  (double_quote_scalar)
+  (single_quote_scalar)
+  (block_scalar)
+  (string_scalar)
+] @string
+
+[
+  (integer_scalar)
+  (float_scalar)
+] @number
+
+(comment) @comment
+
+[
+  (anchor_name)
+  (alias_name)
+] @label
+
+(tag) @type
+
+[
+  (yaml_directive)
+  (tag_directive)
+  (reserved_directive)
+] @attribute
+
+(block_mapping_pair
+  key: (flow_node
+    [
+      (double_quote_scalar)
+      (single_quote_scalar)
+    ] @property))
+
+(block_mapping_pair
+  key: (flow_node
+    (plain_scalar
+      (string_scalar) @property)))
+
+(flow_mapping
+  (_
+    key: (flow_node
+      [
+        (double_quote_scalar)
+        (single_quote_scalar)
+      ] @property)))
+
+(flow_mapping
+  (_
+    key: (flow_node
+      (plain_scalar
+        (string_scalar) @property))))
+
+[
+  ","
+  "-"
+  ":"
+  ">"
+  "?"
+  "|"
+] @punctuation.delimiter
+
+[
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "*"
+  "&"
+  "---"
+  "..."
+] @punctuation.special

package/src/index.tsx

@@ -1,11 +1,31 @@
-import { createCliRenderer } from "@opentui/core";
+import { join } from "node:path";
+import { createCliRenderer, addDefaultParsers } from "@opentui/core";
 import { createRoot } from "@opentui/react";
-import { setAbortController } from "./lib/kubectl/spawn-utils";
+import { setAbortController, abortRunningProcesses } from "./lib/kubectl/spawn-utils";
 import { App } from "./app/app";
 
+const yamlAssetsDir = join(import.meta.dirname, "assets", "tree-sitter", "yaml");
+addDefaultParsers([
+  {
+    filetype: "yaml",
+    aliases: ["yml"],
+    queries: {
+      highlights: [join(yamlAssetsDir, "highlights.scm")],
+    },
+    wasm: join(yamlAssetsDir, "tree-sitter-yaml.wasm"),
+  },
+]);
+
 const abortController = new AbortController();
 setAbortController(abortController);
 
+for (const signal of ["SIGINT", "SIGTERM"] as const) {
+  process.on(signal, () => {
+    abortRunningProcesses();
+    process.exit(0);
+  });
+}
+
 const renderer = await createCliRenderer({
   useMouse: true,
 });

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

@@ -39,4 +39,21 @@ describe("formatAge", () => {
   test("returns '-' for invalid date", () => {
     expect(formatAge("not-a-date")).toBe("-");
   });
+
+  test("parses helm-style timestamp with offset as UTC", () => {
+    const result = formatAge("2024-01-15 10:30:00.000000000 +0000 UTC");
+    expect(result).not.toBe("-");
+  });
+
+  test("parses helm-style timestamp without offset as UTC (not local)", () => {
+    // Regression: helm values without +0000 used to be parsed in local time.
+    // Using a far-past date so the result is well-formed regardless of timezone.
+    const result = formatAge("2000-01-01 00:00:00.000 UTC");
+    expect(result).toMatch(/^\d+d$/);
+  });
+
+  test("does not double-append Z to ISO strings", () => {
+    const result = formatAge("2024-01-15T10:30:00Z");
+    expect(result).not.toBe("-");
+  });
 });

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

@@ -21,6 +21,7 @@ import {
   formatEnvFromSource,
   formatProbe,
   formatVolumeSource,
+  recordsOf,
 } from "../resource-parser";
 
 // ── Type guards ──────────────────────────────────────────────────────────────
@@ -77,6 +78,18 @@ describe("asNumber", () => {
   test("returns zero for zero", () => {
     expect(asNumber(0)).toBe(0);
   });
+
+  test("returns undefined for NaN", () => {
+    expect(asNumber(NaN)).toBeUndefined();
+  });
+
+  test("returns undefined for Infinity", () => {
+    expect(asNumber(Infinity)).toBeUndefined();
+  });
+
+  test("does not let NaN leak through nullish-coalesce fallbacks", () => {
+    expect(asNumber(NaN) ?? 0).toBe(0);
+  });
 });
 
 describe("asBoolean", () => {
@@ -277,6 +290,31 @@ describe("extractContainerPorts", () => {
     expect(extractContainerPorts({})).toEqual([]);
     expect(extractContainerPorts(null)).toEqual([]);
   });
+
+  test("extracts ports from pod-template spec (used by overview-builder)", () => {
+    const template = {
+      spec: {
+        containers: [
+          { ports: [{ containerPort: 8080 }] },
+          { ports: [{ containerPort: 8080 }] },
+        ],
+      },
+    };
+    const ports = extractContainerPorts((template as Record<string, unknown>).spec);
+    expect(ports).toEqual([8080]);
+  });
+});
+
+describe("recordsOf", () => {
+  test("returns records from an array", () => {
+    expect(recordsOf([{ a: 1 }, "x", { b: 2 }])).toEqual([{ a: 1 }, { b: 2 }]);
+  });
+
+  test("returns empty for non-array", () => {
+    expect(recordsOf(undefined)).toEqual([]);
+    expect(recordsOf(null)).toEqual([]);
+    expect(recordsOf({})).toEqual([]);
+  });
 });
 
 describe("extractContainerNames", () => {
@@ -313,11 +351,11 @@ describe("formatContainerState", () => {
   });
 
   test("undefined state", () => {
-    expect(formatContainerState(undefined)).toBe("waiting");
+    expect(formatContainerState(undefined)).toBe("unknown");
   });
 
   test("null state", () => {
-    expect(formatContainerState(null)).toBe("waiting");
+    expect(formatContainerState(null)).toBe("unknown");
   });
 });
 

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

@@ -1,20 +1,26 @@
+import { asRecord, asString } from "../resource-parser";
+import { formatAge } from "../k8s-format";
 import type { ResourceDetailSection } from "../types";
 import type { KubernetesResource } from "../resource-parser";
 
+function asStringOrDash(value: unknown): string {
+  return asString(value) ?? "-";
+}
+
 export function buildEventSections(resource: KubernetesResource): ResourceDetailSection[] {
-  const raw = resource as unknown as Record<string, unknown>;
-  const involvedObject = (raw.involvedObject ?? {}) as Record<string, unknown>;
-  const source = (raw.source ?? {}) as Record<string, unknown>;
+  const raw = asRecord(resource) ?? {};
+  const involvedObject = asRecord(raw.involvedObject) ?? {};
+  const source = asRecord(raw.source) ?? {};
 
   const lines = [
-    `type: ${String(raw.type ?? "-")}`,
-    `reason: ${String(raw.reason ?? "-")}`,
-    `message: ${String(raw.message ?? "-")}`,
-    `count: ${String(raw.count ?? "-")}`,
-    `firstTimestamp: ${String(raw.firstTimestamp ?? "-")}`,
-    `lastTimestamp: ${String(raw.lastTimestamp ?? "-")}`,
-    `source: ${String(source.component ?? raw.reportingComponent ?? "-")}`,
-    `involvedObject: ${String(involvedObject.kind ?? "-")}/${String(involvedObject.name ?? "-")}  ns: ${String(involvedObject.namespace ?? "-")}`,
+    `type: ${asStringOrDash(raw.type)}`,
+    `reason: ${asStringOrDash(raw.reason)}`,
+    `message: ${asStringOrDash(raw.message)}`,
+    `count: ${asStringOrDash(raw.count)}`,
+    `firstTimestamp: ${formatAge(asString(raw.firstTimestamp))}`,
+    `lastTimestamp: ${formatAge(asString(raw.lastTimestamp))}`,
+    `source: ${asStringOrDash(source.component ?? raw.reportingComponent)}`,
+    `involvedObject: ${asStringOrDash(involvedObject.kind)}/${asStringOrDash(involvedObject.name)}  ns: ${asStringOrDash(involvedObject.namespace)}`,
   ];
 
   return [{ title: "Event", lines }];

package/src/lib/k8s/detail-builders/hpa-cronjob-builder.ts

@@ -1,37 +1,40 @@
-import { asArray, asBoolean, asNumber, asRecord, asString } from "../resource-parser";
+import { asArray, asBoolean, asNumber, 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 buildHpaSections(resource: KubernetesResource): ResourceDetailSection[] {
   const spec = resource.spec ?? {};
   const status = resource.status ?? {};
 
-  const scaleTargetRef = (spec.scaleTargetRef ?? {}) as Record<string, unknown>;
+  const scaleTargetRef = asRecord(spec.scaleTargetRef) ?? {};
   const lines = [
-    `scaleTargetRef: ${String(scaleTargetRef.kind ?? "-")}/${String(scaleTargetRef.name ?? "-")}`,
-    `minReplicas: ${String(spec.minReplicas ?? "-")}`,
-    `maxReplicas: ${String(spec.maxReplicas ?? "-")}`,
-    `currentReplicas: ${String(status.currentReplicas ?? "-")}`,
-    `desiredReplicas: ${String(status.desiredReplicas ?? "-")}`,
+    `scaleTargetRef: ${asStringOrDash(scaleTargetRef.kind)}/${asStringOrDash(scaleTargetRef.name)}`,
+    `minReplicas: ${asNumber(spec.minReplicas) ?? "-"}`,
+    `maxReplicas: ${asNumber(spec.maxReplicas) ?? "-"}`,
+    `currentReplicas: ${asNumber(status.currentReplicas) ?? "-"}`,
+    `desiredReplicas: ${asNumber(status.desiredReplicas) ?? "-"}`,
   ];
 
-  const conditions = asArray(status.conditions)
-    .map((c) => asRecord(c))
-    .filter((c): c is Record<string, unknown> => c !== undefined)
-    .map((c) => `${asString(c.type) ?? "Condition"}: ${asString(c.status) ?? "-"} — ${asString(c.message) ?? ""}`);
-
-  const metrics = asArray(status.currentMetrics)
-    .map((m) => asRecord(m))
-    .filter((m): m is Record<string, unknown> => m !== undefined)
-    .map((m) => {
-      const type = asString(m.type) ?? "metric";
-      const resource = asRecord(m.resource);
-      if (resource) {
-        const current = asRecord(resource.current);
-        return `${type}/${String(resource.name ?? "-")}: ${String(current?.averageUtilization ?? current?.averageValue ?? "-")}`;
-      }
-      return type;
-    });
+  const conditions = recordsOf(status.conditions).map((c) => {
+    const message = asString(c.message);
+    return `${asStringOrDash(c.type)}: ${asStringOrDash(c.status)}${message ? ` — ${message}` : ""}`;
+  });
+
+  const metrics = recordsOf(status.currentMetrics).map((m) => {
+    const type = asString(m.type) ?? "metric";
+    const resource = asRecord(m.resource);
+    if (resource) {
+      const current = asRecord(resource.current);
+      const value = current?.averageUtilization ?? current?.averageValue;
+      const label = current?.averageUtilization !== undefined ? `${value}%` : asStringOrDash(value);
+      return `${type}/${asStringOrDash(resource.name)}: ${label}`;
+    }
+    return type;
+  });
 
   return [
     { title: "HPA", lines },
@@ -46,16 +49,16 @@ export function buildCronJobSections(resource: KubernetesResource): ResourceDeta
 
   const activeJobs = asArray(status.active).map((j) => {
     const ref = asRecord(j);
-    return ref ? `${String(ref.kind ?? "Job")}/${String(ref.name ?? "-")}` : "-";
+    return ref ? `${asStringOrDash(ref.kind) ?? "Job"}/${asStringOrDash(ref.name)}` : "-";
   });
 
   const lines = [
-    `schedule: ${asString(spec.schedule) ?? "-"}`,
-    `suspend: ${String(asBoolean(spec.suspend) ?? false)}`,
-    `lastScheduleTime: ${asString(status.lastScheduleTime as unknown) ?? "-"}`,
-    `concurrencyPolicy: ${asString(spec.concurrencyPolicy) ?? "-"}`,
-    `successfulJobsHistoryLimit: ${String(asNumber(spec.successfulJobsHistoryLimit) ?? "-")}`,
-    `failedJobsHistoryLimit: ${String(asNumber(spec.failedJobsHistoryLimit) ?? "-")}`,
+    `schedule: ${asStringOrDash(spec.schedule)}`,
+    `suspend: ${asBoolean(spec.suspend) ?? false}`,
+    `lastScheduleTime: ${asStringOrDash(status.lastScheduleTime)}`,
+    `concurrencyPolicy: ${asStringOrDash(spec.concurrencyPolicy) ?? "Allow"}`,
+    `successfulJobsHistoryLimit: ${asNumber(spec.successfulJobsHistoryLimit) ?? "-"}`,
+    `failedJobsHistoryLimit: ${asNumber(spec.failedJobsHistoryLimit) ?? "-"}`,
     ...(activeJobs.length > 0 ? [`active: ${activeJobs.join(", ")}`] : []),
   ];
 

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

@@ -4,17 +4,17 @@ import type { KubernetesResource } from "../resource-parser";
 
 export function buildNodeSections(resource: KubernetesResource): ResourceDetailSection[] {
   const status = resource.status ?? {};
-  const raw = resource as unknown as Record<string, unknown>;
+  const spec = asRecord(resource.spec) ?? {};
 
-  const nodeInfo = (status.nodeInfo ?? {}) as Record<string, unknown>;
-  const capacity = (status.capacity ?? {}) as Record<string, unknown>;
-  const allocatable = (status.allocatable ?? {}) as Record<string, unknown>;
+  const nodeInfo = asRecord(status.nodeInfo) ?? {};
+  const capacity = asRecord(status.capacity) ?? {};
+  const allocatable = asRecord(status.allocatable) ?? {};
 
   const infoLines = [
-    `kubeletVersion: ${String(nodeInfo.kubeletVersion ?? "-")}`,
-    `containerRuntime: ${String(nodeInfo.containerRuntimeVersion ?? "-")}`,
-    `osImage: ${String(nodeInfo.osImage ?? "-")}`,
-    `architecture: ${String(nodeInfo.architecture ?? "-")}`,
+    `kubeletVersion: ${asString(nodeInfo.kubeletVersion) ?? "-"}`,
+    `containerRuntime: ${asString(nodeInfo.containerRuntimeVersion) ?? "-"}`,
+    `osImage: ${asString(nodeInfo.osImage) ?? "-"}`,
+    `architecture: ${asString(nodeInfo.architecture) ?? "-"}`,
   ];
 
   const capacityLines = Object.entries(capacity).map(([k, v]) => {
@@ -25,12 +25,23 @@ export function buildNodeSections(resource: KubernetesResource): ResourceDetailS
   const conditions = asArray(status.conditions)
     .map((c) => asRecord(c))
     .filter((c): c is Record<string, unknown> => c !== undefined)
-    .map((c) => `${asString(c.type) ?? "Condition"}: ${asString(c.status) ?? "-"}  ${asString(c.reason) ?? ""}`);
+    .map((c) => {
+      const type = asString(c.type) ?? "Condition";
+      const conditionStatus = asString(c.status) ?? "-";
+      const reason = asString(c.reason);
+      return reason ? `${type}: ${conditionStatus}  ${reason}` : `${type}: ${conditionStatus}`;
+    });
 
-  const taints = asArray((raw.spec as Record<string, unknown> | undefined)?.taints)
+  // kubectl convention: key=value:effect (or key:effect when value-less)
+  const taints = asArray(spec.taints)
     .map((t) => asRecord(t))
     .filter((t): t is Record<string, unknown> => t !== undefined)
-    .map((t) => `${asString(t.key) ?? "key"}:${asString(t.effect) ?? "NoSchedule"}${t.value ? `=${String(t.value)}` : ""}`);
+    .map((t) => {
+      const key = asString(t.key) ?? "key";
+      const effect = asString(t.effect) ?? "NoSchedule";
+      const value = asString(t.value);
+      return value ? `${key}=${value}:${effect}` : `${key}:${effect}`;
+    });
 
   return [
     { title: "Node Info", lines: infoLines },

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

@@ -1,7 +1,8 @@
 import {
   asArray, asNumber, asPort, asRecord, asString,
-  extractContainerNames, isPodKind, normalizeKind,
+  extractContainerNames, extractContainerPorts, isPodKind, normalizeKind,
   suggestedLocalPort, summarizeIngressHosts, summarizeLabels,
+  supportsDirectPortForward,
 } from "../resource-parser";
 import type { ResourceDetailSection, ResourceKind, ResourcePortForward } from "../types";
 import type { KubernetesResource } from "../resource-parser";
@@ -24,9 +25,9 @@ export function buildPortForward(
       .map((port) => asPort(asRecord(port)?.port))
       .filter((port): port is number => port !== undefined);
   } else if (isPodKind(kindName)) {
-    remotePorts = extractContainerPortsFromSpec(spec);
+    remotePorts = extractContainerPorts(spec);
   } else {
-    remotePorts = extractContainerPortsFromSpec(asRecord(spec.template)?.spec);
+    remotePorts = extractContainerPorts(asRecord(spec.template)?.spec);
   }
 
   return remotePorts.map((remotePort) => ({
@@ -35,20 +36,6 @@ export function buildPortForward(
   }));
 }
 
-function extractContainerPortsFromSpec(specValue: unknown): number[] {
-  const spec = asRecord(specValue);
-  if (!spec) return [];
-  return asArray(spec.containers)
-    .map((container) => asRecord(container))
-    .filter((c): c is Record<string, unknown> => c !== undefined)
-    .flatMap((c) => asArray(c.ports).map((p) => asPort(asRecord(p)?.containerPort)).filter((p): p is number => p !== undefined));
-}
-
-function supportsDirectPortForward(kind: string): boolean {
-  const normalized = normalizeKind(kind);
-  return ["pod", "pods", "service", "services", "deployment", "deployments", "replicaset", "replicasets", "statefulset", "statefulsets"].includes(normalized);
-}
-
 export function buildOverviewSection(
   resourceKind: ResourceKind | undefined,
   resource: KubernetesResource,