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
| 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 | ); |