From 527be52f2b868de135840d8b93f6ea172cb63fa2 Mon Sep 17 00:00:00 2001 From: "paseo-bot[bot]" <266920839+paseo-bot[bot]@users.noreply.github.com> Date: Wed, 18 Nov 2026 02:04:06 +0000 Subject: [PATCH] Reload the desktop window when its renderer exits (#10035) * Reload the desktop window when its renderer exits When the renderer process of the main window exits without a clean shutdown (killed by an out-of-memory killer, crashed, or out of memory), Electron keeps the window frame but shows nothing until the user presses Ctrl+R. The main process had no handler for render-process-gone, so it neither recovered nor logged the exit. The window now reloads itself and logs the exit reason to main.log. If the renderer exits three times within a minute, it stops reloading and logs that, so a page that crashes on load does not restart in a loop. Fixes #9999 Co-Authored-By: Claude Opus 5.5 * Leave a renderer exit before the first page commits to Chromium Before the window's first navigation commits, Chromium finishes it in a new renderer by itself. Reloading at that point aborted the initial loadURL with ERR_ABORTED, which fails desktop startup. Skip the reload while the window has no committed URL. Co-Authored-By: Claude Opus 5.5 --------- Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5.5 (cherry picked from commit b24eab785bee2df459a4f65ddb2165534ff5c054) --- packages/desktop/e2e/window-startup.e2e.mjs | 36 +++++++- packages/desktop/src/main.ts | 2 + .../src/window/renderer-recovery.test.ts | 86 +++++++++++++++++++ .../desktop/src/window/renderer-recovery.ts | 56 ++++++++++++ 4 files changed, 176 insertions(+), 4 deletions(-) create mode 100644 packages/desktop/src/window/renderer-recovery.test.ts create mode 100644 packages/desktop/src/window/renderer-recovery.ts diff --git a/packages/desktop/e2e/window-startup.e2e.mjs b/packages/desktop/e2e/window-startup.e2e.mjs index e6654c09c2..974cc0f30c 100644 --- a/packages/desktop/e2e/window-startup.e2e.mjs +++ b/packages/desktop/e2e/window-startup.e2e.mjs @@ -5,18 +5,25 @@ import { fileURLToPath } from "node:url"; import { _electron as electron, expect } from "playwright/test"; const root = await mkdtemp(path.join(tmpdir(), "paseo-window-startup-")); -const modulePath = fileURLToPath(new URL("../dist/window/show-when-ready.js", import.meta.url)); +const showWhenReadyPath = fileURLToPath( + new URL("../dist/window/show-when-ready.js", import.meta.url), +); +const rendererRecoveryPath = fileURLToPath( + new URL("../dist/window/renderer-recovery.js", import.meta.url), +); -async function launchWindowWithoutHiddenFrames() { +async function launchDesktopWindow() { const main = path.join(root, "main.cjs"); await writeFile( main, `const { app, BrowserWindow } = require("electron"); - const { showWindowWhenReady } = require(${JSON.stringify(modulePath)}); + const { showWindowWhenReady } = require(${JSON.stringify(showWhenReadyPath)}); + const { reloadWhenRendererExits } = require(${JSON.stringify(rendererRecoveryPath)}); app.setPath("userData", ${JSON.stringify(path.join(root, "user-data"))}); app.whenReady().then(async () => { const win = global.mainWindow = new BrowserWindow({ show: false, paintWhenInitiallyHidden: false }); showWindowWhenReady(win, { showOnLoad: true }); + reloadWhenRendererExits(win); await win.loadURL("data:text/html,

Desktop ready

"); global.visibleAfterLoad = win.isVisible(); });`, @@ -37,11 +44,32 @@ async function expectLoadedDesktopIsShown(desktop) { await expect(page.getByRole("heading", { name: "Desktop ready" })).toBeVisible(); } +function rendererPid(desktop) { + return desktop.evaluate(() => global.mainWindow.webContents.getOSProcessId()); +} + +async function expectDesktopReloadsAfterRendererIsTerminated(desktop) { + const terminated = await rendererPid(desktop); + process.kill(terminated, "SIGTERM"); + await expect.poll(() => rendererPid(desktop), { timeout: 15_000 }).not.toBe(terminated); + await expect + .poll( + () => + desktop.evaluate(() => + global.mainWindow.webContents.executeJavaScript("document.body.textContent"), + ), + { timeout: 15_000 }, + ) + .toBe("Desktop ready"); +} + let desktop; try { - desktop = await launchWindowWithoutHiddenFrames(); + desktop = await launchDesktopWindow(); await expectLoadedDesktopIsShown(desktop); console.log("Loaded desktop is visible without hidden compositor frames"); + await expectDesktopReloadsAfterRendererIsTerminated(desktop); + console.log("Desktop reloads its window after the renderer is terminated"); } finally { await desktop?.close(); await rm(root, { recursive: true, force: true }); diff --git a/packages/desktop/src/main.ts b/packages/desktop/src/main.ts index 072f96a26d..196f9a47f4 100644 --- a/packages/desktop/src/main.ts +++ b/packages/desktop/src/main.ts @@ -46,6 +46,7 @@ import { buildStandardContextMenuItems, } from "./window/window-manager.js"; import { setupDarwinCompositorWatchdog } from "./window/compositor-watchdog/index.js"; +import { reloadWhenRendererExits } from "./window/renderer-recovery.js"; import { showWindowWhenReady } from "./window/show-when-ready.js"; import { resolveDesktopWindowChromeMode, windowChromeModeArgument } from "./window/chrome.js"; import { registerDialogHandlers } from "./features/dialogs.js"; @@ -734,6 +735,7 @@ async function createWindow( } setupDarwinCompositorWatchdog(mainWindow); + reloadWhenRendererExits(mainWindow); setupWindowResizeEvents(mainWindow); if (windowStateStore) { setupWindowStatePersistence(mainWindow, windowStateStore); diff --git a/packages/desktop/src/window/renderer-recovery.test.ts b/packages/desktop/src/window/renderer-recovery.test.ts new file mode 100644 index 0000000000..2d1ba58e4c --- /dev/null +++ b/packages/desktop/src/window/renderer-recovery.test.ts @@ -0,0 +1,86 @@ +import { EventEmitter } from "node:events"; +import { describe, expect, it } from "vitest"; +import { reloadWhenRendererExits } from "./renderer-recovery.js"; + +class Contents extends EventEmitter { + reloads = 0; + url = "paseo://app/"; + getURL() { + return this.url; + } + reload() { + this.reloads += 1; + } + exit(reason: string) { + this.emit("render-process-gone", {}, { reason, exitCode: reason === "clean-exit" ? 0 : 15 }); + } +} + +class Window { + webContents = new Contents(); + destroyed = false; + isDestroyed() { + return this.destroyed; + } +} + +function recoverableWindow() { + const win = new Window(); + let time = 0; + reloadWhenRendererExits(win, { now: () => time }); + return { + win, + advance(ms: number) { + time += ms; + }, + }; +} + +describe("reloadWhenRendererExits", () => { + it("reloads the window when its renderer is killed", () => { + const { win } = recoverableWindow(); + win.webContents.exit("killed"); + expect(win.webContents.reloads).toBe(1); + }); + + it("reloads after a renderer crash or out-of-memory exit", () => { + const { win, advance } = recoverableWindow(); + win.webContents.exit("crashed"); + advance(120_000); + win.webContents.exit("oom"); + expect(win.webContents.reloads).toBe(2); + }); + + it("leaves a renderer that exited cleanly alone", () => { + const { win } = recoverableWindow(); + win.webContents.exit("clean-exit"); + expect(win.webContents.reloads).toBe(0); + }); + + it("leaves a renderer that exits before the first page commits to Chromium", () => { + const { win } = recoverableWindow(); + win.webContents.url = ""; + win.webContents.exit("killed"); + expect(win.webContents.reloads).toBe(0); + }); + + it("leaves a closed window closed", () => { + const { win } = recoverableWindow(); + win.destroyed = true; + win.webContents.exit("killed"); + expect(win.webContents.reloads).toBe(0); + }); + + it("stops reloading a renderer that keeps exiting, and recovers again later", () => { + const { win, advance } = recoverableWindow(); + for (let exit = 0; exit < 5; exit += 1) { + win.webContents.exit("crashed"); + advance(1_000); + } + expect(win.webContents.reloads).toBe(3); + + advance(60_000); + win.webContents.exit("killed"); + expect(win.webContents.reloads).toBe(4); + }); +}); diff --git a/packages/desktop/src/window/renderer-recovery.ts b/packages/desktop/src/window/renderer-recovery.ts new file mode 100644 index 0000000000..4c4befe3ea --- /dev/null +++ b/packages/desktop/src/window/renderer-recovery.ts @@ -0,0 +1,56 @@ +import log from "electron-log/main"; + +// A window whose renderer exits keeps its frame but shows nothing until it is +// reloaded. Reload it, but stop when the renderer keeps exiting so a page that +// crashes on load does not restart in a loop. +const MAX_RELOADS_PER_WINDOW = 3; +const RELOAD_WINDOW_MS = 60_000; + +interface RendererExit { + reason: string; + exitCode: number; +} + +interface RecoverableWindow { + isDestroyed(): boolean; + webContents: { + on( + event: "render-process-gone", + listener: (event: unknown, details: RendererExit) => void, + ): unknown; + getURL(): string; + reload(): void; + }; +} + +export function reloadWhenRendererExits( + win: RecoverableWindow, + options: { now?: () => number } = {}, +): void { + const now = options.now ?? Date.now; + let reloadTimes: number[] = []; + + win.webContents.on("render-process-gone", (_event, details) => { + if (details.reason === "clean-exit" || win.isDestroyed()) return; + // Before the first page commits, Chromium finishes the navigation in a new + // renderer by itself. Reloading then would abort the window's initial load. + if (win.webContents.getURL() === "") return; + + const time = now(); + reloadTimes = reloadTimes.filter((reloadTime) => time - reloadTime < RELOAD_WINDOW_MS); + if (reloadTimes.length >= MAX_RELOADS_PER_WINDOW) { + log.error( + `[renderer-recovery] Renderer exited (${details.reason}, code ${details.exitCode}); ` + + `not reloading after ${reloadTimes.length} reloads in the last minute`, + ); + return; + } + + reloadTimes.push(time); + log.warn( + `[renderer-recovery] Renderer exited (${details.reason}, code ${details.exitCode}); ` + + `reloading the window (reload ${reloadTimes.length} in the last minute)`, + ); + win.webContents.reload(); + }); +}