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

main
ts 727 lines 28.2 KB
Raw
1 import { EnvironmentId } from "@t3tools/contracts";
2 import type {
3 RelayClientEnvironmentRecord,
4 RelayEnvironmentStatusResponse,
5 } from "@t3tools/contracts/relay";
6 import { describe, expect, it } from "@effect/vitest";
7 import * as Deferred from "effect/Deferred";
8 import * as Effect from "effect/Effect";
9 import * as Fiber from "effect/Fiber";
10 import * as Layer from "effect/Layer";
11 import * as Option from "effect/Option";
12 import * as Ref from "effect/Ref";
13 import * as Stream from "effect/Stream";
14 import * as SubscriptionRef from "effect/SubscriptionRef";
15 import { Atom, AtomRegistry } from "effect/reactivity";
16
17 import * as ManagedRelay from "./managedRelay.ts";
18 import * as ClientCapabilities from "../platform/capabilities.ts";
19 import * as Connectivity from "../connection/connectivity.ts";
20 import { ConnectionBlockedError, type NetworkStatus } from "../connection/model.ts";
21 import * as ConnectionWakeups from "../connection/wakeups.ts";
22 import * as RelayEnvironmentDiscovery from "./discovery.ts";
23 import { NETWORK_BLOCKING_HINT } from "../errors/network.ts";
24 import { createRelayEnvironmentDiscoveryAtoms } from "../state/relayDiscovery.ts";
25
26 const environments = [
27 {
28 environmentId: EnvironmentId.make("environment-1"),
29 label: "Environment One",
30 endpoint: {
31 httpBaseUrl: "https://one.example.test",
32 wsBaseUrl: "wss://one.example.test",
33 providerKind: "cloudflare_tunnel",
34 },
35 linkedAt: "2026-06-01T00:00:00.000Z",
36 },
37 {
38 environmentId: EnvironmentId.make("environment-2"),
39 label: "Environment Two",
40 endpoint: {
41 httpBaseUrl: "https://two.example.test",
42 wsBaseUrl: "wss://two.example.test",
43 providerKind: "cloudflare_tunnel",
44 },
45 linkedAt: "2026-06-01T00:00:00.000Z",
46 },
47 ] satisfies ReadonlyArray<RelayClientEnvironmentRecord>;
48
49 function status(
50 environment: RelayClientEnvironmentRecord,
51 value: "online" | "offline",
52 ): RelayEnvironmentStatusResponse {
53 return {
54 environmentId: environment.environmentId,
55 endpoint: environment.endpoint,
56 status: value,
57 checkedAt: "2026-06-01T00:00:00.000Z",
58 };
59 }
60
61 const makeHarness = Effect.fn("RelayDiscoveryTest.makeHarness")(function* () {
62 const networkStatus = yield* SubscriptionRef.make<NetworkStatus>("online");
63 const listCalls = yield* Ref.make(0);
64 const statusCalls = yield* Ref.make(0);
65 const listedEnvironments =
66 yield* Ref.make<ReadonlyArray<RelayClientEnvironmentRecord>>(environments);
67 const listFailure = yield* Ref.make<ManagedRelay.ManagedRelayClientError | null>(null);
68 const secondListCall = yield* Deferred.make<void>();
69 const clerkToken = yield* Ref.make<string | null>("clerk-token");
70 const sessionIdentity = { accountId: "account-1" };
71 const wakeups = yield* SubscriptionRef.make<{
72 readonly sequence: number;
73 readonly reason: ConnectionWakeups.ConnectionWakeup;
74 }>({
75 sequence: 0,
76 reason: "application-active",
77 });
78 const statusRequests = yield* Ref.make(
79 new Map<
80 string,
81 Deferred.Deferred<RelayEnvironmentStatusResponse, ManagedRelay.ManagedRelayClientError>
82 >(),
83 );
84 for (const environment of environments) {
85 const request = yield* Deferred.make<
86 RelayEnvironmentStatusResponse,
87 ManagedRelay.ManagedRelayClientError
88 >();
89 yield* Ref.update(statusRequests, (current) => {
90 const next = new Map(current);
91 next.set(environment.environmentId, request);
92 return next;
93 });
94 }
95
96 const client = ManagedRelay.ManagedRelayClient.of({
97 relayUrl: "https://relay.example.test",
98 listEnvironments: () =>
99 Effect.gen(function* () {
100 const count = yield* Ref.updateAndGet(listCalls, (current) => current + 1);
101 if (count >= 2) {
102 yield* Deferred.succeed(secondListCall, undefined);
103 }
104 const failure = yield* Ref.get(listFailure);
105 if (failure) {
106 return yield* failure;
107 }
108 return yield* Ref.get(listedEnvironments);
109 }),
110 getEnvironmentStatus: ({ environmentId }) =>
111 Ref.update(statusCalls, (current) => current + 1).pipe(
112 Effect.andThen(Ref.get(statusRequests)),
113 Effect.flatMap((requests) => Deferred.await(requests.get(environmentId)!)),
114 ),
115 listDevices: () => Effect.die("unused"),
116 createEnvironmentLinkChallenge: () => Effect.die("unused"),
117 linkEnvironment: () => Effect.die("unused"),
118 unlinkEnvironment: () => Effect.die("unused"),
119 getT3ChatLink: () => Effect.die("unused"),
120 createT3ChatLinkRequest: () => Effect.die("unused"),
121 unlinkT3Chat: () => Effect.die("unused"),
122 connectEnvironment: () => Effect.die("unused"),
123 registerDevice: () => Effect.die("unused"),
124 unregisterDevice: () => Effect.die("unused"),
125 registerLiveActivity: () => Effect.die("unused"),
126 getAgentActivitySnapshot: () => Effect.die("unused"),
127 resetTokenCache: Effect.void,
128 } satisfies ManagedRelay.ManagedRelayClient["Service"]);
129 const connectivity = Connectivity.Connectivity.of({
130 status: SubscriptionRef.get(networkStatus),
131 changes: SubscriptionRef.changes(networkStatus),
132 });
133 const layer = RelayEnvironmentDiscovery.layer.pipe(
134 Layer.provide(
135 Layer.mergeAll(
136 Layer.succeed(ManagedRelay.ManagedRelayClient, client),
137 Layer.succeed(
138 ClientCapabilities.CloudSession,
139 ClientCapabilities.CloudSession.of({
140 identity: Ref.get(clerkToken).pipe(
141 Effect.map((token) =>
142 token === null ? Option.none() : Option.some(sessionIdentity),
143 ),
144 ),
145 clerkToken: Ref.get(clerkToken).pipe(
146 Effect.filterOrFail(
147 (token) => token !== null,
148 () =>
149 new ConnectionBlockedError({
150 reason: "authentication",
151 detail: "Signed out.",
152 }),
153 ),
154 ),
155 }),
156 ),
157 Layer.succeed(Connectivity.Connectivity, connectivity),
158 Layer.succeed(
159 ConnectionWakeups.ConnectionWakeups,
160 ConnectionWakeups.ConnectionWakeups.of({
161 changes: SubscriptionRef.changes(wakeups).pipe(
162 Stream.drop(1),
163 Stream.map((event) => event.reason),
164 ),
165 }),
166 ),
167 ),
168 ),
169 );
170
171 return {
172 layer,
173 listCalls,
174 listedEnvironments,
175 listFailure,
176 clerkToken,
177 networkStatus,
178 secondListCall,
179 statusCalls,
180 statusRequests,
181 wake: (reason: ConnectionWakeups.ConnectionWakeup) =>
182 SubscriptionRef.update(wakeups, (event) => ({
183 sequence: event.sequence + 1,
184 reason,
185 })),
186 };
187 });
188
189 describe("RelayEnvironmentDiscovery", () => {
190 it.effect("fetches a fresh list after removal while an older refresh is checking statuses", () =>
191 Effect.gen(function* () {
192 const harness = yield* makeHarness();
193 yield* Effect.gen(function* () {
194 const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
195 const atoms = createRelayEnvironmentDiscoveryAtoms(
196 Atom.runtime(
197 Layer.succeed(RelayEnvironmentDiscovery.RelayEnvironmentDiscovery, discovery),
198 ),
199 );
200 const registry = AtomRegistry.make();
201 yield* Effect.addFinalizer(() => Effect.sync(() => registry.dispose()));
202
203 const refresh = yield* Effect.forkChild(
204 Effect.exit(atoms.refresh.run(registry, undefined)),
205 { startImmediately: true },
206 );
207 yield* SubscriptionRef.changes(discovery.state).pipe(
208 Stream.filter((state) => state.environments.size === environments.length),
209 Stream.runHead,
210 );
211 const coalescedRefresh = yield* Effect.forkChild(
212 Effect.exit(atoms.refresh.run(registry, undefined)),
213 { startImmediately: true },
214 );
215 yield* Ref.set(harness.listedEnvironments, [environments[1]!]);
216 const mutationRefresh = yield* Effect.forkChild(
217 Effect.exit(atoms.refreshAfterMutation.run(registry, undefined)),
218 { startImmediately: true },
219 );
220
221 const requests = yield* Ref.get(harness.statusRequests);
222 for (const environment of environments) {
223 yield* Deferred.succeed(
224 requests.get(environment.environmentId)!,
225 status(environment, "online"),
226 );
227 }
228 const results = yield* Fiber.joinAll([refresh, coalescedRefresh, mutationRefresh]);
229 for (const result of results) {
230 expect(result._tag).toBe("Success");
231 }
232 expect(yield* Ref.get(harness.listCalls)).toBe(2);
233 const complete = yield* SubscriptionRef.get(discovery.state);
234 expect([...complete.environments.keys()]).toEqual([environments[1]!.environmentId]);
235 expect(complete.refreshing).toBe(false);
236 }).pipe(Effect.provide(harness.layer));
237 }),
238 );
239
240 it.effect("publishes each environment status as soon as that lookup completes", () =>
241 Effect.gen(function* () {
242 const harness = yield* makeHarness();
243 yield* Effect.gen(function* () {
244 const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
245 const refreshFiber = yield* Effect.forkChild(discovery.refresh);
246
247 const checking = yield* SubscriptionRef.changes(discovery.state).pipe(
248 Stream.filter((state) => state.environments.size === 2),
249 Stream.runHead,
250 Effect.map(Option.getOrThrow),
251 );
252 expect(
253 [...checking.environments.values()].every((entry) => entry.availability === "checking"),
254 ).toBe(true);
255
256 const requests = yield* Ref.get(harness.statusRequests);
257 yield* Deferred.succeed(
258 requests.get(environments[1]!.environmentId)!,
259 status(environments[1]!, "online"),
260 );
261
262 const partiallyResolved = yield* SubscriptionRef.changes(discovery.state).pipe(
263 Stream.filter(
264 (state) =>
265 state.environments.get(environments[1]!.environmentId)?.availability === "online",
266 ),
267 Stream.runHead,
268 Effect.map(Option.getOrThrow),
269 );
270 expect(
271 partiallyResolved.environments.get(environments[0]!.environmentId)?.availability,
272 ).toBe("checking");
273
274 yield* Deferred.succeed(
275 requests.get(environments[0]!.environmentId)!,
276 status(environments[0]!, "offline"),
277 );
278 yield* Fiber.join(refreshFiber);
279
280 const complete = yield* SubscriptionRef.get(discovery.state);
281 expect(complete.environments.get(environments[0]!.environmentId)?.availability).toBe(
282 "offline",
283 );
284 expect(complete.refreshing).toBe(false);
285 }).pipe(Effect.provide(harness.layer));
286 }),
287 );
288
289 it.effect("reports an environment as unregistered only once the relay list has loaded", () =>
290 Effect.gen(function* () {
291 const harness = yield* makeHarness();
292 yield* Effect.gen(function* () {
293 const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
294 const listed = environments[0]!.environmentId;
295 const deregistered = "deregistered-environment";
296 const before = yield* SubscriptionRef.get(discovery.state);
297 expect(RelayEnvironmentDiscovery.relayEnvironmentRegistration(before, deregistered)).toBe(
298 "unknown",
299 );
300
301 const requests = yield* Ref.get(harness.statusRequests);
302 for (const environment of environments) {
303 yield* Deferred.succeed(
304 requests.get(environment.environmentId)!,
305 status(environment, "online"),
306 );
307 }
308 yield* discovery.refresh;
309
310 const after = yield* SubscriptionRef.get(discovery.state);
311 expect(RelayEnvironmentDiscovery.relayEnvironmentRegistration(after, listed)).toBe(
312 "registered",
313 );
314 expect(RelayEnvironmentDiscovery.relayEnvironmentRegistration(after, deregistered)).toBe(
315 "unregistered",
316 );
317 }).pipe(Effect.provide(harness.layer));
318 }),
319 );
320
321 it.effect(
322 "preserves discovered rows while offline and refreshes after connectivity returns",
323 () =>
324 Effect.gen(function* () {
325 const harness = yield* makeHarness();
326 yield* Effect.gen(function* () {
327 const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
328 const requests = yield* Ref.get(harness.statusRequests);
329 for (const environment of environments) {
330 yield* Deferred.succeed(
331 requests.get(environment.environmentId)!,
332 status(environment, "online"),
333 );
334 }
335 yield* discovery.refresh;
336
337 const offlineFiber = yield* SubscriptionRef.changes(discovery.state).pipe(
338 Stream.filter((state) => state.offline),
339 Stream.runHead,
340 Effect.forkChild,
341 );
342 yield* SubscriptionRef.set(harness.networkStatus, "offline");
343 yield* Fiber.join(offlineFiber);
344 expect((yield* SubscriptionRef.get(discovery.state)).environments.size).toBe(2);
345
346 yield* SubscriptionRef.set(harness.networkStatus, "online");
347 yield* Deferred.await(harness.secondListCall);
348 expect(yield* Ref.get(harness.listCalls)).toBe(2);
349 }).pipe(Effect.provide(harness.layer));
350 }),
351 );
352
353 it.effect("publishes listing failures without rejecting the refresh command", () =>
354 Effect.gen(function* () {
355 const networkStatus = yield* SubscriptionRef.make<NetworkStatus>("online");
356 const client = ManagedRelay.ManagedRelayClient.of({
357 relayUrl: "https://relay.example.test",
358 listEnvironments: () =>
359 Effect.fail(
360 new ManagedRelay.ManagedRelayRequestTimeoutError({
361 activity: "Relay environment listing",
362 timeoutMs: ManagedRelay.MANAGED_RELAY_REQUEST_TIMEOUT_MS,
363 traceId: null,
364 }),
365 ),
366 getEnvironmentStatus: () => Effect.die("unused"),
367 listDevices: () => Effect.die("unused"),
368 createEnvironmentLinkChallenge: () => Effect.die("unused"),
369 linkEnvironment: () => Effect.die("unused"),
370 unlinkEnvironment: () => Effect.die("unused"),
371 getT3ChatLink: () => Effect.die("unused"),
372 createT3ChatLinkRequest: () => Effect.die("unused"),
373 unlinkT3Chat: () => Effect.die("unused"),
374 connectEnvironment: () => Effect.die("unused"),
375 registerDevice: () => Effect.die("unused"),
376 unregisterDevice: () => Effect.die("unused"),
377 registerLiveActivity: () => Effect.die("unused"),
378 getAgentActivitySnapshot: () => Effect.die("unused"),
379 resetTokenCache: Effect.void,
380 } satisfies ManagedRelay.ManagedRelayClient["Service"]);
381 const layer = RelayEnvironmentDiscovery.layer.pipe(
382 Layer.provide(
383 Layer.mergeAll(
384 Layer.succeed(ManagedRelay.ManagedRelayClient, client),
385 Layer.succeed(ClientCapabilities.CloudSession, {
386 identity: Effect.succeedSome({ accountId: "account-1" }),
387 clerkToken: Effect.succeed("clerk-token"),
388 }),
389 Layer.succeed(Connectivity.Connectivity, {
390 status: SubscriptionRef.get(networkStatus),
391 changes: SubscriptionRef.changes(networkStatus),
392 }),
393 Layer.succeed(
394 ConnectionWakeups.ConnectionWakeups,
395 ConnectionWakeups.ConnectionWakeups.of({ changes: Stream.never }),
396 ),
397 ),
398 ),
399 );
400
401 yield* Effect.gen(function* () {
402 const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
403 yield* discovery.refresh;
404
405 const state = yield* SubscriptionRef.get(discovery.state);
406 expect(state.refreshing).toBe(false);
407 expect(Option.getOrThrow(state.error)).toMatchObject({
408 _tag: "ConnectionTransientError",
409 reason: "timeout",
410 message: `Relay environment listing timed out. ${NETWORK_BLOCKING_HINT}`,
411 });
412 }).pipe(Effect.provide(layer));
413 }),
414 );
415
416 it.effect("clears previously discovered rows when a refresh fails", () =>
417 Effect.gen(function* () {
418 const harness = yield* makeHarness();
419 yield* Effect.gen(function* () {
420 const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
421 const requests = yield* Ref.get(harness.statusRequests);
422 for (const environment of environments) {
423 yield* Deferred.succeed(
424 requests.get(environment.environmentId)!,
425 status(environment, "online"),
426 );
427 }
428 yield* discovery.refresh;
429 expect((yield* SubscriptionRef.get(discovery.state)).environments.size).toBe(2);
430
431 yield* Ref.set(
432 harness.listFailure,
433 new ManagedRelay.ManagedRelayRequestFailedError({
434 action: "list relay-managed environments",
435 cause: new Error("Relay request failed."),
436 }),
437 );
438 yield* discovery.refresh;
439
440 const failed = yield* SubscriptionRef.get(discovery.state);
441 expect(failed.environments.size).toBe(0);
442 expect(Option.isSome(failed.error)).toBe(true);
443 expect(
444 RelayEnvironmentDiscovery.relayEnvironmentRegistration(
445 failed,
446 environments[0]!.environmentId,
447 ),
448 ).toBe("unknown");
449 }).pipe(Effect.provide(harness.layer));
450 }),
451 );
452
453 it.effect("refreshes proactively when credentials change before any manual refresh", () =>
454 Effect.gen(function* () {
455 const harness = yield* makeHarness();
456 yield* Effect.gen(function* () {
457 const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
458 const requests = yield* Ref.get(harness.statusRequests);
459 for (const environment of environments) {
460 yield* Deferred.succeed(
461 requests.get(environment.environmentId)!,
462 status(environment, "online"),
463 );
464 }
465
466 // Let the scoped wakeup subscription start before emitting, mirroring
467 // a real sign-in which always happens long after service start.
468 yield* Effect.yieldNow;
469
470 yield* harness.wake("credentials-changed");
471 const populated = yield* SubscriptionRef.changes(discovery.state).pipe(
472 Stream.filter(
473 (state) => state.environments.size === environments.length && !state.refreshing,
474 ),
475 Stream.runHead,
476 Effect.map(Option.getOrThrow),
477 );
478 expect(Option.isNone(populated.error)).toBe(true);
479 expect(yield* Ref.get(harness.listCalls)).toBe(1);
480 }).pipe(Effect.provide(harness.layer), Effect.scoped);
481 }),
482 );
483
484 it.effect.each(["application-active", "application-active-long", "application-focused"] as const)(
485 "lists the account again when the app returns to the foreground (%s)",
486 (reason) =>
487 Effect.gen(function* () {
488 const harness = yield* makeHarness();
489 yield* Ref.set(harness.listedEnvironments, [environments[0]!]);
490 yield* Effect.gen(function* () {
491 const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
492 const requests = yield* Ref.get(harness.statusRequests);
493 for (const environment of environments) {
494 yield* Deferred.succeed(
495 requests.get(environment.environmentId)!,
496 status(environment, "online"),
497 );
498 }
499 // Let the scoped connectivity and wakeup subscriptions start before signing in.
500 yield* Effect.yieldNow;
501 yield* harness.wake("credentials-changed");
502 const signedIn = yield* SubscriptionRef.changes(discovery.state).pipe(
503 Stream.filter((state) => state.listed && !state.refreshing),
504 Stream.runHead,
505 Effect.map(Option.getOrThrow),
506 );
507 expect([...signedIn.environments.keys()]).toEqual([environments[0]!.environmentId]);
508
509 yield* Ref.set(harness.listedEnvironments, environments);
510 yield* harness.wake(reason);
511 const relisted = yield* SubscriptionRef.changes(discovery.state).pipe(
512 Stream.filter(
513 (state) => state.environments.size === environments.length && !state.refreshing,
514 ),
515 Stream.runHead,
516 Effect.map(Option.getOrThrow),
517 );
518 expect([...relisted.environments.keys()]).toEqual(
519 environments.map((environment) => environment.environmentId),
520 );
521 }).pipe(Effect.provide(harness.layer), Effect.scoped);
522 }),
523 );
524
525 it.effect("lists a registration that lands while an earlier refresh checks statuses", () =>
526 Effect.gen(function* () {
527 const harness = yield* makeHarness();
528 yield* Ref.set(harness.listedEnvironments, [environments[0]!]);
529 yield* Effect.gen(function* () {
530 const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
531 yield* Effect.yieldNow;
532 const refreshFiber = yield* Effect.forkChild(discovery.refresh);
533 yield* SubscriptionRef.changes(discovery.state).pipe(
534 Stream.filter((state) => state.listed),
535 Stream.runHead,
536 );
537
538 yield* Ref.set(harness.listedEnvironments, environments);
539 yield* harness.wake("application-active");
540 // Let the wakeup reach discovery while the first refresh still holds the lock.
541 yield* Effect.yieldNow;
542 const requests = yield* Ref.get(harness.statusRequests);
543 for (const environment of environments) {
544 yield* Deferred.succeed(
545 requests.get(environment.environmentId)!,
546 status(environment, "online"),
547 );
548 }
549 yield* Fiber.join(refreshFiber);
550
551 const relisted = yield* SubscriptionRef.changes(discovery.state).pipe(
552 Stream.filter(
553 (state) => state.environments.size === environments.length && !state.refreshing,
554 ),
555 Stream.runHead,
556 Effect.map(Option.getOrThrow),
557 );
558 expect([...relisted.environments.keys()]).toEqual(
559 environments.map((environment) => environment.environmentId),
560 );
561 }).pipe(Effect.provide(harness.layer), Effect.scoped);
562 }),
563 );
564
565 it.effect("coalesces foreground checks that arrive during an in-flight refresh", () =>
566 Effect.gen(function* () {
567 const harness = yield* makeHarness();
568 yield* Effect.gen(function* () {
569 const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
570 yield* Effect.yieldNow;
571 const refreshFiber = yield* Effect.forkChild(discovery.refresh);
572 yield* SubscriptionRef.changes(discovery.state).pipe(
573 Stream.filter((state) => state.listed),
574 Stream.runHead,
575 );
576
577 for (const reason of [
578 "application-active",
579 "application-focused",
580 "application-active",
581 "application-focused",
582 "application-active-long",
583 ] as const) {
584 yield* harness.wake(reason);
585 yield* Effect.yieldNow;
586 }
587 // Waits on the lock behind every refresh the wakeups queued.
588 const lastRefresh = yield* Effect.forkChild(discovery.refresh);
589 yield* Effect.yieldNow;
590 const requests = yield* Ref.get(harness.statusRequests);
591 for (const environment of environments) {
592 yield* Deferred.succeed(
593 requests.get(environment.environmentId)!,
594 status(environment, "online"),
595 );
596 }
597 yield* Fiber.join(refreshFiber);
598 yield* Fiber.join(lastRefresh);
599
600 // The first refresh, one queued refresh, one trailing check's listing, and the last refresh.
601 expect(yield* Ref.get(harness.listCalls)).toBe(4);
602 }).pipe(Effect.provide(harness.layer), Effect.scoped);
603 }),
604 );
605
606 it.effect("keeps listed rows when the foreground check cannot list the account", () =>
607 Effect.gen(function* () {
608 const harness = yield* makeHarness();
609 yield* Effect.gen(function* () {
610 const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
611 const requests = yield* Ref.get(harness.statusRequests);
612 for (const environment of environments) {
613 yield* Deferred.succeed(
614 requests.get(environment.environmentId)!,
615 status(environment, "online"),
616 );
617 }
618 yield* Effect.yieldNow;
619 yield* discovery.refresh;
620 const settled = yield* SubscriptionRef.get(discovery.state);
621
622 yield* Ref.set(
623 harness.listFailure,
624 new ManagedRelay.ManagedRelayRequestFailedError({
625 action: "list relay-managed environments",
626 cause: new Error("Relay request failed."),
627 }),
628 );
629 yield* harness.wake("application-active");
630 yield* Deferred.await(harness.secondListCall);
631
632 const after = yield* SubscriptionRef.get(discovery.state);
633 expect(after).toBe(settled);
634 expect(after.environments.size).toBe(environments.length);
635 expect(Option.isNone(after.error)).toBe(true);
636 }).pipe(Effect.provide(harness.layer), Effect.scoped);
637 }),
638 );
639
640 it.effect("leaves an unchanged account list untouched when the app returns", () =>
641 Effect.gen(function* () {
642 const harness = yield* makeHarness();
643 yield* Effect.gen(function* () {
644 const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
645 const requests = yield* Ref.get(harness.statusRequests);
646 for (const environment of environments) {
647 yield* Deferred.succeed(
648 requests.get(environment.environmentId)!,
649 status(environment, "online"),
650 );
651 }
652 yield* Effect.yieldNow;
653 yield* discovery.refresh;
654 const settled = yield* SubscriptionRef.get(discovery.state);
655
656 yield* harness.wake("application-active");
657 yield* Deferred.await(harness.secondListCall);
658
659 expect(yield* SubscriptionRef.get(discovery.state)).toBe(settled);
660 expect(yield* Ref.get(harness.listCalls)).toBe(2);
661 expect(yield* Ref.get(harness.statusCalls)).toBe(environments.length);
662 }).pipe(Effect.provide(harness.layer), Effect.scoped);
663 }),
664 );
665
666 it.effect("settles to a clean empty state when refreshed while signed out", () =>
667 Effect.gen(function* () {
668 const harness = yield* makeHarness();
669 yield* Effect.gen(function* () {
670 const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
671 yield* Ref.set(harness.clerkToken, null);
672 yield* discovery.refresh;
673
674 const state = yield* SubscriptionRef.get(discovery.state);
675 expect(state.environments.size).toBe(0);
676 expect(state.refreshing).toBe(false);
677 expect(Option.isNone(state.error)).toBe(true);
678 expect(
679 RelayEnvironmentDiscovery.relayEnvironmentRegistration(
680 state,
681 environments[0]!.environmentId,
682 ),
683 ).toBe("unknown");
684 }).pipe(Effect.provide(harness.layer));
685 }),
686 );
687
688 it.effect("does not republish stale rows after sign-out invalidates an in-flight refresh", () =>
689 Effect.gen(function* () {
690 const harness = yield* makeHarness();
691 yield* Effect.gen(function* () {
692 const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
693 const refreshFiber = yield* Effect.forkChild(discovery.refresh);
694 yield* SubscriptionRef.changes(discovery.state).pipe(
695 Stream.filter((state) => state.environments.size === environments.length),
696 Stream.runHead,
697 );
698
699 yield* Ref.set(harness.clerkToken, null);
700 yield* harness.wake("credentials-changed");
701 yield* SubscriptionRef.changes(discovery.state).pipe(
702 Stream.filter((state) => state.environments.size === 0),
703 Stream.runHead,
704 );
705
706 const requests = yield* Ref.get(harness.statusRequests);
707 for (const environment of environments) {
708 yield* Deferred.succeed(
709 requests.get(environment.environmentId)!,
710 status(environment, "online"),
711 );
712 }
713 yield* Fiber.join(refreshFiber);
714 yield* Effect.yieldNow;
715
716 const signedOut = yield* SubscriptionRef.get(discovery.state);
717 expect(signedOut.environments.size).toBe(0);
718 expect(
719 RelayEnvironmentDiscovery.relayEnvironmentRegistration(
720 signedOut,
721 environments[0]!.environmentId,
722 ),
723 ).toBe("unknown");
724 }).pipe(Effect.provide(harness.layer), Effect.scoped);
725 }),
726 );
727 });