Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
26 changes: 26 additions & 0 deletions apps/desktop/src/main/core/window-manager.ts
Original file line number Diff line number Diff line change
Expand Up @@ -360,6 +360,11 @@ export class WindowManager extends EventEmitter {
);
}

const mainWindow = this.mainWindow;
mainWindow.on("minimize", () => {
void this.hideMinimizedMainWindowToTray(mainWindow);
});

this.mainWindow.on("close", () => {
// "close" fires before destruction — the window is still live here.
this.emit("window-closing", this.mainWindow!);
Expand All @@ -373,6 +378,27 @@ export class WindowManager extends EventEmitter {
this.emit("window-created", this.mainWindow!);
}

/**
* On Windows, honor the minimizeToTray preference: a minimized main window
* leaves the taskbar and stays reachable from the tray icon, whose
* "Open Console" goes through createOrShowMainWindow (restore + show).
*/
private async hideMinimizedMainWindowToTray(
window: BrowserWindow,
): Promise<void> {
if (process.platform !== "win32") {
return;
}
try {
const { minimizeToTray } = await this.settingsService.getPreferences();
if (minimizeToTray && !window.isDestroyed() && window.isMinimized()) {
window.hide();
}
} catch (error) {
logger.main.error("Failed to apply minimizeToTray preference", error);
}
}

/**
* Make sure the widget window exists. The renderer applies normal visibility
* once it has loaded the preference and current widget content state.
Expand Down
81 changes: 81 additions & 0 deletions apps/desktop/tests/main/window-manager.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -121,3 +121,84 @@ describe("WindowManager lifecycle events", () => {
expect(created[1]).not.toBe(created[0]);
});
});

describe("WindowManager main window minimize to tray", () => {
const originalPlatform = process.platform;
let closeScope: (() => Promise<void>) | null = null;

const setPlatform = (value: NodeJS.Platform) => {
Object.defineProperty(process, "platform", { configurable: true, value });
};

afterEach(async () => {
setPlatform(originalPlatform);
if (closeScope) {
await closeScope();
closeScope = null;
}
});

const openMainWindow = async (minimizeToTray: boolean) => {
const settingsService = {
getUISettings: vi.fn(async () => ({ theme: "system", locale: "en" })),
getPreferences: vi.fn(async () => ({ minimizeToTray })),
updateSettings: vi.fn(async () => undefined),
} as unknown as SettingsService;

const scope = Effect.runSync(Scope.make());
const ctx = await Effect.runPromise(
Layer.build(
WindowManager.Live.pipe(
Layer.provide(Layer.succeed(SettingsServiceTag, settingsService)),
),
).pipe(Scope.provide(scope)),
);
closeScope = () => Effect.runPromise(Scope.close(scope, Exit.void));

const manager = Context.get(ctx, WindowManagerTag);
await manager.createOrShowMainWindow();
const window = manager.getMainWindow()!;
// A real BrowserWindow is shown on creation; the fake starts hidden.
window.show();
return { manager, window, settingsService };
};

// The fake window does not emit "minimize" itself; the handler reads the
// preference asynchronously, so let it settle before asserting.
const minimize = async (window: BrowserWindow) => {
window.minimize();
window.emit("minimize");
await new Promise((resolve) => setImmediate(resolve));
};

it("hides the minimized main window on Windows when minimizeToTray is on", async () => {
setPlatform("win32");
const { manager, window } = await openMainWindow(true);

await minimize(window);
expect(window.isVisible()).toBe(false);

// Tray "Open Console" brings it back.
await manager.createOrShowMainWindow();
expect(window.isVisible()).toBe(true);
expect(window.isMinimized()).toBe(false);
});

it("keeps the minimized main window on the taskbar when minimizeToTray is off", async () => {
setPlatform("win32");
const { window, settingsService } = await openMainWindow(false);

await minimize(window);
expect(settingsService.getPreferences).toHaveBeenCalled();
expect(window.isVisible()).toBe(true);
});

it("leaves minimize behavior alone outside Windows", async () => {
setPlatform("darwin");
const { window, settingsService } = await openMainWindow(true);

await minimize(window);
expect(settingsService.getPreferences).not.toHaveBeenCalled();
expect(window.isVisible()).toBe(true);
});
});