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();
+ });
+}