Open History to see the last commit
1import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
2import * as NodeServices from "@effect/platform-node/NodeServices";
3import { assert, it } from "@effect/vitest";
4import * as ConfigProvider from "effect/ConfigProvider";
5import * as Deferred from "effect/Deferred";
6import * as Duration from "effect/Duration";
7import * as Effect from "effect/Effect";
8import * as Base64Url from "effect/encoding/Base64Url";
9import * as Fiber from "effect/Fiber";
10import * as Layer from "effect/Layer";
11import * as Option from "effect/Option";
12import * as Schema from "effect/Schema";
13import * as TestClock from "effect/testing/TestClock";
14import * as HttpClient from "effect/http/HttpClient";
15import * as HttpClientResponse from "effect/http/HttpClientResponse";
16
17import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
18import * as ExternalLauncher from "../process/externalLauncher.ts";
19import * as CliTokenManager from "./CliTokenManager.ts";
20
21const TEST_ENV = {
22 T3CODE_CLERK_PUBLISHABLE_KEY: "pk_test_Y2xlcmsuZXhhbXBsZS50ZXN0JA==",
23 T3CODE_CLERK_CLI_OAUTH_CLIENT_ID: "oauth_client_test",
24 T3CODE_HOSTED_APP_URL: "https://hosted.example.test",
25};
26
27interface RecordedTokenRequest {
28 readonly url: string;
29 readonly params: URLSearchParams;
30}
31
32const TestIdTokenHeaderJson = Schema.fromJsonString(Schema.Struct({ alg: Schema.Literal("none") }));
33const TestIdTokenPayloadJson = Schema.fromJsonString(Schema.Struct({ email: Schema.String }));
34const encodeTestIdTokenHeader = Schema.encodeSync(TestIdTokenHeaderJson);
35const encodeTestIdTokenPayload = Schema.encodeSync(TestIdTokenPayloadJson);
36const idTokenWithEmail = (() => {
37 const header = Base64Url.encode(encodeTestIdTokenHeader({ alg: "none" }));
38 const payload = Base64Url.encode(encodeTestIdTokenPayload({ email: "theo@example.test" }));
39 return `${header}.${payload}.`;
40})();
41
42const TestTokenResponseJson = Schema.fromJsonString(
43 Schema.Struct({
44 access_token: Schema.String,
45 refresh_token: Schema.String,
46 id_token: Schema.String,
47 expires_in: Schema.Number,
48 token_type: Schema.String,
49 }),
50);
51const encodeTestTokenResponse = Schema.encodeSync(TestTokenResponseJson);
52
53const provideTestEnv = Effect.provide(
54 ConfigProvider.layer(ConfigProvider.fromEnv({ env: TEST_ENV })),
55);
56
57interface DeviceFlowServer {
58 readonly requests: Array<RecordedTokenRequest>;
59 readonly tokenReplies: Array<{ readonly status: number; readonly body: string }>;
60}
61
62const DEVICE_AUTHORIZATION_BODY = JSON.stringify({
63 device_code: "device-code-1",
64 user_code: "BCDF-GHJK",
65 verification_uri: "https://accounts.example.test/device",
66 verification_uri_complete: "https://accounts.example.test/device?user_code=BCDF-GHJK",
67 expires_in: 600,
68 interval: 5,
69});
70
71const oauthError = (error: string) => ({ status: 400, body: JSON.stringify({ error }) });
72const tokenGranted = {
73 status: 200,
74 body: encodeTestTokenResponse({
75 access_token: "access-token-1",
76 refresh_token: "refresh-token-1",
77 id_token: idTokenWithEmail,
78 expires_in: 3600,
79 token_type: "bearer",
80 }),
81};
82
83const layerDeviceFlow = (server: DeviceFlowServer) =>
84 Layer.succeed(
85 HttpClient.HttpClient,
86 HttpClient.make((request) =>
87 Effect.sync(() => {
88 const body =
89 request.body._tag === "Uint8Array" ? new TextDecoder().decode(request.body.body) : "";
90 server.requests.push({ url: request.url, params: new URLSearchParams(body) });
91 const reply = request.url.endsWith("/oauth/device_authorization")
92 ? { status: 200, body: DEVICE_AUTHORIZATION_BODY }
93 : ((server.tokenReplies.length > 1
94 ? server.tokenReplies.shift()
95 : server.tokenReplies[0]) ?? oauthError("invalid_grant"));
96 return HttpClientResponse.fromWeb(
97 request,
98 new Response(reply.body, {
99 status: reply.status,
100 headers: { "content-type": "application/json" },
101 }),
102 );
103 }),
104 ),
105 );
106
107const tokenRequests = (requests: ReadonlyArray<RecordedTokenRequest>) =>
108 requests.filter((request) => request.url.endsWith("/oauth/token"));
109
110const expiredStoredToken = new TextEncoder().encode(
111 JSON.stringify({ accessToken: "expired", refreshToken: "refresh-token-1", expiresAtEpochMs: 0 }),
112);
113
114const provideRefreshManager = (
115 httpClient: HttpClient.HttpClient,
116 secrets = Layer.mock(ServerSecretStore.ServerSecretStore)({
117 get: () => Effect.succeedSome(expiredStoredToken),
118 }),
119) =>
120 Effect.provide(
121 CliTokenManager.layer.pipe(
122 Layer.provide(
123 Layer.mergeAll(
124 Layer.succeed(HttpClient.HttpClient, httpClient),
125 secrets,
126 Layer.mock(ExternalLauncher.ExternalLauncher)({}),
127 NodeServices.layer,
128 NodeCrypto.layer,
129 ),
130 ),
131 Layer.provideMerge(ConfigProvider.layer(ConfigProvider.fromEnv({ env: TEST_ENV }))),
132 ),
133 );
134
135it.effect(
136 "persists rotated credentials under the lock despite shutdown, while queued callers can cancel",
137 () =>
138 Effect.gen(function* () {
139 const requestStarted = yield* Deferred.make<void>();
140 const releaseRequest = yield* Deferred.make<void>();
141 const persistStarted = yield* Deferred.make<void>();
142 const releasePersist = yield* Deferred.make<void>();
143 let stored = expiredStoredToken;
144 let reads = 0;
145 const httpClient = HttpClient.make((request) =>
146 Effect.gen(function* () {
147 yield* Deferred.succeed(requestStarted, undefined);
148 yield* Deferred.await(releaseRequest);
149 return HttpClientResponse.fromWeb(
150 request,
151 Response.json({
152 access_token: "rotated-access",
153 refresh_token: "rotated-refresh",
154 expires_in: 3600,
155 token_type: "bearer",
156 }),
157 );
158 }),
159 );
160 const secrets = Layer.mock(ServerSecretStore.ServerSecretStore)({
161 get: () =>
162 Effect.sync(() => {
163 reads++;
164 return Option.some(stored);
165 }),
166 set: (_name, value) =>
167 Effect.gen(function* () {
168 yield* Deferred.succeed(persistStarted, undefined);
169 yield* Deferred.await(releasePersist);
170 stored = new Uint8Array(value);
171 }),
172 });
173
174 yield* Effect.gen(function* () {
175 const manager = yield* CliTokenManager.CloudCliTokenManager;
176 const refresh = yield* manager.getExisting.pipe(Effect.forkChild);
177 assert.isTrue(
178 yield* Effect.raceFirst(
179 Deferred.await(requestStarted).pipe(Effect.as(true)),
180 Fiber.await(refresh).pipe(Effect.as(false)),
181 ),
182 "refresh failed before reaching the endpoint",
183 );
184 const waiter = yield* manager.getExisting.pipe(
185 Effect.forkChild({ startImmediately: true }),
186 );
187 yield* Fiber.interrupt(waiter);
188 assert.equal(reads, 1, "queued caller must not read credentials during refresh");
189 const interruption = yield* Fiber.interrupt(refresh).pipe(
190 Effect.forkChild({ startImmediately: true }),
191 );
192 yield* Deferred.succeed(releaseRequest, undefined);
193 const reachedPersist = yield* Effect.raceFirst(
194 Deferred.await(persistStarted).pipe(Effect.as(true)),
195 Fiber.await(refresh).pipe(Effect.as(false)),
196 );
197 assert.isTrue(reachedPersist, "shutdown discarded the rotated credential");
198 const reader = yield* manager.getExisting.pipe(
199 Effect.forkChild({ startImmediately: true }),
200 );
201 assert.equal(reads, 1, "credential lock must cover persistence");
202 yield* Deferred.succeed(releasePersist, undefined);
203 yield* Fiber.join(interruption);
204 const token = Option.getOrThrow(yield* Fiber.join(reader));
205 assert.equal(token.refreshToken, "rotated-refresh");
206 assert.equal(token.accessToken, "rotated-access");
207 }).pipe(
208 Effect.ensuring(Deferred.succeed(releaseRequest, undefined)),
209 Effect.ensuring(Deferred.succeed(releasePersist, undefined)),
210 provideRefreshManager(httpClient, secrets),
211 );
212 }),
213);
214
215it.effect.each([
216 { status: 400, code: "invalid_grant", requiresLogin: true, diagnostic: true },
217 { status: 403, code: "private-provider-secret", requiresLogin: true, diagnostic: false },
218 { status: 429, code: "invalid_grant", requiresLogin: false, diagnostic: false },
219])(
220 "refresh HTTP $status exposes only a safe login diagnostic",
221 ({ status, code, requiresLogin, diagnostic }) =>
222 Effect.gen(function* () {
223 const manager = yield* CliTokenManager.CloudCliTokenManager;
224 const error = yield* manager.getExisting.pipe(Effect.flip);
225 assert.instanceOf(error, CliTokenManager.CloudCliCredentialRefreshError);
226 assert.equal(error.requiresLogin, requiresLogin);
227 assert.equal(error.message.includes("t3 connect login"), requiresLogin);
228 assert.equal(error.message.includes("OAuth error: invalid_grant"), diagnostic);
229 assert.notInclude(error.message, "private");
230 assert.equal(error.message.includes("OAuth error:"), diagnostic);
231 assert.isTrue(yield* manager.hasCredential);
232 }).pipe(
233 provideRefreshManager(
234 HttpClient.make((request) =>
235 Effect.succeed(
236 HttpClientResponse.fromWeb(
237 request,
238 Response.json(
239 {
240 error: code,
241 error_description: "private-description",
242 refresh_token: "private-refresh-token",
243 },
244 { status },
245 ),
246 ),
247 ),
248 ),
249 ),
250 ),
251);
252
253it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))(
254 "CliTokenManager.deviceAuthorizationLogin",
255 (it) => {
256 it.effect("requests a device code, shows it, and polls until Clerk grants the token", () =>
257 Effect.gen(function* () {
258 const server: DeviceFlowServer = {
259 requests: [],
260 tokenReplies: [oauthError("authorization_pending"), tokenGranted],
261 };
262 const prompts: Array<CliTokenManager.DeviceAuthorizationPrompt> = [];
263
264 const fiber = yield* CliTokenManager.deviceAuthorizationLogin((prompt) =>
265 Effect.sync(() => {
266 prompts.push(prompt);
267 }),
268 ).pipe(Effect.provide(layerDeviceFlow(server)), provideTestEnv, Effect.forkChild);
269
270 yield* TestClock.adjust(Duration.seconds(10));
271 const { token, identity } = yield* Fiber.join(fiber);
272
273 assert.deepEqual(prompts, [
274 {
275 verificationUri: "https://accounts.example.test/device",
276 verificationUriComplete: "https://accounts.example.test/device?user_code=BCDF-GHJK",
277 userCode: "BCDF-GHJK",
278 expiresIn: Duration.seconds(600),
279 },
280 ]);
281 assert.equal(token.accessToken, "access-token-1");
282 assert.equal(token.refreshToken, "refresh-token-1");
283 assert.equal(token.identity, "theo@example.test");
284 assert.equal(identity, "theo@example.test");
285
286 const authorization = server.requests[0]!;
287 assert.equal(authorization.url, "https://clerk.example.test/oauth/device_authorization");
288 assert.equal(authorization.params.get("client_id"), "oauth_client_test");
289 assert.equal(authorization.params.get("scope"), "openid profile email offline_access");
290
291 const polls = tokenRequests(server.requests);
292 assert.lengthOf(polls, 2);
293 for (const poll of polls) {
294 assert.equal(poll.url, "https://clerk.example.test/oauth/token");
295 assert.equal(
296 poll.params.get("grant_type"),
297 "urn:ietf:params:oauth:grant-type:device_code",
298 );
299 assert.equal(poll.params.get("device_code"), "device-code-1");
300 assert.equal(poll.params.get("client_id"), "oauth_client_test");
301 }
302 }),
303 );
304
305 it.effect("fails with a denied error when the user rejects the request", () =>
306 Effect.gen(function* () {
307 const server: DeviceFlowServer = {
308 requests: [],
309 tokenReplies: [oauthError("access_denied")],
310 };
311
312 const fiber = yield* CliTokenManager.deviceAuthorizationLogin(() => Effect.void).pipe(
313 Effect.provide(layerDeviceFlow(server)),
314 provideTestEnv,
315 Effect.flip,
316 Effect.forkChild,
317 );
318 yield* TestClock.adjust(Duration.seconds(5));
319 const result = yield* Fiber.join(fiber);
320
321 assert.instanceOf(result, CliTokenManager.CloudCliAuthorizationDeniedError);
322 assert.lengthOf(tokenRequests(server.requests), 1);
323 }),
324 );
325 },
326);