openk8s 1.0.1 → 1.0.2

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

@@ -1,29 +1,23 @@
 import { useKeyboard, useRenderer } from "@opentui/react";
 import type { ScrollBoxRenderable } from "@opentui/core";
-import { unlinkSync, writeFileSync } from "node:fs";
-import { spawn } from "node:child_process";
 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 {
-  ActivePortForward,
-  NotificationTone,
-  ResourceDetail,
-  ResourceKind,
-  ResourceListItem,
-  ResourceRef,
-} from "../../lib/k8s/types";
+import type { ActivePortForward, NotificationTone, ResourceDetail, ResourceKind, ResourceListItem, ResourceRef } from "../../lib/k8s/types";
 import type { LogsDialogActions } from "../components/overlays";
 import type { StartPortForwardLifecycleOptions } from "../utils";
-import { buildPortForwardEntries } from "../components/overlays";
-import {
-  deleteStatusMessage,
-  parseLocalPort,
-  statusLine,
-} from "../utils";
 import { KubectlService } from "../../lib/kubectl/kubectl-service";
-import { INSPECTOR_TABS } from "../components/inspector";
+
+import { handleCtrlC } from "./keyboard/global-handlers";
+import { handleGlobalHotkeys } from "./keyboard/global-handlers";
+import { handleFilterKeys } from "./keyboard/filter-handlers";
+import { handlePaneNavigation } from "./keyboard/navigation-handlers";
+import { handleGenericEscape, handleOverlayNavigation, handleDeleteConfirm, handleContainerPicker } from "./keyboard/overlay-handlers";
+import { handleLogsKeys } from "./keyboard/logs-handlers";
+import { handlePortForwardKeys } from "./keyboard/port-forward-handlers";
+import { handleHelmRollbackKeys, handleHelmUpgradeKeys } from "./keyboard/helm-handlers";
+import { handleShellKeys, handleEditKeys, handleScaleKeys, handleRolloutRestartKeys } from "./keyboard/shell-edit-handlers";
 
 type Renderer = ReturnType<typeof useRenderer>;
 
