openk8s 1.0.1 → 1.0.3

package/src/app/hooks/keyboard/helm-handlers.ts

@@ -0,0 +1,104 @@
+import type { AppAction } from "../../app-actions";
+import type { AppState, ResourceRef, ResourceKind, ResourceDetail, NotificationTone } from "../../../lib/k8s/types";
+import { KubectlService } from "../../../lib/kubectl/kubectl-service";
+
+export function handleHelmRollbackKeys(
+  key: { name: string },
+  state: AppState,
+  dispatch: React.Dispatch<AppAction>,
+  activeResourceRef: ResourceRef | undefined,
+  kubectl: KubectlService,
+  toast: (tone: NotificationTone, message: string) => void,
+  toastError: (error: unknown) => void,
+  setManualRefreshNonce: React.Dispatch<React.SetStateAction<number>>,
+): boolean {
+  if (state.overlay !== "helm-rollback") return false;
+
+  if (key.name === "return" && activeResourceRef && state.activeContext) {
+    const context = state.activeContext;
+    const namespace = state.activeNamespace;
+    const name = activeResourceRef.name;
+    const revisionStr = state.helmRollbackRevision.trim();
+    const revision = revisionStr ? Number.parseInt(revisionStr, 10) : undefined;
+
+    dispatch({ type: "setOverlay", overlay: undefined });
+    dispatch({
+      type: "setStatusMessage",
+      message: `Rolling back ${name}${revision !== undefined ? ` to r${revision}` : " to previous"}`,
+    });
+
+    void kubectl
+      .helmRollback({ context, namespace, name, revision })
+      .then(() => {
+        toast("success", `${name} rolled back${revision !== undefined ? ` to r${revision}` : ""}`);
+        setManualRefreshNonce((current) => current + 1);
+      })
+      .catch(toastError);
+
+    return true;
+  }
+
+  if (key.name === "escape") {
+    dispatch({ type: "setOverlay", overlay: undefined });
+    return true;
+  }
+
+  return true;
+}
+
+export function handleHelmUpgradeKeys(
+  key: { name: string; shift?: boolean },
+  state: AppState,
+  dispatch: React.Dispatch<AppAction>,
+  renderer: { suspend: () => void; resume: () => void },
+  activeResourceRef: ResourceRef | undefined,
+  selectedKind: ResourceKind | undefined,
+  activeDetail: ResourceDetail | undefined,
+  kubectl: KubectlService,
+  toast: (tone: NotificationTone, message: string) => void,
+  toastError: (error: unknown) => void,
+  setManualRefreshNonce: React.Dispatch<React.SetStateAction<number>>,
+): boolean {
+  if (state.overlay) return false;
+
+  // B → Helm rollback overlay
+  if (key.name === "b" && activeResourceRef?.kind.toLowerCase() === "helmreleases" && state.activeContext) {
+    dispatch({ type: "setHelmRollbackRevision", value: "" });
+    dispatch({ type: "setOverlay", overlay: "helm-rollback" });
+    return true;
+  }
+
+  // U → Helm upgrade --reuse-values
+  if (key.name === "u" && activeResourceRef?.kind.toLowerCase() === "helmreleases" && selectedKind && state.activeContext) {
+    const chartName = activeDetail?.helmChart ?? "";
+    if (!chartName) {
+      dispatch({ type: "setStatusMessage", message: "Chart name unavailable — load the detail pane first" });
+      return true;
+    }
+    const context = state.activeContext;
+    const namespace = state.activeNamespace;
+    const target = activeResourceRef;
+
+    dispatch({ type: "setStatusMessage", message: `Upgrading ${target.name}` });
+    dispatch({ type: "setError", error: undefined });
+    renderer.suspend();
+
+    const upgradeChild = kubectl.helmUpgrade({ context, namespace, name: target.name, chart: chartName });
+    upgradeChild.on("close", (code) => {
+      renderer.resume();
+      if (code === 0) {
+        toast("success", `${target.name} upgraded`);
+        setManualRefreshNonce((current) => current + 1);
+      } else {
+        dispatch({ type: "setStatusMessage", message: `Upgrade failed for ${target.name}` });
+      }
+    });
+    upgradeChild.on("error", (err) => {
+      renderer.resume();
+      toastError(err);
+    });
+    return true;
+  }
+
+  return false;
+}

