@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 389 lines 18.5 KB
Raw
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";
7 import * as Layer from "effect/Layer";
8 import * as FileSystem from "effect/FileSystem";
9 import * as Path from "effect/Path";
10 import * as HttpClient from "effect/http/HttpClient";
11 import { ChildProcessSpawner } from "effect/process";
12 import * as NetService from "@t3tools/shared/Net";
13 import * as Fiber from "effect/Fiber";
14 import * as Option from "effect/Option";
15 import * as Ref from "effect/Ref";
16 import * as Stream from "effect/Stream";
17 import { vi } from "vite-plus/test";
18
19 vi.mock("electron", () => ({}));
20 vi.mock("@clerk/electron", () => ({ createClerkBridge: vi.fn() }));
21 vi.mock("@clerk/electron/storage", () => ({ storage: vi.fn() }));
22 vi.mock("../ipc/DesktopIpcHandlers.ts", () => ({
23 installDesktopIpcHandlers: () => Effect.void,
24 }));
25 vi.mock("../updates/DesktopRemoteUpdates.ts", () => ({ listen: Effect.void }));
26 vi.mock("./DesktopStartupRecovery.ts", () => ({ listen: Effect.void }));
27
28 import * as DesktopApp from "./DesktopApp.ts";
29 import * as DesktopAppActivation from "./DesktopAppActivation.ts";
30 import * as DesktopAppIdentity from "./DesktopAppIdentity.ts";
31 import * as DesktopClerk from "./DesktopClerk.ts";
32 import * as DesktopEnvironment from "./DesktopEnvironment.ts";
33 import * as DesktopLegacyLocalStorage from "./DesktopLegacyLocalStorage.ts";
34 import * as DesktopLifecycle from "./DesktopLifecycle.ts";
35 import * as DesktopLinuxUrlHandler from "./DesktopLinuxUrlHandler.ts";
36 import * as DesktopPreReadyPlatform from "./DesktopPreReadyPlatform.ts";
37 import * as DesktopShutdown from "./DesktopShutdown.ts";
38 import * as DesktopState from "./DesktopState.ts";
39 import * as DesktopBackendPool from "../backend/DesktopBackendPool.ts";
40 import * as DesktopServerExposure from "../backend/DesktopServerExposure.ts";
41 import * as ElectronApp from "../electron/ElectronApp.ts";
42 import * as ElectronDialog from "../electron/ElectronDialog.ts";
43 import * as ElectronProtocol from "../electron/ElectronProtocol.ts";
44 import * as ElectronSafeStorage from "../electron/ElectronSafeStorage.ts";
45 import * as PreviewPasskeys from "../preview/Passkeys.ts";
46 import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";
47 import * as DesktopShellEnvironment from "../shell/DesktopShellEnvironment.ts";
48 import * as DesktopSnapShot from "../snapShot/DesktopSnapShot.ts";
49 import * as DesktopRendererHistory from "../telemetry/DesktopRendererHistory.ts";
50 import * as DesktopUpdates from "../updates/DesktopUpdates.ts";
51 import * as DesktopApplicationMenu from "../window/DesktopApplicationMenu.ts";
52 import * as DesktopWindow from "../window/DesktopWindow.ts";
53 import * as DesktopWslBackend from "../wsl/DesktopWslBackend.ts";
54
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";
62 import * as DesktopLocalEnvironmentAuth from "../backend/DesktopLocalEnvironmentAuth.ts";
63 import * as DesktopManagedPolicy from "./DesktopManagedPolicy.ts";
64 import * as DesktopPrimaryPaste from "./DesktopPrimaryPaste.ts";
65 import * as DesktopSshEnvironment from "../ssh/DesktopSshEnvironment.ts";
66 import * as DesktopSshPasswordPrompts from "../ssh/DesktopSshPasswordPrompts.ts";
67 import * as DesktopTelemetryPublisher from "../telemetry/DesktopTelemetryPublisher.ts";
68 import * as DesktopWebLinks from "./DesktopWebLinks.ts";
69 import * as DesktopWslEnvironment from "../wsl/DesktopWslEnvironment.ts";
70 import * as ElectronMenu from "../electron/ElectronMenu.ts";
71 import * as ElectronShell from "../electron/ElectronShell.ts";
72 import * as ElectronTheme from "../electron/ElectronTheme.ts";
73 import * as ElectronWindow from "../electron/ElectronWindow.ts";
74 import * as MacPermissions from "../permissions/MacPermissions.ts";
75 import * as LoopbackTunnel from "../preview/LoopbackTunnel.ts";
76 import * as PreviewManager from "../preview/Manager.ts";
77 import * as AppleSpeech from "../speech/AppleSpeech.ts";
78
79 interface StubbedDesktop {
80 readonly localEnvironmentEnabled: boolean;
81 readonly environment: Partial<DesktopEnvironment.DesktopEnvironment["Service"]>;
82 readonly fileSystem: Layer.Layer<FileSystem.FileSystem>;
83 readonly record: (event: string) => Effect.Effect<void>;
84 readonly windowStarted: Deferred.Deferred<void>;
85 readonly registerLinuxUrlHandler: Effect.Effect<void>;
86 readonly backends?: ReadonlyArray<{ readonly stop: () => Effect.Effect<void> }>;
87 readonly flushRendererHistory?: Effect.Effect<void>;
88 readonly tokenRequested?: Deferred.Deferred<void>;
89 readonly activationStarted?: Deferred.Deferred<void>;
90 }
91
92 const runStubbedDesktop = (stub: StubbedDesktop) =>
93 Effect.gen(function* () {
94 const quitting = yield* Ref.make(false);
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: stub.record("identity"),
101 } as DesktopAppIdentity.DesktopAppIdentity["Service"]),
102 Effect.provideService(ElectronApp.ElectronApp, {
103 setPath: () => Effect.void,
104 whenReady: stub.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 ...stub.environment,
117 } as unknown as DesktopEnvironment.DesktopEnvironment["Service"]),
118 Effect.provideService(DesktopPreReadyPlatform.DesktopPreReadyElectronOptions, {
119 linux: null,
120 linuxPasswordStoreCommandLine: "basic",
121 }),
122 Effect.provideService(DesktopShellEnvironment.DesktopShellEnvironment, {
123 installIntoProcess: Effect.succeed(true),
124 awaitDiscovery: Effect.succeed(true),
125 awaitUserShellDiscovery: Effect.succeed(true),
126 discoveryFinished: Effect.succeed(true),
127 updates: Stream.empty,
128 }),
129 Effect.provideService(DesktopAppSettings.DesktopAppSettings, {
130 load: Effect.void,
131 get: Effect.succeed({
132 localEnvironmentEnabled: stub.localEnvironmentEnabled,
133 serverExposureMode: "local-only",
134 }),
135 } as unknown as DesktopAppSettings.DesktopAppSettings["Service"]),
136 Effect.provideService(DesktopLifecycle.DesktopLifecycle, {
137 register: Effect.void,
138 relaunch: () => Effect.void,
139 }),
140 Effect.provideService(DesktopClerk.DesktopClerk, {
141 configure: Effect.void,
142 } as DesktopClerk.DesktopClerk["Service"]),
143 Effect.provideService(ElectronSafeStorage.ElectronSafeStorage, {
144 selectedStorageBackend: Effect.succeedNone,
145 } as unknown as ElectronSafeStorage.ElectronSafeStorage["Service"]),
146 Effect.provideService(PreviewPasskeys.PreviewPasskeys, {
147 configure: Effect.void,
148 } as PreviewPasskeys.PreviewPasskeys["Service"]),
149 Effect.provideService(DesktopApplicationMenu.DesktopApplicationMenu, {
150 configure: stub.record("menu"),
151 }),
152 Effect.provideService(DesktopUpdates.DesktopUpdates, {
153 configure: Effect.void,
154 } as unknown as DesktopUpdates.DesktopUpdates["Service"]),
155 Effect.provideService(DesktopLinuxUrlHandler.DesktopLinuxUrlHandler, {
156 register: stub.registerLinuxUrlHandler,
157 }),
158 )
159 .pipe(
160 Effect.provideService(ElectronProtocol.ElectronProtocol, {
161 registerDesktopProtocol: () => Effect.void,
162 } as unknown as ElectronProtocol.ElectronProtocol["Service"]),
163 Effect.provideService(DesktopLegacyLocalStorage.DesktopLegacyLocalStorage, {
164 load: () => Effect.void,
165 } as unknown as DesktopLegacyLocalStorage.DesktopLegacyLocalStorage["Service"]),
166 Effect.provideService(DesktopSnapShot.DesktopSnapShot, {
167 initialize: Effect.void,
168 } as DesktopSnapShot.DesktopSnapShot["Service"]),
169 Effect.provideService(DesktopState.DesktopState, {
170 quitting,
171 } as DesktopState.DesktopState["Service"]),
172 Effect.provideService(DesktopWindow.DesktopWindow, {
173 ensureMain: stub
174 .record("window")
175 .pipe(Effect.andThen(Deferred.succeed(stub.windowStarted, undefined))),
176 createMainIfBackendReady: stub
177 .record("window")
178 .pipe(Effect.andThen(Deferred.succeed(stub.windowStarted, undefined))),
179 } as unknown as DesktopWindow.DesktopWindow["Service"]),
180 Effect.provideService(DesktopBackendPool.DesktopBackendPool, {
181 primary: Effect.succeed({
182 start: stub.record("backend"),
183 currentConfig: Effect.succeedSome({ preflightFailure: Option.none() }),
184 }),
185 list: Effect.succeed(stub.backends ?? []),
186 } as unknown as DesktopBackendPool.DesktopBackendPool["Service"]),
187 Effect.provideService(DesktopServerExposure.DesktopServerExposure, {
188 configureFromSettings: () => Effect.succeed({ mode: "local-only" }),
189 backendConfig: Effect.succeed({ httpBaseUrl: new URL("http://127.0.0.1:3773") }),
190 } as unknown as DesktopServerExposure.DesktopServerExposure["Service"]),
191 Effect.provideService(DesktopWslBackend.DesktopWslBackend, {
192 reconcile: Effect.void,
193 } as DesktopWslBackend.DesktopWslBackend["Service"]),
194 Effect.provideService(DesktopAppActivation.DesktopAppActivation, {
195 start: stub.activationStarted
196 ? Deferred.succeed(stub.activationStarted, undefined)
197 : Effect.void,
198 } as unknown as DesktopAppActivation.DesktopAppActivation["Service"]),
199 Effect.provideService(DesktopRendererHistory.DesktopRendererHistory, {
200 shutdown: stub.flushRendererHistory ?? Effect.void,
201 } as DesktopRendererHistory.DesktopRendererHistory["Service"]),
202 );
203 return yield* runApp.pipe(
204 Effect.provide(
205 Layer.mergeAll(
206 Layer.mock(BrowserImport.BrowserImport, {}),
207 Layer.mock(ChildProcessSpawner.ChildProcessSpawner, {}),
208 Layer.mock(DesktopBackendConfiguration.DesktopBackendConfiguration, {}),
209 Layer.mock(DesktopCliCommand.DesktopCliCommand, {}),
210 Layer.mock(DesktopClientSettings.DesktopClientSettings, {}),
211 Layer.mock(DesktopConnectionCatalogStore.DesktopConnectionCatalogStore, {}),
212 Layer.mock(DesktopIpc.DesktopIpc, {}),
213 Layer.mock(DesktopLocalEnvironmentAuth.DesktopLocalEnvironmentAuth, {
214 getBearerToken: stub
215 .record("token")
216 .pipe(
217 Effect.andThen(
218 stub.tokenRequested
219 ? Deferred.succeed(stub.tokenRequested, undefined)
220 : Effect.void,
221 ),
222 Effect.as("token"),
223 ),
224 }),
225 Layer.mock(DesktopManagedPolicy.DesktopManagedPolicy, {}),
226 Layer.succeed(DesktopPrimaryPaste.DesktopPrimaryPaste, { enabled: true }),
227 Layer.mock(DesktopSshEnvironment.DesktopSshEnvironment, {}),
228 Layer.mock(DesktopSshPasswordPrompts.DesktopSshPasswordPrompts, {}),
229 Layer.mock(DesktopTelemetryPublisher.DesktopTelemetryPublisher, {}),
230 Layer.mock(DesktopWebLinks.DesktopWebLinks, {}),
231 Layer.mock(DesktopWslEnvironment.DesktopWslEnvironment, {}),
232 Layer.mock(ElectronMenu.ElectronMenu, {}),
233 Layer.mock(ElectronShell.ElectronShell, {}),
234 Layer.mock(ElectronTheme.ElectronTheme, {}),
235 Layer.mock(ElectronWindow.ElectronWindow, {}),
236 Layer.mock(MacPermissions.MacPermissions, {}),
237 Layer.mock(AppleSpeech.AppleSpeech, {}),
238 Layer.mock(LoopbackTunnel.LoopbackTunnel, {}),
239 Layer.mock(PreviewManager.PreviewManager, {
240 isBrowserPartition: () => {
241 throw new Error("unexpected browser partition lookup");
242 },
243 }),
244 stub.fileSystem,
245 Layer.mock(NetService.NetService, {}),
246 Path.layer,
247 Layer.succeed(
248 HttpClient.HttpClient,
249 HttpClient.make(() => Effect.die("unexpected HTTP request")),
250 ),
251 ),
252 ),
253 Effect.forkScoped,
254 );
255 });
256
257 it.effect.each([false, true])(
258 "stops backends together before flushing history and cancels Linux registration, stop defect=%s",
259 (stopDefect) =>
260 Effect.gen(function* () {
261 const registrationStarted = yield* Deferred.make<void>();
262 const releaseRegistration = yield* Deferred.make<void>();
263 const registrationStopped = yield* Deferred.make<void>();
264 const windowStarted = yield* Deferred.make<void>();
265 const firstStopStarted = yield* Deferred.make<void>();
266 const secondStopStarted = yield* Deferred.make<void>();
267 const releaseStops = yield* Deferred.make<void>();
268 const historyStarted = yield* Deferred.make<void>();
269 const releaseHistory = yield* Deferred.make<void>();
270 const tokenRequested = yield* Deferred.make<void>();
271 const events: string[] = [];
272 const app = yield* runStubbedDesktop({
273 localEnvironmentEnabled: true,
274 environment: {},
275 fileSystem: FileSystem.layerNoop({}),
276 record: (event) =>
277 Effect.sync(() => {
278 events.push(event);
279 }),
280 windowStarted,
281 tokenRequested,
282 registerLinuxUrlHandler: Deferred.succeed(registrationStarted, undefined).pipe(
283 Effect.andThen(Deferred.await(releaseRegistration)),
284 Effect.ensuring(Deferred.succeed(registrationStopped, undefined)),
285 ),
286 backends: [
287 {
288 stop: () =>
289 Deferred.succeed(firstStopStarted, undefined).pipe(
290 Effect.andThen(Deferred.await(releaseStops)),
291 Effect.andThen(stopDefect ? Effect.die("stop defect") : Effect.void),
292 ),
293 },
294 {
295 stop: () =>
296 Deferred.succeed(secondStopStarted, undefined).pipe(
297 Effect.andThen(Deferred.await(releaseStops)),
298 ),
299 },
300 ],
301 flushRendererHistory: Deferred.succeed(historyStarted, undefined).pipe(
302 Effect.andThen(Deferred.await(releaseHistory)),
303 Effect.asVoid,
304 ),
305 });
306 yield* Deferred.await(registrationStarted);
307 yield* Deferred.await(windowStarted);
308 yield* Deferred.await(tokenRequested);
309 // The backend spawns before menus, and its token is minted without waiting for the renderer.
310 assert.deepEqual(
311 events.filter((event) => event !== "token"),
312 ["identity", "ready", "identity", "backend", "menu", "window"],
313 );
314 assert.isAbove(events.indexOf("token"), events.indexOf("backend"));
315 assert.isFalse(yield* Deferred.isDone(registrationStopped));
316 const shutdown = yield* DesktopShutdown.DesktopShutdown;
317 yield* shutdown.request;
318 yield* Deferred.await(firstStopStarted);
319 yield* Deferred.await(secondStopStarted);
320 assert.isFalse(yield* Deferred.isDone(historyStarted));
321 assert.isFalse(yield* shutdown.isComplete);
322 yield* Deferred.succeed(releaseStops, undefined);
323 yield* Deferred.await(historyStarted);
324 assert.isFalse(yield* shutdown.isComplete);
325 yield* Deferred.succeed(releaseHistory, undefined);
326 const result = yield* Fiber.await(app);
327 assert.equal(Exit.isFailure(result), stopDefect);
328 assert.isTrue(yield* shutdown.isComplete);
329 assert.isTrue(yield* Deferred.isDone(registrationStopped));
330 }).pipe(Effect.provide(DesktopShutdown.layer)),
331 );
332
333 it.effect(
334 "points a stale t3 launcher at the updated AppImage and accepts t3 <dir> with Local environment off",
335 () =>
336 Effect.gen(function* () {
337 const fs = yield* FileSystem.FileSystem;
338 const path = yield* Path.Path;
339 const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-desktop-app-" });
340 const launcher = DesktopCliShim.launcherPath({
341 path,
342 baseDir,
343 platform: "linux",
344 } as DesktopEnvironment.DesktopEnvironment["Service"]);
345 const removedAppImage = path.join(baseDir, "T3-Code-0.1.6-x86_64.AppImage");
346 const updatedAppImage = path.join(baseDir, "T3-Code-0.1.7-x86_64.AppImage");
347 yield* fs.makeDirectory(path.dirname(launcher), { recursive: true });
348 yield* fs.writeFileString(
349 launcher,
350 DesktopCliShim.renderCliShim({
351 target: { kind: "appimage", appImage: removedAppImage, executableName: "t3code" },
352 shimPath: launcher,
353 t3Home: baseDir,
354 }),
355 );
356 yield* fs.writeFileString(updatedAppImage, "", { mode: 0o755 });
357 const windowStarted = yield* Deferred.make<void>();
358 const activationStarted = yield* Deferred.make<void>();
359
360 const app = yield* runStubbedDesktop({
361 localEnvironmentEnabled: false,
362 activationStarted,
363 environment: {
364 path,
365 baseDir,
366 serverRoot: path.join(baseDir, "resources", "app.asar"),
367 appImagePath: Option.some(updatedAppImage),
368 },
369 fileSystem: Layer.succeed(FileSystem.FileSystem, fs),
370 record: () => Effect.void,
371 windowStarted,
372 registerLinuxUrlHandler: Effect.void,
373 });
374 yield* Deferred.await(windowStarted);
375 yield* (yield* DesktopShutdown.DesktopShutdown).request;
376 yield* Fiber.join(app);
377
378 const content = yield* fs.readFileString(launcher);
379 assert.include(
380 content,
381 `app='${updatedAppImage}'`,
382 "startup left the t3 launcher pointing at the removed AppImage",
383 );
384 assert.isTrue(
385 yield* Deferred.isDone(activationStarted),
386 "startup left the t3 <dir> control socket closed",
387 );
388 }).pipe(Effect.provide(Layer.mergeAll(DesktopShutdown.layer, NodeServices.layer))),
389 );