[Init] Initial commit - NetMesh terminal manager

electron/bridges/windowManager/mainWindow.cjs

@@ -0,0 +1,588 @@
+/* eslint-disable no-undef */
+const {
+  windowsFramelessContentChromeOptions,
+} = require("./windowsWindowChrome.cjs");
+const { attachDisplayRecovery } = require("./displayRecovery.cjs");
+
+const TERMINAL_KEYBOARD_FOCUS = Symbol("netcattyTerminalKeyboardFocus");
+
+function setTerminalKeyboardFocusForWindow(win, focused) {
+  if (!win || win.isDestroyed?.() || !win.webContents) return false;
+  const isFocused = focused === true;
+  try {
+    win[TERMINAL_KEYBOARD_FOCUS] = isFocused;
+    win.webContents.setIgnoreMenuShortcuts?.(isFocused);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function hasTerminalKeyboardFocus(win) {
+  return win?.[TERMINAL_KEYBOARD_FOCUS] === true;
+}
+
+function createMainWindowApi(ctx) {
+  with (ctx) {
+    async function createWindow(electronModule, options) {
+      const { BrowserWindow, nativeTheme, app, screen, shell } = electronModule;
+      const {
+        preload,
+        devServerUrl,
+        isDev,
+        appIcon,
+        isMac,
+        onRegisterBridge,
+        electronDir,
+        route,
+        onAppContentWindowClosed,
+        registerAsMainWindow = true,
+        persistWindowState = registerAsMainWindow,
+        registerAsAppContentWindow = true,
+        startHidden = false,
+      } = options;
+      const rendererHash = typeof route === "string" && route.trim()
+        ? `#/${route.trim().replace(/^#?\/*/, "")}`
+        : "";
+      const CHROMIUM_ZOOM_FACTORS = [
+        0.25, 0.33, 0.5, 0.67, 0.75, 0.9, 1, 1.1, 1.25, 1.5, 1.75, 2, 2.5, 3, 4, 5,
+      ];
+
+      const isPrimaryZoomInEqualInput = (input) => {
+        if (input?.type !== "keyDown") return false;
+        if (input.alt) return false;
+        const hasPrimaryModifier = isMac
+          ? Boolean(input.meta) && !input.control
+          : Boolean(input.control) && !input.meta;
+        if (!hasPrimaryModifier || input.shift) return false;
+        return String(input.key || "") === "=";
+      };
+
+      const isPrimaryZoomOutMinusInput = (input) => {
+        if (input?.type !== "keyDown") return false;
+        if (input.alt) return false;
+        const hasPrimaryModifier = isMac
+          ? Boolean(input.meta) && !input.control
+          : Boolean(input.control) && !input.meta;
+        if (!hasPrimaryModifier || input.shift) return false;
+        return String(input.key || "") === "-";
+      };
+
+      const isPrimaryResetZoomInput = (input) => {
+        if (input?.type !== "keyDown") return false;
+        if (input.alt) return false;
+        const hasPrimaryModifier = isMac
+          ? Boolean(input.meta) && !input.control
+          : Boolean(input.control) && !input.meta;
+        if (!hasPrimaryModifier || input.shift) return false;
+        return String(input.key || "") === "0";
+      };
+
+      const adjustWindowZoom = (mode) => {
+        const webContents = win?.webContents;
+        if (!webContents || webContents.isDestroyed?.()) return false;
+        const currentFactor = Number(webContents.getZoomFactor?.());
+        const safeCurrentFactor = Number.isFinite(currentFactor) ? currentFactor : 1;
+        const nextFactor = mode === "in"
+          ? CHROMIUM_ZOOM_FACTORS.find((factor) => factor > safeCurrentFactor + 0.0001)
+          : mode === "out"
+            ? [...CHROMIUM_ZOOM_FACTORS].reverse().find((factor) => factor < safeCurrentFactor - 0.0001)
+            : 1;
+        if (!nextFactor) return false;
+        try {
+          webContents.setZoomFactor?.(nextFactor);
+          return true;
+        } catch {
+          return false;
+        }
+      };
+    
+      // Store app reference for window state persistence
+      electronApp = app;
+    
+      const osTheme = nativeTheme?.shouldUseDarkColors ? "dark" : "light";
+      const effectiveTheme = currentTheme === "dark" || currentTheme === "light" ? currentTheme : osTheme;
+      const frontendBackground = resolveFrontendBackgroundColor(electronDir || __dirname, effectiveTheme);
+      const backgroundColor = frontendBackground || "#1a1a1a";
+      const themeConfig = THEME_COLORS[effectiveTheme] || THEME_COLORS.light;
+    
+      // Load saved window state
+      const savedState = persistWindowState ? loadWindowState() : null;
+      let windowBounds = {
+        width: DEFAULT_WINDOW_WIDTH,
+        height: DEFAULT_WINDOW_HEIGHT,
+      };
+    
+      if (savedState) {
+        // Use saved dimensions, but clamp to the minimum so a previously
+        // shrunk window from an older build cannot start below the minimum.
+        windowBounds.width = Math.max(savedState.width, MIN_WINDOW_WIDTH);
+        windowBounds.height = Math.max(savedState.height, MIN_WINDOW_HEIGHT);
+    
+        // Only use saved position if the screen is available at that location
+        if (typeof savedState.x === "number" && typeof savedState.y === "number") {
+          try {
+            // Check if the saved position is within any available display
+            const displays = screen?.getAllDisplays?.() || [];
+            const isPositionVisible = displays.some((display) => {
+              const { x, y, width, height } = display.bounds;
+              // Check if at least part of the window would be visible on this display
+              return (
+                savedState.x < x + width &&
+                savedState.x + savedState.width > x &&
+                savedState.y < y + height &&
+                savedState.y + savedState.height > y
+              );
+            });
+    
+            if (isPositionVisible) {
+              windowBounds.x = savedState.x;
+              windowBounds.y = savedState.y;
+            }
+          } catch {
+            // Ignore screen check errors, just don't set position
+          }
+        }
+      }
+    
+      const windowsChrome = !isMac ? windowsFramelessContentChromeOptions() : {};
+
+      const win = new BrowserWindow({
+        ...windowBounds,
+        minWidth: MIN_WINDOW_WIDTH,
+        minHeight: MIN_WINDOW_HEIGHT,
+        backgroundColor,
+        icon: appIcon,
+        show: false,
+        frame: isMac,
+        titleBarStyle: isMac ? "hiddenInset" : undefined,
+        trafficLightPosition: isMac ? { x: 12, y: 12 } : undefined,
+        ...windowsChrome,
+        webPreferences: {
+          preload,
+          contextIsolation: true,
+          nodeIntegration: false,
+          sandbox: false,
+          spellcheck: false,
+          backgroundThrottling: false,
+          v8CacheOptions: V8_CACHE_OPTIONS,
+        },
+      });
+    
+      if (registerAsMainWindow) {
+        if (typeof registerMainWindow === "function") {
+          registerMainWindow(win);
+        } else {
+          mainWindow = win;
+        }
+      } else if (registerAsAppContentWindow && typeof registerAppContentWindow === "function") {
+        registerAppContentWindow(win, { queryDirtyEditors: true });
+      }
+    
+      // Multi-monitor recovery (#3244): Windows lock/sleep can temporarily
+      // tear down a secondary display and the OS relocates the window onto
+      // the primary display. When the display comes back, put the window back
+      // where the user left it.
+      let detachDisplayRecovery = null;
+      try {
+        detachDisplayRecovery = attachDisplayRecovery({ win, screen });
+      } catch {
+        detachDisplayRecovery = null;
+      }
+
+      // Clear reference when the main window is destroyed
+      win.on('closed', () => {
+        try {
+          detachDisplayRecovery?.();
+        } catch {
+          // ignore
+        }
+        try {
+          if (win?.webContents?.id) {
+            unhealthyWebContentsIds.delete(win.webContents.id);
+            rendererReadySeenByWebContentsId.delete(win.webContents.id);
+          }
+        } catch {
+          // ignore
+        }
+        if (registerAsMainWindow) {
+          if (typeof unregisterMainWindow === "function") {
+            unregisterMainWindow(win);
+          } else if (mainWindow === win) {
+            mainWindow = null;
+          }
+        } else if (registerAsAppContentWindow && typeof unregisterAppContentWindow === "function") {
+          unregisterAppContentWindow(win);
+        }
+        if (registerAsAppContentWindow) {
+          try {
+            if (typeof notifyAppContentWindowClosed === "function") {
+              notifyAppContentWindowClosed(win);
+            } else {
+              onAppContentWindowClosed?.(win);
+            }
+          } catch {
+            // The application-level close fallback must not disrupt teardown.
+          }
+        }
+      });
+    
+      // Log renderer crashes for diagnostics (skip normal clean exits)
+      win.webContents.on("render-process-gone", (_event, details) => {
+        if (details?.reason === "clean-exit") return;
+        try {
+          if (win.webContents?.id) {
+            unhealthyWebContentsIds.add(win.webContents.id);
+          }
+        } catch {
+          // ignore
+        }
+        try {
+          const crashLogBridge = require("./crashLogBridge.cjs");
+          crashLogBridge.captureError("render-process-gone", new Error(
+            `Renderer process gone: reason=${details?.reason}, exitCode=${details?.exitCode}`
+          ), { reason: details?.reason, exitCode: details?.exitCode });
+        } catch {}
+        console.error("[WindowManager] Renderer process gone:", details);
+      });
+
+      // Prevent top-level navigation away from the app origin. If a remote origin ever
+      // loads in a privileged window (with preload), it can become an RCE vector.
+      const allowedOrigins = new Set(["app://netcatty"]);
+      if (isDev && devServerUrl) {
+        try {
+          allowedOrigins.add(new URL(getDevRendererBaseUrl(devServerUrl)).origin);
+        } catch {
+          // ignore invalid dev server URL
+        }
+      }
+      const isAllowedTopLevelUrl = (targetUrl) => {
+        try {
+          const parsedUrl = new URL(String(targetUrl));
+          if (parsedUrl.protocol === "app:" && parsedUrl.host === "netcatty") return true;
+          return allowedOrigins.has(parsedUrl.origin);
+        } catch {
+          return false;
+        }
+      };
+      win.webContents.on("did-start-navigation", (_event, targetUrl, isInPlace, isMainFrame) => {
+        if (isMainFrame === false || isInPlace === true || !isAllowedTopLevelUrl(targetUrl)) return;
+        try {
+          if (typeof clearRendererReadyForWebContents === "function") {
+            clearRendererReadyForWebContents(win.webContents?.id);
+          }
+        } catch {
+          // ignore
+        }
+      });
+      const blockUntrustedNavigation = (event, targetUrl) => {
+        if (isAllowedTopLevelUrl(targetUrl)) return;
+        try {
+          event.preventDefault();
+        } catch {
+          // ignore
+        }
+        debugLog("Blocked navigation to untrusted origin", { targetUrl });
+      };
+      win.webContents.on("will-navigate", blockUntrustedNavigation);
+      win.webContents.on("will-redirect", blockUntrustedNavigation);
+    
+      // Prevent Chromium from consuming Alt+Arrow as browser back/forward navigation.
+      // Terminal apps need these keys to pass through to the remote shell (e.g., byobu, tmux).
+      // Using setIgnoreMenuShortcuts lets the keydown still reach the page (xterm.js)
+      // while preventing Chromium's built-in shortcuts from triggering.
+      win.webContents.on("before-input-event", (event, input) => {
+        if (isMac && shouldCloseWindowFromInput(input)) {
+          event.preventDefault();
+          requestWindowCommandClose(win);
+          return;
+        }
+
+        const isTerminalFontShortcut =
+          isPrimaryZoomInEqualInput(input)
+          || isPrimaryZoomOutMinusInput(input)
+          || isPrimaryResetZoomInput(input);
+        if (hasTerminalKeyboardFocus(win) && isTerminalFontShortcut) {
+          win.webContents.setIgnoreMenuShortcuts(true);
+          return;
+        }
+
+        if (isPrimaryZoomInEqualInput(input) && adjustWindowZoom("in")) {
+          event.preventDefault();
+          return;
+        }
+
+        if (isPrimaryZoomOutMinusInput(input) && adjustWindowZoom("out")) {
+          event.preventDefault();
+          return;
+        }
+
+        if (isPrimaryResetZoomInput(input) && adjustWindowZoom("reset")) {
+          event.preventDefault();
+          return;
+        }
+
+        if (input.alt && !input.control && !input.meta) {
+          if (input.key === "ArrowLeft" || input.key === "ArrowRight") {
+            win.webContents.setIgnoreMenuShortcuts(true);
+            return;
+          }
+        }
+        win.webContents.setIgnoreMenuShortcuts(false);
+      });
+    
+      // Restore maximized state if it was saved
+      if (savedState?.isMaximized && !savedState?.isFullScreen) {
+        win.once("ready-to-show", () => {
+          try {
+            win.maximize();
+          } catch {
+            // ignore
+          }
+        });
+      }
+    
+      // Track window bounds for saving (use last non-maximized/non-fullscreen bounds)
+      let lastNormalBounds = null;
+      let saveStateTimer = null;
+      let thisWindowCloseRequested = false;
+      let dirtyEditorCloseConfirmed = false;
+    
+      const updateNormalBounds = () => {
+        if (!win.isDestroyed() && !win.isMaximized() && !win.isFullScreen()) {
+          lastNormalBounds = win.getBounds();
+        }
+      };
+    
+      const scheduleSaveState = () => {
+        if (!persistWindowState) return;
+        if (saveStateTimer) clearTimeout(saveStateTimer);
+        saveStateTimer = setTimeout(() => {
+          const state = getWindowBoundsState(win, lastNormalBounds);
+          if (state) queueWindowStateSave(state);
+        }, 500);
+      };
+    
+      // Update normal bounds on resize/move when not maximized/fullscreen
+      win.on("resize", () => {
+        updateNormalBounds();
+        scheduleSaveState();
+      });
+    
+      win.on("move", () => {
+        updateNormalBounds();
+        scheduleSaveState();
+      });
+    
+      win.on("maximize", scheduleSaveState);
+      win.on("unmaximize", () => {
+        updateNormalBounds();
+        scheduleSaveState();
+      });
+    
+      const queryDirtyEditorsBeforeClose = (event, { markCloseRequested = false } = {}) => {
+        event.preventDefault();
+        if (markCloseRequested) {
+          thisWindowCloseRequested = true;
+        }
+        const dirtyEditorQuery = typeof queryDirtyEditors === "function"
+          ? queryDirtyEditors(win.webContents, 5000, { ipcMain: electronModule.ipcMain })
+          : false;
+        Promise.resolve(dirtyEditorQuery)
+          .then((hasDirty) => {
+            if (hasDirty) {
+              thisWindowCloseRequested = false;
+              return;
+            }
+            dirtyEditorCloseConfirmed = true;
+            try {
+              win.close();
+            } catch {
+              // ignore
+            }
+          })
+          .catch(() => {
+            dirtyEditorCloseConfirmed = true;
+            try {
+              win.close();
+            } catch {
+              // ignore
+            }
+          });
+      };
+
+      // Save state when window is about to close
+      win.on("close", (event) => {
+        if (!registerAsMainWindow && registerAsAppContentWindow && !isQuitting && !dirtyEditorCloseConfirmed) {
+          queryDirtyEditorsBeforeClose(event, { markCloseRequested: true });
+          return;
+        }
+
+        // Check if close-to-tray is enabled
+        const trackedMainWindowCount = typeof getMainWindowCount === "function" ? getMainWindowCount() : 1;
+        if (registerAsMainWindow && trackedMainWindowCount <= 1 && !isQuitting && getGlobalShortcutBridge().handleWindowClose(event, win)) {
+          // Window was hidden to tray - save state before returning
+          if (saveStateTimer) clearTimeout(saveStateTimer);
+          const state = persistWindowState ? getWindowBoundsState(win, lastNormalBounds) : null;
+          if (state) saveWindowStateSync(state);
+          hideSettingsWindow();
+          return;
+        }
+
+        if (registerAsMainWindow && registerAsAppContentWindow && !isQuitting && !dirtyEditorCloseConfirmed) {
+          queryDirtyEditorsBeforeClose(event);
+          return;
+        }
+    
+        if (thisWindowCloseRequested) {
+          return;
+        }
+        thisWindowCloseRequested = true;
+        if (saveStateTimer) clearTimeout(saveStateTimer);
+        const state = persistWindowState ? getWindowBoundsState(win, lastNormalBounds) : null;
+        if (pendingWindowStateWrite) {
+          event.preventDefault();
+          if (state) queuedWindowState = state;
+          pendingWindowStateWrite
+            .catch(() => {
+              // ignore async write errors before closing
+            })
+            .finally(() => {
+              const finalState = persistWindowState ? getWindowBoundsState(win, lastNormalBounds) : null;
+              if (finalState) saveWindowStateSync(finalState);
+              if (registerAsMainWindow) closeSettingsWindow();
+              try {
+                win.close();
+              } catch {
+                // ignore
+              }
+            });
+          return;
+        }
+        if (state) saveWindowStateSync(state);
+        if (registerAsMainWindow) closeSettingsWindow();
+      });
+    
+      const safeSend = (channel, ...args) => {
+        try {
+          if (!win.isDestroyed() && win.webContents && !win.webContents.isDestroyed()) {
+            win.webContents.send(channel, ...args);
+          }
+        } catch {
+          // Render frame disposed during HMR / reload – safe to ignore
+        }
+      };
+    
+      win.on("enter-full-screen", () => {
+        safeSend("netcatty:window:fullscreen-changed", true);
+        scheduleSaveState();
+      });
+    
+      win.on("leave-full-screen", () => {
+        safeSend("netcatty:window:fullscreen-changed", false);
+        updateNormalBounds();
+        scheduleSaveState();
+      });
+
+      win.on("show", () => {
+        safeSend("netcatty:window:shown");
+        if (startHidden) {
+          // The hidden-launch tray pin exists so a --hidden cold start is
+          // never a windowless, trayless zombie; once this window is
+          // actually visible that concern no longer applies, so hand tray
+          // lifetime back to the user's normal close-to-tray preference.
+          try {
+            getGlobalShortcutBridge().releaseHiddenLaunchTrayPin?.();
+          } catch (err) {
+            console.warn("[MainWindow] Failed to release hidden-launch tray pin:", err?.message || err);
+          }
+        }
+      });
+    
+      // Ensure native background matches frontend background, even before first paint.
+      try {
+        win.setBackgroundColor(backgroundColor);
+      } catch {
+        // ignore
+      }
+
+      applyWindowOpacityToWindow(win);
+    
+      // Defer show until renderer is ready; use fallback timeout to avoid keeping window hidden forever.
+      // Production gets a shorter timeout since the splash screen provides visual feedback.
+      setupDeferredShow(win, { timeoutMs: isDev ? 3000 : 1500, startHidden });
+    
+      win.webContents.on("did-create-window", (childWindow) => {
+        try {
+          childWindow.setMenuBarVisibility(false);
+          childWindow.autoHideMenuBar = true;
+          childWindow.removeMenu();
+        } catch {
+          // ignore
+        }
+        try {
+          const iconPath = resolveLiveAppIcon(appIcon);
+          if (iconPath && childWindow.setIcon) childWindow.setIcon(iconPath);
+        } catch {
+          // ignore
+        }
+        // Never allow chained popups from remote content windows.
+        try {
+          childWindow.webContents?.setWindowOpenHandler?.(createExternalOnlyWindowOpenHandler(shell));
+        } catch {
+          // ignore
+        }
+        attachOAuthLoadingOverlay(childWindow);
+      });
+    
+      win.webContents.setWindowOpenHandler(
+        createAppWindowOpenHandler(shell, {
+          backgroundColor,
+          appIcon,
+          getAppIcon: () => resolveLiveAppIcon(appIcon),
+        })
+      );
+    
+      // Register window control handlers
+      registerWindowHandlers(electronModule.ipcMain, nativeTheme);
+    
+      // Register IPC handlers BEFORE loading any URL so the renderer never
+      // calls a handler that hasn't been registered yet.
+      onRegisterBridge?.(win);
+
+      if (startHidden) {
+        // Belt-and-suspenders: guarantee a tray icon exists as soon as
+        // bridges (and electronModule) are ready, and keep it pinned
+        // (independent of the user's separate close-to-tray preference)
+        // until this window is actually shown — see releaseHiddenLaunchTrayPin
+        // in the "show" handler below.
+        try {
+          getGlobalShortcutBridge().pinTrayForHiddenLaunch?.();
+        } catch (err) {
+          console.warn("[MainWindow] Failed to create tray for hidden launch:", err?.message || err);
+        }
+      }
+
+      if (isDev) {
+        try {
+          await win.loadURL(`${getDevRendererBaseUrl(devServerUrl)}${rendererHash}`);
+          win.webContents.openDevTools({ mode: "detach" });
+          return win;
+        } catch (e) {
+          console.warn("Dev server not reachable, falling back to bundled dist.", e);
+        }
+      }
+    
+      // Production mode - load via custom protocol.
+      await win.loadURL(`app://netcatty/index.html${rendererHash}`);
+      return win;
+    }
+
+    return { createWindow };
+  }
+}
+
+module.exports = {
+  createMainWindowApi,
+  setTerminalKeyboardFocusForWindow,
+};