openk8s 1.0.1 → 1.0.2

package/src/app/hooks/use-app-side-effects.ts

@@ -1,7 +1,7 @@
 import { useEffect } from "react";
 import type { ChildProcess } from "node:child_process";
 
-import type { AppAction } from "../app-state";
+import type { AppAction } from "../app-actions";
 import type { AppState } from "../../lib/k8s/types";
 import type { ResourceRef } from "../../lib/k8s/types";
 import { savePersistedState } from "../persistence";

package/src/app/hooks/use-clipboard.ts

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { useCallback } from "react";
 
-import type { AppAction } from "../app-state";
+import type { AppAction } from "../app-actions";
 import type { NotificationTone } from "../../lib/k8s/types";
 import { loadError } from "../utils";
 

package/src/app/hooks/use-data-fetching.ts

@@ -1,7 +1,7 @@
 import { useEffect, useRef } from "react";
 import type { Dispatch, SetStateAction } from "react";
 
-import type { AppAction } from "../app-state";
+import type { AppAction } from "../app-actions";
 import type { AppState } from "../../lib/k8s/types";
 import type { ResourceKind, ResourceListItem, ResourceRef } from "../../lib/k8s/types";
 import { defaultNamespace, loadError, nextVisibleResourceName } from "../utils";
@@ -28,8 +28,6 @@ export function useDataFetching(
   selectedResourceDetailRef.current = state.selectedResourceDetail;
   const eventsLengthRef = useRef(state.events.length);
   eventsLengthRef.current = state.events.length;
-  const lastLoadedResourceKeyRef = useRef<string | undefined>(undefined);
-
   // Clamp visible selection to the filtered list when filter changes
   useEffect(() => {
     const nextSelection = nextVisibleResourceName({
@@ -187,10 +185,7 @@ export function useDataFetching(
     let cancelled = false;
 
     async function loadResources(): Promise<void> {
-      const resourceKey = `${activeContext}:${activeNamespace}:${activeKind.name}`;
-      if (lastLoadedResourceKeyRef.current !== resourceKey && resourcesLengthRef.current > 0) {
-        dispatch({ type: "setResourcesStatus", status: "loading" });
-      }
+      dispatch({ type: "setResourcesStatus", status: "loading" });
 
       try {
         const resources = await kubectl.listResources({
@@ -203,8 +198,6 @@ export function useDataFetching(
           return;
         }
 
-        lastLoadedResourceKeyRef.current = resourceKey;
-
         const preservedSelection = resources.find(
           (resource) => resource.ref.name === selectedResourceNameRef.current,
         )?.ref.name;

package/src/app/hooks/use-log-stream.ts

@@ -1,7 +1,7 @@
 import { useEffect, useRef } from "react";
 import type { ChildProcess } from "node:child_process";
 
-import type { AppAction } from "../app-state";
+import type { AppAction } from "../app-actions";
 import type { AppState, LoadStatus } from "../../lib/k8s/types";
 import { loadError } from "../utils";
 import { KubectlService } from "../../lib/kubectl/kubectl-service";

package/src/app/hooks/use-port-forward.ts

@@ -1,7 +1,7 @@
 import { useRef } from "react";
 import type { ChildProcess } from "node:child_process";
 
-import type { AppAction } from "../app-state";
+import type { AppAction } from "../app-actions";
 import type { ActivePortForward, ResourceDetail, ResourceRef } from "../../lib/k8s/types";
 import type { StartPortForwardLifecycleOptions } from "../utils";
 import { portForwardId, statusLine } from "../utils";

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

@@ -0,0 +1,107 @@
+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 { KubectlService } from "../lib/kubectl/kubectl-service";
+
+export function useFooterHints(
+  filterMode: boolean,
+  state: AppState,
+  activeResourceRef: ResourceRef | undefined,
+  activeDetail: ResourceDetail | undefined,
+  selectedResourcePortForwards: ActivePortForward[],
+  deleteTargets: { length: number },
+  kubectl: KubectlService,
+): [string, string][] {
+  return useMemo((): [string, string][] => {
+    if (filterMode) {
+      return [
+        [GLYPHS.enter, "confirm"],
+        [GLYPHS.esc, "cancel"],
+        ["^U", "clear"],
+      ];
+    }
+
+    const isHelm = activeResourceRef?.kind.toLowerCase() === "helmreleases";
+    const hasResource = Boolean(activeResourceRef);
+    const hasPortForwards =
+      (activeDetail?.portForwards?.length ?? 0) > 0 || selectedResourcePortForwards.length > 0;
+
+    if (state.activePane === "clusters") {
+      return [
+        [GLYPHS.tab, "panes"],
+        ["↑↓", "kinds"],
+        ["R", "refresh"],
+      ];
+    }
+
+    if (state.activePane === "inspector") {
+      return [
+        [GLYPHS.tab, "panes"],
+        ["←", "back"],
+        ["R", "refresh"],
+      ];
+    }
+
+    const hints: [string, string][] = [
+      [GLYPHS.tab, "panes"],
+      ["↑↓", "navigate"],
+      ["/", "filter"],
+      ["R", "refresh"],
+    ];
+
+    if (!hasResource) return hints;
+
+    if (isHelm) {
+      hints.push(
+        ["E", "edit values"],
+        ...(deleteTargets.length > 0 ? [["D", "delete"] as [string, string]] : []),
+        ["B", "rollback"],
+        ["U", "upgrade"],
+      );
+    } else {
+      hints.push(["L", "logs"], ["E", "edit"], ["X", "shell"]);
+      if (hasPortForwards) hints.push(["F", "forward"]);
+      if (deleteTargets.length > 0) hints.push(["D", "delete"]);
+      if (activeResourceRef && kubectl.canScale(activeResourceRef)) hints.push(["⇧S", "scale"]);
+      if (activeResourceRef && kubectl.canRolloutRestart(activeResourceRef)) hints.push(["⇧R", "restart"]);
+    }
+
+    return hints;
+  }, [
+    filterMode,
+    state.activePane,
+    activeResourceRef,
+    activeDetail,
+    selectedResourcePortForwards,
+    deleteTargets,
+  ]);
+}
+
+export function useFooterHintRows(
+  footerHints: [string, string][],
+  terminalWidth: number,
+): { footerHintsRow1: [string, string][]; footerHintsRow2: [string, string][] } {
+  return useMemo(() => {
+    const innerWidth = terminalWidth - 4;
+    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 gap1 = row1.length === 0 ? 0 : 2;
+      const gap2 = row2.length === 0 ? 0 : 2;
+      if (used1 + gap1 + w <= innerWidth) {
+        used1 += gap1 + w;
+        row1.push([key, label]);
+      } else if (used2 + gap2 + w <= innerWidth) {
+        used2 += gap2 + w;
+        row2.push([key, label]);
+      }
+    }
+
+    return { footerHintsRow1: row1, footerHintsRow2: row2 };
+  }, [footerHints, terminalWidth]);
+}

package/src/index.tsx

@@ -1,7 +1,11 @@
 import { createCliRenderer } from "@opentui/core";
 import { createRoot } from "@opentui/react";
+import { setAbortController } from "./lib/kubectl/spawn-utils";
 import { App } from "./app/app";
 
+const abortController = new AbortController();
+setAbortController(abortController);
+
 const renderer = await createCliRenderer({
   useMouse: true,
 });

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

@@ -0,0 +1,42 @@
+import { describe, expect, test } from "bun:test";
+import { formatAge } from "../k8s-format";
+
+describe("formatAge", () => {
+  test("returns '-' for undefined", () => {
+    expect(formatAge(undefined)).toBe("-");
+  });
+
+  test("returns '-' for empty string", () => {
+    expect(formatAge("")).toBe("-");
+  });
+
+  test("returns 'now' for very recent timestamp", () => {
+    const result = formatAge(new Date().toISOString());
+    expect(result).toBe("now");
+  });
+
+  test("formats minutes", () => {
+    const past = new Date(Date.now() - 5 * 60_000).toISOString();
+    expect(formatAge(past)).toMatch(/^\d+m$/);
+  });
+
+  test("formats hours", () => {
+    const past = new Date(Date.now() - 3 * 3600_000).toISOString();
+    expect(formatAge(past)).toMatch(/^\d+h$/);
+  });
+
+  test("formats days", () => {
+    const past = new Date(Date.now() - 5 * 86400_000).toISOString();
+    expect(formatAge(past)).toMatch(/^\d+d$/);
+  });
+
+  test("handles RFC3339 timestamps from Kubernetes", () => {
+    const result = formatAge("2024-01-15T10:30:00Z");
+    expect(typeof result).toBe("string");
+    expect(result).toMatch(/^\d+[mhd]$/);
+  });
+
+  test("returns '-' for invalid date", () => {
+    expect(formatAge("not-a-date")).toBe("-");
+  });
+});

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

@@ -0,0 +1,215 @@
+import { describe, expect, test } from "bun:test";
+import { buildResourceDetail } from "../resource-detail-builder";
+import type { ResourceKind } from "../types";
+
+const defaultKind: ResourceKind = { name: "pods", namespaced: true, shortNames: ["po"] };
+
+const metadata = { name: "test-pod", namespace: "default", creationTimestamp: "2024-01-01T00:00:00Z", labels: { app: "test" } };
+
+describe("buildResourceDetail", () => {
+  test("builds overview section for any resource", () => {
+    const detail = buildResourceDetail({
+      resourceKind: defaultKind,
+      resource: { apiVersion: "v1", kind: "Pod", metadata },
+      yaml: "apiVersion: v1\nkind: Pod",
+      describe: "Name: test-pod",
+    });
+
+    expect(detail.ref.kind).toBe("Pod");
+    expect(detail.ref.name).toBe("test-pod");
+    expect(detail.yaml).toContain("apiVersion: v1");
+    expect(detail.describe).toContain("Name: test-pod");
+    expect(detail.summarySections[0]?.title).toBe("Overview");
+  });
+
+  test("builds pod sections", () => {
+    const detail = buildResourceDetail({
+      resourceKind: defaultKind,
+      resource: {
+        apiVersion: "v1",
+        kind: "Pod",
+        metadata,
+        spec: {
+          containers: [
+            { name: "nginx", image: "nginx:1.25", ports: [{ containerPort: 80 }] },
+          ],
+        },
+        status: { phase: "Running", containerStatuses: [{ name: "nginx", ready: true, restartCount: 0, state: { running: {} } }] },
+      },
+      yaml: "",
+    });
+
+    expect(detail.containers).toEqual(["nginx"]);
+    expect(detail.summarySections.some((s) => s.title === "Containers")).toBe(true);
+    expect(detail.summarySections.some((s) => s.title === "Ports")).toBe(true);
+  });
+
+  test("builds HPA sections", () => {
+    const detail = buildResourceDetail({
+      resourceKind: { name: "horizontalpodautoscalers", namespaced: true, shortNames: ["hpa"] },
+      resource: {
+        apiVersion: "autoscaling/v2",
+        kind: "HorizontalPodAutoscaler",
+        metadata,
+        spec: { scaleTargetRef: { kind: "Deployment", name: "web" }, minReplicas: 1, maxReplicas: 10 },
+        status: { currentReplicas: 3, desiredReplicas: 5 },
+      },
+      yaml: "",
+    });
+
+    expect(detail.summarySections.some((s) => s.title === "HPA")).toBe(true);
+    expect(detail.summaryLines.some((l) => l.includes("minReplicas: 1"))).toBe(true);
+    expect(detail.summaryLines.some((l) => l.includes("maxReplicas: 10"))).toBe(true);
+  });
+
+  test("builds CronJob sections", () => {
+    const detail = buildResourceDetail({
+      resourceKind: { name: "cronjobs", namespaced: true, shortNames: ["cj"] },
+      resource: {
+        apiVersion: "batch/v1",
+        kind: "CronJob",
+        metadata,
+        spec: { schedule: "*/5 * * * *" },
+        status: {},
+      },
+      yaml: "",
+    });
+
+    expect(detail.summarySections.some((s) => s.title === "CronJob")).toBe(true);
+    expect(detail.summaryLines.some((l) => l.includes("schedule"))).toBe(true);
+  });
+
+  test("builds Node sections", () => {
+    const detail = buildResourceDetail({
+      resourceKind: { name: "nodes", namespaced: false, shortNames: ["no"] },
+      resource: {
+        apiVersion: "v1",
+        kind: "Node",
+        metadata: { name: "node-1", creationTimestamp: "2024-01-01T00:00:00Z", labels: {} },
+        status: {
+          nodeInfo: { kubeletVersion: "v1.28" },
+          capacity: { cpu: "4", memory: "16Gi" },
+          allocatable: { cpu: "3", memory: "14Gi" },
+        },
+        spec: {},
+      },
+      yaml: "",
+    });
+
+    expect(detail.summarySections.some((s) => s.title === "Node Info")).toBe(true);
+    expect(detail.summarySections.some((s) => s.title === "Capacity / Allocatable")).toBe(true);
+  });
+
+  test("builds Event sections", () => {
+    const detail = buildResourceDetail({
+      resourceKind: { name: "events", namespaced: false, shortNames: ["ev"] },
+      resource: {
+        apiVersion: "v1",
+        kind: "Event",
+        metadata: { name: "test-event", creationTimestamp: "2024-01-01T00:00:00Z" },
+        type: "Warning",
+        reason: "BackOff",
+        message: "Back-off restarting",
+        involvedObject: { kind: "Pod", name: "web", namespace: "default" },
+      },
+      yaml: "",
+    });
+
+    expect(detail.summarySections.some((s) => s.title === "Event")).toBe(true);
+    expect(detail.summaryLines.some((l) => l.includes("BackOff"))).toBe(true);
+  });
+
+  test("builds Role sections", () => {
+    const detail = buildResourceDetail({
+      resourceKind: { name: "roles", namespaced: true, shortNames: [] },
+      resource: {
+        apiVersion: "rbac.authorization.k8s.io/v1",
+        kind: "Role",
+        metadata: { name: "pod-reader", namespace: "default", creationTimestamp: "2024-01-01T00:00:00Z" },
+        rules: [
+          { apiGroups: [""], resources: ["pods"], verbs: ["get", "watch", "list"] },
+        ],
+      },
+      yaml: "",
+    });
+
+    expect(detail.summarySections.some((s) => s.title === "Rules")).toBe(true);
+  });
+
+  test("builds RoleBinding sections", () => {
+    const detail = buildResourceDetail({
+      resourceKind: { name: "rolebindings", namespaced: true, shortNames: [] },
+      resource: {
+        apiVersion: "rbac.authorization.k8s.io/v1",
+        kind: "RoleBinding",
+        metadata: { name: "admin-binding", namespace: "default", creationTimestamp: "2024-01-01T00:00:00Z" },
+        roleRef: { kind: "Role", name: "admin" },
+        subjects: [{ kind: "User", name: "jane" }],
+      },
+      yaml: "",
+    });
+
+    expect(detail.summarySections.some((s) => s.title === "RoleRef")).toBe(true);
+    expect(detail.summarySections.some((s) => s.title === "Subjects")).toBe(true);
+  });
+
+  test("builds ServiceAccount sections", () => {
+    const detail = buildResourceDetail({
+      resourceKind: { name: "serviceaccounts", namespaced: true, shortNames: ["sa"] },
+      resource: {
+        apiVersion: "v1",
+        kind: "ServiceAccount",
+        metadata: { name: "default", namespace: "default", creationTimestamp: "2024-01-01T00:00:00Z" },
+        secrets: [{ name: "default-token-abc" }],
+      },
+      yaml: "",
+    });
+
+    expect(detail.summarySections.some((s) => s.title === "Secrets")).toBe(true);
+  });
+
+  test("handles unknown kind gracefully", () => {
+    const detail = buildResourceDetail({
+      resourceKind: { name: "configmaps", namespaced: true, shortNames: ["cm"] },
+      resource: {
+        apiVersion: "v1",
+        kind: "ConfigMap",
+        metadata: { name: "my-config", namespace: "default", creationTimestamp: "2024-01-01T00:00:00Z", labels: {} },
+      },
+      yaml: "",
+    });
+
+    expect(detail.ref.kind).toBe("ConfigMap");
+    expect(detail.summarySections).toHaveLength(1);
+    expect(detail.summarySections[0]?.title).toBe("Overview");
+  });
+
+  test("includes port forwards for pod resources", () => {
+    const detail = buildResourceDetail({
+      resourceKind: defaultKind,
+      resource: {
+        apiVersion: "v1",
+        kind: "Pod",
+        metadata,
+        spec: { containers: [{ name: "nginx", ports: [{ containerPort: 80 }] }] },
+        status: { phase: "Running" },
+      },
+      yaml: "",
+    });
+
+    expect(detail.portForwards).toBeDefined();
+    expect(detail.portForwards).toHaveLength(1);
+    expect(detail.portForwards![0]?.remotePort).toBe(80);
+  });
+
+  test("handles missing metadata gracefully", () => {
+    const detail = buildResourceDetail({
+      resourceKind: defaultKind,
+      resource: { kind: "Pod" },
+      yaml: "",
+    });
+
+    expect(detail.ref.name).toBe("unknown");
+    expect(detail.ref.namespace).toBeUndefined();
+  });
+});