openk8s 1.0.1 → 1.0.3

package/src/app/hooks/keyboard/shell-edit-handlers.ts

@@ -0,0 +1,253 @@
+import { unlinkSync, writeFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+
+import type { AppAction } from "../../app-actions";
+import type { AppState, ResourceRef, ResourceKind, ResourceDetail, NotificationTone } from "../../../lib/k8s/types";
+import { statusLine } from "../../utils";
+import { KubectlService } from "../../../lib/kubectl/kubectl-service";
+
+export function handleShellKeys(
+  key: { name: string; shift?: boolean },
+  state: AppState,
+  dispatch: React.Dispatch<AppAction>,
+  renderer: { suspend: () => void; resume: () => void },
+  activeResourceRef: ResourceRef | undefined,
+  selectedKind: ResourceKind | undefined,
+  kubectl: KubectlService,
+  toastError: (error: unknown) => void,
+  setManualRefreshNonce: React.Dispatch<React.SetStateAction<number>>,
+): boolean {
+  if (state.overlay) return false;
+
+  if (key.name === "x" && activeResourceRef && selectedKind && state.activeContext) {
+    if (activeResourceRef.kind.toLowerCase() === "helmreleases") {
+      dispatch({ type: "setStatusMessage", message: "Shell not supported for Helm releases" });
+      return true;
+    }
+
+    dispatch({ type: "setStatusMessage", message: `Opening shell in ${statusLine({ ref: activeResourceRef })}` });
+    dispatch({ type: "setError", error: undefined });
+    renderer.suspend();
+
+    const context = state.activeContext;
+    const namespace = state.activeNamespace;
+    const namespaced = selectedKind.namespaced;
+    const target = activeResourceRef;
+
+    const child = kubectl.startShell({ context, namespace, resourceRef: target, namespaced });
+    child.on("close", () => {
+      renderer.resume();
+      dispatch({ type: "setError", error: undefined });
+      dispatch({ type: "setStatusMessage", message: `Returned from shell in ${statusLine({ ref: target })}` });
+      setManualRefreshNonce((current) => current + 1);
+    });
+    child.on("error", (error) => {
+      renderer.resume();
+      toastError(error);
+      dispatch({ type: "setStatusMessage", message: `Shell failed for ${statusLine({ ref: target })}` });
+    });
+    return true;
+  }
+
+  return false;
+}
+
+export function handleEditKeys(
+  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;
+
+  if (key.name === "e" && !key.shift && activeResourceRef && selectedKind && state.activeContext) {
+    const context = state.activeContext;
+    const namespace = state.activeNamespace;
+    const namespaced = selectedKind.namespaced;
+    const target = activeResourceRef;
+    const isHelm = target.kind.toLowerCase() === "helmreleases";
+
+    if (isHelm) {
+      const chartName = activeDetail?.helmChart ?? "";
+      const values = activeDetail?.yaml ?? "";
+      const tmpPath = `/tmp/openk8s-${target.name}-${Date.now()}.yaml`;
+      const cleanupTmp = (): void => { try { unlinkSync(tmpPath); } catch { /* ignore */ } };
+
+      if (!chartName) {
+        dispatch({ type: "setStatusMessage", message: "Chart name unavailable — load the detail pane first" });
+        return true;
+      }
+
+      try {
+        writeFileSync(tmpPath, values, "utf8");
+      } catch (err) {
+        toastError(err);
+        return true;
+      }
+
+      dispatch({ type: "setStatusMessage", message: `Editing values for ${target.name}` });
+      dispatch({ type: "setError", error: undefined });
+      renderer.suspend();
+
+      const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
+      const editorChild = spawn(editor, [tmpPath], { env: process.env, stdio: "inherit" });
+
+      editorChild.on("close", (code) => {
+        if (code === 0) {
+          kubectl
+            .helmUpgradeValues({ context, namespace, name: target.name, chart: chartName, valuesFile: tmpPath })
+            .then(() => {
+              renderer.resume();
+              toast("success", `${target.name} upgraded`);
+              setManualRefreshNonce((current) => current + 1);
+            })
+            .catch((err: unknown) => {
+              renderer.resume();
+              toastError(err);
+            })
+            .finally(cleanupTmp);
+        } else {
+          renderer.resume();
+          dispatch({ type: "setStatusMessage", message: "Edit cancelled" });
+          cleanupTmp();
+        }
+      });
+
+      editorChild.on("error", (err) => {
+        renderer.resume();
+        toastError(err);
+        cleanupTmp();
+      });
+    } else {
+      dispatch({ type: "setStatusMessage", message: `Editing ${statusLine({ ref: target })}` });
+      dispatch({ type: "setError", error: undefined });
+      renderer.suspend();
+
+      const editChild = kubectl.editResource({ context, namespace, resourceRef: target, namespaced });
+
+      editChild.on("close", (code) => {
+        renderer.resume();
+        if (code === 0) {
+          dispatch({ type: "setStatusMessage", message: `Saved ${statusLine({ ref: target })}` });
+          setManualRefreshNonce((current) => current + 1);
+        } else if (code !== null) {
+          dispatch({ type: "setStatusMessage", message: `Edit cancelled for ${statusLine({ ref: target })}` });
+        }
+      });
+
+      editChild.on("error", (err) => {
+        renderer.resume();
+        toastError(err);
+        dispatch({ type: "setStatusMessage", message: `Edit failed for ${statusLine({ ref: target })}` });
+      });
+    }
+    return true;
+  }
+
+  // Shift+S → scale dialog
+  if (key.shift && key.name === "s" && activeResourceRef && selectedKind && state.activeContext && kubectl.canScale(activeResourceRef)) {
+    return false; // handled by scale handler
+  }
+
+  return false;
+}
+
+export function handleScaleKeys(
+  key: { name: string },
+  state: AppState,
+  dispatch: React.Dispatch<AppAction>,
+  activeResourceRef: ResourceRef | undefined,
+  selectedKind: ResourceKind | undefined,
+  scaleReplicasInput: string,
+  kubectl: KubectlService,
+  toastError: (error: unknown) => void,
+  setManualRefreshNonce: React.Dispatch<React.SetStateAction<number>>,
+): boolean {
+  if (state.overlay !== "scale") return false;
+
+  if (key.name === "return" && activeResourceRef && selectedKind && state.activeContext) {
+    const replicas = Number.parseInt(scaleReplicasInput, 10);
+
+    if (!Number.isNaN(replicas) && replicas >= 0) {
+      const context = state.activeContext;
+      const namespace = state.activeNamespace;
+      const namespaced = selectedKind.namespaced;
+      const target = activeResourceRef;
+
+      dispatch({ type: "setStatusMessage", message: `Scaling ${statusLine({ ref: target })} to ${replicas}` });
+      dispatch({ type: "setError", error: undefined });
+      dispatch({ type: "setOverlay", overlay: undefined });
+
+      void kubectl
+        .scaleResource({ context, namespace, resourceRef: target, namespaced, replicas })
+        .then(() => {
+          dispatch({
+            type: "setStatusMessage",
+            message: `Scaled ${statusLine({ ref: target })} to ${replicas}`,
+          });
+          setManualRefreshNonce((current) => current + 1);
+        })
+        .catch((error: unknown) => {
+          toastError(error);
+          dispatch({
+            type: "setStatusMessage",
+            message: `Scale failed for ${statusLine({ ref: target })}`,
+          });
+        });
+    }
+    return true;
+  }
+
+  return true;
+}
+
+export function handleRolloutRestartKeys(
+  key: { name: string; shift?: boolean },
+  state: AppState,
+  dispatch: React.Dispatch<AppAction>,
+  activeResourceRef: ResourceRef | undefined,
+  selectedKind: ResourceKind | undefined,
+  kubectl: KubectlService,
+  toastError: (error: unknown) => void,
+  setManualRefreshNonce: React.Dispatch<React.SetStateAction<number>>,
+): boolean {
+  if (state.overlay) return false;
+
+  if (key.shift && key.name === "r") {
+    if (activeResourceRef && selectedKind && state.activeContext && kubectl.canRolloutRestart(activeResourceRef)) {
+      const context = state.activeContext;
+      const namespace = state.activeNamespace;
+      const namespaced = selectedKind.namespaced;
+      const target = activeResourceRef;
+
+      dispatch({ type: "setStatusMessage", message: `Restarting ${statusLine({ ref: target })}` });
+      dispatch({ type: "setError", error: undefined });
+
+      void kubectl
+        .rolloutRestart({ context, namespace, resourceRef: target, namespaced })
+        .then(() => {
+          dispatch({ type: "setStatusMessage", message: `Restarted ${statusLine({ ref: target })}` });
+          setManualRefreshNonce((current) => current + 1);
+        })
+        .catch((error: unknown) => {
+          toastError(error);
+          dispatch({
+            type: "setStatusMessage",
+            message: `Rollout restart failed for ${statusLine({ ref: target })}`,
+          });
+        });
+    } else {
+      dispatch({ type: "setStatusMessage", message: "Rollout restart not supported for this resource" });
+    }
+    return true;
+  }
+
+  return false;
+}