@devries-cameron20 / t3code Mirror · read-only / commits / acddfae513
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, 09:45 UTC

fix(desktop): opening the app refreshes the t3 launcher with Local environment off (#31522)

Julius Marminge committed Nov 16, 2026 at 13:40 UTC acddfae5139ac0bda3300af4440b8f9bbea7a7de
2 files changed +258 -167
apps/desktop/src/app/DesktopApp.test.ts
+255 -167
@@ -1,5 +1,6 @@
1 import { assert, it } from "@effect/vitest";
2 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
3 +import * as NodeServices from "@effect/platform-node/NodeServices";
4 import * as Deferred from "effect/Deferred";
5 import * as Effect from "effect/Effect";
6 import * as Exit from "effect/Exit";
@@ -54,6 +55,7 @@ import * as DesktopWslBackend from "../wsl/DesktopWslBackend.ts";
55 import * as BrowserImport from "../preview/BrowserImport/BrowserImport.ts";
56 import * as DesktopBackendConfiguration from "../backend/DesktopBackendConfiguration.ts";
57 import * as DesktopCliCommand from "./DesktopCliCommand.ts";
58 +import * as DesktopCliShim from "./DesktopCliShim.ts";
59 import * as DesktopClientSettings from "../settings/DesktopClientSettings.ts";
60 import * as DesktopConnectionCatalogStore from "./DesktopConnectionCatalogStore.ts";
61 import * as DesktopIpc from "../ipc/DesktopIpc.ts";
@@ -72,6 +74,178 @@ import * as ElectronWindow from "../electron/ElectronWindow.ts";
74 import * as MacPermissions from "../permissions/MacPermissions.ts";
75 import * as PreviewManager from "../preview/Manager.ts";
76
77 +interface StubbedDesktop {
78 + readonly localEnvironmentEnabled: boolean;
79 + readonly environment: Partial<DesktopEnvironment.DesktopEnvironment["Service"]>;
80 + readonly fileSystem: Layer.Layer<FileSystem.FileSystem>;
81 + readonly record: (event: string) => Effect.Effect<void>;
82 + readonly windowStarted: Deferred.Deferred<void>;
83 + readonly registerLinuxUrlHandler: Effect.Effect<void>;
84 + readonly backends?: ReadonlyArray<{ readonly stop: () => Effect.Effect<void> }>;
85 + readonly flushRendererHistory?: Effect.Effect<void>;
86 + readonly tokenRequested?: Deferred.Deferred<void>;
87 +}
88 +
89 +const runStubbedDesktop = (stub: StubbedDesktop) =>
90 + Effect.gen(function* () {
91 + const quitting = yield* Ref.make(false);
92 + const runApp = DesktopApp.program
93 + .pipe(
94 + Effect.provide(NodeCrypto.layer),
95 + Effect.provideService(DesktopAppIdentity.DesktopAppIdentity, {
96 + resolveUserDataPath: Effect.succeed("/isolated/userdata"),
97 + configure: stub.record("identity"),
98 + } as DesktopAppIdentity.DesktopAppIdentity["Service"]),
99 + Effect.provideService(ElectronApp.ElectronApp, {
100 + setPath: () => Effect.void,
101 + whenReady: stub.record("ready"),
102 + } as unknown as ElectronApp.ElectronApp["Service"]),
103 + Effect.provideService(ElectronDialog.ElectronDialog, {
104 + showErrorBox: () => Effect.die("unexpected fatal startup error"),
105 + } as unknown as ElectronDialog.ElectronDialog["Service"]),
106 + Effect.provideService(DesktopEnvironment.DesktopEnvironment, {
107 + platform: "linux",
108 + isDevelopment: false,
109 + isPackaged: true,
110 + stateDir: "/isolated/userdata",
111 + configuredBackendPort: Option.some(3773),
112 + defaultDesktopSettings: { serverExposureMode: "local-only" },
113 + ...stub.environment,
114 + } as unknown as DesktopEnvironment.DesktopEnvironment["Service"]),
115 + Effect.provideService(DesktopPreReadyPlatform.DesktopPreReadyElectronOptions, {
116 + linux: null,
117 + linuxPasswordStoreCommandLine: "basic",
118 + }),
119 + Effect.provideService(DesktopShellEnvironment.DesktopShellEnvironment, {
120 + installIntoProcess: Effect.succeed(true),
121 + awaitDiscovery: Effect.succeed(true),
122 + awaitUserShellDiscovery: Effect.succeed(true),
123 + updates: Stream.empty,
124 + }),
125 + Effect.provideService(DesktopAppSettings.DesktopAppSettings, {
126 + load: Effect.void,
127 + get: Effect.succeed({
128 + localEnvironmentEnabled: stub.localEnvironmentEnabled,
129 + serverExposureMode: "local-only",
130 + }),
131 + } as unknown as DesktopAppSettings.DesktopAppSettings["Service"]),
132 + Effect.provideService(DesktopLifecycle.DesktopLifecycle, {
133 + register: Effect.void,
134 + relaunch: () => Effect.void,
135 + }),
136 + Effect.provideService(DesktopClerk.DesktopClerk, {
137 + configure: Effect.void,
138 + } as DesktopClerk.DesktopClerk["Service"]),
139 + Effect.provideService(ElectronSafeStorage.ElectronSafeStorage, {
140 + selectedStorageBackend: Effect.succeedNone,
141 + } as unknown as ElectronSafeStorage.ElectronSafeStorage["Service"]),
142 + Effect.provideService(PreviewPasskeys.PreviewPasskeys, {
143 + configure: Effect.void,
144 + } as PreviewPasskeys.PreviewPasskeys["Service"]),
145 + Effect.provideService(DesktopApplicationMenu.DesktopApplicationMenu, {
146 + configure: stub.record("menu"),
147 + }),
148 + Effect.provideService(DesktopUpdates.DesktopUpdates, {
149 + configure: Effect.void,
150 + } as unknown as DesktopUpdates.DesktopUpdates["Service"]),
151 + Effect.provideService(DesktopLinuxUrlHandler.DesktopLinuxUrlHandler, {
152 + register: stub.registerLinuxUrlHandler,
153 + }),
154 + )
155 + .pipe(
156 + Effect.provideService(ElectronProtocol.ElectronProtocol, {
157 + registerDesktopProtocol: () => Effect.void,
158 + } as unknown as ElectronProtocol.ElectronProtocol["Service"]),
159 + Effect.provideService(DesktopLegacyLocalStorage.DesktopLegacyLocalStorage, {
160 + load: () => Effect.void,
161 + } as unknown as DesktopLegacyLocalStorage.DesktopLegacyLocalStorage["Service"]),
162 + Effect.provideService(DesktopSnapShot.DesktopSnapShot, {
163 + initialize: Effect.void,
164 + } as DesktopSnapShot.DesktopSnapShot["Service"]),
165 + Effect.provideService(DesktopState.DesktopState, {
166 + quitting,
167 + } as DesktopState.DesktopState["Service"]),
168 + Effect.provideService(DesktopWindow.DesktopWindow, {
169 + ensureMain: stub
170 + .record("window")
171 + .pipe(Effect.andThen(Deferred.succeed(stub.windowStarted, undefined))),
172 + createMainIfBackendReady: stub
173 + .record("window")
174 + .pipe(Effect.andThen(Deferred.succeed(stub.windowStarted, undefined))),
175 + } as unknown as DesktopWindow.DesktopWindow["Service"]),
176 + Effect.provideService(DesktopBackendPool.DesktopBackendPool, {
177 + primary: Effect.succeed({
178 + start: stub.record("backend"),
179 + currentConfig: Effect.succeedSome({ preflightFailure: Option.none() }),
180 + }),
181 + list: Effect.succeed(stub.backends ?? []),
182 + } as unknown as DesktopBackendPool.DesktopBackendPool["Service"]),
183 + Effect.provideService(DesktopServerExposure.DesktopServerExposure, {
184 + configureFromSettings: () => Effect.succeed({ mode: "local-only" }),
185 + backendConfig: Effect.succeed({ httpBaseUrl: new URL("http://127.0.0.1:3773") }),
186 + } as unknown as DesktopServerExposure.DesktopServerExposure["Service"]),
187 + Effect.provideService(DesktopWslBackend.DesktopWslBackend, {
188 + reconcile: Effect.void,
189 + } as DesktopWslBackend.DesktopWslBackend["Service"]),
190 + Effect.provideService(DesktopAppActivation.DesktopAppActivation, {
191 + start: Effect.void,
192 + } as unknown as DesktopAppActivation.DesktopAppActivation["Service"]),
193 + Effect.provideService(DesktopRendererHistory.DesktopRendererHistory, {
194 + shutdown: stub.flushRendererHistory ?? Effect.void,
195 + } as DesktopRendererHistory.DesktopRendererHistory["Service"]),
196 + );
197 + return yield* runApp.pipe(
198 + Effect.provide(
199 + Layer.mergeAll(
200 + Layer.mock(BrowserImport.BrowserImport, {}),
201 + Layer.mock(ChildProcessSpawner.ChildProcessSpawner, {}),
202 + Layer.mock(DesktopBackendConfiguration.DesktopBackendConfiguration, {}),
203 + Layer.mock(DesktopCliCommand.DesktopCliCommand, {}),
204 + Layer.mock(DesktopClientSettings.DesktopClientSettings, {}),
205 + Layer.mock(DesktopConnectionCatalogStore.DesktopConnectionCatalogStore, {}),
206 + Layer.mock(DesktopIpc.DesktopIpc, {}),
207 + Layer.mock(DesktopLocalEnvironmentAuth.DesktopLocalEnvironmentAuth, {
208 + getBearerToken: stub
209 + .record("token")
210 + .pipe(
211 + Effect.andThen(
212 + stub.tokenRequested
213 + ? Deferred.succeed(stub.tokenRequested, undefined)
214 + : Effect.void,
215 + ),
216 + Effect.as("token"),
217 + ),
218 + }),
219 + Layer.mock(DesktopManagedPolicy.DesktopManagedPolicy, {}),
220 + Layer.succeed(DesktopPrimaryPaste.DesktopPrimaryPaste, { enabled: true }),
221 + Layer.mock(DesktopSshEnvironment.DesktopSshEnvironment, {}),
222 + Layer.mock(DesktopSshPasswordPrompts.DesktopSshPasswordPrompts, {}),
223 + Layer.mock(DesktopTelemetryPublisher.DesktopTelemetryPublisher, {}),
224 + Layer.mock(DesktopWebLinks.DesktopWebLinks, {}),
225 + Layer.mock(DesktopWslEnvironment.DesktopWslEnvironment, {}),
226 + Layer.mock(ElectronMenu.ElectronMenu, {}),
227 + Layer.mock(ElectronShell.ElectronShell, {}),
228 + Layer.mock(ElectronTheme.ElectronTheme, {}),
229 + Layer.mock(ElectronWindow.ElectronWindow, {}),
230 + Layer.mock(MacPermissions.MacPermissions, {}),
231 + Layer.mock(PreviewManager.PreviewManager, {
232 + isBrowserPartition: () => {
233 + throw new Error("unexpected browser partition lookup");
234 + },
235 + }),
236 + stub.fileSystem,
237 + Layer.mock(NetService.NetService, {}),
238 + Path.layer,
239 + Layer.succeed(
240 + HttpClient.HttpClient,
241 + HttpClient.make(() => Effect.die("unexpected HTTP request")),
242 + ),
243 + ),
244 + ),
245 + Effect.forkScoped,
246 + );
247 + });
248 +
249 it.effect.each([false, true])(
250 "stops backends together before flushing history and cancels Linux registration, stop defect=%s",
251 (stopDefect) =>
@@ -85,178 +259,42 @@ it.effect.each([false, true])(
259 const releaseStops = yield* Deferred.make<void>();
260 const historyStarted = yield* Deferred.make<void>();
261 const releaseHistory = yield* Deferred.make<void>();
88 - const quitting = yield* Ref.make(false);
262 const tokenRequested = yield* Deferred.make<void>();
263 const events: string[] = [];
91 - const record = (event: string) =>
92 - Effect.sync(() => {
93 - events.push(event);
94 - });
95 - const runApp = DesktopApp.program
96 - .pipe(
97 - Effect.provide(NodeCrypto.layer),
98 - Effect.provideService(DesktopAppIdentity.DesktopAppIdentity, {
99 - resolveUserDataPath: Effect.succeed("/isolated/userdata"),
100 - configure: record("identity"),
101 - } as DesktopAppIdentity.DesktopAppIdentity["Service"]),
102 - Effect.provideService(ElectronApp.ElectronApp, {
103 - setPath: () => Effect.void,
104 - whenReady: record("ready"),
105 - } as unknown as ElectronApp.ElectronApp["Service"]),
106 - Effect.provideService(ElectronDialog.ElectronDialog, {
107 - showErrorBox: () => Effect.die("unexpected fatal startup error"),
108 - } as unknown as ElectronDialog.ElectronDialog["Service"]),
109 - Effect.provideService(DesktopEnvironment.DesktopEnvironment, {
110 - platform: "linux",
111 - isDevelopment: false,
112 - isPackaged: true,
113 - stateDir: "/isolated/userdata",
114 - configuredBackendPort: Option.some(3773),
115 - defaultDesktopSettings: { serverExposureMode: "local-only" },
116 - } as unknown as DesktopEnvironment.DesktopEnvironment["Service"]),
117 - Effect.provideService(DesktopPreReadyPlatform.DesktopPreReadyElectronOptions, {
118 - linux: null,
119 - linuxPasswordStoreCommandLine: "basic",
120 - }),
121 - Effect.provideService(DesktopShellEnvironment.DesktopShellEnvironment, {
122 - installIntoProcess: Effect.succeed(true),
123 - awaitDiscovery: Effect.succeed(true),
124 - awaitUserShellDiscovery: Effect.succeed(true),
125 - updates: Stream.empty,
264 + const app = yield* runStubbedDesktop({
265 + localEnvironmentEnabled: true,
266 + environment: {},
267 + fileSystem: FileSystem.layerNoop({}),
268 + record: (event) =>
269 + Effect.sync(() => {
270 + events.push(event);
271 }),
127 - Effect.provideService(DesktopAppSettings.DesktopAppSettings, {
128 - load: Effect.void,
129 - get: Effect.succeed({
130 - localEnvironmentEnabled: true,
131 - serverExposureMode: "local-only",
132 - }),
133 - } as unknown as DesktopAppSettings.DesktopAppSettings["Service"]),
134 - Effect.provideService(DesktopLifecycle.DesktopLifecycle, {
135 - register: Effect.void,
136 - relaunch: () => Effect.void,
137 - }),
138 - Effect.provideService(DesktopClerk.DesktopClerk, {
139 - configure: Effect.void,
140 - } as DesktopClerk.DesktopClerk["Service"]),
141 - Effect.provideService(ElectronSafeStorage.ElectronSafeStorage, {
142 - selectedStorageBackend: Effect.succeedNone,
143 - } as unknown as ElectronSafeStorage.ElectronSafeStorage["Service"]),
144 - Effect.provideService(PreviewPasskeys.PreviewPasskeys, {
145 - configure: Effect.void,
146 - } as PreviewPasskeys.PreviewPasskeys["Service"]),
147 - Effect.provideService(DesktopApplicationMenu.DesktopApplicationMenu, {
148 - configure: record("menu"),
149 - }),
150 - Effect.provideService(DesktopUpdates.DesktopUpdates, {
151 - configure: Effect.void,
152 - } as unknown as DesktopUpdates.DesktopUpdates["Service"]),
153 - Effect.provideService(DesktopLinuxUrlHandler.DesktopLinuxUrlHandler, {
154 - register: Deferred.succeed(registrationStarted, undefined).pipe(
155 - Effect.andThen(Deferred.await(releaseRegistration)),
156 - Effect.ensuring(Deferred.succeed(registrationStopped, undefined)),
157 - ),
158 - }),
159 - )
160 - .pipe(
161 - Effect.provideService(ElectronProtocol.ElectronProtocol, {
162 - registerDesktopProtocol: () => Effect.void,
163 - } as unknown as ElectronProtocol.ElectronProtocol["Service"]),
164 - Effect.provideService(DesktopLegacyLocalStorage.DesktopLegacyLocalStorage, {
165 - load: () => Effect.void,
166 - } as unknown as DesktopLegacyLocalStorage.DesktopLegacyLocalStorage["Service"]),
167 - Effect.provideService(DesktopSnapShot.DesktopSnapShot, {
168 - initialize: Effect.void,
169 - } as DesktopSnapShot.DesktopSnapShot["Service"]),
170 - Effect.provideService(DesktopState.DesktopState, {
171 - quitting,
172 - } as DesktopState.DesktopState["Service"]),
173 - Effect.provideService(DesktopWindow.DesktopWindow, {
174 - ensureMain: record("window").pipe(
175 - Effect.andThen(Deferred.succeed(windowStarted, undefined)),
176 - ),
177 - } as unknown as DesktopWindow.DesktopWindow["Service"]),
178 - Effect.provideService(DesktopBackendPool.DesktopBackendPool, {
179 - primary: Effect.succeed({
180 - start: record("backend"),
181 - currentConfig: Effect.succeedSome({ preflightFailure: Option.none() }),
182 - }),
183 - list: Effect.succeed([
184 - {
185 - stop: () =>
186 - Deferred.succeed(firstStopStarted, undefined).pipe(
187 - Effect.andThen(Deferred.await(releaseStops)),
188 - Effect.andThen(stopDefect ? Effect.die("stop defect") : Effect.void),
189 - ),
190 - },
191 - {
192 - stop: () =>
193 - Deferred.succeed(secondStopStarted, undefined).pipe(
194 - Effect.andThen(Deferred.await(releaseStops)),
195 - ),
196 - },
197 - ]),
198 - } as unknown as DesktopBackendPool.DesktopBackendPool["Service"]),
199 - Effect.provideService(DesktopServerExposure.DesktopServerExposure, {
200 - configureFromSettings: () => Effect.succeed({ mode: "local-only" }),
201 - backendConfig: Effect.succeed({ httpBaseUrl: new URL("http://127.0.0.1:3773") }),
202 - } as unknown as DesktopServerExposure.DesktopServerExposure["Service"]),
203 - Effect.provideService(DesktopWslBackend.DesktopWslBackend, {
204 - reconcile: Effect.void,
205 - } as DesktopWslBackend.DesktopWslBackend["Service"]),
206 - Effect.provideService(DesktopAppActivation.DesktopAppActivation, {
207 - start: Effect.void,
208 - } as unknown as DesktopAppActivation.DesktopAppActivation["Service"]),
209 - Effect.provideService(DesktopRendererHistory.DesktopRendererHistory, {
210 - shutdown: Deferred.succeed(historyStarted, undefined).pipe(
211 - Effect.andThen(Deferred.await(releaseHistory)),
212 - Effect.asVoid,
213 - ),
214 - } as DesktopRendererHistory.DesktopRendererHistory["Service"]),
215 - );
216 - const app = yield* runApp.pipe(
217 - Effect.provide(
218 - Layer.mergeAll(
219 - Layer.mock(BrowserImport.BrowserImport, {}),
220 - Layer.mock(ChildProcessSpawner.ChildProcessSpawner, {}),
221 - Layer.mock(DesktopBackendConfiguration.DesktopBackendConfiguration, {}),
222 - Layer.mock(DesktopCliCommand.DesktopCliCommand, {}),
223 - Layer.mock(DesktopClientSettings.DesktopClientSettings, {}),
224 - Layer.mock(DesktopConnectionCatalogStore.DesktopConnectionCatalogStore, {}),
225 - Layer.mock(DesktopIpc.DesktopIpc, {}),
226 - Layer.mock(DesktopLocalEnvironmentAuth.DesktopLocalEnvironmentAuth, {
227 - getBearerToken: record("token").pipe(
228 - Effect.andThen(Deferred.succeed(tokenRequested, undefined)),
229 - Effect.as("token"),
272 + windowStarted,
273 + tokenRequested,
274 + registerLinuxUrlHandler: Deferred.succeed(registrationStarted, undefined).pipe(
275 + Effect.andThen(Deferred.await(releaseRegistration)),
276 + Effect.ensuring(Deferred.succeed(registrationStopped, undefined)),
277 + ),
278 + backends: [
279 + {
280 + stop: () =>
281 + Deferred.succeed(firstStopStarted, undefined).pipe(
282 + Effect.andThen(Deferred.await(releaseStops)),
283 + Effect.andThen(stopDefect ? Effect.die("stop defect") : Effect.void),
284 ),
231 - }),
232 - Layer.mock(DesktopManagedPolicy.DesktopManagedPolicy, {}),
233 - Layer.succeed(DesktopPrimaryPaste.DesktopPrimaryPaste, { enabled: true }),
234 - Layer.mock(DesktopSshEnvironment.DesktopSshEnvironment, {}),
235 - Layer.mock(DesktopSshPasswordPrompts.DesktopSshPasswordPrompts, {}),
236 - Layer.mock(DesktopTelemetryPublisher.DesktopTelemetryPublisher, {}),
237 - Layer.mock(DesktopWebLinks.DesktopWebLinks, {}),
238 - Layer.mock(DesktopWslEnvironment.DesktopWslEnvironment, {}),
239 - Layer.mock(ElectronMenu.ElectronMenu, {}),
240 - Layer.mock(ElectronShell.ElectronShell, {}),
241 - Layer.mock(ElectronTheme.ElectronTheme, {}),
242 - Layer.mock(ElectronWindow.ElectronWindow, {}),
243 - Layer.mock(MacPermissions.MacPermissions, {}),
244 - Layer.mock(PreviewManager.PreviewManager, {
245 - isBrowserPartition: () => {
246 - throw new Error("unexpected browser partition lookup");
247 - },
248 - }),
249 - FileSystem.layerNoop({}),
250 - Layer.mock(NetService.NetService, {}),
251 - Path.layer,
252 - Layer.succeed(
253 - HttpClient.HttpClient,
254 - HttpClient.make(() => Effect.die("unexpected HTTP request")),
255 - ),
256 - ),
285 + },
286 + {
287 + stop: () =>
288 + Deferred.succeed(secondStopStarted, undefined).pipe(
289 + Effect.andThen(Deferred.await(releaseStops)),
290 + ),
291 + },
292 + ],
293 + flushRendererHistory: Deferred.succeed(historyStarted, undefined).pipe(
294 + Effect.andThen(Deferred.await(releaseHistory)),
295 + Effect.asVoid,
296 ),
258 - Effect.forkScoped,
259 - );
297 + });
298 yield* Deferred.await(registrationStarted);
299 yield* Deferred.await(windowStarted);
300 yield* Deferred.await(tokenRequested);
@@ -283,3 +321,53 @@ it.effect.each([false, true])(
321 assert.isTrue(yield* Deferred.isDone(registrationStopped));
322 }).pipe(Effect.provide(DesktopShutdown.layer)),
323 );
324 +
325 +it.effect("points a stale t3 launcher at the updated AppImage with Local environment off", () =>
326 + Effect.gen(function* () {
327 + const fs = yield* FileSystem.FileSystem;
328 + const path = yield* Path.Path;
329 + const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-desktop-app-" });
330 + const launcher = DesktopCliShim.launcherPath({
331 + path,
332 + baseDir,
333 + platform: "linux",
334 + } as DesktopEnvironment.DesktopEnvironment["Service"]);
335 + const removedAppImage = path.join(baseDir, "T3-Code-0.1.6-x86_64.AppImage");
336 + const updatedAppImage = path.join(baseDir, "T3-Code-0.1.7-x86_64.AppImage");
337 + yield* fs.makeDirectory(path.dirname(launcher), { recursive: true });
338 + yield* fs.writeFileString(
339 + launcher,
340 + DesktopCliShim.renderCliShim({
341 + target: { kind: "appimage", appImage: removedAppImage, executableName: "t3code" },
342 + shimPath: launcher,
343 + t3Home: baseDir,
344 + }),
345 + );
346 + yield* fs.writeFileString(updatedAppImage, "", { mode: 0o755 });
347 + const windowStarted = yield* Deferred.make<void>();
348 +
349 + const app = yield* runStubbedDesktop({
350 + localEnvironmentEnabled: false,
351 + environment: {
352 + path,
353 + baseDir,
354 + serverRoot: path.join(baseDir, "resources", "app.asar"),
355 + appImagePath: Option.some(updatedAppImage),
356 + },
357 + fileSystem: Layer.succeed(FileSystem.FileSystem, fs),
358 + record: () => Effect.void,
359 + windowStarted,
360 + registerLinuxUrlHandler: Effect.void,
361 + });
362 + yield* Deferred.await(windowStarted);
363 + yield* (yield* DesktopShutdown.DesktopShutdown).request;
364 + yield* Fiber.join(app);
365 +
366 + const content = yield* fs.readFileString(launcher);
367 + assert.include(
368 + content,
369 + `app='${updatedAppImage}'`,
370 + "startup left the t3 launcher pointing at the removed AppImage",
371 + );
372 + }).pipe(Effect.provide(Layer.mergeAll(DesktopShutdown.layer, NodeServices.layer))),
373 +);
apps/desktop/src/app/DesktopApp.ts
+3
@@ -15,6 +15,7 @@ import { installDesktopIpcHandlers } from "../ipc/DesktopIpcHandlers.ts";
15 import * as DesktopAppActivation from "./DesktopAppActivation.ts";
16 import * as DesktopAppIdentity from "./DesktopAppIdentity.ts";
17 import * as DesktopClerk from "./DesktopClerk.ts";
18 +import * as DesktopCliShim from "./DesktopCliShim.ts";
19 import * as DesktopCliCommand from "./DesktopCliCommand.ts";
20 import * as DesktopApplicationMenu from "../window/DesktopApplicationMenu.ts";
21 import * as DesktopWindow from "../window/DesktopWindow.ts";
@@ -301,6 +302,8 @@ const bootstrap = Effect.fn("desktop.bootstrap")(function* (backendStarted: bool
302 );
303
304 if (!settings.localEnvironmentEnabled) {
305 + // The backend config refreshes the launcher when the local environment runs; an update may move the app.
306 + yield* DesktopCliShim.install;
307 if (!(yield* Ref.get(state.quitting))) {
308 yield* desktopWindow.createMainIfBackendReady;
309 }