@devries-cameron20 / t3code-1 / commits / 5eb81547bd
Fork 0

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

perf(desktop): keep Linux MIME helpers off the startup path (#29247)

Lakshmi Tanmay committed Nov 3, 2026 at 07:11 UTC 5eb81547bd200b7463c29cff37cbc93f13af8c39
2 files changed +235 -1
apps/desktop/src/app/DesktopApp.test.ts new
+233
@@ -0,0 +1,233 @@
1 +import { assert, it } from "@effect/vitest";
2 +import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
3 +import * as Deferred from "effect/Deferred";
4 +import * as Effect from "effect/Effect";
5 +import * as Layer from "effect/Layer";
6 +import * as FileSystem from "effect/FileSystem";
7 +import * as Path from "effect/Path";
8 +import * as HttpClient from "effect/http/HttpClient";
9 +import * as NetService from "@t3tools/shared/Net";
10 +import * as Fiber from "effect/Fiber";
11 +import * as Option from "effect/Option";
12 +import * as Ref from "effect/Ref";
13 +import * as Stream from "effect/Stream";
14 +import { vi } from "vite-plus/test";
15 +
16 +vi.mock("electron", () => ({}));
17 +vi.mock("@clerk/electron", () => ({ createClerkBridge: vi.fn() }));
18 +vi.mock("@clerk/electron/storage", () => ({ storage: vi.fn() }));
19 +vi.mock("../ipc/DesktopIpcHandlers.ts", () => ({
20 + installDesktopIpcHandlers: () => Effect.void,
21 +}));
22 +vi.mock("../updates/DesktopRemoteUpdates.ts", () => ({ listen: Effect.void }));
23 +vi.mock("./DesktopStartupRecovery.ts", () => ({ listen: Effect.void }));
24 +
25 +import * as DesktopApp from "./DesktopApp.ts";
26 +import * as DesktopAppActivation from "./DesktopAppActivation.ts";
27 +import * as DesktopAppIdentity from "./DesktopAppIdentity.ts";
28 +import * as DesktopClerk from "./DesktopClerk.ts";
29 +import * as DesktopEnvironment from "./DesktopEnvironment.ts";
30 +import * as DesktopLegacyLocalStorage from "./DesktopLegacyLocalStorage.ts";
31 +import * as DesktopLifecycle from "./DesktopLifecycle.ts";
32 +import * as DesktopLinuxUrlHandler from "./DesktopLinuxUrlHandler.ts";
33 +import * as DesktopPreReadyPlatform from "./DesktopPreReadyPlatform.ts";
34 +import * as DesktopShutdown from "./DesktopShutdown.ts";
35 +import * as DesktopState from "./DesktopState.ts";
36 +import * as DesktopBackendPool from "../backend/DesktopBackendPool.ts";
37 +import * as DesktopServerExposure from "../backend/DesktopServerExposure.ts";
38 +import * as ElectronApp from "../electron/ElectronApp.ts";
39 +import * as ElectronDialog from "../electron/ElectronDialog.ts";
40 +import * as ElectronProtocol from "../electron/ElectronProtocol.ts";
41 +import * as ElectronSafeStorage from "../electron/ElectronSafeStorage.ts";
42 +import * as PreviewPasskeys from "../preview/Passkeys.ts";
43 +import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";
44 +import * as DesktopShellEnvironment from "../shell/DesktopShellEnvironment.ts";
45 +import * as DesktopSnapShot from "../snapShot/DesktopSnapShot.ts";
46 +import * as DesktopRendererHistory from "../telemetry/DesktopRendererHistory.ts";
47 +import * as DesktopUpdates from "../updates/DesktopUpdates.ts";
48 +import * as DesktopApplicationMenu from "../window/DesktopApplicationMenu.ts";
49 +import * as DesktopWindow from "../window/DesktopWindow.ts";
50 +import * as DesktopWslBackend from "../wsl/DesktopWslBackend.ts";
51 +
52 +import * as BrowserImport from "../preview/BrowserImport/BrowserImport.ts";
53 +import * as DesktopBackendConfiguration from "../backend/DesktopBackendConfiguration.ts";
54 +import * as DesktopCliCommand from "./DesktopCliCommand.ts";
55 +import * as DesktopClientSettings from "../settings/DesktopClientSettings.ts";
56 +import * as DesktopConnectionCatalogStore from "./DesktopConnectionCatalogStore.ts";
57 +import * as DesktopIpc from "../ipc/DesktopIpc.ts";
58 +import * as DesktopLocalEnvironmentAuth from "../backend/DesktopLocalEnvironmentAuth.ts";
59 +import * as DesktopManagedPolicy from "./DesktopManagedPolicy.ts";
60 +import * as DesktopSshEnvironment from "../ssh/DesktopSshEnvironment.ts";
61 +import * as DesktopSshPasswordPrompts from "../ssh/DesktopSshPasswordPrompts.ts";
62 +import * as DesktopTelemetryPublisher from "../telemetry/DesktopTelemetryPublisher.ts";
63 +import * as DesktopWebLinks from "./DesktopWebLinks.ts";
64 +import * as DesktopWslEnvironment from "../wsl/DesktopWslEnvironment.ts";
65 +import * as ElectronMenu from "../electron/ElectronMenu.ts";
66 +import * as ElectronShell from "../electron/ElectronShell.ts";
67 +import * as ElectronTheme from "../electron/ElectronTheme.ts";
68 +import * as ElectronWindow from "../electron/ElectronWindow.ts";
69 +import * as MacPermissions from "../permissions/MacPermissions.ts";
70 +import * as PreviewManager from "../preview/Manager.ts";
71 +
72 +it.effect(
73 + "starts the backend and window while Linux registration is stalled and cancels it on shutdown",
74 + () =>
75 + Effect.gen(function* () {
76 + const registrationStarted = yield* Deferred.make<void>();
77 + const releaseRegistration = yield* Deferred.make<void>();
78 + const registrationStopped = yield* Deferred.make<void>();
79 + const windowStarted = yield* Deferred.make<void>();
80 + const quitting = yield* Ref.make(false);
81 + const events: string[] = [];
82 + const record = (event: string) =>
83 + Effect.sync(() => {
84 + events.push(event);
85 + });
86 + const runApp = DesktopApp.program
87 + .pipe(
88 + Effect.provide(NodeCrypto.layer),
89 + Effect.provideService(DesktopAppIdentity.DesktopAppIdentity, {
90 + resolveUserDataPath: Effect.succeed("/isolated/userdata"),
91 + configure: record("identity"),
92 + } as DesktopAppIdentity.DesktopAppIdentity["Service"]),
93 + Effect.provideService(ElectronApp.ElectronApp, {
94 + setPath: () => Effect.void,
95 + whenReady: record("ready"),
96 + } as unknown as ElectronApp.ElectronApp["Service"]),
97 + Effect.provideService(ElectronDialog.ElectronDialog, {
98 + showErrorBox: () => Effect.die("unexpected fatal startup error"),
99 + } as unknown as ElectronDialog.ElectronDialog["Service"]),
100 + Effect.provideService(DesktopEnvironment.DesktopEnvironment, {
101 + platform: "linux",
102 + isDevelopment: false,
103 + isPackaged: true,
104 + configuredBackendPort: Option.some(3773),
105 + defaultDesktopSettings: { serverExposureMode: "local-only" },
106 + } as unknown as DesktopEnvironment.DesktopEnvironment["Service"]),
107 + Effect.provideService(DesktopPreReadyPlatform.DesktopPreReadyElectronOptions, {
108 + linux: null,
109 + linuxPasswordStoreCommandLine: "basic",
110 + }),
111 + Effect.provideService(DesktopShellEnvironment.DesktopShellEnvironment, {
112 + installIntoProcess: Effect.succeed(true),
113 + awaitDiscovery: Effect.succeed(true),
114 + updates: Stream.empty,
115 + }),
116 + Effect.provideService(DesktopAppSettings.DesktopAppSettings, {
117 + load: Effect.void,
118 + get: Effect.succeed({
119 + localEnvironmentEnabled: true,
120 + serverExposureMode: "local-only",
121 + }),
122 + } as unknown as DesktopAppSettings.DesktopAppSettings["Service"]),
123 + Effect.provideService(DesktopLifecycle.DesktopLifecycle, {
124 + register: Effect.void,
125 + relaunch: () => Effect.void,
126 + }),
127 + Effect.provideService(DesktopClerk.DesktopClerk, {
128 + configure: Effect.void,
129 + } as DesktopClerk.DesktopClerk["Service"]),
130 + Effect.provideService(ElectronSafeStorage.ElectronSafeStorage, {
131 + selectedStorageBackend: Effect.succeedNone,
132 + } as unknown as ElectronSafeStorage.ElectronSafeStorage["Service"]),
133 + Effect.provideService(PreviewPasskeys.PreviewPasskeys, {
134 + configure: Effect.void,
135 + } as PreviewPasskeys.PreviewPasskeys["Service"]),
136 + Effect.provideService(DesktopApplicationMenu.DesktopApplicationMenu, {
137 + configure: Effect.void,
138 + }),
139 + Effect.provideService(DesktopUpdates.DesktopUpdates, {
140 + configure: Effect.void,
141 + } as unknown as DesktopUpdates.DesktopUpdates["Service"]),
142 + Effect.provideService(DesktopLinuxUrlHandler.DesktopLinuxUrlHandler, {
143 + register: Deferred.succeed(registrationStarted, undefined).pipe(
144 + Effect.andThen(Deferred.await(releaseRegistration)),
145 + Effect.ensuring(Deferred.succeed(registrationStopped, undefined)),
146 + ),
147 + }),
148 + )
149 + .pipe(
150 + Effect.provideService(ElectronProtocol.ElectronProtocol, {
151 + registerDesktopProtocol: () => Effect.void,
152 + } as unknown as ElectronProtocol.ElectronProtocol["Service"]),
153 + Effect.provideService(DesktopLegacyLocalStorage.DesktopLegacyLocalStorage, {
154 + load: () => Effect.void,
155 + } as unknown as DesktopLegacyLocalStorage.DesktopLegacyLocalStorage["Service"]),
156 + Effect.provideService(DesktopSnapShot.DesktopSnapShot, {
157 + initialize: Effect.void,
158 + } as DesktopSnapShot.DesktopSnapShot["Service"]),
159 + Effect.provideService(DesktopState.DesktopState, {
160 + quitting,
161 + } as DesktopState.DesktopState["Service"]),
162 + Effect.provideService(DesktopWindow.DesktopWindow, {
163 + ensureMain: record("window").pipe(
164 + Effect.andThen(Deferred.succeed(windowStarted, undefined)),
165 + ),
166 + } as unknown as DesktopWindow.DesktopWindow["Service"]),
167 + Effect.provideService(DesktopBackendPool.DesktopBackendPool, {
168 + primary: Effect.succeed({
169 + start: record("backend"),
170 + currentConfig: Effect.succeedSome({ preflightFailure: Option.none() }),
171 + }),
172 + list: Effect.succeed([]),
173 + } as unknown as DesktopBackendPool.DesktopBackendPool["Service"]),
174 + Effect.provideService(DesktopServerExposure.DesktopServerExposure, {
175 + configureFromSettings: () => Effect.succeed({ mode: "local-only" }),
176 + backendConfig: Effect.succeed({ httpBaseUrl: new URL("http://127.0.0.1:3773") }),
177 + } as unknown as DesktopServerExposure.DesktopServerExposure["Service"]),
178 + Effect.provideService(DesktopWslBackend.DesktopWslBackend, {
179 + reconcile: Effect.void,
180 + } as DesktopWslBackend.DesktopWslBackend["Service"]),
181 + Effect.provideService(DesktopAppActivation.DesktopAppActivation, {
182 + start: Effect.void,
183 + } as unknown as DesktopAppActivation.DesktopAppActivation["Service"]),
184 + Effect.provideService(DesktopRendererHistory.DesktopRendererHistory, {
185 + shutdown: Effect.void,
186 + } as DesktopRendererHistory.DesktopRendererHistory["Service"]),
187 + );
188 + const app = yield* runApp.pipe(
189 + Effect.provide(
190 + Layer.mergeAll(
191 + Layer.mock(BrowserImport.BrowserImport, {}),
192 + Layer.mock(DesktopBackendConfiguration.DesktopBackendConfiguration, {}),
193 + Layer.mock(DesktopCliCommand.DesktopCliCommand, {}),
194 + Layer.mock(DesktopClientSettings.DesktopClientSettings, {}),
195 + Layer.mock(DesktopConnectionCatalogStore.DesktopConnectionCatalogStore, {}),
196 + Layer.mock(DesktopIpc.DesktopIpc, {}),
197 + Layer.mock(DesktopLocalEnvironmentAuth.DesktopLocalEnvironmentAuth, {}),
198 + Layer.mock(DesktopManagedPolicy.DesktopManagedPolicy, {}),
199 + Layer.mock(DesktopSshEnvironment.DesktopSshEnvironment, {}),
200 + Layer.mock(DesktopSshPasswordPrompts.DesktopSshPasswordPrompts, {}),
201 + Layer.mock(DesktopTelemetryPublisher.DesktopTelemetryPublisher, {}),
202 + Layer.mock(DesktopWebLinks.DesktopWebLinks, {}),
203 + Layer.mock(DesktopWslEnvironment.DesktopWslEnvironment, {}),
204 + Layer.mock(ElectronMenu.ElectronMenu, {}),
205 + Layer.mock(ElectronShell.ElectronShell, {}),
206 + Layer.mock(ElectronTheme.ElectronTheme, {}),
207 + Layer.mock(ElectronWindow.ElectronWindow, {}),
208 + Layer.mock(MacPermissions.MacPermissions, {}),
209 + Layer.mock(PreviewManager.PreviewManager, {
210 + isBrowserPartition: () => {
211 + throw new Error("unexpected browser partition lookup");
212 + },
213 + }),
214 + FileSystem.layerNoop({}),
215 + Layer.mock(NetService.NetService, {}),
216 + Path.layer,
217 + Layer.succeed(
218 + HttpClient.HttpClient,
219 + HttpClient.make(() => Effect.die("unexpected HTTP request")),
220 + ),
221 + ),
222 + ),
223 + Effect.forkScoped,
224 + );
225 + yield* Deferred.await(registrationStarted);
226 + yield* Deferred.await(windowStarted);
227 + assert.deepEqual(events, ["identity", "ready", "identity", "backend", "window"]);
228 + assert.isFalse(yield* Deferred.isDone(registrationStopped));
229 + yield* (yield* DesktopShutdown.DesktopShutdown).request;
230 + yield* Fiber.join(app);
231 + assert.isTrue(yield* Deferred.isDone(registrationStopped));
232 + }).pipe(Effect.provide(DesktopShutdown.layer)),
233 +);
apps/desktop/src/app/DesktopApp.ts
+2 -1
@@ -337,7 +337,8 @@ const startup = Effect.gen(function* () {
337 yield* updates.configure;
338 yield* DesktopRemoteUpdates.listen;
339 yield* DesktopStartupRecovery.listen;
340 - yield* linuxUrlHandler.register;
340 + // Portal identity is prepared pre-ready; MIME helpers must not gate the backend or window.
341 + yield* linuxUrlHandler.register.pipe(Effect.forkScoped);
342 yield* bootstrap.pipe(Effect.catchCause((cause) => fatalStartupCause("bootstrap", cause)));
343 }).pipe(Effect.withSpan("desktop.startup"));
344