@@ -68,656 +62,97 @@ export function useAppKeyboard(
   logsActionsRef: React.MutableRefObject<LogsDialogActions | null>,
 ) {
   useKeyboard((key) => {
-    // Exit immediately on Ctrl+C — one press, no ambiguity
-    if (key.ctrl && key.name === "c") {
-      renderer.destroy();
-      return;
-    }
-
-    if (key.name === "tab") {
-      dispatch({ type: "cyclePane", direction: key.shift ? -1 : 1 });
-      return;
-    }
+    if (handleCtrlC(key, renderer)) return;
 
-    if (filterMode && key.name === "escape") {
-      setFilterMode(false);
-      return;
+    // Logs overlay: special multi-level escape handling
+    if (state.overlay === "logs") {
+      if (handleLogsKeys(key, state, dispatch, logsInputMode, logsInputValue, logsSearchMode,
+        setLogsInputMode, setLogsInputValue, setLogsSearchMode, setLogsSearchText,
+        setOverlayIndex, logsScrollRef, logsActionsRef, activeDetail?.containers)) {
+        return;
+      }
     }
 
-    // Port-forward overlay: ESC closes; Up/Down navigate port list; Enter starts; X stops
+    // Port-forward overlay
     if (state.overlay === "port-forward") {
-      if (key.name === "escape") {
-        dispatch({ type: "setOverlay", overlay: undefined });
+      if (handlePortForwardKeys(key, state, dispatch, overlayIndex, portForwardLocalPort,
+        setOverlayIndex, setPortForwardLocalPort, activeResourceRef, selectedKind,
+        activeDetail, selectedResourcePortForwards, stopPortForward, startPortForward)) {
         return;
       }
-      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;
-      }
-      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;
-      }
-      const selectedEntry = pfEntries[overlayIndex];
-      if (key.name === "x" && selectedEntry?.activeForward) {
-        stopPortForward(selectedEntry.activeForward.id);
-        return;
-      }
-      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;
     }
 
-    // Scale overlay: Enter confirms, everything else is swallowed
+    // Scale overlay
     if (state.overlay === "scale") {
-      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;
-    }
-
-    // Logs overlay: multi-level ESC, scroll, and option/search hotkeys
-    // This block must come BEFORE the generic escape so multi-level ESC works correctly.
-    if (state.overlay === "logs") {
-      if (key.name === "escape") {
-        if (logsInputMode !== undefined) {
-          setLogsInputMode(undefined);
-          setLogsInputValue("");
-          return;
-        }
-        if (logsSearchMode) {
-          setLogsSearchMode(false);
-          setLogsSearchText("");
-          return;
-        }
-        // Fall through to generic escape below, which closes the overlay
-      } else {
-        // All non-escape keys are handled then swallowed
-        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") {
-            const containers = activeDetail?.containers ?? [];
-            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);
-        }
+      if (handleScaleKeys(key, state, dispatch, activeResourceRef, selectedKind,
+        scaleReplicasInput, kubectl, toastError, setManualRefreshNonce)) {
         return;
       }
     }
 
-    // Helm rollback overlay: Enter confirms, ESC closes
+    // Helm rollback overlay
     if (state.overlay === "helm-rollback") {
-      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);
-      }
-      if (key.name === "escape") {
-        dispatch({ type: "setOverlay", overlay: undefined });
+      if (handleHelmRollbackKeys(key, state, dispatch, activeResourceRef, kubectl,
+        toast, toastError, setManualRefreshNonce)) {
+        return;
       }
-      return;
     }
 
-    if (key.name === "escape") {
-      if (state.overlay) {
-        dispatch({ type: "setOverlay", overlay: undefined });
-      }
+    // Generic escape
+    if (handleGenericEscape(key, state, dispatch)) {
       return;
     }
 
-    // Generic list-overlay navigation (cluster-switcher, namespace-switcher, container-picker)
+    // Generic overlay navigation
     if (state.overlay) {
-      const items: Array<unknown> =
-        state.overlay === "cluster-switcher"
-          ? state.contexts
-          : state.overlay === "namespace-switcher"
-            ? state.namespaces
-            : state.overlay === "container-picker"
-              ? (activeDetail?.containers ?? [])
-              : [];
-
-      if (key.name === "up") {
-        setOverlayIndex((current) => Math.max(0, current - 1));
-        return;
-      }
-
-      if (key.name === "down") {
-        setOverlayIndex((current) => Math.min(items.length - 1, current + 1));
-        return;
-      }
+      if (handleOverlayNavigation(key, state, dispatch, overlayIndex, setOverlayIndex)) return;
 
       if (state.overlay === "delete-confirm") {
-        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;
+        if (handleDeleteConfirm(key, state, dispatch, selectedKind, deleteTargets, kubectl, toastError, setManualRefreshNonce)) return;
       }
 
-      if (key.name === "return") {
-        if (state.overlay === "container-picker") {
-          const container = (activeDetail?.containers ?? [])[overlayIndex];
-          if (container !== undefined) {
-            dispatch({ type: "setLogsContainer", container });
-          }
-          dispatch({ type: "setOverlay", overlay: "logs" });
-          return;
-        }
-
-        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 });
+      if (state.overlay === "container-picker") {
+        if (handleContainerPicker(key, state, dispatch, overlayIndex, activeDetail?.containers)) return;
       }
-      return;
-    }
 
-    // Filter mode input
-    if (state.activePane === "resources" && (key.sequence === "/" || key.name === "slash")) {
-      setFilterMode(true);
       return;
     }
 
-    if (filterMode && state.activePane === "resources") {
-      if (key.ctrl && key.name === "u") {
-        dispatch({ type: "setResourceFilter", value: "" });
-        return;
-      }
-
-      if (key.name === "return") {
-        setFilterMode(false);
-        return;
-      }
-
-      return;
-    }
-
-    if (state.activePane === "resources" && !filterMode && key.ctrl && key.name === "u") {
-      dispatch({ type: "setResourceFilter", value: "" });
-      return;
-    }
+    // Filter mode
+    if (handleFilterKeys(key, filterMode, state.activePane, dispatch, setFilterMode)) return;
 
     // Global hotkeys
-    if (key.name === "c") {
-      dispatch({ type: "setOverlay", overlay: "cluster-switcher" });
-      setOverlayIndex(Math.max(0, state.contexts.findIndex((context) => context.name === state.activeContext)));
-      return;
-    }
-
-    if (key.name === "n") {
-      dispatch({ type: "setOverlay", overlay: "namespace-switcher" });
-      setOverlayIndex(Math.max(0, state.namespaces.findIndex((namespace) => namespace.name === state.activeNamespace)));
-      return;
-    }
-
-    if (key.name === "r" && !key.shift) {
-      toast("info", "Refreshing current view");
-      setManualRefreshNonce((current) => current + 1);
-      return;
-    }
-
-    if (key.name === "s" && !key.shift) {
-      dispatch({ type: "setInspectorTab", tab: "summary" });
-      return;
-    }
-
-    if (key.name === "y") {
-      // y when already on yaml tab → copy full YAML to clipboard
-      if (state.inspectorTab === "yaml" && activeDetail?.yaml) {
-        copyToClipboard(activeDetail.yaml, "YAML");
-      } else {
-        dispatch({ type: "setInspectorTab", tab: "yaml" });
-      }
+    if (handleGlobalHotkeys(key, state, dispatch, activeResourceRef, selectedKind, activeDetail,
+      selectedResourcePortForwards, deleteTargets, visibleSelectedResourceName,
+      setOverlayIndex, openPortForwardOverlay, toast, copyToClipboard, setManualRefreshNonce, setScaleReplicasInput)) {
       return;
     }
 
-    if (key.name === "v") {
-      dispatch({ type: "setInspectorTab", tab: "events" });
+    // Helm upgrade
+    if (handleHelmUpgradeKeys(key, state, dispatch, renderer, activeResourceRef, selectedKind,
+      activeDetail, kubectl, toast, toastError, setManualRefreshNonce)) {
       return;
     }
 
-    if (key.name === "i") {
-      dispatch({ type: "setInspectorTab", tab: "describe" });
+    // Shell
+    if (handleShellKeys(key, state, dispatch, renderer, activeResourceRef, selectedKind,
+      kubectl, toastError, setManualRefreshNonce)) {
       return;
     }
 
-    // B → Helm rollback overlay (helmreleases only)
-    if (key.name === "b" && activeResourceRef?.kind.toLowerCase() === "helmreleases" && state.activeContext) {
-      dispatch({ type: "setHelmRollbackRevision", value: "" });
-      dispatch({ type: "setOverlay", overlay: "helm-rollback" });
+    // Edit
+    if (handleEditKeys(key, state, dispatch, renderer, activeResourceRef, selectedKind,
+      activeDetail, kubectl, toast, toastError, setManualRefreshNonce)) {
       return;
     }
 
-    // U → Helm upgrade --reuse-values (helmreleases only)
-    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;
-      }
-      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;
-    }
-
-    if (key.name === "l") {
-      if (activeResourceRef) {
-        if (activeResourceRef.kind.toLowerCase() === "helmreleases") {
-          dispatch({ type: "setStatusMessage", message: "Logs not supported for Helm releases" });
-          return;
-        }
-        const containers = activeDetail?.containers ?? [];
-        if (containers.length > 1 && !state.logsContainer) {
-          setOverlayIndex(0);
-          dispatch({ type: "setOverlay", overlay: "container-picker" });
-        } else {
-          dispatch({ type: "setOverlay", overlay: "logs" });
-        }
-        dispatch({
-          type: "setStatusMessage",
-          message: `Showing logs for ${statusLine({ ref: activeResourceRef })}`,
-        });
-      }
-      return;
-    }
-
-    if (key.name === "f" && activeResourceRef && selectedKind && state.activeContext && ((activeDetail?.portForwards?.length ?? 0) > 0 || selectedResourcePortForwards.length > 0)) {
-      openPortForwardOverlay();
-      return;
-    }
-
-    if (key.name === "d" && selectedKind && state.activeContext && deleteTargets.length > 0) {
-      dispatch({ type: "setOverlay", overlay: "delete-confirm" });
-      return;
-    }
-
-    if (state.activePane === "resources" && !filterMode && key.name === "space" && visibleSelectedResourceName) {
-      dispatch({ type: "toggleSelectedResource", name: visibleSelectedResourceName });
-      return;
-    }
-
-    if (key.name === "x" && activeResourceRef && selectedKind && state.activeContext) {
-      if (activeResourceRef.kind.toLowerCase() === "helmreleases") {
-        dispatch({ type: "setStatusMessage", message: "Shell not supported for Helm releases" });
-        return;
-      }
-      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;
-    }
-
-    // E → edit resource (kubectl edit) or edit helm values ($EDITOR + helm upgrade)
-    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;
-        }
-
-        try {
-          writeFileSync(tmpPath, values, "utf8");
-        } catch (err) {
-          toastError(err);
-          return;
-        }
-
-        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;
-    }
-
-    // Shift+S → scale dialog
-    if (key.shift && key.name === "s" && activeResourceRef && selectedKind && state.activeContext && kubectl.canScale(activeResourceRef)) {
-      setScaleReplicasInput(activeDetail?.replicas !== undefined ? String(activeDetail.replicas) : "");
-      dispatch({ type: "setOverlay", overlay: "scale" });
-      return;
-    }
-
-    // Shift+R → rollout restart (direct, no overlay); always captured to provide feedback
-    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" });
-      }
+    // Rollout restart
+    if (handleRolloutRestartKeys(key, state, dispatch, activeResourceRef, selectedKind,
+      kubectl, toastError, setManualRefreshNonce)) {
       return;
     }
 
     // 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;
-      }
-
-      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;
-      }
-
-      if (key.name === "right") {
-        dispatch({ type: "setActivePane", pane: "resources" });
-        return;
-      }
-    }
-
-    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;
-      }
-
-      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;
-      }
-
-      if (key.name === "left" || key.name === "h") {
-        dispatch({ type: "setActivePane", pane: "clusters" });
-        return;
-      }
-
-      if (key.name === "right") {
-        dispatch({ type: "setActivePane", pane: "inspector" });
-        return;
-      }
-    }
-
-    if (state.activePane === "inspector") {
-      // left/right (and h) navigate between tabs; left on first tab → back to resources pane
-      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;
-      }
-
-      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;
-      }
-      // up/down are NOT intercepted here — they fall through to the focused scrollbox
-    }
+    if (handlePaneNavigation(key, state, dispatch, filteredResources, visibleSelectedResourceName)) return;
   });
 }