package/src/app/hooks/keyboard/logs-handlers.ts

@@ -0,0 +1,80 @@
+import type { ScrollBoxRenderable } from "@opentui/core";
+
+import type { AppAction } from "../../app-actions";
+import type { AppState } from "../../../lib/k8s/types";
+import type { LogsDialogActions } from "../../components/overlays";
+
+export function handleLogsKeys(
+  key: { name: string; shift?: boolean; sequence?: string },
+  state: AppState,
+  dispatch: React.Dispatch<AppAction>,
+  logsInputMode: "tail" | "since" | undefined,
+  logsInputValue: string,
+  logsSearchMode: boolean,
+  setLogsInputMode: React.Dispatch<React.SetStateAction<"tail" | "since" | undefined>>,
+  setLogsInputValue: React.Dispatch<React.SetStateAction<string>>,
+  setLogsSearchMode: React.Dispatch<React.SetStateAction<boolean>>,
+  setLogsSearchText: React.Dispatch<React.SetStateAction<string>>,
+  setOverlayIndex: React.Dispatch<React.SetStateAction<number>>,
+  logsScrollRef: React.MutableRefObject<ScrollBoxRenderable | null>,
+  logsActionsRef: React.MutableRefObject<LogsDialogActions | null>,
+  containers: string[] | undefined,
+): boolean {
+  if (state.overlay !== "logs") return false;
+
+  if (key.name === "escape") {
+    if (logsInputMode !== undefined) {
+      setLogsInputMode(undefined);
+      setLogsInputValue("");
+      return true;
+    }
+    if (logsSearchMode) {
+      setLogsSearchMode(false);
+      setLogsSearchText("");
+      return true;
+    }
+    return false; // fall through to generic escape
+  }
+
+  if (!logsInputMode && !logsSearchMode) {
+    if (key.name === "up" || key.name === "k") {
+      logsScrollRef.current?.scrollBy(-3);
+    } else if (key.name === "down" || key.name === "j") {
+      logsScrollRef.current?.scrollBy(3);
+    } else if (key.name === "c") {
+      if ((containers ?? []).length > 1) {
+        setOverlayIndex(0);
+        dispatch({ type: "setOverlay", overlay: "container-picker" });
+      }
+    } else if (key.name === "p") {
+      dispatch({ type: "setLogsOptions", options: { ...state.logsOptions, previous: !state.logsOptions.previous } });
+    } else if (key.name === "t") {
+      setLogsInputMode("tail");
+      setLogsInputValue(String(state.logsOptions.tail));
+    } else if (key.name === "s") {
+      setLogsInputMode("since");
+      setLogsInputValue(state.logsOptions.since ?? "");
+    } else if (key.sequence === "/" || key.name === "slash") {
+      setLogsSearchMode(true);
+    } else if (key.name === "n" && !key.shift) {
+      logsActionsRef.current?.nextMatch();
+    } else if (key.shift && key.name === "n") {
+      logsActionsRef.current?.prevMatch();
+    }
+  } else if (logsInputMode && key.name === "return") {
+    if (logsInputMode === "tail") {
+      const tail = Number.parseInt(logsInputValue, 10);
+      if (!Number.isNaN(tail) && tail > 0) {
+        dispatch({ type: "setLogsOptions", options: { ...state.logsOptions, tail } });
+      }
+    } else if (logsInputMode === "since") {
+      dispatch({ type: "setLogsOptions", options: { ...state.logsOptions, since: logsInputValue || undefined } });
+    }
+    setLogsInputMode(undefined);
+    setLogsInputValue("");
+  } else if (logsSearchMode && key.name === "return") {
+    setLogsSearchMode(false);
+  }
+
+  return true;
+}

