Open History to see the last commit
1import {
2 AuthStandardClientScopes,
3 EnvironmentId,
4 ORCHESTRATION_PROTOCOL_VERSION,
5 type ExecutionEnvironmentDescriptor,
6} from "@t3tools/contracts";
7import { type RelayEnvironmentConnectResponse } from "@t3tools/contracts/relay";
8import { describe, expect, it } from "@effect/vitest";
9import * as Deferred from "effect/Deferred";
10import * as Effect from "effect/Effect";
11import * as Fiber from "effect/Fiber";
12import * as Layer from "effect/Layer";
13import * as Option from "effect/Option";
14import * as Queue from "effect/Queue";
15import * as Ref from "effect/Ref";
16import * as TestClock from "effect/testing/TestClock";
17
18import * as ManagedRelay from "../relay/managedRelay.ts";
19import * as RpcHttp from "../rpc/http.ts";
20import * as ClientCapabilities from "../platform/capabilities.ts";
21import * as RemoteEnvironmentAuthorization from "./service.ts";
22import * as TokenStore from "./tokenStore.ts";
23import { BearerConnectionCredential, BearerConnectionProfile } from "../connection/catalog.ts";
24import * as ConnectionCredentialStore from "../connection/credentialStore.ts";
25import { BearerConnectionTarget } from "../connection/model.ts";
26import * as ConnectionProfileStore from "../connection/profileStore.ts";
27import * as ConnectionResolver from "../connection/resolver.ts";
28
29const ENVIRONMENT_ID = EnvironmentId.make("environment-1");
30const ENDPOINT = {
31 httpBaseUrl: "https://environment.example.test",
32 wsBaseUrl: "wss://environment.example.test",
33 providerKind: "cloudflare_tunnel" as const,
34};
35const DESCRIPTOR = {
36 environmentId: ENVIRONMENT_ID,
37 label: "Remote environment",
38 platform: {
39 os: "linux",
40 arch: "x64",
41 },
42 serverVersion: "0.0.0-test",
43 capabilities: {
44 repositoryIdentity: true,
45 },
46};
47const BOOTSTRAP: RelayEnvironmentConnectResponse = {
48 environmentId: ENVIRONMENT_ID,
49 endpoint: ENDPOINT,
50 credential: "relay-bootstrap",
51 expiresAt: "2026-06-06T01:00:00.000Z",
52};
53
54type RecordedResponse = Response | ((init: RequestInit) => Response | Promise<Response>);
55
56function recordedFetch(responses: ReadonlyArray<RecordedResponse>, descriptor?: object) {
57 const calls: Array<readonly [RequestInfo | URL, RequestInit]> = [];
58 let responseIndex = 0;
59 const fetchFn = ((input, init) => {
60 calls.push([input, init ?? {}]);
61 if (descriptor !== undefined && String(input).endsWith("/.well-known/t3/environment")) {
62 return Promise.resolve(Response.json(descriptor));
63 }
64 const response = responses[responseIndex++];
65 return response === undefined
66 ? Promise.reject(new Error(`Unexpected fetch call to ${String(input)}`))
67 : Promise.resolve(typeof response === "function" ? response(init ?? {}) : response);
68 }) satisfies typeof fetch;
69 return { calls, fetchFn };
70}
71
72const websocketTicket = (ticket: string) =>
73 Response.json({
74 ticket,
75 expiresAt: "2026-06-06T01:00:00.000Z",
76 });
77
78const accessToken = (token: string, scope = AuthStandardClientScopes.join(" ")) =>
79 Response.json({
80 access_token: token,
81 issued_token_type: "urn:ietf:params:oauth:token-type:access_token",
82 token_type: "DPoP",
83 expires_in: 3_600,
84 scope,
85 });
86
87const authInvalid = () =>
88 Response.json(
89 {
90 _tag: "EnvironmentAuthInvalidError",
91 code: "auth_invalid",
92 reason: "invalid_credential",
93 traceId: "trace-auth-invalid",
94 },
95 { status: 401 },
96 );
97
98const persistedToken = (
99 input: {
100 readonly environmentId?: EnvironmentId;
101 readonly accessToken?: string;
102 readonly expiresAtEpochMs?: number;
103 readonly dpopThumbprint?: string;
104 } = {},
105) =>
106 new TokenStore.RemoteDpopAccessToken({
107 environmentId: input.environmentId ?? ENVIRONMENT_ID,
108 accountId: "account-1",
109 label: DESCRIPTOR.label,
110 endpoint: ENDPOINT,
111 accessToken: input.accessToken ?? "cached-access-token",
112 expiresAtEpochMs: input.expiresAtEpochMs ?? Number.MAX_SAFE_INTEGER,
113 dpopThumbprint: input.dpopThumbprint ?? "thumbprint-1",
114 });
115
116const makeHarness = Effect.fn("TestRemoteAuthorization.makeHarness")(function* (input: {
117 readonly initialToken?: TokenStore.RemoteDpopAccessToken;
118 readonly responses: ReadonlyArray<RecordedResponse>;
119 /** Answers every descriptor read, so one that runs beside a ticket does not shift `responses`. */
120 readonly descriptor?: object;
121 readonly bootstrap?: RelayEnvironmentConnectResponse;
122 readonly beforeBootstrap?: Effect.Effect<void, ManagedRelay.ManagedRelayClientError>;
123 readonly beforePut?: Effect.Effect<void>;
124 readonly clerkToken?: ClientCapabilities.CloudSession["Service"]["clerkToken"];
125}) {
126 const tokens = yield* Ref.make(
127 new Map(
128 input.initialToken === undefined
129 ? []
130 : [[input.initialToken.environmentId, input.initialToken]],
131 ),
132 );
133 const bootstrapCalls = yield* Ref.make(0);
134 const relayInputs = yield* Ref.make<
135 ReadonlyArray<Parameters<ManagedRelay.ManagedRelayClient["Service"]["connectEnvironment"]>[0]>
136 >([]);
137 const session = yield* Ref.make<Option.Option<ClientCapabilities.CloudSessionIdentity>>(
138 Option.some({ accountId: "account-1" }),
139 );
140 const thumbprint = yield* Ref.make("thumbprint-1");
141 const tokenReads = yield* Queue.unbounded<EnvironmentId>();
142 const proofInputs = yield* Ref.make<
143 ReadonlyArray<{
144 readonly method: string;
145 readonly url: string;
146 readonly accessToken?: string;
147 }>
148 >([]);
149 const fetch = recordedFetch(input.responses, input.descriptor);
150
151 const tokenStore = TokenStore.RemoteDpopAccessTokenStore.of({
152 get: (environmentId) =>
153 Ref.get(tokens).pipe(
154 Effect.map((current) => Option.fromUndefinedOr(current.get(environmentId))),
155 Effect.tap(() => Queue.offer(tokenReads, environmentId)),
156 ),
157 put: (token) =>
158 (input.beforePut ?? Effect.void).pipe(
159 Effect.andThen(
160 Ref.update(tokens, (current) => {
161 const next = new Map(current);
162 next.set(token.environmentId, token);
163 return next;
164 }),
165 ),
166 ),
167 remove: (environmentId) =>
168 Ref.update(tokens, (current) => {
169 const next = new Map(current);
170 next.delete(environmentId);
171 return next;
172 }),
173 });
174 const signer = ManagedRelay.ManagedRelayDpopSigner.of({
175 thumbprint: Ref.get(thumbprint),
176 createProof: (proofInput) =>
177 Ref.update(proofInputs, (current) => [...current, proofInput]).pipe(
178 Effect.as(`proof:${proofInput.url}`),
179 ),
180 });
181 const unexpected = () => Effect.die("Unexpected relay request");
182 const relay = ManagedRelay.ManagedRelayClient.of({
183 relayUrl: "https://relay.example.test",
184 listEnvironments: unexpected,
185 listDevices: unexpected,
186 createEnvironmentLinkChallenge: unexpected,
187 linkEnvironment: unexpected,
188 unlinkEnvironment: unexpected,
189 getT3ChatLink: unexpected,
190 createT3ChatLinkRequest: unexpected,
191 unlinkT3Chat: unexpected,
192 getEnvironmentStatus: unexpected,
193 connectEnvironment: (request) =>
194 Effect.gen(function* () {
195 yield* Ref.update(bootstrapCalls, (count) => count + 1);
196 yield* Ref.update(relayInputs, (current) => [...current, request]);
197 yield* input.beforeBootstrap ?? Effect.void;
198 return input.bootstrap ?? BOOTSTRAP;
199 }),
200 registerDevice: unexpected,
201 unregisterDevice: unexpected,
202 registerLiveActivity: unexpected,
203 getAgentActivitySnapshot: unexpected,
204 resetTokenCache: Effect.void,
205 });
206 const layer = RemoteEnvironmentAuthorization.layer.pipe(
207 Layer.provideMerge(
208 Layer.mergeAll(
209 RpcHttp.layerRemoteHttpClient(fetch.fetchFn),
210 Layer.succeed(ManagedRelay.ManagedRelayDpopSigner, signer),
211 Layer.succeed(ManagedRelay.ManagedRelayClient, relay),
212 Layer.succeed(ClientCapabilities.CloudSession, {
213 identity: Ref.get(session),
214 clerkToken: input.clerkToken ?? Effect.succeed("clerk-session"),
215 }),
216 Layer.succeed(ClientCapabilities.RelayDeviceIdentity, {
217 deviceId: Effect.succeedSome("device-1"),
218 }),
219 Layer.succeed(TokenStore.RemoteDpopAccessTokenStore, tokenStore),
220 Layer.succeed(
221 ClientCapabilities.ClientPresentation,
222 ClientCapabilities.ClientPresentation.of({
223 metadata: {
224 label: "T3 Code Test",
225 deviceType: "mobile",
226 os: "test",
227 },
228 }),
229 ),
230 ),
231 ),
232 );
233 return {
234 layer,
235 tokens,
236 bootstrapCalls,
237 proofInputs,
238 fetch,
239 relayInputs,
240 session,
241 thumbprint,
242 tokenReads,
243 };
244});
245
246const requestsTo = (harness: Effect.Success<ReturnType<typeof makeHarness>>, path: string) =>
247 harness.fetch.calls.filter(([url]) => String(url).endsWith(path)).length;
248
249const prepareDirectBearer = Effect.fn("TestRemoteAuthorization.prepareDirectBearer")(function* (
250 harness: Effect.Success<ReturnType<typeof makeHarness>>,
251 times: number,
252) {
253 const target = new BearerConnectionTarget({
254 environmentId: ENVIRONMENT_ID,
255 label: DESCRIPTOR.label,
256 connectionId: "direct-1",
257 });
258 const entry = {
259 target,
260 profile: Option.some(
261 new BearerConnectionProfile({
262 connectionId: target.connectionId,
263 environmentId: ENVIRONMENT_ID,
264 label: target.label,
265 httpBaseUrl: ENDPOINT.httpBaseUrl,
266 wsBaseUrl: ENDPOINT.wsBaseUrl,
267 }),
268 ),
269 enabled: true,
270 };
271 const unused = () => Effect.die("unused");
272 const layer = ConnectionResolver.layer.pipe(
273 Layer.provide(
274 Layer.mergeAll(
275 harness.layer,
276 Layer.succeed(ConnectionProfileStore.ConnectionProfileStore, {
277 get: unused,
278 put: unused,
279 remove: unused,
280 }),
281 Layer.succeed(ConnectionCredentialStore.ConnectionCredentialStore, {
282 get: () => Effect.succeedSome(new BearerConnectionCredential({ token: "bearer-token" })),
283 put: unused,
284 remove: unused,
285 }),
286 Layer.succeed(ClientCapabilities.PrimaryEnvironmentAuth, {
287 bearerToken: Effect.succeedNone,
288 }),
289 Layer.succeed(ClientCapabilities.SshEnvironmentGateway, {
290 provision: unused,
291 prepare: unused,
292 disconnect: unused,
293 }),
294 ),
295 ),
296 );
297 const resolver = yield* ConnectionResolver.ConnectionResolver.pipe(Effect.provide(layer));
298 return yield* Effect.forEach(Array.from({ length: times }), () =>
299 resolver.prepare(entry).pipe(Effect.result),
300 );
301});
302
303describe("RemoteEnvironmentAuthorization", () => {
304 it.effect("prepares a cold direct bearer connection with one descriptor request", () =>
305 Effect.gen(function* () {
306 const harness = yield* makeHarness({
307 responses: [
308 Response.json({
309 ...DESCRIPTOR,
310 orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION,
311 }),
312 websocketTicket("cold-ticket"),
313 ],
314 });
315
316 const [prepared] = yield* prepareDirectBearer(harness, 1);
317
318 expect(prepared).toMatchObject({
319 _tag: "Success",
320 success: { socketUrl: expect.stringContaining("wsTicket=cold-ticket") },
321 });
322 expect(harness.fetch.calls.map(([url]) => new URL(String(url)).pathname)).toEqual([
323 "/.well-known/t3/environment",
324 "/api/auth/websocket-ticket/rpc",
325 ]);
326 }),
327 );
328
329 it.effect("reuses a matching descriptor a check just read, once, while fresh", () =>
330 Effect.gen(function* () {
331 const descriptor = {
332 ...DESCRIPTOR,
333 orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION,
334 } as ExecutionEnvironmentDescriptor;
335 const harness = yield* makeHarness({
336 responses: [
337 websocketTicket("reused"),
338 ...Array.from({ length: 4 }, () => [
339 Response.json(descriptor),
340 websocketTicket("fresh"),
341 ]).flat(),
342 websocketTicket("reused over plain HTTP"),
343 Response.json(descriptor),
344 websocketTicket("fresh"),
345 ],
346 });
347
348 yield* Effect.gen(function* () {
349 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
350 const authorizeAt = (httpBaseUrl: string) =>
351 remote.authorizeBearer({
352 expectedEnvironmentId: ENVIRONMENT_ID,
353 httpBaseUrl,
354 wsBaseUrl: httpBaseUrl.replace(/^http/, "ws"),
355 bearerToken: "bearer-token",
356 connectionMethod: "direct",
357 });
358 const authorize = authorizeAt(ENDPOINT.httpBaseUrl);
359 const remember = (value: Option.Option<ExecutionEnvironmentDescriptor>) =>
360 remote.rememberCheckedDescriptor(ENDPOINT.httpBaseUrl, value, true);
361
362 yield* remember(Option.some(descriptor));
363 yield* authorize;
364 // Used once.
365 yield* authorize;
366 // Stale.
367 yield* remember(Option.some(descriptor));
368 yield* TestClock.adjust("6 seconds");
369 yield* authorize;
370 // A mismatch reads again, so a host back on the right environment is not blocked.
371 yield* remember(Option.some({ ...descriptor, environmentId: "other" as never }));
372 yield* authorize;
373 // A failed check drops an older match.
374 yield* remember(Option.some(descriptor));
375 yield* remember(Option.none());
376 yield* authorize;
377 // Plain HTTP is no reason to read again where the address keeps its host.
378 yield* remote.rememberCheckedDescriptor(
379 "http://127.0.0.1:3773",
380 Option.some(descriptor),
381 true,
382 );
383 yield* authorizeAt("http://127.0.0.1:3773");
384 // After a network change, a plain LAN address can belong to another machine.
385 yield* remote.rememberCheckedDescriptor(
386 "http://192.168.1.2:3773",
387 Option.some(descriptor),
388 false,
389 );
390 yield* authorizeAt("http://192.168.1.2:3773");
391 }).pipe(Effect.provide(harness.layer));
392
393 expect(harness.fetch.calls.map(([url]) => new URL(String(url)).pathname)).toEqual([
394 "/api/auth/websocket-ticket/rpc",
395 ...Array.from({ length: 4 }, () => [
396 "/.well-known/t3/environment",
397 "/api/auth/websocket-ticket/rpc",
398 ]).flat(),
399 "/api/auth/websocket-ticket/rpc",
400 "/.well-known/t3/environment",
401 "/api/auth/websocket-ticket/rpc",
402 ]);
403 }),
404 );
405
406 it.effect("blocks a warm direct bearer prepare when the environment changes identity", () =>
407 Effect.gen(function* () {
408 const harness = yield* makeHarness({
409 responses: [
410 Response.json({
411 ...DESCRIPTOR,
412 orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION,
413 }),
414 websocketTicket("first-ticket"),
415 Response.json({
416 ...DESCRIPTOR,
417 environmentId: "another-environment",
418 orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION,
419 }),
420 ],
421 });
422
423 const [first, second] = yield* prepareDirectBearer(harness, 2);
424
425 expect(first?._tag).toBe("Success");
426 expect(second).toMatchObject({
427 _tag: "Failure",
428 failure: { _tag: "ConnectionBlockedError", reason: "configuration" },
429 });
430 expect(
431 harness.fetch.calls.filter(([url]) =>
432 String(url).endsWith("/api/auth/websocket-ticket/rpc"),
433 ),
434 ).toHaveLength(1);
435 }),
436 );
437 it.effect("validates a fresh bearer descriptor while issuing fresh websocket tickets", () =>
438 Effect.gen(function* () {
439 const harness = yield* makeHarness({
440 responses: [
441 Response.json(DESCRIPTOR),
442 websocketTicket("first-ticket"),
443 Response.json(DESCRIPTOR),
444 websocketTicket("second-ticket"),
445 ],
446 });
447
448 const [first, second] = yield* Effect.gen(function* () {
449 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
450 const authorize = () =>
451 remote.authorizeBearer({
452 expectedEnvironmentId: ENVIRONMENT_ID,
453 httpBaseUrl: ENDPOINT.httpBaseUrl,
454 wsBaseUrl: ENDPOINT.wsBaseUrl,
455 bearerToken: "bearer-token",
456 connectionMethod: "direct",
457 });
458 return [yield* authorize(), yield* authorize()] as const;
459 }).pipe(Effect.provide(harness.layer));
460
461 expect(first.socketUrl).toContain("wsTicket=first-ticket");
462 expect(second.socketUrl).toContain("wsTicket=second-ticket");
463 expect(
464 harness.fetch.calls.filter(([url]) => String(url).endsWith("/.well-known/t3/environment")),
465 ).toHaveLength(2);
466 expect(
467 harness.fetch.calls.filter(([url]) =>
468 String(url).endsWith("/api/auth/websocket-ticket/rpc"),
469 ),
470 ).toHaveLength(2);
471 }),
472 );
473
474 it.effect("gives up on a silent loopback or LAN address sooner than on a remote one", () =>
475 Effect.gen(function* () {
476 const silent = () => new Promise<Response>(() => {});
477 const harness = yield* makeHarness({ responses: [silent, silent, silent] });
478
479 yield* Effect.gen(function* () {
480 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
481 const authorizeAt = (httpBaseUrl: string, connectionMethod: "direct" | "ssh" = "direct") =>
482 remote
483 .authorizeBearer({
484 expectedEnvironmentId: ENVIRONMENT_ID,
485 httpBaseUrl,
486 wsBaseUrl: httpBaseUrl.replace(/^http/, "ws"),
487 bearerToken: "bearer-token",
488 connectionMethod,
489 })
490 .pipe(Effect.flip, Effect.forkChild);
491 const lan = yield* authorizeAt("http://192.168.1.2:3773");
492 const tailnet = yield* authorizeAt("http://100.101.102.103:3773");
493 // An SSH forward listens on loopback but reaches a remote host.
494 const forwarded = yield* authorizeAt("http://127.0.0.1:4010", "ssh");
495
496 yield* TestClock.adjust("3 seconds");
497 expect(lan.pollUnsafe()).toBeDefined();
498 expect(tailnet.pollUnsafe()).toBeUndefined();
499 expect(forwarded.pollUnsafe()).toBeUndefined();
500 expect(yield* Fiber.join(lan)).toMatchObject({
501 _tag: "ConnectionTransientError",
502 reason: "timeout",
503 });
504
505 yield* TestClock.adjust("7 seconds");
506 expect(tailnet.pollUnsafe()).toBeDefined();
507 expect(forwarded.pollUnsafe()).toBeDefined();
508 }).pipe(Effect.provide(harness.layer));
509 }),
510 );
511
512 it.effect("reuses a same-account persisted environment token without contacting the relay", () =>
513 Effect.gen(function* () {
514 const cached = new TokenStore.RemoteDpopAccessToken({
515 environmentId: ENVIRONMENT_ID,
516 accountId: "account-1",
517 label: DESCRIPTOR.label,
518 endpoint: ENDPOINT,
519 accessToken: "cached-access-token",
520 expiresAtEpochMs: Number.MAX_SAFE_INTEGER,
521 dpopThumbprint: "thumbprint-1",
522 });
523 const harness = yield* makeHarness({
524 initialToken: cached,
525 descriptor: DESCRIPTOR,
526 responses: [websocketTicket("cached-ticket")],
527 });
528
529 const authorized = yield* Effect.gen(function* () {
530 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
531 return yield* remote.authorizeDpop({
532 expectedEnvironmentId: ENVIRONMENT_ID,
533 });
534 }).pipe(Effect.provide(harness.layer));
535
536 expect(authorized.socketUrl).toContain("wsTicket=cached-ticket");
537 expect(authorized.socketUrl).toContain("connectionMethod=relay");
538 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(0);
539 // The descriptor is read beside the ticket, so the connect needs no later read.
540 expect(authorized.descriptor).toMatchObject({ environmentId: ENVIRONMENT_ID });
541 expect(harness.fetch.calls.map(([url]) => String(url)).toSorted()).toEqual([
542 "https://environment.example.test/.well-known/t3/environment",
543 "https://environment.example.test/api/auth/websocket-ticket/rpc",
544 ]);
545 }),
546 );
547
548 it.effect("uses the T3 Connect token on a learned direct address without the relay", () =>
549 Effect.gen(function* () {
550 const cached = new TokenStore.RemoteDpopAccessToken({
551 environmentId: ENVIRONMENT_ID,
552 accountId: "account-1",
553 label: DESCRIPTOR.label,
554 endpoint: ENDPOINT,
555 accessToken: "cached-access-token",
556 expiresAtEpochMs: Number.MAX_SAFE_INTEGER,
557 dpopThumbprint: "thumbprint-1",
558 });
559 const harness = yield* makeHarness({
560 initialToken: cached,
561 responses: [Response.json(DESCRIPTOR), websocketTicket("lan-ticket")],
562 });
563
564 const authorized = yield* Effect.gen(function* () {
565 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
566 return yield* remote.authorizeDpop({
567 expectedEnvironmentId: ENVIRONMENT_ID,
568 directEndpoint: {
569 httpBaseUrl: "http://192.168.1.10:3773/",
570 wsBaseUrl: "ws://192.168.1.10:3773/",
571 },
572 });
573 }).pipe(Effect.provide(harness.layer));
574
575 expect(authorized.httpBaseUrl).toBe("http://192.168.1.10:3773/");
576 expect(authorized.socketUrl).toMatch(/^ws:\/\/192\.168\.1\.10:3773\/ws\?/);
577 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(0);
578 expect(harness.fetch.calls.map(([url]) => String(url))).toEqual([
579 "http://192.168.1.10:3773/.well-known/t3/environment",
580 "http://192.168.1.10:3773/api/auth/websocket-ticket/rpc",
581 ]);
582 }),
583 );
584
585 it.effect("sends no token to a direct address that answers as another machine", () =>
586 Effect.gen(function* () {
587 const harness = yield* makeHarness({
588 initialToken: persistedToken({ accessToken: "cached-access-token" }),
589 responses: [
590 Response.json({ ...DESCRIPTOR, environmentId: EnvironmentId.make("someone-else") }),
591 ],
592 });
593
594 const error = yield* Effect.gen(function* () {
595 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
596 return yield* remote
597 .authorizeDpop({
598 expectedEnvironmentId: ENVIRONMENT_ID,
599 directEndpoint: {
600 httpBaseUrl: "http://192.168.1.10:3773/",
601 wsBaseUrl: "ws://192.168.1.10:3773/",
602 },
603 })
604 .pipe(Effect.flip);
605 }).pipe(Effect.provide(harness.layer));
606
607 expect(error).toMatchObject({ _tag: "ConnectionBlockedError", reason: "configuration" });
608 expect(harness.fetch.calls.map(([url]) => String(url))).toEqual([
609 "http://192.168.1.10:3773/.well-known/t3/environment",
610 ]);
611 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)?.accessToken).toBe(
612 "cached-access-token",
613 );
614 }),
615 );
616
617 it.effect("refreshes and persists an expired environment token", () =>
618 Effect.gen(function* () {
619 const expired = new TokenStore.RemoteDpopAccessToken({
620 environmentId: ENVIRONMENT_ID,
621 accountId: "account-1",
622 label: DESCRIPTOR.label,
623 endpoint: ENDPOINT,
624 accessToken: "expired-access-token",
625 expiresAtEpochMs: 0,
626 dpopThumbprint: "thumbprint-1",
627 });
628 const harness = yield* makeHarness({
629 initialToken: expired,
630 responses: [
631 Response.json(DESCRIPTOR),
632 accessToken("fresh-access-token"),
633 websocketTicket("fresh-ticket"),
634 ],
635 });
636
637 const authorized = yield* Effect.gen(function* () {
638 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
639 return yield* remote.authorizeDpop({
640 expectedEnvironmentId: ENVIRONMENT_ID,
641 });
642 }).pipe(Effect.provide(harness.layer));
643
644 expect(authorized.socketUrl).toContain("wsTicket=fresh-ticket");
645 // The mint already read the descriptor.
646 expect(authorized.descriptor).toMatchObject({ environmentId: ENVIRONMENT_ID });
647 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
648 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)).toEqual(
649 expect.objectContaining({
650 accessToken: "fresh-access-token",
651 dpopThumbprint: "thumbprint-1",
652 }),
653 );
654 expect(harness.fetch.calls).toHaveLength(3);
655 }),
656 );
657
658 it.effect.each([
659 { name: "read-only", grantScopes: ["orchestration:read"] },
660 { name: "default", grantScopes: AuthStandardClientScopes },
661 ] as const)(
662 "inherits $name pairing grant scopes for websocket authorization and HTTP renewal",
663 ({ grantScopes }) =>
664 Effect.gen(function* () {
665 const grantedScope = grantScopes.join(" ");
666 let exchangeCount = 0;
667 const tokenFields = (init: RequestInit) =>
668 new URLSearchParams(
669 init.body instanceof Uint8Array
670 ? new TextDecoder().decode(init.body)
671 : String(init.body),
672 );
673 const exchangeGrant = (init: RequestInit) => {
674 const fields = tokenFields(init);
675 expect(fields.get("scope")).toBeNull();
676 const scope = fields.get("scope") ?? grantedScope;
677 const scopes = scope.split(" ");
678 if (scopes.some((requested) => !grantScopes.some((grant) => grant === requested))) {
679 return authInvalid();
680 }
681 return accessToken(`access-token:${++exchangeCount}:${scopes.join(",")}`, scope);
682 };
683 const harness = yield* makeHarness({
684 responses: [
685 Response.json(DESCRIPTOR),
686 exchangeGrant,
687 websocketTicket("granted-ticket"),
688 Response.json(DESCRIPTOR),
689 exchangeGrant,
690 ],
691 });
692
693 const [authorized, refreshed] = yield* Effect.gen(function* () {
694 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
695 const first = yield* remote.authorizeDpop({
696 expectedEnvironmentId: ENVIRONMENT_ID,
697 });
698 yield* TestClock.adjust("1 hour");
699 const refreshed = yield* remote.authorizeDpopHttp({
700 expectedEnvironmentId: ENVIRONMENT_ID,
701 });
702 return [first, refreshed] as const;
703 }).pipe(Effect.provide(Layer.merge(harness.layer, TestClock.layer())));
704
705 expect(authorized.socketUrl).toContain("wsTicket=granted-ticket");
706 expect(authorized.httpAuthorization).toMatchObject({
707 _tag: "Dpop",
708 accessToken: `access-token:1:${grantScopes.join(",")}`,
709 });
710 expect(refreshed.httpAuthorization).toMatchObject({
711 _tag: "Dpop",
712 accessToken: `access-token:2:${grantScopes.join(",")}`,
713 });
714 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)).toMatchObject({
715 accessToken: `access-token:2:${grantScopes.join(",")}`,
716 dpopThumbprint: "thumbprint-1",
717 });
718 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(2);
719 const exchanges = harness.fetch.calls.filter(([url]) =>
720 String(url).endsWith("/oauth/token"),
721 );
722 expect(exchanges).toHaveLength(2);
723 for (const [, init] of exchanges) {
724 expect(Object.fromEntries(tokenFields(init))).toMatchObject({
725 subject_token: BOOTSTRAP.credential,
726 client_label: "T3 Code Test",
727 client_device_type: "mobile",
728 client_os: "test",
729 });
730 }
731 }),
732 );
733
734 it.effect("renews a live socket's token in the minute before each expiry", () =>
735 Effect.gen(function* () {
736 const puts = yield* Queue.unbounded<void>();
737 const relayBlips = yield* Ref.make(1);
738 const harness = yield* makeHarness({
739 beforeBootstrap: Ref.getAndUpdate(relayBlips, (count) => count - 1).pipe(
740 Effect.flatMap((count) =>
741 count > 0
742 ? Effect.fail(
743 new ManagedRelay.ManagedRelayRequestTimeoutError({
744 activity: "Relay environment connection",
745 timeoutMs: 30_000,
746 traceId: null,
747 }),
748 )
749 : Effect.void,
750 ),
751 ),
752 initialToken: persistedToken({ expiresAtEpochMs: 3_600_000 }),
753 responses: [
754 Response.json(DESCRIPTOR),
755 accessToken("renewed-1"),
756 Response.json(DESCRIPTOR),
757 accessToken("renewed-2"),
758 ],
759 beforePut: Queue.offer(puts, undefined).pipe(Effect.asVoid),
760 });
761
762 yield* Effect.gen(function* () {
763 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
764 yield* remote
765 .renewDpopBeforeExpiry({
766 expectedEnvironmentId: ENVIRONMENT_ID,
767 expiresAtEpochMs: 3_600_000,
768 })
769 .pipe(Effect.forkScoped);
770 yield* TestClock.adjust(3_540_000 - 1);
771 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(0);
772 // The first try hits a relay blip, and the retry 5 s later succeeds.
773 yield* TestClock.adjust(1);
774 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
775 yield* TestClock.adjust(5_000);
776 yield* Queue.take(puts);
777 // Renewed at 0:59:05, so the next renewal is at 1:58:05.
778 yield* TestClock.adjust(7_085_000 - 3_545_000 - 1);
779 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(2);
780 yield* TestClock.adjust(1);
781 yield* Queue.take(puts);
782 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(3);
783 }).pipe(Effect.scoped, Effect.provide(Layer.merge(harness.layer, TestClock.layer())));
784 }),
785 );
786
787 it.effect("evicts an auth-invalid cached token and obtains a fresh bootstrap", () =>
788 Effect.gen(function* () {
789 const cached = new TokenStore.RemoteDpopAccessToken({
790 environmentId: ENVIRONMENT_ID,
791 accountId: "account-1",
792 label: DESCRIPTOR.label,
793 endpoint: ENDPOINT,
794 accessToken: "invalid-access-token",
795 expiresAtEpochMs: Number.MAX_SAFE_INTEGER,
796 dpopThumbprint: "thumbprint-1",
797 });
798 const harness = yield* makeHarness({
799 initialToken: cached,
800 descriptor: DESCRIPTOR,
801 responses: [
802 authInvalid(),
803 accessToken("replacement-access-token"),
804 websocketTicket("replacement-ticket"),
805 ],
806 });
807
808 const authorized = yield* Effect.gen(function* () {
809 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
810 return yield* remote.authorizeDpop({
811 expectedEnvironmentId: ENVIRONMENT_ID,
812 });
813 }).pipe(Effect.provide(harness.layer));
814
815 expect(authorized.socketUrl).toContain("wsTicket=replacement-ticket");
816 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
817 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)).toEqual(
818 expect.objectContaining({
819 accessToken: "replacement-access-token",
820 }),
821 );
822 expect(requestsTo(harness, "/api/auth/websocket-ticket/rpc")).toBe(2);
823 expect(requestsTo(harness, "/oauth/token")).toBe(1);
824 }),
825 );
826
827 it.effect("refreshes a cached endpoint after its first transient failure", () =>
828 Effect.gen(function* () {
829 const cached = new TokenStore.RemoteDpopAccessToken({
830 environmentId: ENVIRONMENT_ID,
831 accountId: "account-1",
832 label: DESCRIPTOR.label,
833 endpoint: ENDPOINT,
834 accessToken: "cached-access-token",
835 expiresAtEpochMs: Number.MAX_SAFE_INTEGER,
836 dpopThumbprint: "thumbprint-1",
837 });
838 const harness = yield* makeHarness({
839 initialToken: cached,
840 descriptor: DESCRIPTOR,
841 responses: [
842 new Response("endpoint unavailable", { status: 503 }),
843 accessToken("replacement-access-token"),
844 websocketTicket("replacement-ticket"),
845 ],
846 });
847
848 const authorized = yield* Effect.gen(function* () {
849 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
850 return yield* remote.authorizeDpop({
851 expectedEnvironmentId: ENVIRONMENT_ID,
852 });
853 }).pipe(Effect.provide(harness.layer));
854
855 expect(authorized.socketUrl).toContain("wsTicket=replacement-ticket");
856 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
857 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)).toEqual(
858 expect.objectContaining({
859 accessToken: "replacement-access-token",
860 }),
861 );
862 expect(requestsTo(harness, "/api/auth/websocket-ticket/rpc")).toBe(2);
863 expect(requestsTo(harness, "/oauth/token")).toBe(1);
864 }),
865 );
866
867 it.effect("removes a newly refreshed token when websocket ticket authorization fails", () =>
868 Effect.gen(function* () {
869 const harness = yield* makeHarness({
870 responses: [
871 Response.json(DESCRIPTOR),
872 accessToken("unusable-access-token"),
873 new Response("endpoint unavailable", { status: 503 }),
874 ],
875 });
876
877 yield* Effect.gen(function* () {
878 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
879 return yield* remote.authorizeDpop({
880 expectedEnvironmentId: ENVIRONMENT_ID,
881 });
882 }).pipe(Effect.provide(harness.layer), Effect.flip);
883
884 expect((yield* Ref.get(harness.tokens)).has(ENVIRONMENT_ID)).toBe(false);
885 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
886 expect(harness.fetch.calls).toHaveLength(3);
887 }),
888 );
889
890 it.effect("does not evict a replacement token when a late request rejects the old one", () =>
891 Effect.gen(function* () {
892 const harness = yield* makeHarness({
893 initialToken: persistedToken(),
894 responses: [Response.json(DESCRIPTOR), accessToken("replacement-token")],
895 });
896 yield* Effect.gen(function* () {
897 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
898 const initial = yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
899 const retry = {
900 expectedEnvironmentId: ENVIRONMENT_ID,
901 rejectedAccessToken: initial.httpAuthorization.accessToken,
902 };
903 const first = yield* remote.authorizeDpopHttp(retry);
904 const late = yield* remote.authorizeDpopHttp(retry);
905 expect(first.httpAuthorization.accessToken).toBe("replacement-token");
906 expect(late).toEqual(first);
907 }).pipe(Effect.provide(harness.layer));
908
909 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
910 expect(harness.fetch.calls).toHaveLength(2);
911 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)?.accessToken).toBe(
912 "replacement-token",
913 );
914 }),
915 );
916
917 it.effect("shares one in-flight renewal between concurrent HTTP requests", () =>
918 Effect.gen(function* () {
919 const started = yield* Deferred.make<void>();
920 const release = yield* Deferred.make<void>();
921 const harness = yield* makeHarness({
922 initialToken: persistedToken({ expiresAtEpochMs: 0 }),
923 beforeBootstrap: Deferred.succeed(started, undefined).pipe(
924 Effect.andThen(Deferred.await(release)),
925 ),
926 responses: [Response.json(DESCRIPTOR), accessToken("shared-token")],
927 });
928 yield* Effect.gen(function* () {
929 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
930 const requests = yield* Effect.all(
931 Array.from({ length: 6 }, () =>
932 remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID }),
933 ),
934 { concurrency: "unbounded" },
935 ).pipe(Effect.forkChild);
936 yield* Queue.takeN(harness.tokenReads, 6);
937 yield* Deferred.await(started);
938 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
939 yield* Deferred.succeed(release, undefined);
940 const results = yield* Fiber.join(requests);
941 expect(results.map((result) => result.httpAuthorization.accessToken)).toEqual(
942 Array(6).fill("shared-token"),
943 );
944 }).pipe(Effect.provide(harness.layer));
945
946 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
947 expect(harness.fetch.calls).toHaveLength(2);
948 }),
949 );
950
951 it.effect(
952 "shares a failed renewal and allows a later attempt instead of caching its failure",
953 () =>
954 Effect.gen(function* () {
955 const release = yield* Deferred.make<void, ManagedRelay.ManagedRelayClientError>();
956 const failure = new ManagedRelay.ManagedRelayRequestTimeoutError({
957 activity: "Relay environment connection",
958 timeoutMs: ManagedRelay.MANAGED_RELAY_REQUEST_TIMEOUT_MS,
959 traceId: null,
960 });
961 const harness = yield* makeHarness({
962 responses: [],
963 beforeBootstrap: Deferred.await(release),
964 });
965 yield* Effect.gen(function* () {
966 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
967 const requests = yield* Effect.all(
968 Array.from({ length: 6 }, () =>
969 remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID }).pipe(Effect.flip),
970 ),
971 { concurrency: "unbounded" },
972 ).pipe(Effect.forkChild);
973 yield* Queue.takeN(harness.tokenReads, 6);
974 yield* Deferred.fail(release, failure);
975 const failures = yield* Fiber.join(requests);
976 expect(failures).toEqual(
977 Array(6).fill(
978 expect.objectContaining({
979 _tag: "ConnectionTransientError",
980 reason: "timeout",
981 }),
982 ),
983 );
984 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
985 yield* remote
986 .authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID })
987 .pipe(Effect.flip);
988 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(2);
989 }).pipe(Effect.provide(harness.layer));
990 expect(harness.fetch.calls).toHaveLength(0);
991 }),
992 );
993
994 it.effect("does not block another environment behind a pending renewal", () =>
995 Effect.gen(function* () {
996 const started = yield* Deferred.make<void>();
997 const release = yield* Deferred.make<void>();
998 const otherEnvironmentId = EnvironmentId.make("environment-2");
999 const harness = yield* makeHarness({
1000 initialToken: persistedToken({
1001 environmentId: otherEnvironmentId,
1002 accessToken: "other-token",
1003 }),
1004 beforeBootstrap: Deferred.succeed(started, undefined).pipe(
1005 Effect.andThen(Deferred.await(release)),
1006 ),
1007 responses: [Response.json(DESCRIPTOR), accessToken("fresh-token")],
1008 });
1009 yield* Effect.gen(function* () {
1010 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1011 const pending = yield* remote
1012 .authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID })
1013 .pipe(Effect.forkChild);
1014 yield* Deferred.await(started);
1015 const other = yield* remote.authorizeDpopHttp({
1016 expectedEnvironmentId: otherEnvironmentId,
1017 });
1018 expect(other.httpAuthorization.accessToken).toBe("other-token");
1019 yield* Deferred.succeed(release, undefined);
1020 yield* Fiber.join(pending);
1021 }).pipe(Effect.provide(harness.layer));
1022 }),
1023 );
1024
1025 it.effect("retries instead of blocking while the cloud session has not loaded", () =>
1026 Effect.gen(function* () {
1027 const harness = yield* makeHarness({
1028 responses: [Response.json(DESCRIPTOR), accessToken("loaded-token")],
1029 });
1030 yield* Ref.set(harness.session, Option.none());
1031 yield* Effect.gen(function* () {
1032 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1033 const pending = yield* remote
1034 .authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID })
1035 .pipe(Effect.flip);
1036 expect(pending).toMatchObject({
1037 _tag: "ConnectionTransientError",
1038 reason: "session-pending",
1039 });
1040 yield* Ref.set(harness.session, Option.some({ accountId: "account-1" }));
1041 const loaded = yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
1042 expect(loaded.httpAuthorization.accessToken).toBe("loaded-token");
1043 }).pipe(Effect.provide(harness.layer));
1044 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
1045 }),
1046 );
1047
1048 it.effect("does not return or persist credentials after logout during renewal", () =>
1049 Effect.gen(function* () {
1050 const started = yield* Deferred.make<void>();
1051 const release = yield* Deferred.make<void>();
1052 const harness = yield* makeHarness({
1053 beforeBootstrap: Deferred.succeed(started, undefined).pipe(
1054 Effect.andThen(Deferred.await(release)),
1055 ),
1056 responses: [],
1057 });
1058 yield* Effect.gen(function* () {
1059 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1060 const pending = yield* remote
1061 .authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID })
1062 .pipe(Effect.flip, Effect.forkChild);
1063 yield* Deferred.await(started);
1064 yield* Ref.set(harness.session, Option.none());
1065 yield* Deferred.succeed(release, undefined);
1066 expect(yield* Fiber.join(pending)).toMatchObject({
1067 _tag: "ConnectionBlockedError",
1068 reason: "authentication",
1069 });
1070 }).pipe(Effect.provide(harness.layer));
1071 expect((yield* Ref.get(harness.tokens)).size).toBe(0);
1072 expect(harness.fetch.calls).toHaveLength(0);
1073 }),
1074 );
1075
1076 it.effect("removes an obsolete credential if logout overlaps the persistent write", () =>
1077 Effect.gen(function* () {
1078 const started = yield* Deferred.make<void>();
1079 const release = yield* Deferred.make<void>();
1080 const harness = yield* makeHarness({
1081 beforePut: Deferred.succeed(started, undefined).pipe(
1082 Effect.andThen(Deferred.await(release)),
1083 ),
1084 responses: [Response.json(DESCRIPTOR), accessToken("obsolete-token")],
1085 });
1086 yield* Effect.gen(function* () {
1087 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1088 const pending = yield* remote
1089 .authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID })
1090 .pipe(Effect.flip, Effect.forkChild);
1091 yield* Deferred.await(started);
1092 yield* Ref.set(harness.session, Option.none());
1093 yield* Deferred.succeed(release, undefined);
1094 expect(yield* Fiber.join(pending)).toMatchObject({
1095 _tag: "ConnectionBlockedError",
1096 reason: "authentication",
1097 });
1098 }).pipe(Effect.provide(harness.layer));
1099 expect((yield* Ref.get(harness.tokens)).size).toBe(0);
1100 }),
1101 );
1102
1103 it.effect(
1104 "renews another account's persisted token after the authorization service restarts",
1105 () =>
1106 Effect.gen(function* () {
1107 const harness = yield* makeHarness({
1108 initialToken: persistedToken(),
1109 responses: [Response.json(DESCRIPTOR), accessToken("account-2-token")],
1110 });
1111 const authorize = Effect.gen(function* () {
1112 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1113 return yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
1114 }).pipe(Effect.provide(harness.layer));
1115
1116 expect((yield* authorize).httpAuthorization.accessToken).toBe("cached-access-token");
1117 yield* Ref.set(harness.session, Option.some({ accountId: "account-2" }));
1118 expect((yield* authorize).httpAuthorization.accessToken).toBe("account-2-token");
1119 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)?.accountId).toBe("account-2");
1120
1121 yield* Ref.set(harness.session, Option.some({ accountId: "account-2" }));
1122 expect((yield* authorize).httpAuthorization.accessToken).toBe("account-2-token");
1123 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
1124 expect(harness.fetch.calls).toHaveLength(2);
1125 }),
1126 );
1127
1128 it.effect("renews a legacy unowned token once and reuses its account-bound replacement", () =>
1129 Effect.gen(function* () {
1130 const legacy = new TokenStore.RemoteDpopAccessToken({
1131 environmentId: ENVIRONMENT_ID,
1132 label: DESCRIPTOR.label,
1133 endpoint: ENDPOINT,
1134 accessToken: "legacy-access-token",
1135 expiresAtEpochMs: Number.MAX_SAFE_INTEGER,
1136 dpopThumbprint: "thumbprint-1",
1137 });
1138 const harness = yield* makeHarness({
1139 initialToken: legacy,
1140 responses: [Response.json(DESCRIPTOR), accessToken("account-bound-token")],
1141 });
1142 const authorize = Effect.gen(function* () {
1143 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1144 return yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
1145 }).pipe(Effect.provide(harness.layer));
1146
1147 expect((yield* authorize).httpAuthorization.accessToken).toBe("account-bound-token");
1148 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)?.accountId).toBe("account-1");
1149 expect((yield* authorize).httpAuthorization.accessToken).toBe("account-bound-token");
1150 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
1151 expect(harness.fetch.calls).toHaveLength(2);
1152 }),
1153 );
1154
1155 it.effect("requires fresh credentials after signing back into the same account", () =>
1156 Effect.gen(function* () {
1157 const harness = yield* makeHarness({
1158 initialToken: persistedToken(),
1159 responses: [Response.json(DESCRIPTOR), accessToken("new-session-token")],
1160 });
1161 yield* Effect.gen(function* () {
1162 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1163 yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
1164 yield* Ref.set(harness.session, Option.none());
1165 yield* Ref.set(harness.session, Option.some({ accountId: "account-1" }));
1166 const signedIn = yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
1167 expect(signedIn.httpAuthorization.accessToken).toBe("new-session-token");
1168 }).pipe(Effect.provide(harness.layer));
1169 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
1170 }),
1171 );
1172
1173 it.effect("renews a cached credential bound to a different signing key", () =>
1174 Effect.gen(function* () {
1175 const harness = yield* makeHarness({
1176 initialToken: persistedToken(),
1177 responses: [Response.json(DESCRIPTOR), accessToken("new-key-token")],
1178 });
1179 yield* Ref.set(harness.thumbprint, "thumbprint-2");
1180 yield* Effect.gen(function* () {
1181 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1182 const authorized = yield* remote.authorizeDpopHttp({
1183 expectedEnvironmentId: ENVIRONMENT_ID,
1184 });
1185 expect(authorized.httpAuthorization.accessToken).toBe("new-key-token");
1186 }).pipe(Effect.provide(harness.layer));
1187 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)?.dpopThumbprint).toBe(
1188 "thumbprint-2",
1189 );
1190 }),
1191 );
1192
1193 it.effect("rejects a relay bootstrap for a different environment before contacting it", () =>
1194 Effect.gen(function* () {
1195 const harness = yield* makeHarness({
1196 responses: [],
1197 bootstrap: { ...BOOTSTRAP, environmentId: EnvironmentId.make("wrong-environment") },
1198 });
1199 const failure = yield* Effect.gen(function* () {
1200 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1201 return yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
1202 }).pipe(Effect.provide(harness.layer), Effect.flip);
1203 expect(failure).toMatchObject({ _tag: "ConnectionBlockedError", reason: "configuration" });
1204 expect(harness.fetch.calls).toHaveLength(0);
1205 }),
1206 );
1207
1208 it.effect("keeps a shared renewal alive when one waiting request is interrupted", () =>
1209 Effect.gen(function* () {
1210 const started = yield* Deferred.make<void>();
1211 const release = yield* Deferred.make<void>();
1212 const harness = yield* makeHarness({
1213 beforeBootstrap: Deferred.succeed(started, undefined).pipe(
1214 Effect.andThen(Deferred.await(release)),
1215 ),
1216 responses: [Response.json(DESCRIPTOR), accessToken("fresh-token")],
1217 });
1218 yield* Effect.gen(function* () {
1219 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1220 const pending = yield* remote
1221 .authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID })
1222 .pipe(Effect.forkChild);
1223 yield* Deferred.await(started);
1224 const other = yield* remote
1225 .authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID })
1226 .pipe(Effect.forkChild);
1227 yield* Queue.takeN(harness.tokenReads, 2);
1228 yield* Fiber.interrupt(pending);
1229 yield* Deferred.succeed(release, undefined);
1230 const authorized = yield* Fiber.join(other);
1231 expect(authorized.httpAuthorization.accessToken).toBe("fresh-token");
1232 const cached = yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
1233 expect(cached).toEqual(authorized);
1234 }).pipe(Effect.provide(harness.layer));
1235 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
1236 }),
1237 );
1238});