openk8s 0.0.1 → 1.0.0

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

@@ -0,0 +1,39 @@
+import { useEffect } from "react";
+import type { ChildProcess } from "node:child_process";
+
+import type { AppAction } from "../app-state";
+import type { AppState } from "../../lib/k8s/types";
+import type { ResourceRef } from "../../lib/k8s/types";
+import { savePersistedState } from "../persistence";
+
+export function useAppSideEffects(
+  state: AppState,
+  dispatch: React.Dispatch<AppAction>,
+  portForwardProcessesRef: React.MutableRefObject<Map<string, ChildProcess>>,
+  notificationTimersRef: React.MutableRefObject<Map<string, ReturnType<typeof setTimeout>>>,
+  activeResourceRef: ResourceRef | undefined,
+) {
+  // Kill all port-forward processes and cancel notification timers on unmount
+  useEffect(() => {
+    return () => {
+      for (const child of portForwardProcessesRef.current.values()) {
+        child.kill("SIGINT");
+      }
+      portForwardProcessesRef.current.clear();
+      for (const timer of notificationTimersRef.current.values()) {
+        clearTimeout(timer);
+      }
+      notificationTimersRef.current.clear();
+    };
+  }, []);
+
+  // Persist active context and namespace whenever they change
+  useEffect(() => {
+    savePersistedState({ activeContext: state.activeContext, activeNamespace: state.activeNamespace });
+  }, [state.activeContext, state.activeNamespace]);
+
+  // Clear selected container when the active resource changes
+  useEffect(() => {
+    dispatch({ type: "setLogsContainer", container: undefined });
+  }, [activeResourceRef?.kind, activeResourceRef?.name, activeResourceRef?.namespace]);
+}

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

@@ -0,0 +1,54 @@
+import { spawn } from "node:child_process";
+import { useCallback } from "react";
+
+import type { AppAction } from "../app-state";
+import type { NotificationTone } from "../../lib/k8s/types";
+import { loadError } from "../utils";
+
+export function useClipboard(
+  dispatch: React.Dispatch<AppAction>,
+  toast: (tone: NotificationTone, message: string) => void,
+) {
+  const copyToClipboard = useCallback((text: string, label?: string): void => {
+    let cmd: string;
+    let args: string[];
+
+    if (process.env.WAYLAND_DISPLAY) {
+      cmd = "wl-copy";
+      args = [];
+    } else if (process.env.DISPLAY) {
+      cmd = "xclip";
+      args = ["-selection", "clipboard"];
+    } else if (process.platform === "darwin") {
+      cmd = "pbcopy";
+      args = [];
+    } else {
+      dispatch({ type: "setStatusMessage", message: "Clipboard not available on this platform" });
+      return;
+    }
+
+    const toastMessage = label ? `${label} copied to clipboard` : "Copied to clipboard";
+
+    try {
+      const child = spawn(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
+      child.stdin?.write(text);
+      child.stdin?.end();
+      child.on("error", () => {
+        dispatch({ type: "setStatusMessage", message: `Copy failed — is ${cmd} installed?` });
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          toast("success", toastMessage);
+        }
+      });
+    } catch {
+      dispatch({ type: "setStatusMessage", message: `Copy failed — is ${cmd} installed?` });
+    }
+  }, [toast, dispatch]);
+
+  const toastError = useCallback((error: unknown): void => {
+    toast("danger", loadError(error).message);
+  }, [toast]);
+
+  return { copyToClipboard, toastError };
+}

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

