@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 520 lines 19.8 KB
Raw
1 import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
2 import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
3 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
4 import * as NodeServices from "@effect/platform-node/NodeServices";
5 import { assert, describe, it } from "@effect/vitest";
6 import * as Deferred from "effect/Deferred";
7 import * as Effect from "effect/Effect";
8 import * as Fiber from "effect/Fiber";
9 import * as FileSystem from "effect/FileSystem";
10 import * as Layer from "effect/Layer";
11 import * as Option from "effect/Option";
12 import * as Sink from "effect/Sink";
13 import * as Stream from "effect/Stream";
14 import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
15
16 import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
17 import * as DesktopConfig from "../app/DesktopConfig.ts";
18 import * as DesktopManagedPolicy from "../app/DesktopManagedPolicy.ts";
19 import * as DesktopNetworkInterfaces from "./DesktopNetworkInterfaces.ts";
20 import * as DesktopServerExposure from "./DesktopServerExposure.ts";
21 import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";
22
23 const encoder = new TextEncoder();
24
25 const emptyNetworkInterfaces: DesktopNetworkInterfaces.NetworkInterfaces = {};
26 const lanNetworkInterfaces: DesktopNetworkInterfaces.NetworkInterfaces = {
27 en0: [
28 {
29 address: "192.168.1.20",
30 family: "IPv4",
31 internal: false,
32 },
33 ],
34 };
35
36 const tailnetNetworkInterfaces: DesktopNetworkInterfaces.NetworkInterfaces = {
37 tailscale0: [
38 {
39 address: "100.90.1.2",
40 family: "IPv4",
41 internal: false,
42 },
43 ],
44 };
45
46 function layerMockSpawner(statusJson: string | (() => string) = "{}", onSpawn?: () => void) {
47 return Layer.succeed(
48 ChildProcessSpawner.ChildProcessSpawner,
49 ChildProcessSpawner.make(() =>
50 Effect.sync(() => {
51 onSpawn?.();
52 return ChildProcessSpawner.makeHandle({
53 pid: ChildProcessSpawner.ProcessId(1),
54 exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(0)),
55 isRunning: Effect.succeed(false),
56 kill: () => Effect.void,
57 unref: Effect.succeed(Effect.void),
58 stdin: Sink.drain,
59 stdout: Stream.make(
60 encoder.encode(typeof statusJson === "string" ? statusJson : statusJson()),
61 ),
62 stderr: Stream.empty,
63 all: Stream.empty,
64 getInputFd: () => Sink.drain,
65 getOutputFd: () => Stream.empty,
66 });
67 }),
68 ),
69 );
70 }
71
72 function layerEnvironmentFor(baseDir: string, env: Record<string, string | undefined> = {}) {
73 return DesktopEnvironment.layer({
74 dirname: "/repo/apps/desktop/src",
75 homeDirectory: baseDir,
76 platform: "darwin",
77 processArch: "x64",
78 appVersion: "1.2.3",
79 appPath: "/repo",
80 isPackaged: true,
81 resourcesPath: "/missing/resources",
82 runningUnderArm64Translation: false,
83 }).pipe(
84 Layer.provide(
85 Layer.mergeAll(
86 NodeServices.layer,
87 NodeCrypto.layer,
88 DesktopConfig.layerTest({ T3CODE_HOME: baseDir, ...env }),
89 ),
90 ),
91 );
92 }
93
94 function layer(input: {
95 readonly baseDir: string;
96 readonly networkInterfaces?: DesktopNetworkInterfaces.NetworkInterfaces;
97 readonly env?: Record<string, string | undefined>;
98 readonly spawnerLayer?: Layer.Layer<ChildProcessSpawner.ChildProcessSpawner>;
99 readonly desktopSettingsLayer?: Layer.Layer<DesktopAppSettings.DesktopAppSettings>;
100 readonly managedPolicyLayer?: Layer.Layer<DesktopManagedPolicy.DesktopManagedPolicy>;
101 }) {
102 const env = { T3CODE_HOME: input.baseDir, ...input.env };
103 const layerEnvironment = layerEnvironmentFor(input.baseDir, env);
104 const layerNetwork = Layer.succeed(DesktopNetworkInterfaces.DesktopNetworkInterfaces, {
105 read: Effect.succeed(input.networkInterfaces ?? emptyNetworkInterfaces),
106 });
107
108 return DesktopServerExposure.layer.pipe(
109 Layer.provideMerge(input.desktopSettingsLayer ?? DesktopAppSettings.layer),
110 Layer.provideMerge(input.managedPolicyLayer ?? DesktopManagedPolicy.layerTest()),
111 Layer.provideMerge(NodeFileSystem.layer),
112 Layer.provideMerge(NodeHttpClient.layerUndici),
113 Layer.provideMerge(input.spawnerLayer ?? layerMockSpawner()),
114 Layer.provideMerge(layerNetwork),
115 Layer.provideMerge(DesktopConfig.layerTest(env)),
116 Layer.provideMerge(layerEnvironment),
117 );
118 }
119
120 const withHarness = <A, E, R>(
121 networkInterfaces: DesktopNetworkInterfaces.NetworkInterfaces,
122 effect: Effect.Effect<
123 A,
124 E,
125 | R
126 | DesktopEnvironment.DesktopEnvironment
127 | FileSystem.FileSystem
128 | DesktopServerExposure.DesktopServerExposure
129 | DesktopAppSettings.DesktopAppSettings
130 >,
131 env: Record<string, string | undefined> = {},
132 spawnerLayer?: Layer.Layer<ChildProcessSpawner.ChildProcessSpawner>,
133 desktopSettingsLayer?: Layer.Layer<DesktopAppSettings.DesktopAppSettings>,
134 managedPolicyLayer?: Layer.Layer<DesktopManagedPolicy.DesktopManagedPolicy>,
135 ) =>
136 Effect.gen(function* () {
137 const fileSystem = yield* FileSystem.FileSystem;
138 const baseDir = yield* fileSystem.makeTempDirectoryScoped({
139 prefix: "t3-desktop-server-exposure-test-",
140 });
141 return yield* effect.pipe(
142 Effect.provide(
143 layer({
144 baseDir,
145 networkInterfaces,
146 env,
147 ...(spawnerLayer ? { spawnerLayer } : {}),
148 ...(desktopSettingsLayer ? { desktopSettingsLayer } : {}),
149 ...(managedPolicyLayer ? { managedPolicyLayer } : {}),
150 }),
151 ),
152 );
153 }).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)), Effect.scoped);
154
155 describe("DesktopServerExposure", () => {
156 it.effect("uses cached Tailscale identity to exclude another VPN's pairing address", () => {
157 let statusReads = 0;
158 return withHarness(
159 {
160 ...lanNetworkInterfaces,
161 pvpnksintrf1: [{ address: "100.85.0.1", family: "IPv4", internal: false }],
162 vpn0: [{ address: "100.74.126.34", family: "IPv4", internal: false }],
163 },
164 Effect.gen(function* () {
165 const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
166 yield* serverExposure.configureFromSettings({ port: 4173 });
167 yield* serverExposure.setMode("network-accessible");
168
169 const endpoints = yield* serverExposure.getAdvertisedEndpoints;
170 assert.deepEqual(
171 endpoints.map((endpoint) => endpoint.httpBaseUrl),
172 ["http://127.0.0.1:4173/", "http://192.168.1.20:4173/", "http://100.74.126.34:4173/"],
173 );
174 assert.deepEqual(yield* serverExposure.getAdvertisedEndpoints, endpoints);
175 assert.equal(statusReads, 1);
176 }),
177 {},
178 layerMockSpawner(`{"Self":{"TailscaleIPs":["100.74.126.34"]}}`, () => {
179 statusReads += 1;
180 }),
181 );
182 });
183
184 it.effect("falls back to local-only without losing the requested network preference", () =>
185 withHarness(
186 emptyNetworkInterfaces,
187 Effect.gen(function* () {
188 const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
189 const settings = yield* DesktopAppSettings.DesktopAppSettings;
190
191 yield* settings.setServerExposureMode("network-accessible");
192
193 const state = yield* serverExposure.configureFromSettings({ port: 4173 });
194 assert.equal(state.mode, "local-only");
195 assert.equal(state.endpointUrl, null);
196 assert.equal((yield* settings.get).serverExposureMode, "network-accessible");
197
198 const backendConfig = yield* serverExposure.backendConfig;
199 assert.equal(backendConfig.bindHost, "127.0.0.1");
200 assert.equal(backendConfig.httpBaseUrl.href, "http://127.0.0.1:4173/");
201 }),
202 ),
203 );
204
205 it.effect("starts local-only, Serve off, when a managed policy keeps clients local", () =>
206 withHarness(
207 lanNetworkInterfaces,
208 Effect.gen(function* () {
209 const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
210 const settings = yield* DesktopAppSettings.DesktopAppSettings;
211 yield* settings.setServerExposureMode("network-accessible");
212 yield* settings.setTailscaleServe({ enabled: true, port: Option.none() });
213
214 const state = yield* serverExposure.configureFromSettings({ port: 4173 });
215 assert.equal(state.mode, "local-only");
216 const backendConfig = yield* serverExposure.backendConfig;
217 assert.equal(backendConfig.bindHost, "127.0.0.1");
218 assert.isFalse(backendConfig.tailscaleServeEnabled);
219 // Choosing them again while the policy applies does not widen the backend either.
220 yield* serverExposure.setMode("network-accessible");
221 yield* serverExposure.setTailscaleServeEnabled({ enabled: true });
222 assert.equal((yield* serverExposure.backendConfig).bindHost, "127.0.0.1");
223 assert.isFalse((yield* serverExposure.backendConfig).tailscaleServeEnabled);
224 // The saved choice returns once the policy allows it.
225 const saved = yield* settings.get;
226 assert.equal(saved.serverExposureMode, "network-accessible");
227 assert.isTrue(saved.tailscaleServeEnabled);
228 }),
229 {},
230 undefined,
231 undefined,
232 DesktopManagedPolicy.layerTest({
233 schemaVersion: 1,
234 organization: "Example Corp",
235 limits: { clients: ["desktop"] },
236 }),
237 ),
238 );
239
240 it.effect("persists network-accessible mode and updates backend binding state", () =>
241 withHarness(
242 lanNetworkInterfaces,
243 Effect.gen(function* () {
244 const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
245 const settings = yield* DesktopAppSettings.DesktopAppSettings;
246
247 yield* settings.load;
248 yield* serverExposure.configureFromSettings({ port: 4173 });
249
250 const change = yield* serverExposure.setMode("network-accessible");
251 assert.equal(change.requiresRelaunch, true);
252 assert.deepEqual(change.state, {
253 mode: "network-accessible",
254 endpointUrl: "http://192.168.1.20:4173",
255 advertisedHost: "192.168.1.20",
256 tailscaleServeEnabled: false,
257 tailscaleServePort: 443,
258 });
259
260 const backendConfig = yield* serverExposure.backendConfig;
261 assert.equal(backendConfig.bindHost, "0.0.0.0");
262 assert.equal(backendConfig.httpBaseUrl.href, "http://127.0.0.1:4173/");
263
264 const persisted = yield* settings.get;
265 assert.equal(persisted.serverExposureMode, "network-accessible");
266 }),
267 ),
268 );
269
270 it.effect("advertises the Wi-Fi or Ethernet address ahead of bridges and tunnels", () =>
271 withHarness(
272 {
273 bridge0: [{ address: "192.168.2.1", family: "IPv4", internal: false }],
274 utun4: [{ address: "10.8.0.2", family: "IPv4", internal: false }],
275 en0: [{ address: "192.168.1.20", family: "IPv4", internal: false }],
276 },
277 Effect.gen(function* () {
278 const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
279 yield* serverExposure.configureFromSettings({ port: 4173 });
280
281 const change = yield* serverExposure.setMode("network-accessible");
282 assert.equal(change.state.advertisedHost, "192.168.1.20");
283 }),
284 ),
285 );
286
287 it.effect("advertises the current LAN address after the network changes", () => {
288 const networkInterfaces: Record<
289 string,
290 readonly DesktopNetworkInterfaces.DesktopNetworkInterfaceInfo[] | undefined
291 > = { ...lanNetworkInterfaces };
292
293 return withHarness(
294 networkInterfaces,
295 Effect.gen(function* () {
296 const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
297 yield* serverExposure.configureFromSettings({ port: 4173 });
298 yield* serverExposure.setMode("network-accessible");
299
300 networkInterfaces.en0 = [{ address: "10.0.0.5", family: "IPv4", internal: false }];
301
302 const state = yield* serverExposure.getState;
303 assert.equal(state.advertisedHost, "10.0.0.5");
304 assert.equal(state.endpointUrl, "http://10.0.0.5:4173");
305 const endpoints = yield* serverExposure.getAdvertisedEndpoints;
306 assert.deepEqual(
307 endpoints.map((endpoint) => endpoint.httpBaseUrl),
308 ["http://127.0.0.1:4173/", "http://10.0.0.5:4173/"],
309 );
310 assert.equal((yield* serverExposure.backendConfig).bindHost, "0.0.0.0");
311 }),
312 );
313 });
314
315 it.effect("persists tailscale serve preferences atomically and reports no-op updates", () =>
316 withHarness(
317 emptyNetworkInterfaces,
318 Effect.gen(function* () {
319 const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
320 const settings = yield* DesktopAppSettings.DesktopAppSettings;
321
322 yield* settings.load;
323 yield* serverExposure.configureFromSettings({ port: 4173 });
324
325 const changed = yield* serverExposure.setTailscaleServeEnabled({
326 enabled: true,
327 port: 8443,
328 });
329 assert.equal(changed.requiresRelaunch, true);
330 assert.equal(changed.state.tailscaleServeEnabled, true);
331 assert.equal(changed.state.tailscaleServePort, 8443);
332
333 const unchanged = yield* serverExposure.setTailscaleServeEnabled({
334 enabled: true,
335 port: 8443,
336 });
337 assert.equal(unchanged.requiresRelaunch, false);
338
339 const persisted = yield* settings.get;
340 assert.equal(persisted.tailscaleServeEnabled, true);
341 assert.equal(persisted.tailscaleServePort, 8443);
342 }),
343 ),
344 );
345
346 it.effect("keeps a Tailscale Serve change made while a mode change is saving", () =>
347 Effect.gen(function* () {
348 const modeWriteStarted = yield* Deferred.make<void>();
349 const releaseModeWrite = yield* Deferred.make<void>();
350 const settingsLayer = Layer.effect(
351 DesktopAppSettings.DesktopAppSettings,
352 Effect.gen(function* () {
353 const settings = yield* DesktopAppSettings.DesktopAppSettings;
354 return DesktopAppSettings.DesktopAppSettings.of({
355 ...settings,
356 setServerExposureMode: (mode) =>
357 Deferred.succeed(modeWriteStarted, undefined).pipe(
358 Effect.andThen(Deferred.await(releaseModeWrite)),
359 Effect.andThen(settings.setServerExposureMode(mode)),
360 ),
361 });
362 }),
363 ).pipe(Layer.provide(DesktopAppSettings.layerTest()));
364
365 return yield* withHarness(
366 lanNetworkInterfaces,
367 Effect.gen(function* () {
368 const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
369 yield* serverExposure.configureFromSettings({ port: 4173 });
370
371 const modeChange = yield* serverExposure
372 .setMode("network-accessible")
373 .pipe(Effect.forkChild({ startImmediately: true }));
374 yield* Deferred.await(modeWriteStarted);
375 const tailscaleChange = yield* serverExposure
376 .setTailscaleServeEnabled({ enabled: true, port: 8443 })
377 .pipe(Effect.forkChild({ startImmediately: true }));
378 yield* Deferred.succeed(releaseModeWrite, undefined);
379 yield* Fiber.join(modeChange);
380 yield* Fiber.join(tailscaleChange);
381
382 const state = yield* serverExposure.getState;
383 assert.equal(state.mode, "network-accessible");
384 assert.equal(state.tailscaleServeEnabled, true);
385 assert.equal(state.tailscaleServePort, 8443);
386 }),
387 {},
388 undefined,
389 settingsLayer,
390 );
391 }),
392 );
393
394 it.effect("keeps LAN and Tailscale endpoints distinct when Tailscale is enumerated first", () =>
395 withHarness(
396 { ...tailnetNetworkInterfaces, ...lanNetworkInterfaces },
397 Effect.gen(function* () {
398 const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
399 yield* serverExposure.configureFromSettings({ port: 4173 });
400 yield* serverExposure.setMode("network-accessible");
401
402 const endpoints = yield* serverExposure.getAdvertisedEndpoints;
403 assert.deepEqual(
404 endpoints.map((endpoint) => endpoint.httpBaseUrl),
405 ["http://127.0.0.1:4173/", "http://192.168.1.20:4173/", "http://100.90.1.2:4173/"],
406 );
407 }),
408 ),
409 );
410
411 it.effect("keeps Tailscale-only hosts network-accessible", () =>
412 withHarness(
413 tailnetNetworkInterfaces,
414 Effect.gen(function* () {
415 const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
416 const settings = yield* DesktopAppSettings.DesktopAppSettings;
417 yield* settings.setServerExposureMode("network-accessible");
418
419 const state = yield* serverExposure.configureFromSettings({ port: 4173 });
420 assert.equal(state.mode, "network-accessible");
421 assert.equal(state.advertisedHost, null);
422 assert.equal(state.endpointUrl, null);
423 assert.equal((yield* serverExposure.backendConfig).bindHost, "0.0.0.0");
424
425 const endpoints = yield* serverExposure.getAdvertisedEndpoints;
426 assert.deepEqual(
427 endpoints.map((endpoint) => [endpoint.reachability, endpoint.httpBaseUrl]),
428 [
429 ["loopback", "http://127.0.0.1:4173/"],
430 ["private-network", "http://100.90.1.2:4173/"],
431 ],
432 );
433 }),
434 ),
435 );
436
437 it.effect(
438 "refreshes Tailscale status when addresses change and caches unchanged addresses",
439 () => {
440 const networkInterfaces: Record<
441 string,
442 readonly DesktopNetworkInterfaces.DesktopNetworkInterfaceInfo[] | undefined
443 > = { ...lanNetworkInterfaces };
444 let statusJson = "{}";
445 let statusReads = 0;
446
447 return withHarness(
448 networkInterfaces,
449 Effect.gen(function* () {
450 const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
451 yield* serverExposure.configureFromSettings({ port: 4173 });
452 yield* serverExposure.setMode("network-accessible");
453
454 const initial = yield* serverExposure.getAdvertisedEndpoints;
455 assert.deepEqual(
456 initial.map((endpoint) => endpoint.httpBaseUrl),
457 ["http://127.0.0.1:4173/", "http://192.168.1.20:4173/"],
458 );
459 assert.equal(statusReads, 1);
460
461 for (const [address, dnsName] of [
462 ["100.90.1.2", "desktop.tail.ts.net"],
463 ["100.90.1.3", "desktop.other-tail.ts.net"],
464 ] as const) {
465 networkInterfaces.vpn0 = [{ address, family: "IPv4", internal: false }];
466 statusJson = JSON.stringify({
467 Self: { DNSName: `${dnsName}.`, TailscaleIPs: [address] },
468 });
469 const previousReads = statusReads;
470
471 const endpoints = yield* serverExposure.getAdvertisedEndpoints;
472 assert.deepEqual(
473 endpoints.map((endpoint) => endpoint.httpBaseUrl),
474 [
475 "http://127.0.0.1:4173/",
476 "http://192.168.1.20:4173/",
477 `http://${address}:4173/`,
478 `https://${dnsName}/`,
479 ],
480 );
481 assert.equal(statusReads, previousReads + 1);
482 assert.deepEqual(yield* serverExposure.getAdvertisedEndpoints, endpoints);
483 assert.equal(statusReads, previousReads + 1);
484 }
485 }),
486 {},
487 layerMockSpawner(
488 () => statusJson,
489 () => {
490 statusReads += 1;
491 },
492 ),
493 );
494 },
495 );
496
497 it.effect("preserves explicit Tailscale exposure overrides", () =>
498 withHarness(
499 lanNetworkInterfaces,
500 Effect.gen(function* () {
501 const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
502 yield* serverExposure.configureFromSettings({ port: 4173 });
503 const change = yield* serverExposure.setMode("network-accessible");
504
505 assert.equal(change.state.advertisedHost, "100.90.1.2");
506 assert.equal(change.state.endpointUrl, "http://100.90.1.2:4173");
507
508 const endpoints = yield* serverExposure.getAdvertisedEndpoints;
509 assert.deepEqual(
510 endpoints.map((endpoint) => endpoint.httpBaseUrl),
511 ["http://127.0.0.1:4173/", "http://100.90.1.2:4173/", "https://public.example.test/"],
512 );
513 }),
514 {
515 T3CODE_DESKTOP_LAN_HOST: "100.90.1.2",
516 T3CODE_DESKTOP_HTTPS_ENDPOINTS: "https://public.example.test",
517 },
518 ),
519 );
520 });