feat(window): restore fullscreen after update restart only

Persist a one-shot "restore fullscreen" flag set exactly on the
update-quit path (AppLifecycleService.setQuittingForUpdate), so a
"restart to apply" relaunch reopens fullscreen if the session was
fullscreen. A normal quit (Cmd+Q, window close) never sets the flag, so
the app reverts to windowed launch behaviour.

Live-track fullscreen via enter/leave-full-screen listeners, guard
saveWindowState against persisting maximized/fullscreen bounds, and clear
the flag on both launch (one-shot) and aborted update handoff.

Generated-By: PostHog Code
Task-Id: 2854ee1d-35b1-479f-aea5-07c367280dc4

Author: gantoine

apps/code/src/main/services/app-lifecycle/service.test.ts

@@ -13,6 +13,8 @@ const {
   mockShutdownPostHog,
   mockShutdownOtelTransport,
   mockProcessExit,
+  mockGetFullScreenState,
+  mockSetRestoreFullScreenOnNextLaunch,
 } = vi.hoisted(() => {
   const mockDatabaseService = {
     close: vi.fn(),
@@ -49,9 +51,16 @@ const {
     mockShutdownPostHog: vi.fn(() => Promise.resolve()),
     mockShutdownOtelTransport: vi.fn(() => Promise.resolve()),
     mockProcessExit: vi.fn() as unknown as (code?: number) => never,
+    mockGetFullScreenState: vi.fn(() => false),
+    mockSetRestoreFullScreenOnNextLaunch: vi.fn(),
   };
 });
 
+vi.mock("../../utils/store.js", () => ({
+  getFullScreenState: mockGetFullScreenState,
+  setRestoreFullScreenOnNextLaunch: mockSetRestoreFullScreenOnNextLaunch,
+}));
+
 vi.mock("../../utils/logger.js", () => ({
   logger: {
     scope: () => ({
@@ -119,6 +128,27 @@ describe("AppLifecycleService", () => {
       service.clearQuittingForUpdate();
       expect(service.isQuittingForUpdate).toBe(false);
     });
+
+    it("remembers fullscreen for the next launch when quitting for update in fullscreen", () => {
+      mockGetFullScreenState.mockReturnValue(true);
+      service.setQuittingForUpdate();
+      expect(mockSetRestoreFullScreenOnNextLaunch).toHaveBeenCalledWith(true);
+    });
+
+    it("does not schedule a fullscreen restore when not fullscreen", () => {
+      mockGetFullScreenState.mockReturnValue(false);
+      service.setQuittingForUpdate();
+      expect(mockSetRestoreFullScreenOnNextLaunch).toHaveBeenCalledWith(false);
+    });
+
+    it("clears the fullscreen-restore flag when the update handoff is aborted", () => {
+      mockGetFullScreenState.mockReturnValue(true);
+      service.setQuittingForUpdate();
+      service.clearQuittingForUpdate();
+      expect(mockSetRestoreFullScreenOnNextLaunch).toHaveBeenLastCalledWith(
+        false,
+      );
+    });
   });
 
   describe("isShuttingDown", () => {

apps/code/src/main/services/app-lifecycle/service.ts

@@ -17,6 +17,10 @@ import { posthogNodeAnalytics } from "../../platform-adapters/posthog-analytics"
 import { withTimeout } from "../../utils/async";
 import { logger } from "../../utils/logger";
 import { shutdownOtelTransport } from "../../utils/otel-log-transport";
+import {
+  getFullScreenState,
+  setRestoreFullScreenOnNextLaunch,
+} from "../../utils/store";
 
 const log = logger.scope("app-lifecycle");
 
@@ -53,10 +57,17 @@ export class AppLifecycleService {
 
   setQuittingForUpdate(): void {
     this._isQuittingForUpdate = true;
+    // Remember whether we were fullscreen so the post-update relaunch restores
+    // it. A normal quit never runs this, so the flag stays false and the app
+    // reopens windowed.
+    setRestoreFullScreenOnNextLaunch(getFullScreenState());
   }
 
   clearQuittingForUpdate(): void {
     this._isQuittingForUpdate = false;
+    // The install handoff was aborted; don't let a stale flag restore
+    // fullscreen on the next manual launch.
+    setRestoreFullScreenOnNextLaunch(false);
   }
 
   /**

apps/code/src/main/utils/store.ts

@@ -25,6 +25,8 @@ export interface WindowStateSchema {
   height: number;
   isMaximized: boolean;
   zoomLevel: number;
+  isFullScreen: boolean;
+  restoreFullScreenOnNextLaunch: boolean;
 }
 
 const userDataDir = getUserDataDir();
@@ -52,9 +54,33 @@ export const windowStateStore = new Store<WindowStateSchema>({
     height: 600,
     isMaximized: true,
     zoomLevel: 0,
+    isFullScreen: false,
+    restoreFullScreenOnNextLaunch: false,
   },
 });
 
 export function saveZoomLevel(level: number): void {
   windowStateStore.set("zoomLevel", level);
 }
+
+export function saveFullScreenState(isFullScreen: boolean): void {
+  windowStateStore.set("isFullScreen", isFullScreen);
+}
+
+export function getFullScreenState(): boolean {
+  return windowStateStore.get("isFullScreen", false);
+}
+
+/**
+ * One-shot flag that survives a single relaunch. Set only when the app quits
+ * to install an update, so a fullscreen session is restored after the
+ * "restart to apply" handoff — but a normal quit (Cmd+Q, window close) leaves
+ * it false and launches windowed.
+ */
+export function setRestoreFullScreenOnNextLaunch(restore: boolean): void {
+  windowStateStore.set("restoreFullScreenOnNextLaunch", restore);
+}
+
+export function getRestoreFullScreenOnNextLaunch(): boolean {
+  return windowStateStore.get("restoreFullScreenOnNextLaunch", false);
+}

apps/code/src/main/window.ts

@@ -24,7 +24,10 @@ import { collectMemorySnapshot } from "./utils/crash-diagnostics";
 import { isDevBuild } from "./utils/env";
 import { logger, readChromiumLogTail } from "./utils/logger";
 import {
+  getRestoreFullScreenOnNextLaunch,
+  saveFullScreenState,
   saveZoomLevel,
+  setRestoreFullScreenOnNextLaunch,
   type WindowStateSchema,
   windowStateStore,
 } from "./utils/store";
@@ -54,6 +57,11 @@ function getSavedWindowState(): WindowStateSchema {
     height: windowStateStore.get("height", 600),
     isMaximized: windowStateStore.get("isMaximized", true),
     zoomLevel: windowStateStore.get("zoomLevel", 0),
+    isFullScreen: windowStateStore.get("isFullScreen", false),
+    restoreFullScreenOnNextLaunch: windowStateStore.get(
+      "restoreFullScreenOnNextLaunch",
+      false,
+    ),
   };
 
   // Validate position is still on a connected display
@@ -71,9 +79,11 @@ export function saveWindowState(window: BrowserWindow): void {
   const isMaximized = window.isMaximized();
   windowStateStore.set("isMaximized", isMaximized);
 
-  // Only save bounds when not maximized, so restoring from maximized
-  // gives the user their previous windowed size/position
-  if (!isMaximized) {
+  // Only save bounds when the window is in its normal state. Persisting the
+  // maximized or fullscreen bounds would clobber the user's windowed
+  // size/position, so a later "revert to windowed" launch has nothing to
+  // restore to.
+  if (!isMaximized && !window.isFullScreen()) {
     const bounds = window.getBounds();
     windowStateStore.set("x", bounds.x);
     windowStateStore.set("y", bounds.y);
@@ -158,6 +168,15 @@ function setupEditableContextMenu(window: BrowserWindow): void {
 export function createWindow(): void {
   const isDev = isDevBuild();
   const savedState = getSavedWindowState();
+
+  // Read the one-shot fullscreen-restore flag and clear it immediately, so it
+  // only ever affects the single launch that follows an update restart. A
+  // normal quit never sets it, so this is false and the app launches windowed.
+  const restoreFullScreen = getRestoreFullScreenOnNextLaunch();
+  if (restoreFullScreen) {
+    setRestoreFullScreenOnNextLaunch(false);
+  }
+
   let saveTimeout: ReturnType<typeof setTimeout> | null = null;
 
   const scheduleSaveWindowState = (window: BrowserWindow): void => {
@@ -232,7 +251,9 @@ export function createWindow(): void {
     if (windowShown) return;
     windowShown = true;
     clearTimeout(showFallback);
-    if (savedState.isMaximized) {
+    if (restoreFullScreen) {
+      mainWindow?.setFullScreen(true);
+    } else if (savedState.isMaximized) {
       mainWindow?.maximize();
     }
     mainWindow?.show();
@@ -273,6 +294,10 @@ export function createWindow(): void {
   mainWindow.on("unmaximize", () => mainWindow && saveWindowState(mainWindow));
   mainWindow.on("close", () => mainWindow && saveWindowState(mainWindow));
 
+  // Live-track fullscreen so the update-quit path can read the current state.
+  mainWindow.on("enter-full-screen", () => saveFullScreenState(true));
+  mainWindow.on("leave-full-screen", () => saveFullScreenState(false));
+
   container
     .get<ElectronMainWindow>(MAIN_WINDOW_SERVICE)
     .setMainWindowGetter(() => mainWindow);