@@ -0,0 +1,366 @@
+import { useEffect, useRef } from "react";
+import type { Dispatch, SetStateAction } from "react";
+
+import type { AppAction } from "../app-state";
+import type { AppState } from "../../lib/k8s/types";
+import type { ResourceKind, ResourceListItem, ResourceRef } from "../../lib/k8s/types";
+import { defaultNamespace, loadError, nextVisibleResourceName } from "../utils";
+import { KubectlService } from "../../lib/kubectl/kubectl-service";
+
+export function useDataFetching(
+  state: AppState,
+  dispatch: React.Dispatch<AppAction>,
+  selectedKind: ResourceKind | undefined,
+  activeResourceRef: ResourceRef | undefined,
+  viewPollTick: number,
+  clusterPollTick: number,
+  metricsPollTick: number,
+  manualRefreshNonce: number,
+  filteredResources: ResourceListItem[],
+  kubectl: KubectlService,
+  setFilterMode: Dispatch<SetStateAction<boolean>>,
+) {
+  const resourcesLengthRef = useRef(state.resources.length);
+  resourcesLengthRef.current = state.resources.length;
+  const selectedResourceNameRef = useRef(state.selectedResourceName);
+  selectedResourceNameRef.current = state.selectedResourceName;
+  const selectedResourceDetailRef = useRef(state.selectedResourceDetail);
+  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({
+      resources: filteredResources,
+      selectedName: state.selectedResourceName,
+    });
+
+    if (nextSelection !== state.selectedResourceName) {
+      dispatch({ type: "setSelectedResourceName", name: nextSelection });
+    }
+  }, [filteredResources, state.selectedResourceName]);
+
+  // Exit filter mode when leaving the resources pane or opening an overlay
+  useEffect(() => {
+    if (state.activePane !== "resources" || state.overlay) {
+      setFilterMode(false);
+    }
+  }, [state.activePane, state.overlay]);
+
+  // Bootstrap: check kubectl availability and load contexts
+  useEffect(() => {
+    let cancelled = false;
+
+    async function bootstrap(): Promise<void> {
+      dispatch({ type: "setStatusMessage", message: "Checking kubectl" });
+      const available = await kubectl.isAvailable();
+
+      if (cancelled) {
+        return;
+      }
+
+      dispatch({ type: "setKubectlAvailable", available });
+
+      if (!available) {
+        dispatch({
+          type: "setError",
+          error: {
+            message: "kubectl is not installed or not on PATH",
+            detail: "Install kubectl to enable cluster discovery and resource browsing.",
+          },
+        });
+        dispatch({ type: "setStatusMessage", message: "kubectl unavailable" });
+        return;
+      }
+
+      dispatch({ type: "setContextsStatus", status: "loading" });
+
+      try {
+        const contexts = await kubectl.listContexts();
+
+        if (cancelled) {
+          return;
+        }
+
+        const activeContext =
+          contexts.find((context) => context.name === state.activeContext)?.name ??
+          contexts.find((context) => context.isCurrent)?.name ??
+          contexts[0]?.name;
+
+        dispatch({ type: "setContexts", contexts, activeContext });
+        dispatch({ type: "setContextsStatus", status: "ready" });
+        dispatch({ type: "setError", error: undefined });
+        dispatch({
+          type: "setStatusMessage",
+          message: activeContext ? `Connected to ${activeContext}` : "No contexts found",
+        });
+      } catch (error) {
+        if (cancelled) {
+          return;
+        }
+
+        dispatch({ type: "setContextsStatus", status: "error" });
+        dispatch({ type: "setError", error: loadError(error) });
+        dispatch({ type: "setStatusMessage", message: "Failed to load contexts" });
+      }
+    }
+
+    void bootstrap();
+    return () => {
+      cancelled = true;
+    };
+  }, [manualRefreshNonce, state.activeContext]);
+
+  // Load namespaces and resource kinds whenever the context changes or cluster poll ticks
+  useEffect(() => {
+    const context = state.activeContext;
+
+    if (!context || !state.kubectlAvailable) {
+      return;
+    }
+
+    const activeContext = context;
+    let cancelled = false;
+
+    async function loadClusterData(): Promise<void> {
+      dispatch({ type: "setNamespacesStatus", status: "loading" });
+      dispatch({ type: "setResourceKindsStatus", status: "loading" });
+
+      try {
+        const [namespaces, resourceKinds] = await Promise.all([
+          kubectl.listNamespaces({ context: activeContext }),
+          kubectl.listResourceKinds({ context: activeContext }),
+        ]);
+
+        if (cancelled) {
+          return;
+        }
+
+        const nextNamespace = defaultNamespace({ namespaces, currentNamespace: state.activeNamespace });
+        const nextSelectedKind =
+          resourceKinds.find((kind) => kind.name === state.selectedKind)?.name ?? resourceKinds[0]?.name ?? "pods";
+
+        dispatch({ type: "setNamespaces", namespaces, activeNamespace: nextNamespace });
+        dispatch({ type: "setNamespacesStatus", status: "ready" });
+        dispatch({ type: "setResourceKinds", resourceKinds, selectedKind: nextSelectedKind });
+        dispatch({ type: "setResourceKindsStatus", status: "ready" });
+        dispatch({ type: "setError", error: undefined });
+      } catch (error) {
+        if (cancelled) {
+          return;
+        }
+
+        dispatch({ type: "setNamespacesStatus", status: "error" });
+        dispatch({ type: "setResourceKindsStatus", status: "error" });
+        dispatch({ type: "setError", error: loadError(error) });
+        dispatch({ type: "setStatusMessage", message: "Failed to load cluster metadata" });
+      }
+    }
+
+    void loadClusterData();
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    state.activeContext,
+    state.kubectlAvailable,
+    clusterPollTick,
+    manualRefreshNonce,
+    state.activeNamespace,
+    state.selectedKind,
+  ]);
+
+  // Load the resource list. Bug-fix: removed state.resources.length and state.selectedResourceName
+  // from deps (they caused re-fetches on every load/cursor-move). Read via refs instead.
+  useEffect(() => {
+    const context = state.activeContext;
+
+    if (!context || !selectedKind) {
+      return;
+    }
+
+    const activeContext = context;
+    const activeKind = selectedKind;
+    const activeNamespace = state.activeNamespace;
+    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" });
+      }
+
+      try {
+        const resources = await kubectl.listResources({
+          context: activeContext,
+          namespace: activeNamespace,
+          resourceKind: activeKind,
+        });
+
+        if (cancelled) {
+          return;
+        }
+
+        lastLoadedResourceKeyRef.current = resourceKey;
+
+        const preservedSelection = resources.find(
+          (resource) => resource.ref.name === selectedResourceNameRef.current,
+        )?.ref.name;
+
+        dispatch({
+          type: "setResources",
+          resources,
+          selectedResourceName: preservedSelection ?? resources[0]?.ref.name,
+        });
+        dispatch({ type: "setResourcesStatus", status: "ready" });
+        dispatch({ type: "setError", error: undefined });
+      } catch (error) {
+        if (cancelled) {
+          return;
+        }
+
+        dispatch({ type: "setResourcesStatus", status: "error" });
+        dispatch({ type: "setError", error: loadError(error) });
+        dispatch({ type: "setStatusMessage", message: `Failed to load ${activeKind.name}` });
+      }
+    }
+
+    void loadResources();
+    return () => {
+      cancelled = true;
+    };
+  }, [selectedKind, state.activeContext, state.activeNamespace, viewPollTick, manualRefreshNonce]);
+
+  // Load detail for the selected resource. Bug-fix: removed state.selectedResourceDetail from deps
+  // (it caused an infinite re-fetch loop). Read via ref instead.
+  useEffect(() => {
+    const context = state.activeContext;
+    const selectedName = state.selectedResourceName;
+
+    if (!context || !selectedName || !selectedKind) {
+      return;
+    }
+
+    const activeContext = context;
+    const activeKind = selectedKind;
+    const activeName = selectedName;
+    const activeNamespace = state.activeNamespace;
+    let cancelled = false;
+
+    async function loadDetail(): Promise<void> {
+      const currentDetail = selectedResourceDetailRef.current;
+      const isSameDetail =
+        currentDetail?.ref.name === activeName &&
+        currentDetail?.ref.kind === activeKind.name &&
+        (currentDetail?.ref.namespace ?? "") === activeNamespace;
+
+      if (!isSameDetail) {
+        dispatch({ type: "setSelectedResourceDetailStatus", status: "loading" });
+      }
+
+      try {
+        const detail = await kubectl.getResourceDetail({
+          context: activeContext,
+          namespace: activeNamespace,
+          resourceKind: activeKind,
+          name: activeName,
+        });
+
+        if (cancelled) {
+          return;
+        }
+
+        dispatch({ type: "setSelectedResourceDetail", detail });
+        dispatch({ type: "setSelectedResourceDetailStatus", status: "ready" });
+        dispatch({ type: "setError", error: undefined });
+      } catch (error) {
+        if (cancelled) {
+          return;
+        }
+
+        dispatch({ type: "setSelectedResourceDetailStatus", status: "error" });
+        dispatch({ type: "setError", error: loadError(error) });
+      }
+    }
+
+    void loadDetail();
+    return () => {
+      cancelled = true;
+    };
+  }, [selectedKind, state.activeContext, state.activeNamespace, state.selectedResourceName, viewPollTick, manualRefreshNonce]);
+
+  // Load events for the active resource. Bug-fix: removed state.events.length from deps
+  // (it caused re-fetches after every successful load). Read via ref instead.
+  useEffect(() => {
+    const context = state.activeContext;
+
+    if (!context || !activeResourceRef || !selectedKind || state.inspectorTab !== "events") {
+      return;
+    }
+
+    const activeContext = context;
+    const activeResource = activeResourceRef;
+    const activeKind = selectedKind;
+    const activeNamespace = state.activeNamespace;
+    let cancelled = false;
+
+    async function loadEvents(): Promise<void> {
+      if (eventsLengthRef.current === 0) {
+        dispatch({ type: "setEventsStatus", status: "loading" });
+      }
+
+      try {
+        const events = await kubectl.listResourceEvents({
+          context: activeContext,
+          namespace: activeNamespace,
+          resourceRef: activeResource,
+          namespaced: activeKind.namespaced,
+        });
+
+        if (cancelled) {
+          return;
+        }
+
+        dispatch({ type: "setEvents", events });
+        dispatch({ type: "setEventsStatus", status: "ready" });
+        dispatch({ type: "setError", error: undefined });
+      } catch (error) {
+        if (cancelled) {
+          return;
+        }
+
+        dispatch({ type: "setEventsStatus", status: "error" });
+        dispatch({ type: "setError", error: loadError(error) });
+      }
+    }
+
+    void loadEvents();
+    return () => {
+      cancelled = true;
+    };
+  }, [activeResourceRef, selectedKind, state.activeContext, state.activeNamespace, state.inspectorTab, viewPollTick, manualRefreshNonce]);
+
+  // Poll pod metrics when viewing pods (silent degradation on error)
+  useEffect(() => {
+    const context = state.activeContext;
+    if (!context || state.selectedKind !== "pods") return;
+    void kubectl
+      .getPodMetrics({ context, namespace: state.activeNamespace })
+      .then((metrics) => dispatch({ type: "setPodMetrics", metrics }))
+      .catch(() => {/* metrics-server absent — silent degradation */});
+  }, [state.activeContext, state.activeNamespace, state.selectedKind, metricsPollTick]);
+
+  // Poll node metrics when viewing nodes (silent degradation on error)
+  useEffect(() => {
+    const context = state.activeContext;
+    if (!context || state.selectedKind !== "nodes") return;
+    void kubectl
+      .getNodeMetrics({ context })
+      .then((metrics) => dispatch({ type: "setNodeMetrics", metrics }))
+      .catch(() => {/* metrics-server absent — silent degradation */});
+  }, [state.activeContext, state.selectedKind, metricsPollTick]);
+
+  return { resourcesLengthRef, selectedResourceNameRef, selectedResourceDetailRef, eventsLengthRef };
+}

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

