@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 1,679 lines 67 KB
Raw
1 import * as NodeServices from "@effect/platform-node/NodeServices";
2 import { assert, describe, it } from "@effect/vitest";
3 import * as Deferred from "effect/Deferred";
4 import { DesktopSnapShotId } from "@t3tools/contracts";
5 import * as Effect from "effect/Effect";
6 import * as Exit from "effect/Exit";
7 import * as Fiber from "effect/Fiber";
8 import * as Layer from "effect/Layer";
9 import * as Logger from "effect/Logger";
10 import * as Option from "effect/Option";
11 import * as Ref from "effect/Ref";
12 import * as Schema from "effect/Schema";
13 import * as TestClock from "effect/testing/TestClock";
14
15 import * as Electron from "electron";
16 import { vi } from "vite-plus/test";
17
18 vi.mock("electron", async (importOriginal) => ({
19 ...(await importOriginal<typeof import("electron")>()),
20 session: {
21 fromPartition: vi.fn(() => ({
22 getUserAgent: vi.fn(() => "Mozilla/5.0 Electron/41.5.0 t3code/1.2.3"),
23 setPermissionRequestHandler: vi.fn(),
24 setUserAgent: vi.fn(),
25 })),
26 },
27 screen: {
28 getAllDisplays: vi.fn(() => [
29 {
30 bounds: { x: 0, y: 0, width: 1920, height: 1080 },
31 },
32 ]),
33 },
34 }));
35
36 import * as DesktopAssets from "../app/DesktopAssets.ts";
37 import * as DesktopConfig from "../app/DesktopConfig.ts";
38 import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
39 import * as DesktopPrimaryPaste from "../app/DesktopPrimaryPaste.ts";
40 import * as DesktopState from "../app/DesktopState.ts";
41 import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";
42 import * as DesktopClientSettings from "../settings/DesktopClientSettings.ts";
43 import * as ElectronApp from "../electron/ElectronApp.ts";
44 import * as DesktopRendererHistory from "../telemetry/DesktopRendererHistory.ts";
45 import * as ElectronMenu from "../electron/ElectronMenu.ts";
46 import * as ElectronShell from "../electron/ElectronShell.ts";
47 import * as ElectronTheme from "../electron/ElectronTheme.ts";
48 import * as ElectronWindow from "../electron/ElectronWindow.ts";
49 import { SNAP_SHOT_EVENT_CHANNEL } from "../ipc/channels.ts";
50 import * as DesktopServerExposure from "../backend/DesktopServerExposure.ts";
51 import * as DesktopWindow from "./DesktopWindow.ts";
52 import {
53 PASSKEY_BRIDGE_ARGUMENT,
54 PRIMARY_PASTE_DISABLED_ARGUMENT,
55 } from "../preview/GuestProtocol.ts";
56 import * as PreviewManager from "../preview/Manager.ts";
57 import * as PreviewPasskeys from "../preview/Passkeys.ts";
58
59 const environmentInput = {
60 dirname: "/repo/apps/desktop/dist-electron",
61 homeDirectory: "/Users/alice",
62 platform: "darwin",
63 processArch: "arm64",
64 appVersion: "1.2.3",
65 appPath: "/repo",
66 isPackaged: false,
67 resourcesPath: "/repo/resources",
68 runningUnderArm64Translation: false,
69 } satisfies DesktopEnvironment.MakeDesktopEnvironmentInput;
70
71 function makeFakeBrowserWindow() {
72 const windowListeners = new Map<string, (...args: readonly unknown[]) => void>();
73 const webContentsListeners = new Map<string, (...args: readonly unknown[]) => void>();
74 let zoomLevel = 0;
75 const webContents = {
76 copyImageAt: vi.fn(),
77 focus: vi.fn(),
78 isDestroyed: vi.fn(() => false),
79 getURL: vi.fn(() => "t3code-dev://app/"),
80 getZoomLevel: vi.fn(() => zoomLevel),
81 getZoomFactor: vi.fn(() => 1.2 ** zoomLevel),
82 setZoomLevel: vi.fn((level: number) => {
83 zoomLevel = level;
84 }),
85 isLoadingMainFrame: vi.fn(() => false),
86 navigationHistory: {
87 canGoBack: vi.fn(() => true),
88 canGoForward: vi.fn(() => true),
89 goBack: vi.fn(),
90 goForward: vi.fn(),
91 },
92 on: vi.fn((eventName: string, listener: (...args: readonly unknown[]) => void) => {
93 webContentsListeners.set(eventName, listener);
94 }),
95 once: vi.fn<(eventName: string, listener: (...args: readonly unknown[]) => void) => void>(),
96 openDevTools: vi.fn(),
97 reload: vi.fn(),
98 reloadIgnoringCache: vi.fn(),
99 replaceMisspelling: vi.fn(),
100 send: vi.fn(),
101 setBackgroundThrottling: vi.fn(),
102 setIgnoreMenuShortcuts: vi.fn(),
103 setWindowOpenHandler: vi.fn(),
104 toggleDevTools: vi.fn(),
105 };
106
107 const window = {
108 close: vi.fn(),
109 focus: vi.fn(),
110 getBounds: vi.fn(() => ({ x: 0, y: 0, width: 1100, height: 780 })),
111 getNormalBounds: vi.fn(() => ({ x: 0, y: 0, width: 1100, height: 780 })),
112 isDestroyed: vi.fn(() => false),
113 isFullScreen: vi.fn(() => false),
114 isMaximized: vi.fn(() => false),
115 isMinimized: vi.fn(() => false),
116 isVisible: vi.fn(() => true),
117 loadURL: vi.fn(() => Promise.resolve()),
118 maximize: vi.fn(),
119 on: vi.fn((eventName: string, listener: (...args: readonly unknown[]) => void) => {
120 windowListeners.set(eventName, listener);
121 }),
122 once: vi.fn((eventName: string, listener: (...args: readonly unknown[]) => void) => {
123 windowListeners.set(eventName, listener);
124 }),
125 restore: vi.fn(),
126 setBackgroundColor: vi.fn(),
127 setAutoHideCursor: vi.fn(),
128 setFullScreen: vi.fn(),
129 setOpacity: vi.fn(),
130 setTitle: vi.fn(),
131 setTitleBarOverlay: vi.fn(),
132 setWindowButtonPosition: vi.fn(),
133 show: vi.fn(),
134 webContents,
135 };
136
137 return {
138 window: window as unknown as Electron.BrowserWindow,
139 getBounds: window.getBounds,
140 getNormalBounds: window.getNormalBounds,
141 isDestroyed: window.isDestroyed,
142 isFullScreen: window.isFullScreen,
143 isMaximized: window.isMaximized,
144 isMinimized: window.isMinimized,
145 loadURL: window.loadURL,
146 maximize: window.maximize,
147 openDevTools: webContents.openDevTools,
148 reload: webContents.reload,
149 reloadIgnoringCache: webContents.reloadIgnoringCache,
150 toggleDevTools: webContents.toggleDevTools,
151 navigationHistory: webContents.navigationHistory,
152 setIgnoreMenuShortcuts: webContents.setIgnoreMenuShortcuts,
153 send: webContents.send,
154 setZoomLevel: webContents.setZoomLevel,
155 setWindowButtonPosition: window.setWindowButtonPosition,
156 setBackgroundThrottling: webContents.setBackgroundThrottling,
157 setAutoHideCursor: window.setAutoHideCursor,
158 setFullScreen: window.setFullScreen,
159 setOpacity: window.setOpacity,
160 webContentsListeners,
161 webContentsOnce: webContents.once,
162 windowListeners,
163 };
164 }
165
166 const layerDesktopClientSettings = Layer.mock(DesktopClientSettings.DesktopClientSettings)({
167 get: Effect.succeedNone,
168 });
169
170 const layerElectronApp = Layer.mock(ElectronApp.ElectronApp)({
171 quit: Effect.void,
172 });
173
174 const layerDesktopAssets = Layer.succeed(DesktopAssets.DesktopAssets, {
175 iconPaths: Effect.succeed({
176 ico: Option.none<string>(),
177 icns: Option.none<string>(),
178 png: Option.none<string>(),
179 }),
180 resolveResourcePath: () => Effect.succeed(Option.none<string>()),
181 } satisfies DesktopAssets.DesktopAssets["Service"]);
182
183 const layerDesktopServerExposure = Layer.succeed(DesktopServerExposure.DesktopServerExposure, {
184 getState: Effect.die("unexpected getState"),
185 backendConfig: Effect.succeed({
186 port: 3773,
187 bindHost: "127.0.0.1",
188 httpBaseUrl: new URL("http://127.0.0.1:3773"),
189 tailscaleServeEnabled: false,
190 tailscaleServePort: 443,
191 }),
192 configureFromSettings: () => Effect.die("unexpected configureFromSettings"),
193 setMode: () => Effect.die("unexpected setMode"),
194 setTailscaleServeEnabled: () => Effect.die("unexpected setTailscaleServeEnabled"),
195 getAdvertisedEndpoints: Effect.die("unexpected getAdvertisedEndpoints"),
196 } satisfies DesktopServerExposure.DesktopServerExposure["Service"]);
197
198 const layerElectronMenu = Layer.succeed(ElectronMenu.ElectronMenu, {
199 setApplicationMenu: () => Effect.void,
200 popupTemplate: () => Effect.void,
201 showContextMenu: () => Effect.succeedNone,
202 } satisfies ElectronMenu.ElectronMenu["Service"]);
203
204 const layerElectronTheme = Layer.succeed(ElectronTheme.ElectronTheme, {
205 shouldUseDarkColors: Effect.succeed(false),
206 setSource: () => Effect.void,
207 onUpdated: () => Effect.void,
208 } satisfies ElectronTheme.ElectronTheme["Service"]);
209
210 const layerDesktopEnvironmentFor = (platform: NodeJS.Platform) =>
211 DesktopEnvironment.layer({ ...environmentInput, platform }).pipe(
212 Layer.provide(
213 Layer.mergeAll(
214 NodeServices.layer,
215 DesktopConfig.layerTest({
216 T3CODE_PORT: "3773",
217 VITE_DEV_SERVER_URL: "http://127.0.0.1:5733",
218 }),
219 ),
220 ),
221 );
222
223 const layerDesktopEnvironment = layerDesktopEnvironmentFor(environmentInput.platform);
224
225 const desktopWindowBoundsEquivalence = Schema.toEquivalence(
226 DesktopAppSettings.DesktopWindowBoundsSchema,
227 );
228
229 function layerTest(input: {
230 readonly window: Electron.BrowserWindow;
231 readonly createCount: Ref.Ref<number>;
232 readonly mainWindow: Ref.Ref<Option.Option<Electron.BrowserWindow>>;
233 readonly createdWindowOptions?: Electron.BrowserWindowConstructorOptions[];
234 readonly desktopSettings?: DesktopAppSettings.DesktopSettings;
235 readonly mainWindowBoundsUpdates?: DesktopAppSettings.DesktopWindowBounds[];
236 readonly mainWindowMaximizedUpdates?: boolean[];
237 readonly beforeMainWindowBoundsUpdate?: (
238 bounds: DesktopAppSettings.DesktopWindowBounds,
239 ) => Effect.Effect<void>;
240 readonly setPreviewMainWindow?: (window: Electron.BrowserWindow) => Effect.Effect<void>;
241 readonly destroyAll?: Effect.Effect<void>;
242 readonly onWindowCreate?: Effect.Effect<void>;
243 readonly openedExternalUrls?: unknown[];
244 readonly onCopyText?: (text: string) => Effect.Effect<void>;
245 readonly onPopupTemplate?: (input: ElectronMenu.ElectronMenuTemplateInput) => Effect.Effect<void>;
246 readonly previewZoomReapplies?: number[];
247 readonly onReveal?: (window: Electron.BrowserWindow) => void;
248 readonly focusedWindow?: Electron.BrowserWindow;
249 readonly fallbackWindow?: Electron.BrowserWindow;
250 readonly platform?: NodeJS.Platform;
251 readonly appearanceWindows?: ReadonlyArray<{
252 readonly window: Electron.BrowserWindow;
253 readonly titleBarOverlay: boolean;
254 }>;
255 readonly primaryPasteEnabled?: boolean;
256 readonly previewPasskeyBridgeEnabled?: boolean;
257 }) {
258 let desktopSettings = input.desktopSettings ?? DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS;
259 const layerDesktopAppSettings = Layer.succeed(DesktopAppSettings.DesktopAppSettings, {
260 get: Effect.sync(() => desktopSettings),
261 load: Effect.sync(() => desktopSettings),
262 setMainWindowBounds: (bounds, isMaximized) =>
263 Effect.gen(function* () {
264 if (input.beforeMainWindowBoundsUpdate) {
265 yield* input.beforeMainWindowBoundsUpdate(bounds);
266 }
267 const changed =
268 desktopSettings.mainWindowBounds === null ||
269 !desktopWindowBoundsEquivalence(desktopSettings.mainWindowBounds, bounds) ||
270 desktopSettings.mainWindowMaximized !== isMaximized;
271 if (changed) {
272 desktopSettings = {
273 ...desktopSettings,
274 mainWindowBounds: bounds,
275 mainWindowMaximized: isMaximized,
276 };
277 input.mainWindowBoundsUpdates?.push(bounds);
278 input.mainWindowMaximizedUpdates?.push(isMaximized);
279 }
280 return { settings: desktopSettings, changed };
281 }),
282 setServerExposureMode: () => Effect.die("unexpected server exposure update"),
283 setTailscaleServe: () => Effect.die("unexpected Tailscale Serve update"),
284 setUpdateChannel: () => Effect.die("unexpected update channel change"),
285 setWslBackendEnabled: () => Effect.die("unexpected WSL backend toggle"),
286 setWslDistro: () => Effect.die("unexpected WSL distro change"),
287 setWslOnly: () => Effect.die("unexpected WSL-only toggle"),
288 setLocalEnvironmentEnabled: () => Effect.die("unexpected local environment toggle"),
289 applyWslWindowsFallback: Effect.die("unexpected WSL Windows fallback"),
290 applyWslWindowsFallbackInMemory: Effect.die("unexpected WSL Windows fallback"),
291 } satisfies DesktopAppSettings.DesktopAppSettings["Service"]);
292
293 const layerElectronWindow = Layer.succeed(ElectronWindow.ElectronWindow, {
294 create: (options) =>
295 Effect.sync(() => {
296 input.createdWindowOptions?.push(options);
297 }).pipe(
298 Effect.andThen(Ref.update(input.createCount, (count) => count + 1)),
299 Effect.andThen(input.onWindowCreate ?? Effect.void),
300 Effect.as(input.window),
301 ),
302 main: Ref.get(input.mainWindow),
303 currentMainOrFirst: Ref.get(input.mainWindow).pipe(
304 Effect.map(Option.orElse(() => Option.fromNullishOr(input.fallbackWindow ?? null))),
305 ),
306 focusedMainOrFirst:
307 input.focusedWindow === undefined
308 ? Ref.get(input.mainWindow)
309 : Effect.succeedSome(input.focusedWindow),
310 setMain: (window) => Ref.set(input.mainWindow, Option.some(window)),
311 clearMain: () => Ref.set(input.mainWindow, Option.none()),
312 prepareReveal: () => Effect.succeed(false),
313 reveal: (window) => Effect.sync(() => input.onReveal?.(window)),
314 sendAll: () => Effect.void,
315 destroyAll: input.destroyAll ?? Effect.void,
316 syncAllAppearance: (sync) =>
317 input.appearanceWindows === undefined
318 ? sync(input.window, { titleBarOverlay: true })
319 : Effect.forEach(
320 input.appearanceWindows,
321 ({ window, titleBarOverlay }) => sync(window, { titleBarOverlay }),
322 { discard: true },
323 ),
324 } satisfies ElectronWindow.ElectronWindow["Service"]);
325
326 return DesktopWindow.layer.pipe(
327 Layer.provide(
328 Layer.mergeAll(
329 layerDesktopAssets,
330 Layer.succeed(DesktopRendererHistory.DesktopRendererHistory, {
331 register: () => Effect.void,
332 recordMetrics: () => Effect.void,
333 shutdown: Effect.void,
334 }),
335 input.platform === undefined
336 ? layerDesktopEnvironment
337 : layerDesktopEnvironmentFor(input.platform),
338 layerDesktopAppSettings,
339 layerDesktopClientSettings,
340 layerDesktopServerExposure,
341 DesktopState.layer,
342 layerElectronApp,
343 Layer.succeed(ElectronMenu.ElectronMenu, {
344 setApplicationMenu: () => Effect.void,
345 showContextMenu: () => Effect.succeedNone,
346 popupTemplate: input.onPopupTemplate ?? (() => Effect.void),
347 }),
348 Layer.succeed(ElectronShell.ElectronShell, {
349 openExternal: (url) =>
350 Effect.sync(() => {
351 input.openedExternalUrls?.push(url);
352 return true;
353 }),
354 openSystemSettings: () => Effect.succeed(true),
355 copyText: input.onCopyText ?? (() => Effect.void),
356 } satisfies ElectronShell.ElectronShell["Service"]),
357 layerElectronTheme,
358 layerElectronWindow,
359 Layer.succeed(DesktopPrimaryPaste.DesktopPrimaryPaste, {
360 enabled: input.primaryPasteEnabled ?? true,
361 }),
362 Layer.mock(PreviewPasskeys.PreviewPasskeys)({
363 bridgeEnabled: input.previewPasskeyBridgeEnabled ?? false,
364 installSessionHandlers: () => {},
365 attachGuest: () => () => {},
366 }),
367 Layer.mock(PreviewManager.PreviewManager)({
368 getBrowserSession: () => Effect.succeed({} as Electron.Session),
369 setMainWindow: input.setPreviewMainWindow ?? (() => Effect.void),
370 prepareWebview: () => Effect.void,
371 isBrowserPartition: (partition) => partition.startsWith("persist:t3code-preview-"),
372 getBrowserPartition: () => Effect.succeed("persist:t3code-preview-test"),
373 reapplyZoom: () =>
374 Effect.sync(() => {
375 input.previewZoomReapplies?.push(input.window.webContents.getZoomLevel());
376 }),
377 }),
378 ),
379 ),
380 Layer.merge(DesktopState.layer),
381 );
382 }
383
384 const makeSplashScenario = (createOutcomes: readonly (Electron.BrowserWindow | null)[]) =>
385 Effect.gen(function* () {
386 const createdWindows = yield* Ref.make<Electron.BrowserWindow[]>([]);
387 const createCalls = yield* Ref.make(0);
388 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
389 const revealedWindows = yield* Ref.make<Electron.BrowserWindow[]>([]);
390 const fallbackWindow = createOutcomes.find(
391 (window): window is Electron.BrowserWindow => window !== null,
392 );
393
394 const currentMainOrFirst = Effect.gen(function* () {
395 const registered = yield* Ref.get(mainWindow);
396 if (Option.isSome(registered)) {
397 return registered;
398 }
399 const created = yield* Ref.get(createdWindows);
400 return Option.fromNullishOr(created[0] ?? null);
401 });
402
403 const electronWindowShape = {
404 create: () =>
405 Effect.gen(function* () {
406 const index = yield* Ref.getAndUpdate(createCalls, (count) => count + 1);
407 const outcome = createOutcomes[index] ?? null;
408 if (outcome === null) {
409 return yield* new ElectronWindow.ElectronWindowCreateError({
410 options: {
411 title: null,
412 width: null,
413 height: null,
414 minWidth: null,
415 minHeight: null,
416 show: null,
417 modal: null,
418 frame: null,
419 transparent: null,
420 backgroundColor: null,
421 webPreferences: {
422 preload: null,
423 partition: null,
424 backgroundThrottling: null,
425 sandbox: null,
426 contextIsolation: null,
427 nodeIntegration: null,
428 webviewTag: null,
429 },
430 },
431 cause: new Error("simulated window-open failure"),
432 });
433 }
434 yield* Ref.update(createdWindows, (windows) => [...windows, outcome]);
435 return outcome;
436 }),
437 main: Ref.get(mainWindow),
438 currentMainOrFirst,
439 focusedMainOrFirst: currentMainOrFirst,
440 setMain: (window) => Ref.set(mainWindow, Option.some(window)),
441 clearMain: () => Ref.set(mainWindow, Option.none()),
442 prepareReveal: () => Effect.succeed(false),
443 reveal: (window) => Ref.update(revealedWindows, (windows) => [...windows, window]),
444 sendAll: () => Effect.void,
445 destroyAll: Effect.void,
446 syncAllAppearance: (sync) =>
447 fallbackWindow ? sync(fallbackWindow, { titleBarOverlay: true }) : Effect.void,
448 } satisfies ElectronWindow.ElectronWindow["Service"];
449
450 const layer = DesktopWindow.layer.pipe(
451 Layer.provide(
452 Layer.mergeAll(
453 layerDesktopAssets,
454 Layer.succeed(DesktopRendererHistory.DesktopRendererHistory, {
455 register: () => Effect.void,
456 recordMetrics: () => Effect.void,
457 shutdown: Effect.void,
458 }),
459 layerDesktopEnvironment,
460 DesktopAppSettings.layerTest(),
461 layerDesktopClientSettings,
462 layerDesktopServerExposure,
463 DesktopState.layer,
464 layerElectronApp,
465 layerElectronMenu,
466 Layer.succeed(ElectronShell.ElectronShell, {
467 openExternal: () => Effect.succeed(true),
468 openSystemSettings: () => Effect.succeed(true),
469 copyText: () => Effect.void,
470 } satisfies ElectronShell.ElectronShell["Service"]),
471 layerElectronTheme,
472 Layer.succeed(ElectronWindow.ElectronWindow, electronWindowShape),
473 Layer.succeed(DesktopPrimaryPaste.DesktopPrimaryPaste, { enabled: true }),
474 Layer.mock(PreviewPasskeys.PreviewPasskeys)({
475 bridgeEnabled: false,
476 installSessionHandlers: () => {},
477 attachGuest: () => () => {},
478 }),
479 Layer.mock(PreviewManager.PreviewManager)({
480 getBrowserSession: () => Effect.succeed({} as Electron.Session),
481 setMainWindow: () => Effect.void,
482 isBrowserPartition: (partition) => partition.startsWith("persist:t3code-preview-"),
483 getBrowserPartition: () => Effect.succeed("persist:t3code-preview-test"),
484 }),
485 ),
486 ),
487 );
488
489 return { layer, createCalls, mainWindow, revealedWindows } as const;
490 });
491
492 const captureOne = DesktopSnapShotId.make("11111111-1111-4111-8111-111111111111");
493 const captureTwo = DesktopSnapShotId.make("22222222-2222-4222-8222-222222222222");
494
495 describe("DesktopWindow", () => {
496 it("restores bounds only when the window fits within a connected display", () => {
497 const persistedBounds = { x: 2040, y: 80, width: 1320, height: 880 };
498 const displays = [
499 { x: 0, y: 0, width: 1920, height: 1080 },
500 { x: 1920, y: 0, width: 2560, height: 1440 },
501 ];
502
503 assert.deepEqual(
504 DesktopWindow.resolveInitialMainWindowBounds(persistedBounds, displays),
505 persistedBounds,
506 );
507 assert.deepEqual(
508 DesktopWindow.resolveInitialMainWindowBounds(persistedBounds, [displays[0]!]),
509 DesktopAppSettings.DEFAULT_MAIN_WINDOW_SIZE,
510 );
511 });
512
513 it("restores a window saved 1px past a display edge, and nothing further out", () => {
514 const displays = [
515 { x: 0, y: 0, width: 1920, height: 1280 },
516 { x: 1920, y: 0, width: 1280, height: 1920 },
517 ];
518 const snappedBounds = { x: 1921, y: 30, width: 1280, height: 945 };
519
520 assert.strictEqual(
521 DesktopWindow.resolveInitialMainWindowBounds(snappedBounds, displays),
522 snappedBounds,
523 );
524 for (const bounds of [
525 { x: 1922, y: 30, width: 1280, height: 945 },
526 { x: 1918, y: 30, width: 1280, height: 945 },
527 { x: 1921, y: -2, width: 1279, height: 945 },
528 { x: 1920, y: 976, width: 1280, height: 946 },
529 ]) {
530 assert.deepEqual(
531 DesktopWindow.resolveInitialMainWindowBounds(bounds, displays),
532 DesktopAppSettings.DEFAULT_MAIN_WINDOW_SIZE,
533 );
534 }
535 });
536
537 it("rejects renderer navigations whose origin only serializes as null", () => {
538 for (const applicationUrl of ["t3code://app/", "t3code-dev://app/"]) {
539 assert.isTrue(
540 DesktopWindow.isSameOriginRendererNavigation({
541 applicationUrl,
542 navigationUrl: `${applicationUrl}threads?id=1#latest`,
543 }),
544 applicationUrl,
545 );
546 }
547 for (const navigationUrl of [
548 "t3code://other/",
549 "t3code://app.example/",
550 "t3code://app:8080/",
551 "t3code://user@other/",
552 "t3code:app",
553 "t3code-dev://app/",
554 "file:///etc/passwd",
555 "data:text/html,<p>hi</p>",
556 "javascript:alert(1)",
557 "about:blank",
558 "blob:t3code://app/0b5e2c4a",
559 ]) {
560 assert.isFalse(
561 DesktopWindow.isSameOriginRendererNavigation({
562 applicationUrl: "t3code://app/",
563 navigationUrl,
564 }),
565 navigationUrl,
566 );
567 }
568 assert.isFalse(
569 DesktopWindow.isSameOriginRendererNavigation({
570 applicationUrl: "data:text/html,app",
571 navigationUrl: "data:text/html,other",
572 }),
573 );
574 });
575
576 it.effect(
577 "opens and reopens the window without backend readiness when local execution is disabled",
578 () =>
579 Effect.gen(function* () {
580 const fakeWindow = makeFakeBrowserWindow();
581 const createCount = yield* Ref.make(0);
582 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
583 const layer = layerTest({
584 window: fakeWindow.window,
585 createCount,
586 mainWindow,
587 createdWindowOptions: [],
588 desktopSettings: {
589 ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
590 localEnvironmentEnabled: false,
591 },
592 });
593 yield* Effect.gen(function* () {
594 const desktopWindow = yield* DesktopWindow.DesktopWindow;
595 yield* desktopWindow.createMainIfBackendReady;
596 assert.equal(yield* Ref.get(createCount), 1);
597 yield* Ref.set(mainWindow, Option.none());
598 yield* desktopWindow.activate;
599 assert.equal(yield* Ref.get(createCount), 2);
600 yield* Ref.set(mainWindow, Option.none());
601 yield* desktopWindow.dispatchMenuAction("new-thread");
602 assert.equal(yield* Ref.get(createCount), 3);
603 }).pipe(Effect.provide(layer));
604 }),
605 );
606
607 it.effect.each(["before", "after"] as const)(
608 "keeps a closed startup window closed until activation %s backend readiness",
609 (activation) =>
610 Effect.gen(function* () {
611 const fake = makeFakeBrowserWindow();
612 const createCount = yield* Ref.make(0);
613 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
614 yield* Effect.gen(function* () {
615 const windows = yield* DesktopWindow.DesktopWindow;
616 yield* windows.ensureMain;
617 fake.windowListeners.get("ready-to-show")?.();
618 fake.isDestroyed.mockReturnValue(true);
619 fake.windowListeners.get("closed")?.();
620 assert.isTrue(Option.isNone(yield* Ref.get(mainWindow)));
621 if (activation === "after") {
622 yield* windows.handleBackendReady(new URL("http://127.0.0.1:3773"));
623 assert.equal(yield* Ref.get(createCount), 1);
624 }
625 fake.isDestroyed.mockReturnValue(false);
626 yield* windows.activate;
627 assert.equal(yield* Ref.get(createCount), 2);
628 yield* windows.handleBackendReady(new URL("http://127.0.0.1:3773"));
629 assert.equal(yield* Ref.get(createCount), 2);
630 }).pipe(Effect.provide(layerTest({ window: fake.window, createCount, mainWindow })));
631 }),
632 );
633
634 it.effect.each(["renderer", "backend"] as const)(
635 "reveals the painted boot shell when %s becomes ready first",
636 (first) =>
637 Effect.gen(function* () {
638 const fake = makeFakeBrowserWindow();
639 const createCount = yield* Ref.make(0);
640 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
641 const reveal = vi.fn();
642 const painted = Promise.withResolvers<void>();
643 yield* Effect.gen(function* () {
644 const windows = yield* DesktopWindow.DesktopWindow;
645 yield* windows.ensureMain;
646 assert.equal(fake.loadURL.mock.calls.length, 1);
647 yield* windows.activate;
648 yield* windows.revealOrCreateMain;
649 yield* windows.dispatchMenuAction("open-settings");
650 assert.equal(reveal.mock.calls.length, 0);
651 if (first === "backend") {
652 yield* windows.handleBackendReady(new URL("http://127.0.0.1:3773"));
653 assert.equal(reveal.mock.calls.length, 0);
654 }
655 fake.windowListeners.get("ready-to-show")?.();
656 yield* Effect.promise(() => painted.promise);
657 assert.equal(reveal.mock.calls.length, 1);
658 yield* windows.handleBackendReady(new URL("http://127.0.0.1:3773"));
659 assert.equal(yield* Ref.get(createCount), 1);
660 assert.equal(reveal.mock.calls.length, 1);
661 yield* windows.handleBackendNotReady;
662 yield* windows.activate;
663 assert.equal(reveal.mock.calls.length, 2);
664 }).pipe(
665 Effect.provide(
666 layerTest({
667 window: fake.window,
668 createCount,
669 mainWindow,
670 onReveal: () => {
671 reveal();
672 painted.resolve();
673 },
674 }),
675 ),
676 );
677 }),
678 );
679
680 it.effect("leaves Cmd+W to the renderer and blocks repeated presses", () =>
681 Effect.gen(function* () {
682 const fakeWindow = makeFakeBrowserWindow();
683 const createCount = yield* Ref.make(0);
684 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
685 const layer = layerTest({
686 window: fakeWindow.window,
687 createCount,
688 mainWindow,
689 });
690
691 yield* Effect.gen(function* () {
692 const desktopWindow = yield* DesktopWindow.DesktopWindow;
693 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
694
695 const beforeInput = fakeWindow.webContentsListeners.get("before-input-event");
696 if (!beforeInput) {
697 return yield* Effect.die("before-input-event listener was not registered");
698 }
699
700 let prevented = false;
701 const event = { preventDefault: () => (prevented = true) };
702 const input = {
703 type: "keyDown",
704 isAutoRepeat: true,
705 key: "W",
706 meta: true,
707 control: false,
708 alt: false,
709 shift: false,
710 };
711 beforeInput(event, input);
712 assert.isTrue(prevented);
713
714 prevented = false;
715 beforeInput(event, { ...input, isAutoRepeat: false });
716 assert.isFalse(prevented);
717
718 prevented = false;
719 beforeInput(event, { ...input, meta: false });
720 assert.isFalse(prevented);
721
722 assert.deepEqual(
723 fakeWindow.setIgnoreMenuShortcuts.mock.calls.map(([ignore]) => ignore),
724 [true, true, false],
725 );
726 beforeInput(event, { ...input, key: "r", isAutoRepeat: false });
727 assert.isFalse(fakeWindow.setIgnoreMenuShortcuts.mock.lastCall?.[0]);
728 }).pipe(Effect.provide(layer));
729 }),
730 );
731
732 it.effect("ignores input that arrives after the window is destroyed", () =>
733 Effect.gen(function* () {
734 const fakeWindow = makeFakeBrowserWindow();
735 const createCount = yield* Ref.make(0);
736 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
737 const layer = layerTest({
738 window: fakeWindow.window,
739 createCount,
740 mainWindow,
741 });
742
743 yield* Effect.gen(function* () {
744 const desktopWindow = yield* DesktopWindow.DesktopWindow;
745 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
746
747 const beforeInput = fakeWindow.webContentsListeners.get("before-input-event");
748 const inputEvent = fakeWindow.webContentsListeners.get("input-event");
749 if (!beforeInput || !inputEvent) {
750 return yield* Effect.die("input listeners were not registered");
751 }
752
753 // Electron throws on any member access of a destroyed BrowserWindow.
754 fakeWindow.isDestroyed.mockReturnValue(true);
755 Object.defineProperty(fakeWindow.window, "webContents", {
756 get: () => {
757 throw new TypeError("Object has been destroyed");
758 },
759 });
760
761 // A held Cmd+Q quits from the grace timer, so the trailing Q keyUp lands here.
762 assert.doesNotThrow(() =>
763 beforeInput(
764 { preventDefault: () => {} },
765 {
766 type: "keyUp",
767 isAutoRepeat: false,
768 key: "q",
769 meta: true,
770 control: false,
771 alt: false,
772 shift: false,
773 },
774 ),
775 );
776 assert.doesNotThrow(() => inputEvent({}, { type: "gestureScrollEnd" }));
777 }).pipe(Effect.provide(layer));
778 }),
779 );
780
781 // Chromium hands the main window's zoom level down to embedded preview
782 // guests, so every app zoom has to put the preview browser back at its own
783 // zoom or zooming the UI drags the previewed page with it.
784 it.effect("zooms main with a focused popup and reapplies preview zoom", () =>
785 Effect.gen(function* () {
786 const fakeWindow = makeFakeBrowserWindow();
787 const popup = makeFakeBrowserWindow();
788 const createCount = yield* Ref.make(0);
789 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
790 const previewZoomReapplies: number[] = [];
791 const layer = layerTest({
792 window: fakeWindow.window,
793 createCount,
794 mainWindow,
795 previewZoomReapplies,
796 focusedWindow: popup.window,
797 });
798
799 yield* Effect.gen(function* () {
800 const desktopWindow = yield* DesktopWindow.DesktopWindow;
801 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
802
803 yield* desktopWindow.zoomMain("out");
804 yield* desktopWindow.zoomMain("out");
805 yield* desktopWindow.zoomMain("in");
806 yield* desktopWindow.zoomMain("reset");
807
808 assert.deepEqual(
809 fakeWindow.setZoomLevel.mock.calls.map(([level]) => level),
810 [-0.5, -1, -0.5, 0],
811 );
812 assert.deepEqual(previewZoomReapplies, [-0.5, -1, -0.5, 0]);
813 assert.equal(popup.setZoomLevel.mock.calls.length, 0);
814 }).pipe(Effect.provide(layer));
815 }),
816 );
817
818 it.effect("zooms the app from Ctrl+wheel like the menu does", () =>
819 Effect.gen(function* () {
820 const fakeWindow = makeFakeBrowserWindow();
821 const createCount = yield* Ref.make(0);
822 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
823 const previewZoomReapplies: number[] = [];
824 const layer = layerTest({
825 window: fakeWindow.window,
826 createCount,
827 mainWindow,
828 previewZoomReapplies,
829 });
830
831 yield* Effect.gen(function* () {
832 const desktopWindow = yield* DesktopWindow.DesktopWindow;
833 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
834
835 const zoomChanged = fakeWindow.webContentsListeners.get("zoom-changed");
836 if (!zoomChanged) return yield* Effect.die("zoom-changed listener was not registered");
837 zoomChanged({}, "in");
838 zoomChanged({}, "out");
839 zoomChanged({}, "out");
840
841 assert.deepEqual(
842 fakeWindow.setZoomLevel.mock.calls.map(([level]) => level),
843 [0.5, 0, -0.5],
844 );
845 assert.deepEqual(previewZoomReapplies, [0.5, 0, -0.5]);
846 }).pipe(Effect.provide(layer));
847 }),
848 );
849
850 it.effect("routes menu commands to the main window even when a popup has focus", () =>
851 Effect.gen(function* () {
852 const fakeWindow = makeFakeBrowserWindow();
853 const popup = makeFakeBrowserWindow();
854 const createCount = yield* Ref.make(0);
855 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
856 const layer = layerTest({
857 window: fakeWindow.window,
858 createCount,
859 mainWindow,
860 focusedWindow: popup.window,
861 });
862
863 yield* Effect.gen(function* () {
864 const desktopWindow = yield* DesktopWindow.DesktopWindow;
865 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
866
867 yield* desktopWindow.runMainContentsCommand("reload");
868 yield* desktopWindow.runMainContentsCommand("forceReload");
869 yield* desktopWindow.runMainContentsCommand("toggleDevTools");
870 yield* desktopWindow.dispatchMenuAction("open-settings");
871
872 assert.deepEqual(fakeWindow.send.mock.calls, [["desktop:menu-action", "open-settings"]]);
873 assert.equal(popup.send.mock.calls.length, 0);
874 assert.equal(fakeWindow.reload.mock.calls.length, 1);
875 assert.equal(fakeWindow.reloadIgnoringCache.mock.calls.length, 1);
876 assert.equal(fakeWindow.toggleDevTools.mock.calls.length, 1);
877 assert.equal(popup.reload.mock.calls.length, 0);
878 assert.equal(popup.reloadIgnoringCache.mock.calls.length, 0);
879 assert.equal(popup.toggleDevTools.mock.calls.length, 0);
880 }).pipe(Effect.provide(layer));
881 }),
882 );
883
884 it.effect("recreates main for Settings when only an unregistered popup survives", () =>
885 Effect.gen(function* () {
886 const main = makeFakeBrowserWindow();
887 const auxiliary = makeFakeBrowserWindow();
888 const createCount = yield* Ref.make(0);
889 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
890
891 yield* Effect.gen(function* () {
892 const windows = yield* DesktopWindow.DesktopWindow;
893 yield* windows.dispatchMenuAction("open-settings");
894 assert.deepEqual(main.send.mock.calls, [["desktop:menu-action", "open-settings"]]);
895 assert.equal(auxiliary.send.mock.calls.length, 0);
896 assert.equal(yield* Ref.get(createCount), 1);
897 assert.strictEqual(yield* windows.ensureMain, main.window);
898 assert.equal(yield* Ref.get(createCount), 1);
899 }).pipe(
900 Effect.provide(
901 layerTest({
902 window: main.window,
903 createCount,
904 mainWindow,
905 fallbackWindow: auxiliary.window,
906 desktopSettings: {
907 ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
908 localEnvironmentEnabled: false,
909 },
910 }),
911 ),
912 );
913 }),
914 );
915
916 it.effect("does not open main or splash windows once quitting has started", () =>
917 Effect.gen(function* () {
918 const fake = makeFakeBrowserWindow();
919 const createCount = yield* Ref.make(0);
920 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
921 yield* Effect.gen(function* () {
922 const windows = yield* DesktopWindow.DesktopWindow;
923 const state = yield* DesktopState.DesktopState;
924 yield* Ref.set(state.quitting, true);
925
926 yield* windows.showConnectingSplash;
927 yield* windows.handleBackendReady(new URL("http://127.0.0.1:3773"));
928 yield* windows.activate;
929 yield* windows.dispatchMenuAction("open-settings");
930 for (const creation of [
931 windows.createMain,
932 windows.ensureMain,
933 windows.revealOrCreateMain,
934 ]) {
935 assert.isTrue(Exit.isFailure(yield* Effect.exit(creation)));
936 }
937
938 assert.equal(yield* Ref.get(createCount), 0);
939 assert.isTrue(Option.isNone(yield* Ref.get(mainWindow)));
940 assert.equal(fake.send.mock.calls.length, 0);
941 }).pipe(Effect.provide(layerTest({ window: fake.window, createCount, mainWindow })));
942 }),
943 );
944
945 it.effect.each(["main", "splash"] as const)(
946 "destroys a %s window when quit races native creation without loading or revealing it",
947 (kind) =>
948 Effect.gen(function* () {
949 const fake = makeFakeBrowserWindow();
950 const createCount = yield* Ref.make(0);
951 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
952 const creationStarted = yield* Deferred.make<void>();
953 const releaseCreation = yield* Deferred.make<void>();
954 const reveal = vi.fn();
955 const layer = layerTest({
956 window: fake.window,
957 createCount,
958 mainWindow,
959 onWindowCreate: Deferred.succeed(creationStarted, undefined).pipe(
960 Effect.andThen(Deferred.await(releaseCreation)),
961 ),
962 destroyAll: Effect.sync(() => fake.isDestroyed.mockReturnValue(true)),
963 onReveal: reveal,
964 });
965
966 yield* Effect.gen(function* () {
967 const windows = yield* DesktopWindow.DesktopWindow;
968 const state = yield* DesktopState.DesktopState;
969 const fiber = yield* (
970 kind === "splash"
971 ? windows.showConnectingSplash
972 : windows.handleBackendReady(new URL("http://127.0.0.1:3773"))
973 ).pipe(Effect.forkChild({ startImmediately: true }));
974 yield* Deferred.await(creationStarted);
975 yield* Ref.set(state.quitting, true);
976 yield* Deferred.succeed(releaseCreation, undefined);
977 assert.isTrue(Exit.isSuccess(yield* Fiber.await(fiber)));
978 assert.equal(yield* Ref.get(createCount), 1);
979 assert.isTrue(fake.window.isDestroyed());
980 assert.isTrue(Option.isNone(yield* Ref.get(mainWindow)));
981 assert.equal(fake.loadURL.mock.calls.length, 0);
982 assert.equal(fake.openDevTools.mock.calls.length, 0);
983 assert.equal(reveal.mock.calls.length, 0);
984 }).pipe(Effect.provide(layer));
985 }),
986 );
987
988 it.effect.each(["backend ready", "activation", "renderer event"] as const)(
989 "quietly cancels %s when quit races preview cleanup",
990 (entry) =>
991 Effect.gen(function* () {
992 const fake = makeFakeBrowserWindow();
993 const createCount = yield* Ref.make(0);
994 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
995 const previewStarted = yield* Deferred.make<void>();
996 const releasePreview = yield* Deferred.make<void>();
997 const reveal = vi.fn();
998 const warnings: unknown[] = [];
999 const logger = Logger.make(({ logLevel, message }) => {
1000 if (logLevel === "Warn" || logLevel === "Error") warnings.push(message);
1001 });
1002 const layer = layerTest({
1003 window: fake.window,
1004 createCount,
1005 mainWindow,
1006 desktopSettings: {
1007 ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
1008 localEnvironmentEnabled: false,
1009 },
1010 setPreviewMainWindow: () =>
1011 Deferred.succeed(previewStarted, undefined).pipe(
1012 Effect.andThen(Deferred.await(releasePreview)),
1013 ),
1014 destroyAll: Effect.sync(() => fake.isDestroyed.mockReturnValue(true)),
1015 onReveal: reveal,
1016 });
1017
1018 yield* Effect.gen(function* () {
1019 const windows = yield* DesktopWindow.DesktopWindow;
1020 const state = yield* DesktopState.DesktopState;
1021 const creation =
1022 entry === "backend ready"
1023 ? windows.handleBackendReady(new URL("http://127.0.0.1:3773"))
1024 : entry === "activation"
1025 ? windows.activate
1026 : windows.dispatchMenuAction("open-settings");
1027 const fiber = yield* creation.pipe(Effect.forkChild({ startImmediately: true }));
1028 yield* Deferred.await(previewStarted);
1029 yield* Ref.set(state.quitting, true);
1030 // Cover both an already-destroyed window and one shutdown has yet to destroy.
1031 fake.isDestroyed.mockReturnValue(entry !== "backend ready");
1032 yield* Deferred.succeed(releasePreview, undefined);
1033
1034 assert.isTrue(Exit.isSuccess(yield* Fiber.await(fiber)));
1035 assert.isTrue(fake.window.isDestroyed());
1036 assert.isTrue(Option.isNone(yield* Ref.get(mainWindow)));
1037 assert.equal(fake.loadURL.mock.calls.length, 0);
1038 assert.equal(fake.openDevTools.mock.calls.length, 0);
1039 assert.equal(fake.send.mock.calls.length, 0);
1040 assert.equal(reveal.mock.calls.length, 0);
1041 assert.deepEqual(warnings, []);
1042 }).pipe(
1043 Effect.provide(
1044 Layer.mergeAll(layer, Logger.layer([logger], { mergeWithExisting: false })),
1045 ),
1046 );
1047 }),
1048 );
1049
1050 it.effect("persists normal bounds and state for a maximized window", () =>
1051 Effect.gen(function* () {
1052 const fakeWindow = makeFakeBrowserWindow();
1053 fakeWindow.isMaximized.mockReturnValue(true);
1054 fakeWindow.getBounds.mockReturnValue({ x: 0, y: 0, width: 1920, height: 1080 });
1055 fakeWindow.getNormalBounds.mockReturnValue({ x: 220, y: 140, width: 1380, height: 920 });
1056 const createCount = yield* Ref.make(0);
1057 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
1058 const mainWindowBoundsUpdates: DesktopAppSettings.DesktopWindowBounds[] = [];
1059 const mainWindowMaximizedUpdates: boolean[] = [];
1060 const layer = layerTest({
1061 window: fakeWindow.window,
1062 createCount,
1063 mainWindow,
1064 mainWindowBoundsUpdates,
1065 mainWindowMaximizedUpdates,
1066 });
1067
1068 yield* Effect.gen(function* () {
1069 const desktopWindow = yield* DesktopWindow.DesktopWindow;
1070 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
1071
1072 const close = fakeWindow.windowListeners.get("close");
1073 if (!close) {
1074 return yield* Effect.die("window close listener was not registered");
1075 }
1076 close();
1077 yield* Effect.promise(() => Promise.resolve());
1078
1079 assert.deepEqual(mainWindowBoundsUpdates, [{ x: 220, y: 140, width: 1380, height: 920 }]);
1080 assert.deepEqual(mainWindowMaximizedUpdates, [true]);
1081 assert.equal(fakeWindow.getNormalBounds.mock.calls.length, 1);
1082 }).pipe(Effect.provide(layer));
1083 }),
1084 );
1085
1086 it.effect.each([
1087 { normal: "on display 1", width: 1920, height: 1080, x: 220 },
1088 { normal: "on display 1", width: 1280, height: 720, x: 220 },
1089 { normal: "straddling both displays", width: 1920, height: 1080, x: 1800 },
1090 ])(
1091 "persists bounds on the display a maximized window was moved to ($width x $height, normal $normal)",
1092 ({ width, height, x }) =>
1093 Effect.gen(function* () {
1094 const displayOne = { x: 0, y: 0, width: 1920, height: 1080 };
1095 const displayTwo = { x: 1920, y: 0, width, height };
1096 const getAllDisplays = vi.mocked(Electron.screen.getAllDisplays);
1097 getAllDisplays.mockReturnValue([
1098 { bounds: displayOne, workArea: displayOne },
1099 { bounds: displayTwo, workArea: displayTwo },
1100 ] as unknown as Electron.Display[]);
1101 const fakeWindow = makeFakeBrowserWindow();
1102 fakeWindow.isMaximized.mockReturnValue(true);
1103 fakeWindow.getBounds.mockReturnValue(displayTwo);
1104 fakeWindow.getNormalBounds.mockReturnValue({ x, y: 140, width: 1380, height: 920 });
1105 const createCount = yield* Ref.make(0);
1106 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
1107 const mainWindowBoundsUpdates: DesktopAppSettings.DesktopWindowBounds[] = [];
1108 const mainWindowMaximizedUpdates: boolean[] = [];
1109 const layer = layerTest({
1110 window: fakeWindow.window,
1111 createCount,
1112 mainWindow,
1113 mainWindowBoundsUpdates,
1114 mainWindowMaximizedUpdates,
1115 });
1116
1117 yield* Effect.gen(function* () {
1118 const desktopWindow = yield* DesktopWindow.DesktopWindow;
1119 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
1120
1121 const move = fakeWindow.windowListeners.get("move");
1122 if (!move) {
1123 return yield* Effect.die("window move listener was not registered");
1124 }
1125 move();
1126 yield* TestClock.adjust(500);
1127 yield* Effect.promise(() => Promise.resolve());
1128
1129 const persisted = mainWindowBoundsUpdates.at(-1);
1130 assert.isDefined(persisted, "maximized window bounds were not persisted");
1131 const persistedDisplay = [displayOne, displayTwo].findIndex(
1132 (display) =>
1133 persisted.x >= display.x &&
1134 persisted.y >= display.y &&
1135 persisted.x + persisted.width <= display.x + display.width &&
1136 persisted.y + persisted.height <= display.y + display.height,
1137 );
1138 assert.equal(
1139 persistedDisplay,
1140 1,
1141 `window maximized on display 2 persisted bounds ${JSON.stringify(persisted)}, which restore on display ${persistedDisplay + 1}`,
1142 );
1143 assert.deepEqual(mainWindowMaximizedUpdates, [true]);
1144 }).pipe(
1145 Effect.provide(layer),
1146 Effect.ensuring(Effect.sync(() => getAllDisplays.mockReset())),
1147 );
1148 }),
1149 );
1150
1151 it.effect("preserves unrestorable bounds until the user changes the window", () =>
1152 Effect.gen(function* () {
1153 const fakeWindow = makeFakeBrowserWindow();
1154 const createCount = yield* Ref.make(0);
1155 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
1156 const mainWindowBoundsUpdates: DesktopAppSettings.DesktopWindowBounds[] = [];
1157 const layer = layerTest({
1158 window: fakeWindow.window,
1159 createCount,
1160 mainWindow,
1161 mainWindowBoundsUpdates,
1162 desktopSettings: {
1163 ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
1164 mainWindowBounds: { x: 2040, y: 80, width: 1320, height: 880 },
1165 },
1166 });
1167
1168 yield* Effect.gen(function* () {
1169 const desktopWindow = yield* DesktopWindow.DesktopWindow;
1170 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
1171
1172 const close = fakeWindow.windowListeners.get("close");
1173 const move = fakeWindow.windowListeners.get("move");
1174 if (!close || !move) {
1175 return yield* Effect.die("window lifecycle listeners were not registered");
1176 }
1177
1178 close();
1179 yield* Effect.promise(() => Promise.resolve());
1180 assert.deepEqual(mainWindowBoundsUpdates, []);
1181
1182 fakeWindow.getBounds.mockReturnValue({ x: 80, y: 60, width: 1280, height: 840 });
1183 move();
1184 yield* TestClock.adjust(500);
1185 yield* Effect.promise(() => Promise.resolve());
1186 assert.deepEqual(mainWindowBoundsUpdates, [{ x: 80, y: 60, width: 1280, height: 840 }]);
1187 }).pipe(Effect.provide(layer));
1188 }),
1189 );
1190
1191 it.effect("flushes normal bounds when minimized before the debounce completes", () =>
1192 Effect.gen(function* () {
1193 const fakeWindow = makeFakeBrowserWindow();
1194 fakeWindow.getBounds.mockReturnValue({ x: 180, y: 120, width: 1440, height: 960 });
1195 const createCount = yield* Ref.make(0);
1196 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
1197 const mainWindowBoundsUpdates: DesktopAppSettings.DesktopWindowBounds[] = [];
1198 const layer = layerTest({
1199 window: fakeWindow.window,
1200 createCount,
1201 mainWindow,
1202 mainWindowBoundsUpdates,
1203 });
1204
1205 yield* Effect.gen(function* () {
1206 const desktopWindow = yield* DesktopWindow.DesktopWindow;
1207 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
1208
1209 const resize = fakeWindow.windowListeners.get("resize");
1210 if (!resize) {
1211 return yield* Effect.die("window resize listener was not registered");
1212 }
1213 resize();
1214 yield* TestClock.adjust(250);
1215 // Windows reports a minimized window at -32000.
1216 fakeWindow.isMinimized.mockReturnValue(true);
1217 fakeWindow.getBounds.mockReturnValue({ x: -32_000, y: -32_000, width: 160, height: 28 });
1218
1219 yield* desktopWindow.flushMainWindowBounds;
1220 resize();
1221 yield* TestClock.adjust(500);
1222 yield* Effect.promise(() => Promise.resolve());
1223
1224 assert.deepEqual(mainWindowBoundsUpdates, [{ x: 180, y: 120, width: 1440, height: 960 }]);
1225 }).pipe(Effect.provide(layer));
1226 }),
1227 );
1228
1229 it.effect(
1230 "brings the window back after the renderer dies more often than the reload budget",
1231 () =>
1232 Effect.gen(function* () {
1233 const fakeWindow = makeFakeBrowserWindow();
1234 const createCount = yield* Ref.make(0);
1235 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
1236 const layer = layerTest({ window: fakeWindow.window, createCount, mainWindow });
1237
1238 yield* Effect.gen(function* () {
1239 const desktopWindow = yield* DesktopWindow.DesktopWindow;
1240 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
1241
1242 const renderProcessGone = fakeWindow.webContentsListeners.get("render-process-gone");
1243 if (!renderProcessGone) {
1244 return yield* Effect.die("render-process-gone listener was not registered");
1245 }
1246 for (let crash = 1; crash <= 4; crash++) {
1247 const loadsBefore = fakeWindow.loadURL.mock.calls.length;
1248 renderProcessGone({}, { reason: "oom", exitCode: -536870904 });
1249 yield* TestClock.adjust(crash < 4 ? 1_000 : 60_000);
1250 yield* Effect.promise(() => Promise.resolve());
1251 assert.isAbove(
1252 fakeWindow.loadURL.mock.calls.length,
1253 loadsBefore,
1254 `window shows nothing after renderer crash ${crash}`,
1255 );
1256 }
1257 }).pipe(Effect.provide(layer));
1258 }),
1259 );
1260
1261 it.effect("updates title bar overlays only on windows created with one", () =>
1262 Effect.gen(function* () {
1263 const framed = makeFakeBrowserWindow();
1264 vi.mocked(framed.window.setTitleBarOverlay).mockImplementation(() => {
1265 throw new TypeError("Titlebar overlay is not enabled");
1266 });
1267 const overlay = makeFakeBrowserWindow();
1268 const layer = layerTest({
1269 window: overlay.window,
1270 createCount: yield* Ref.make(0),
1271 mainWindow: yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none()),
1272 platform: "win32",
1273 appearanceWindows: [
1274 { window: framed.window, titleBarOverlay: false },
1275 { window: overlay.window, titleBarOverlay: true },
1276 ],
1277 });
1278
1279 yield* Effect.gen(function* () {
1280 const desktopWindow = yield* DesktopWindow.DesktopWindow;
1281 yield* desktopWindow.syncAppearance;
1282 }).pipe(Effect.provide(layer));
1283
1284 assert.deepEqual(vi.mocked(framed.window.setBackgroundColor).mock.calls, [["#ffffff"]]);
1285 assert.lengthOf(vi.mocked(framed.window.setTitleBarOverlay).mock.calls, 0);
1286 assert.deepEqual(vi.mocked(overlay.window.setBackgroundColor).mock.calls, [["#ffffff"]]);
1287 assert.lengthOf(vi.mocked(overlay.window.setTitleBarOverlay).mock.calls, 1);
1288 }),
1289 );
1290
1291 it.effect.each([
1292 { window: "normal", write: "flush" },
1293 { window: "normal", write: "debounce" },
1294 { window: "maximized", write: "flush" },
1295 { window: "maximized", write: "debounce" },
1296 ] as const)("persists a $window window change minimized before its $write", (input) =>
1297 Effect.gen(function* () {
1298 const displayOne = { x: 0, y: 0, width: 1920, height: 1080 };
1299 const displayTwo = { x: 1920, y: 0, width: 1920, height: 1080 };
1300 const getAllDisplays = vi.mocked(Electron.screen.getAllDisplays);
1301 getAllDisplays.mockReturnValue([
1302 { bounds: displayOne, workArea: displayOne },
1303 { bounds: displayTwo, workArea: displayTwo },
1304 ] as unknown as Electron.Display[]);
1305 const maximized = input.window === "maximized";
1306 const fakeWindow = makeFakeBrowserWindow();
1307 fakeWindow.isMaximized.mockReturnValue(maximized);
1308 fakeWindow.getBounds.mockReturnValue(
1309 maximized ? displayTwo : { x: 220, y: 140, width: 1380, height: 920 },
1310 );
1311 fakeWindow.getNormalBounds.mockReturnValue({ x: 220, y: 140, width: 1380, height: 920 });
1312 const createCount = yield* Ref.make(0);
1313 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
1314 const mainWindowBoundsUpdates: DesktopAppSettings.DesktopWindowBounds[] = [];
1315 const mainWindowMaximizedUpdates: boolean[] = [];
1316 const layer = layerTest({
1317 window: fakeWindow.window,
1318 createCount,
1319 mainWindow,
1320 mainWindowBoundsUpdates,
1321 mainWindowMaximizedUpdates,
1322 });
1323
1324 yield* Effect.gen(function* () {
1325 const desktopWindow = yield* DesktopWindow.DesktopWindow;
1326 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
1327
1328 const move = fakeWindow.windowListeners.get("move");
1329 if (!move) {
1330 return yield* Effect.die("window move listener was not registered");
1331 }
1332 move();
1333 yield* TestClock.adjust(250);
1334 // Minimized windows report stale state: macOS unmaximized at the pre-move frame.
1335 fakeWindow.isMinimized.mockReturnValue(true);
1336 fakeWindow.isMaximized.mockReturnValue(false);
1337 fakeWindow.getBounds.mockReturnValue({ x: 100, y: 100, width: 1100, height: 780 });
1338 fakeWindow.getNormalBounds.mockReturnValue({ x: 100, y: 100, width: 1100, height: 780 });
1339 if (input.write === "debounce") {
1340 yield* TestClock.adjust(250);
1341 yield* Effect.promise(() => Promise.resolve());
1342 }
1343 yield* desktopWindow.flushMainWindowBounds;
1344
1345 assert.deepEqual(mainWindowBoundsUpdates, [
1346 maximized
1347 ? { x: 2140, y: 140, width: 1380, height: 920 }
1348 : { x: 220, y: 140, width: 1380, height: 920 },
1349 ]);
1350 assert.deepEqual(mainWindowMaximizedUpdates, [maximized]);
1351 }).pipe(
1352 Effect.provide(layer),
1353 Effect.ensuring(Effect.sync(() => getAllDisplays.mockReset())),
1354 );
1355 }),
1356 );
1357
1358 it.effect("maps macOS horizontal swipes to available history navigation", () =>
1359 Effect.gen(function* () {
1360 const fakeWindow = makeFakeBrowserWindow();
1361 const createCount = yield* Ref.make(0);
1362 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
1363 const layer = layerTest({ window: fakeWindow.window, createCount, mainWindow });
1364
1365 yield* Effect.gen(function* () {
1366 const desktopWindow = yield* DesktopWindow.DesktopWindow;
1367 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
1368 const swipe = fakeWindow.windowListeners.get("swipe");
1369 assert.isDefined(swipe);
1370 if (!swipe) return;
1371 const history = fakeWindow.navigationHistory;
1372
1373 swipe({}, "left");
1374 assert.equal(history.goBack.mock.calls.length, 1);
1375 assert.equal(history.goForward.mock.calls.length, 0);
1376 swipe({}, "right");
1377 assert.equal(history.goForward.mock.calls.length, 1);
1378
1379 swipe({}, "up");
1380 swipe({}, "down");
1381 history.canGoBack.mockReturnValue(false);
1382 history.canGoForward.mockReturnValue(false);
1383 swipe({}, "left");
1384 swipe({}, "right");
1385 assert.equal(history.goBack.mock.calls.length, 1);
1386 assert.equal(history.goForward.mock.calls.length, 1);
1387 }).pipe(Effect.provide(layer));
1388 }),
1389 );
1390
1391 it.effect("persists the current main window bounds before the window closes", () =>
1392 Effect.gen(function* () {
1393 const fakeWindow = makeFakeBrowserWindow();
1394 fakeWindow.getBounds.mockReturnValue({ x: 240, y: 160, width: 1410, height: 930 });
1395 const createCount = yield* Ref.make(0);
1396 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
1397 const mainWindowBoundsUpdates: DesktopAppSettings.DesktopWindowBounds[] = [];
1398 const writeStarted = yield* Deferred.make<void>();
1399 const allowWrite = yield* Deferred.make<void>();
1400 const flushCompleted = yield* Deferred.make<void>();
1401 const layer = layerTest({
1402 window: fakeWindow.window,
1403 createCount,
1404 mainWindow,
1405 mainWindowBoundsUpdates,
1406 beforeMainWindowBoundsUpdate: () =>
1407 Deferred.succeed(writeStarted, undefined).pipe(
1408 Effect.andThen(Deferred.await(allowWrite)),
1409 Effect.asVoid,
1410 ),
1411 });
1412
1413 yield* Effect.gen(function* () {
1414 const desktopWindow = yield* DesktopWindow.DesktopWindow;
1415 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
1416
1417 const close = fakeWindow.windowListeners.get("close");
1418 if (!close) {
1419 return yield* Effect.die("window close listener was not registered");
1420 }
1421 close();
1422 yield* Deferred.await(writeStarted);
1423 fakeWindow.isDestroyed.mockReturnValue(true);
1424
1425 const flushFiber = yield* desktopWindow.flushMainWindowBounds.pipe(
1426 Effect.andThen(Deferred.succeed(flushCompleted, undefined)),
1427 Effect.forkChild({ startImmediately: true }),
1428 );
1429 yield* Effect.yieldNow;
1430 assert.isFalse(yield* Deferred.isDone(flushCompleted));
1431
1432 yield* Deferred.succeed(allowWrite, undefined);
1433 yield* Fiber.join(flushFiber);
1434 assert.isTrue(yield* Deferred.isDone(flushCompleted));
1435
1436 assert.deepEqual(mainWindowBoundsUpdates, [
1437 {
1438 x: 240,
1439 y: 160,
1440 width: 1410,
1441 height: 930,
1442 },
1443 ]);
1444 }).pipe(Effect.provide(layer));
1445 }),
1446 );
1447
1448 it.effect.each([
1449 {
1450 primaryPasteEnabled: false,
1451 expected: [PASSKEY_BRIDGE_ARGUMENT, PRIMARY_PASTE_DISABLED_ARGUMENT],
1452 },
1453 { primaryPasteEnabled: true, expected: [PASSKEY_BRIDGE_ARGUMENT] },
1454 ])(
1455 "passes the primary-paste setting to preview guests (enabled: $primaryPasteEnabled)",
1456 ({ primaryPasteEnabled, expected }) =>
1457 Effect.gen(function* () {
1458 const fakeWindow = makeFakeBrowserWindow();
1459 const layer = layerTest({
1460 window: fakeWindow.window,
1461 createCount: yield* Ref.make(0),
1462 mainWindow: yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none()),
1463 primaryPasteEnabled,
1464 previewPasskeyBridgeEnabled: true,
1465 });
1466
1467 yield* Effect.gen(function* () {
1468 const desktopWindow = yield* DesktopWindow.DesktopWindow;
1469 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
1470
1471 const willAttachWebview = fakeWindow.webContentsListeners.get("will-attach-webview");
1472 if (!willAttachWebview) {
1473 return yield* Effect.die("will-attach-webview listener was not registered");
1474 }
1475 const webPreferences: Electron.WebPreferences = {};
1476 willAttachWebview({ preventDefault: () => {} }, webPreferences, {
1477 partition: "persist:t3code-preview-test",
1478 });
1479
1480 assert.deepEqual(webPreferences.additionalArguments, expected);
1481 }).pipe(Effect.provide(layer));
1482 }),
1483 );
1484
1485 it.effect("opens safe off-origin renderer navigations in the system browser", () =>
1486 Effect.gen(function* () {
1487 const fakeWindow = makeFakeBrowserWindow();
1488 const createCount = yield* Ref.make(0);
1489 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
1490 const openedExternalUrls: unknown[] = [];
1491 const layer = layerTest({
1492 window: fakeWindow.window,
1493 createCount,
1494 mainWindow,
1495 openedExternalUrls,
1496 });
1497
1498 yield* Effect.gen(function* () {
1499 const desktopWindow = yield* DesktopWindow.DesktopWindow;
1500 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
1501
1502 const willNavigate = fakeWindow.webContentsListeners.get("will-navigate");
1503 if (!willNavigate) {
1504 return yield* Effect.die("will-navigate listener was not registered");
1505 }
1506 for (const [url, expectedPrevented] of [
1507 ["t3code-dev://app/threads?id=1#latest", false],
1508 ["t3code-dev://other/", true],
1509 ["t3code://app/", true],
1510 ] as const) {
1511 const preventDefault = vi.fn();
1512 willNavigate({ preventDefault }, url);
1513 assert.equal(preventDefault.mock.calls.length, expectedPrevented ? 1 : 0, url);
1514 }
1515 assert.deepEqual(openedExternalUrls, []);
1516
1517 let prevented = false;
1518 willNavigate(
1519 {
1520 preventDefault: () => {
1521 prevented = true;
1522 },
1523 },
1524 "https://accounts.microsoft.com/oauth",
1525 );
1526 yield* Effect.promise(() => Promise.resolve());
1527
1528 assert.isTrue(prevented);
1529 assert.deepEqual(openedExternalUrls, ["https://accounts.microsoft.com/oauth"]);
1530 }).pipe(Effect.provide(layer));
1531 }),
1532 );
1533
1534 it.effect("offers to copy the bare address when right-clicking a mailto link", () =>
1535 Effect.gen(function* () {
1536 const fakeWindow = makeFakeBrowserWindow();
1537 const createCount = yield* Ref.make(0);
1538 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
1539 const popup = yield* Deferred.make<ElectronMenu.ElectronMenuTemplateInput>();
1540 const copied = yield* Deferred.make<string>();
1541 const layer = layerTest({
1542 window: fakeWindow.window,
1543 createCount,
1544 mainWindow,
1545 onPopupTemplate: (input) => Deferred.succeed(popup, input),
1546 onCopyText: (text) => Deferred.succeed(copied, text),
1547 });
1548
1549 yield* Effect.gen(function* () {
1550 const desktopWindow = yield* DesktopWindow.DesktopWindow;
1551 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
1552
1553 const contextMenu = fakeWindow.webContentsListeners.get("context-menu");
1554 if (!contextMenu) {
1555 return yield* Effect.die("context-menu listener was not registered");
1556 }
1557 contextMenu(
1558 { preventDefault: vi.fn() },
1559 {
1560 linkURL: "mailto:restaurant%40example.com?subject=Hi",
1561 misspelledWord: "",
1562 dictionarySuggestions: [],
1563 mediaType: "none",
1564 editFlags: { canCut: false, canCopy: false, canPaste: false, canSelectAll: true },
1565 },
1566 );
1567
1568 const { template } = yield* Deferred.await(popup);
1569 const copyEmail = template.find((item) => item.label === "Copy Email Address");
1570 assert.isDefined(
1571 copyEmail,
1572 `no "Copy Email Address" item in ${JSON.stringify(template.map((item) => item.label ?? item.role ?? item.type))}`,
1573 );
1574 copyEmail?.click?.(
1575 {} as Electron.MenuItem,
1576 fakeWindow.window,
1577 {} as Electron.KeyboardEvent,
1578 );
1579 assert.equal(yield* Deferred.await(copied), "restaurant@example.com");
1580 }).pipe(Effect.provide(layer));
1581 }),
1582 );
1583
1584 it.effect(
1585 "retries opening the real main on activate when a failed post-readiness open left only the splash",
1586 () =>
1587 Effect.gen(function* () {
1588 const splash = makeFakeBrowserWindow();
1589 const main = makeFakeBrowserWindow();
1590 const scenario = yield* makeSplashScenario([splash.window, null, main.window]);
1591
1592 yield* Effect.gen(function* () {
1593 const desktopWindow = yield* DesktopWindow.DesktopWindow;
1594
1595 yield* desktopWindow.showConnectingSplash;
1596 assert.equal(yield* Ref.get(scenario.createCalls), 1);
1597
1598 const readyExit = yield* Effect.exit(
1599 desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773")),
1600 );
1601 assert.equal(readyExit._tag, "Failure");
1602 assert.equal(yield* Ref.get(scenario.createCalls), 2);
1603 assert.isTrue(Option.isNone(yield* Ref.get(scenario.mainWindow)));
1604
1605 yield* desktopWindow.activate;
1606 assert.equal(yield* Ref.get(scenario.createCalls), 3);
1607 const registeredMain = yield* Ref.get(scenario.mainWindow);
1608 assert.isTrue(Option.isSome(registeredMain));
1609 assert.equal(Option.getOrThrow(registeredMain), main.window);
1610 }).pipe(Effect.provide(scenario.layer));
1611 }),
1612 );
1613
1614 it.effect("delivers capture completion and late errors without taking focus back", () =>
1615 Effect.gen(function* () {
1616 const operations: Array<string> = [];
1617 let foreground = "Discord";
1618 const fakeWindow = makeFakeBrowserWindow();
1619 fakeWindow.send.mockImplementation(() => {
1620 operations.push("send");
1621 });
1622 const createCount = yield* Ref.make(0);
1623 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
1624 const layer = layerTest({
1625 window: fakeWindow.window,
1626 createCount,
1627 mainWindow,
1628 onReveal: () => {
1629 foreground = "T3 Code";
1630 operations.push("reveal");
1631 },
1632 });
1633
1634 yield* Effect.gen(function* () {
1635 const desktopWindow = yield* DesktopWindow.DesktopWindow;
1636 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
1637 fakeWindow.windowListeners.get("ready-to-show")?.();
1638 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
1639 operations.length = 0;
1640 foreground = "Discord";
1641 yield* desktopWindow.dispatchSnapShotEvent({ type: "started", id: captureOne });
1642 assert.equal(foreground, "T3 Code");
1643 foreground = "Explorer";
1644 yield* desktopWindow.dispatchSnapShotEvent({ type: "ready", id: captureOne });
1645 yield* desktopWindow.dispatchSnapShotEvent({ type: "failed", id: captureTwo });
1646
1647 assert.equal(foreground, "Explorer");
1648 assert.deepEqual(operations, ["send", "reveal", "send", "send"]);
1649 assert.deepEqual(fakeWindow.send.mock.calls, [
1650 [SNAP_SHOT_EVENT_CHANNEL, { type: "started", id: captureOne }],
1651 [SNAP_SHOT_EVENT_CHANNEL, { type: "ready", id: captureOne }],
1652 [SNAP_SHOT_EVENT_CHANNEL, { type: "failed", id: captureTwo }],
1653 ]);
1654 }).pipe(Effect.provide(layer));
1655 }),
1656 );
1657
1658 it.effect("does not reopen a closed main window for a completed capture", () =>
1659 Effect.gen(function* () {
1660 const fakeWindow = makeFakeBrowserWindow();
1661 const createCount = yield* Ref.make(0);
1662 const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
1663 const onReveal = vi.fn();
1664 const layer = layerTest({ window: fakeWindow.window, createCount, mainWindow, onReveal });
1665
1666 yield* Effect.gen(function* () {
1667 const desktopWindow = yield* DesktopWindow.DesktopWindow;
1668 yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
1669 fakeWindow.isDestroyed.mockReturnValue(true);
1670 yield* Ref.set(mainWindow, Option.none());
1671 yield* desktopWindow.dispatchSnapShotEvent({ type: "ready", id: captureOne });
1672
1673 assert.equal(yield* Ref.get(createCount), 1);
1674 assert.equal(fakeWindow.send.mock.calls.length, 0);
1675 assert.equal(onReveal.mock.calls.length, 0);
1676 }).pipe(Effect.provide(layer));
1677 }),
1678 );
1679 });