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
}