package/src/app/hooks/keyboard/navigation-handlers.ts

@@ -0,0 +1,103 @@
+import type { AppAction } from "../../app-actions";
+import { INSPECTOR_TABS } from "../../components/inspector";
+import type { AppState, ResourceKind, ResourceListItem } from "../../../lib/k8s/types";
+
+export function handlePaneNavigation(
+  key: { name: string; shift?: boolean },
+  state: AppState,
+  dispatch: React.Dispatch<AppAction>,
+  filteredResources: ResourceListItem[],
+  visibleSelectedResourceName: string | undefined,
+): boolean {
+  if (key.name === "tab") {
+    dispatch({ type: "cyclePane", direction: key.shift ? -1 : 1 });
+    return true;
+  }
+
+  // Clusters pane navigation
+  if (state.activePane === "clusters") {
+    const currentIndex = Math.max(0, state.resourceKinds.findIndex((kind) => kind.name === state.selectedKind));
+
+    if ((key.name === "up" || key.name === "k") && currentIndex > 0) {
+      const nextKind = state.resourceKinds[currentIndex - 1];
+      if (nextKind) {
+        dispatch({ type: "setSelectedKind", kind: nextKind.name });
+      }
+      return true;
+    }
+
+    if ((key.name === "down" || key.name === "j") && currentIndex < state.resourceKinds.length - 1) {
+      const nextKind = state.resourceKinds[currentIndex + 1];
+      if (nextKind) {
+        dispatch({ type: "setSelectedKind", kind: nextKind.name });
+      }
+      return true;
+    }
+
+    if (key.name === "right") {
+      dispatch({ type: "setActivePane", pane: "resources" });
+      return true;
+    }
+
+    return true;
+  }
+
+  // Resources pane navigation
+  if (state.activePane === "resources") {
+    const currentIndex = Math.max(
+      0,
+      filteredResources.findIndex((resource) => resource.ref.name === visibleSelectedResourceName),
+    );
+
+    if ((key.name === "up" || key.name === "k") && currentIndex > 0) {
+      const nextResource = filteredResources[currentIndex - 1];
+      if (nextResource) {
+        dispatch({ type: "setSelectedResourceName", name: nextResource.ref.name });
+      }
+      return true;
+    }
+
+    if ((key.name === "down" || key.name === "j") && currentIndex < filteredResources.length - 1) {
+      const nextResource = filteredResources[currentIndex + 1];
+      if (nextResource) {
+        dispatch({ type: "setSelectedResourceName", name: nextResource.ref.name });
+      }
+      return true;
+    }
+
+    if (key.name === "left" || key.name === "h") {
+      dispatch({ type: "setActivePane", pane: "clusters" });
+      return true;
+    }
+
+    if (key.name === "right") {
+      dispatch({ type: "setActivePane", pane: "inspector" });
+      return true;
+    }
+  }
+
+  // Inspector pane navigation
+  if (state.activePane === "inspector") {
+    if (key.name === "left" || key.name === "h") {
+      const currentIndex = INSPECTOR_TABS.findIndex((tab) => tab.id === state.inspectorTab);
+      if (currentIndex > 0) {
+        const prevTab = INSPECTOR_TABS[currentIndex - 1];
+        if (prevTab) dispatch({ type: "setInspectorTab", tab: prevTab.id });
+      } else {
+        dispatch({ type: "setActivePane", pane: "resources" });
+      }
+      return true;
+    }
+
+    if (key.name === "right") {
+      const currentIndex = INSPECTOR_TABS.findIndex((tab) => tab.id === state.inspectorTab);
+      const nextTab = INSPECTOR_TABS[currentIndex + 1];
+      if (nextTab) {
+        dispatch({ type: "setInspectorTab", tab: nextTab.id });
+      }
+      return true;
+    }
+  }
+
+  return false;
+}