@@ -0,0 +1,113 @@
+import { useEffect, useRef } from "react";
+import type { ChildProcess } from "node:child_process";
+
+import type { AppAction } from "../app-state";
+import type { AppState, LoadStatus } from "../../lib/k8s/types";
+import { loadError } from "../utils";
+import { KubectlService } from "../../lib/kubectl/kubectl-service";
+
+export function useLogStream(
+  dispatch: React.Dispatch<AppAction>,
+  state: Pick<AppState, "overlay" | "activeContext" | "activeNamespace" | "logsContainer" | "logsOptions">,
+  activeLogsRef: { kind: string; name: string; namespaced: boolean } | undefined,
+  activeLogsTarget: string | undefined,
+  activeLogsKey: string | undefined,
+  kubectl: KubectlService,
+) {
+  const logStreamRef = useRef<ChildProcess | undefined>(undefined);
+
+  useEffect(() => {
+    const context = state.activeContext;
+
+    if (state.overlay !== "logs" || !context || !activeLogsTarget || !activeLogsRef || !activeLogsKey) {
+      if (logStreamRef.current) {
+        logStreamRef.current.kill();
+        logStreamRef.current = undefined;
+      }
+      return;
+    }
+
+    let cancelled = false;
+    let flushTimer: ReturnType<typeof setTimeout> | undefined;
+
+    try {
+      const { target, child } = kubectl.streamLogs({
+        context,
+        namespace: state.activeNamespace,
+        resourceRef: activeLogsRef,
+        namespaced: activeLogsRef.namespaced,
+        container: state.logsContainer,
+        logOptions: state.logsOptions,
+      });
+
+      if (logStreamRef.current) {
+        logStreamRef.current.kill();
+      }
+
+      logStreamRef.current = child;
+
+      let buffer = "";
+
+      const flush = (status: LoadStatus): void => {
+        if (cancelled) {
+          return;
+        }
+        dispatch({ type: "setLogsData", logsTarget: target, logsText: buffer, logsStatus: status });
+      };
+
+      const scheduleFlush = (status: LoadStatus): void => {
+        if (flushTimer) {
+          return;
+        }
+        flushTimer = setTimeout(() => {
+          flushTimer = undefined;
+          flush(status);
+        }, 80);
+      };
+
+      dispatch({ type: "setLogsData", logsTarget: target, logsText: "", logsStatus: "loading" });
+
+      child.stdout?.on("data", (chunk: Buffer | string) => {
+        if (cancelled) return;
+        buffer += chunk.toString();
+        scheduleFlush("ready");
+      });
+
+      child.stderr?.on("data", (chunk: Buffer | string) => {
+        if (cancelled) return;
+        buffer += chunk.toString();
+        scheduleFlush("error");
+      });
+
+      child.on("close", () => {
+        if (cancelled) return;
+        if (flushTimer) {
+          clearTimeout(flushTimer);
+          flushTimer = undefined;
+        }
+        flush("ready");
+      });
+    } catch (error) {
+      const parsed = loadError(error);
+      dispatch({
+        type: "setLogsData",
+        logsTarget: `${activeLogsRef.kind}/${activeLogsRef.name}`,
+        logsText: parsed.detail ? `${parsed.message}\n${parsed.detail}` : parsed.message,
+        logsStatus: "error",
+      });
+    }
+
+    return () => {
+      cancelled = true;
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+      }
+      if (logStreamRef.current) {
+        logStreamRef.current.kill();
+        logStreamRef.current = undefined;
+      }
+    };
+  }, [state.overlay, activeLogsKey, state.activeContext, state.activeNamespace, activeLogsRef, activeLogsTarget]);
+
+  return logStreamRef;
+}