[Init] Initial commit - NetMesh terminal manager

components/terminal/useTerminalHibernateEffect.ts

@@ -0,0 +1,213 @@
+import { useEffect, useRef } from "react";
+
+import {
+  canHibernateTerminalRuntimeStatus,
+  type TerminalHibernateWakePayload,
+} from "../../domain/terminalHibernate";
+import { logger } from "../../lib/logger";
+import {
+  resolvePaneVisible,
+  subscribePaneVisible,
+} from "./paneVisibilityStore";
+import type { TerminalSession } from "../../types";
+
+type UseTerminalHibernateEffectOptions = {
+  sessionId: string;
+  isVisible: boolean;
+  isVisibleRef: React.MutableRefObject<boolean>;
+  getSessionConnectedRef: React.MutableRefObject<() => boolean>;
+  status: TerminalSession["status"];
+  isSearchOpen: boolean;
+  hibernateEnabled: boolean;
+  hibernateDelayMs: number;
+  fileTransferActive: boolean;
+  hibernatedRef: React.MutableRefObject<boolean>;
+  softHiddenRef: React.MutableRefObject<boolean>;
+  hibernatePendingBufferRef: React.MutableRefObject<string>;
+  hibernateSnapshotRef: React.MutableRefObject<string>;
+  hibernateViewportSnapshotRef: React.MutableRefObject<string>;
+  hibernateScrollbackSnapshotRef: React.MutableRefObject<string>;
+  hibernateContextSnapshotRef: React.MutableRefObject<string>;
+  hibernateContextViewportSnapshotRef: React.MutableRefObject<string>;
+  hibernateContextScrollbackSnapshotRef: React.MutableRefObject<string>;
+  hibernateAlternateScreenRef: React.MutableRefObject<boolean>;
+  hasRuntimeRef: React.MutableRefObject<boolean>;
+  onHibernate: () => void;
+  onSoftHideWake: () => void;
+  onWake: (
+    getPayload: () => TerminalHibernateWakePayload,
+    options: { sessionConnected: boolean },
+  ) => boolean | Promise<boolean>;
+};
+
+export function useTerminalHibernateEffect({
+  sessionId,
+  isVisible,
+  isVisibleRef,
+  getSessionConnectedRef,
+  status,
+  isSearchOpen,
+  hibernateEnabled,
+  hibernateDelayMs,
+  fileTransferActive,
+  hibernatedRef,
+  softHiddenRef,
+  hibernatePendingBufferRef,
+  hibernateSnapshotRef,
+  hibernateViewportSnapshotRef,
+  hibernateScrollbackSnapshotRef,
+  hibernateContextSnapshotRef,
+  hibernateContextViewportSnapshotRef,
+  hibernateContextScrollbackSnapshotRef,
+  hibernateAlternateScreenRef,
+  hasRuntimeRef,
+  onHibernate,
+  onSoftHideWake,
+  onWake,
+}: UseTerminalHibernateEffectOptions): void {
+  const hiddenSinceRef = useRef<number | null>(null);
+  const hibernateTimerRef = useRef<number | null>(null);
+  const paneVisibleRef = useRef(resolvePaneVisible(sessionId, isVisible));
+  const onHibernateRef = useRef(onHibernate);
+  const onSoftHideWakeRef = useRef(onSoftHideWake);
+  const onWakeRef = useRef(onWake);
+  onHibernateRef.current = onHibernate;
+  onSoftHideWakeRef.current = onSoftHideWake;
+  onWakeRef.current = onWake;
+
+  useEffect(() => {
+    const resolveVisible = () => resolvePaneVisible(sessionId, isVisibleRef.current);
+
+    const clearHibernateTimer = () => {
+      if (hibernateTimerRef.current !== null) {
+        window.clearTimeout(hibernateTimerRef.current);
+        hibernateTimerRef.current = null;
+      }
+    };
+
+    const clearHibernateState = () => {
+      hibernateSnapshotRef.current = "";
+      hibernateViewportSnapshotRef.current = "";
+      hibernateScrollbackSnapshotRef.current = "";
+      hibernateContextSnapshotRef.current = "";
+      hibernateContextViewportSnapshotRef.current = "";
+      hibernateContextScrollbackSnapshotRef.current = "";
+      hibernatePendingBufferRef.current = "";
+      hibernateAlternateScreenRef.current = false;
+      hibernatedRef.current = false;
+    };
+
+    const scheduleHibernate = () => {
+      if (!hibernateEnabled) return;
+      clearHibernateTimer();
+      if (hibernatedRef.current || !hasRuntimeRef.current) return;
+      if (!canHibernateTerminalRuntimeStatus(status)) return;
+      if (isSearchOpen) return;
+      if (fileTransferActive) return;
+
+      hiddenSinceRef.current = Date.now();
+      const hiddenAt = hiddenSinceRef.current;
+      hibernateTimerRef.current = window.setTimeout(() => {
+        hibernateTimerRef.current = null;
+        if (hiddenSinceRef.current !== hiddenAt) return;
+        if (resolveVisible()) return;
+        onHibernateRef.current();
+      }, hibernateDelayMs);
+    };
+
+    const tryWake = () => {
+      if (softHiddenRef.current) {
+        onSoftHideWakeRef.current();
+        return;
+      }
+      if (!hibernatedRef.current) return;
+
+      const sessionConnected = getSessionConnectedRef.current();
+      const getPayload = (): TerminalHibernateWakePayload => ({
+        snapshot: hibernateSnapshotRef.current,
+        viewportSnapshot: hibernateViewportSnapshotRef.current || hibernateSnapshotRef.current,
+        scrollbackSnapshot: hibernateScrollbackSnapshotRef.current,
+        pendingBuffer: hibernatePendingBufferRef.current,
+        alternateScreen: hibernateAlternateScreenRef.current,
+      });
+      logger.info("[Terminal] Waking from hibernate", {
+        sessionId,
+        snapshotChars: hibernateSnapshotRef.current.length,
+        viewportChars: hibernateViewportSnapshotRef.current.length,
+        scrollbackChars: hibernateScrollbackSnapshotRef.current.length,
+        pendingChars: hibernatePendingBufferRef.current.length,
+        sessionConnected,
+      });
+      void Promise.resolve(onWakeRef.current(getPayload, { sessionConnected })).then((accepted) => {
+        if (accepted !== false) {
+          clearHibernateState();
+          if (!resolveVisible()) {
+            scheduleHibernate();
+          }
+        }
+      });
+    };
+
+    const applyVisibility = (visible: boolean) => {
+      paneVisibleRef.current = visible;
+      // Keep the write/recovery ref current even when Terminal memo used to skip
+      // isVisible-only updates, and even when hibernate itself is disabled.
+      isVisibleRef.current = visible;
+
+      if (visible) {
+        hiddenSinceRef.current = null;
+        clearHibernateTimer();
+        tryWake();
+        return;
+      }
+
+      if (hibernateEnabled) {
+        scheduleHibernate();
+      }
+    };
+
+    if (!hibernateEnabled) {
+      // Turning hibernate off must wake already soft-hidden / hibernated panes
+      // immediately; waiting for the next tab select would leave the setting
+      // ineffective for currently hidden sessions.
+      clearHibernateTimer();
+      if (hibernatedRef.current || softHiddenRef.current) {
+        tryWake();
+      }
+    }
+
+    applyVisibility(resolveVisible());
+
+    const unsubscribe = subscribePaneVisible(sessionId, () => {
+      const visible = resolveVisible();
+      if (visible === paneVisibleRef.current) return;
+      applyVisibility(visible);
+    });
+
+    return () => {
+      clearHibernateTimer();
+      unsubscribe();
+    };
+  }, [
+    fileTransferActive,
+    getSessionConnectedRef,
+    hasRuntimeRef,
+    hibernateAlternateScreenRef,
+    hibernateDelayMs,
+    hibernateEnabled,
+    hibernateContextScrollbackSnapshotRef,
+    hibernateContextSnapshotRef,
+    hibernateContextViewportSnapshotRef,
+    hibernatePendingBufferRef,
+    hibernateScrollbackSnapshotRef,
+    hibernateSnapshotRef,
+    hibernateViewportSnapshotRef,
+    hibernatedRef,
+    isSearchOpen,
+    isVisible,
+    isVisibleRef,
+    sessionId,
+    softHiddenRef,
+    status,
+  ]);
+}