package/src/app/hooks/keyboard/overlay-handlers.ts

@@ -0,0 +1,138 @@
+import type { AppAction } from "../../app-actions";
+import type { AppState, ResourceListItem, ResourceKind, ResourceRef } from "../../../lib/k8s/types";
+import { deleteStatusMessage, statusLine } from "../../utils";
+import { KubectlService } from "../../../lib/kubectl/kubectl-service";
+
+export function handleGenericEscape(
+  key: { name: string },
+  state: AppState,
+  dispatch: React.Dispatch<AppAction>,
+): boolean {
+  if (key.name === "escape") {
+    if (state.overlay) {
+      dispatch({ type: "setOverlay", overlay: undefined });
+    }
+    return true;
+  }
+  return false;
+}
+
+export function handleOverlayNavigation(
+  key: { name: string },
+  state: AppState,
+  dispatch: React.Dispatch<AppAction>,
+  overlayIndex: number,
+  setOverlayIndex: React.Dispatch<React.SetStateAction<number>>,
+): boolean {
+  if (!state.overlay) return false;
+
+  const items: Array<unknown> =
+    state.overlay === "cluster-switcher"
+      ? state.contexts
+      : state.overlay === "namespace-switcher"
+        ? state.namespaces
+        : state.overlay === "container-picker"
+          ? []
+          : [];
+
+  if (key.name === "up") {
+    setOverlayIndex((current) => Math.max(0, current - 1));
+    return true;
+  }
+
+  if (key.name === "down") {
+    setOverlayIndex((current) => Math.min(items.length - 1, current + 1));
+    return true;
+  }
+
+  // Cluster / namespace / container picker selection
+  if (key.name === "return") {
+    if (state.overlay === "container-picker") {
+      return false; // handled by the caller
+    }
+
+    if (state.overlay === "cluster-switcher") {
+      const selectedContext = state.contexts[overlayIndex];
+      if (selectedContext) {
+        dispatch({ type: "setActiveContext", activeContext: selectedContext.name });
+      }
+    }
+
+    if (state.overlay === "namespace-switcher") {
+      const selectedNamespace = state.namespaces[overlayIndex];
+      if (selectedNamespace) {
+        dispatch({ type: "setActiveNamespace", namespace: selectedNamespace.name });
+      }
+    }
+
+    dispatch({ type: "setOverlay", overlay: undefined });
+    return true;
+  }
+
+  return false;
+}
+
+export function handleDeleteConfirm(
+  key: { name: string },
+  state: AppState,
+  dispatch: React.Dispatch<AppAction>,
+  selectedKind: ResourceKind | undefined,
+  deleteTargets: ResourceListItem[],
+  kubectl: KubectlService,
+  toastError: (error: unknown) => void,
+  setManualRefreshNonce: React.Dispatch<React.SetStateAction<number>>,
+): boolean {
+  if (state.overlay !== "delete-confirm") return false;
+
+  if (key.name === "return" && selectedKind && state.activeContext && deleteTargets.length > 0) {
+    const context = state.activeContext;
+    const namespace = state.activeNamespace;
+    const namespaced = selectedKind.namespaced;
+    const targets = deleteTargets.map((resource) => resource.ref);
+
+    dispatch({ type: "setStatusMessage", message: deleteStatusMessage(targets, "Deleting") });
+
+    void Promise.all(
+      targets.map((target) => kubectl.deleteResource({ context, namespace, resourceRef: target, namespaced })),
+    )
+      .then(() => {
+        dispatch({ type: "clearTransientViews" });
+        dispatch({ type: "setSelectedResourceDetail", detail: undefined });
+        dispatch({ type: "setSelectedResourceName", name: undefined });
+        dispatch({ type: "clearSelectedResources" });
+        dispatch({ type: "setError", error: undefined });
+        dispatch({ type: "setStatusMessage", message: deleteStatusMessage(targets, "Deleted") });
+        setManualRefreshNonce((current) => current + 1);
+      })
+      .catch((error: unknown) => {
+        toastError(error);
+        dispatch({ type: "setStatusMessage", message: deleteStatusMessage(targets, "Delete failed for") });
+      });
+
+    dispatch({ type: "setOverlay", overlay: undefined });
+    return true;
+  }
+
+  return false;
+}
+
+export function handleContainerPicker(
+  key: { name: string },
+  state: AppState,
+  dispatch: React.Dispatch<AppAction>,
+  overlayIndex: number,
+  containers: string[] | undefined,
+): boolean {
+  if (state.overlay !== "container-picker") return false;
+
+  if (key.name === "return") {
+    const container = (containers ?? [])[overlayIndex];
+    if (container !== undefined) {
+      dispatch({ type: "setLogsContainer", container });
+    }
+    dispatch({ type: "setOverlay", overlay: "logs" });
+    return true;
+  }
+
+  return false;
+}

