@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, 03:37 UTC

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