package/src/app/hooks/keyboard/port-forward-handlers.ts

@@ -0,0 +1,71 @@
+import type { AppAction } from "../../app-actions";
+import type { AppState, ActivePortForward, ResourceRef, ResourceKind, ResourceDetail } from "../../../lib/k8s/types";
+import type { StartPortForwardLifecycleOptions } from "../../utils";
+import { parseLocalPort } from "../../utils";
+import { buildPortForwardEntries } from "../../components/overlays";
+
+export function handlePortForwardKeys(
+  key: { name: string },
+  state: AppState,
+  dispatch: React.Dispatch<AppAction>,
+  overlayIndex: number,
+  portForwardLocalPort: string,
+  setOverlayIndex: React.Dispatch<React.SetStateAction<number>>,
+  setPortForwardLocalPort: React.Dispatch<React.SetStateAction<string>>,
+  activeResourceRef: ResourceRef | undefined,
+  selectedKind: ResourceKind | undefined,
+  activeDetail: ResourceDetail | undefined,
+  selectedResourcePortForwards: ActivePortForward[],
+  stopPortForward: (id: string) => void,
+  startPortForward: (options: StartPortForwardLifecycleOptions) => void,
+): boolean {
+  if (state.overlay !== "port-forward") return false;
+
+  if (key.name === "escape") {
+    dispatch({ type: "setOverlay", overlay: undefined });
+    return true;
+  }
+
+  const pfEntries = buildPortForwardEntries(activeDetail?.portForwards ?? [], selectedResourcePortForwards);
+
+  if (key.name === "up" || key.name === "k") {
+    const newIndex = Math.max(0, overlayIndex - 1);
+    setOverlayIndex(newIndex);
+    const entry = pfEntries[newIndex];
+    if (entry && !entry.activeForward) {
+      setPortForwardLocalPort(String(entry.suggestedLocalPort));
+    }
+    return true;
+  }
+
+  if (key.name === "down" || key.name === "j") {
+    const newIndex = Math.min(Math.max(0, pfEntries.length - 1), overlayIndex + 1);
+    setOverlayIndex(newIndex);
+    const entry = pfEntries[newIndex];
+    if (entry && !entry.activeForward) {
+      setPortForwardLocalPort(String(entry.suggestedLocalPort));
+    }
+    return true;
+  }
+
+  const selectedEntry = pfEntries[overlayIndex];
+
+  if (key.name === "x" && selectedEntry?.activeForward) {
+    stopPortForward(selectedEntry.activeForward.id);
+    return true;
+  }
+
+  if (key.name === "return" && activeResourceRef && selectedKind && state.activeContext && selectedEntry && !selectedEntry.activeForward) {
+    const localPort = parseLocalPort(portForwardLocalPort) ?? selectedEntry.suggestedLocalPort;
+    startPortForward({
+      context: state.activeContext,
+      namespace: state.activeNamespace,
+      target: activeResourceRef,
+      namespaced: selectedKind.namespaced,
+      localPort,
+      remotePort: selectedEntry.remotePort,
+    });
+  }
+
+  return true;
+}