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, 04:45 UTC
| 1 | import { describe, expect, it } from "@effect/vitest"; |
| 2 | import * as NodeServices from "@effect/platform-node/NodeServices"; |
| 3 | import * as Effect from "effect/Effect"; |
| 4 | import * as Exit from "effect/Exit"; |
| 5 | import * as FileSystem from "effect/FileSystem"; |
| 6 | import * as Path from "effect/Path"; |
| 7 | import * as Redacted from "effect/Redacted"; |
| 8 | import { HttpClient, HttpClientError, HttpClientResponse } from "effect/http"; |
| 9 | import * as HostProcess from "@t3tools/shared/HostProcess"; |
| 10 | |
| 11 | import { makeExpoApi, resolveExpoCredential, type ExpoCredential } from "./ExpoApi.ts"; |
| 12 | |
| 13 | const header = (credential: ExpoCredential) => ({ |
| 14 | source: credential.source, |
| 15 | name: credential.header.name, |
| 16 | value: Redacted.value(credential.header.value), |
| 17 | }); |
| 18 | |
| 19 | describe("Expo credentials", () => { |
| 20 | it.effect("prefer the saved token, then EXPO_TOKEN, then the eas login session", () => |
| 21 | Effect.gen(function* () { |
| 22 | const fs = yield* FileSystem.FileSystem; |
| 23 | const path = yield* Path.Path; |
| 24 | const home = yield* fs.makeTempDirectoryScoped({ prefix: "t3-expo-home-" }); |
| 25 | yield* fs.makeDirectory(path.join(home, ".expo")); |
| 26 | yield* fs.writeFileString( |
| 27 | path.join(home, ".expo", "state.json"), |
| 28 | JSON.stringify({ auth: { sessionSecret: "session-secret", username: "julius" } }), |
| 29 | ); |
| 30 | const resolve = (saved: string, env: NodeJS.ProcessEnv) => |
| 31 | resolveExpoCredential(saved).pipe( |
| 32 | Effect.provideService(HostProcess.HomeDirectory, home), |
| 33 | Effect.provideService(HostProcess.Environment, env), |
| 34 | Effect.map(header), |
| 35 | ); |
| 36 | expect(yield* resolve(" saved ", { EXPO_TOKEN: "env-token" })).toEqual({ |
| 37 | source: "settings", |
| 38 | name: "authorization", |
| 39 | value: "Bearer saved", |
| 40 | }); |
| 41 | expect(yield* resolve("", { EXPO_TOKEN: "env-token" })).toEqual({ |
| 42 | source: "env", |
| 43 | name: "authorization", |
| 44 | value: "Bearer env-token", |
| 45 | }); |
| 46 | expect(yield* resolve("", {})).toEqual({ |
| 47 | source: "eas-login", |
| 48 | name: "expo-session", |
| 49 | value: "session-secret", |
| 50 | }); |
| 51 | yield* fs.writeFileString( |
| 52 | path.join(home, ".expo", "state.json"), |
| 53 | JSON.stringify({ auth: null }), |
| 54 | ); |
| 55 | const missing = yield* resolve("", {}).pipe(Effect.exit); |
| 56 | expect(Exit.isFailure(missing) && missing.cause.toString()).toContain("eas login"); |
| 57 | }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), |
| 58 | ); |
| 59 | |
| 60 | it.effect.each([ |
| 61 | { case: "the redacted placeholder", saved: "\u2022\u2022\u2022\u2022\u2022\u2022", env: {} }, |
| 62 | { case: "a pasted newline", saved: "abc\ndef", env: {} }, |
| 63 | { case: "a malformed EXPO_TOKEN", saved: "", env: { EXPO_TOKEN: "abc def" } }, |
| 64 | ])("refuses $case without echoing it", ({ saved, env }) => |
| 65 | Effect.gen(function* () { |
| 66 | const error = yield* resolveExpoCredential(saved).pipe( |
| 67 | Effect.provideService(HostProcess.Environment, env), |
| 68 | Effect.flip, |
| 69 | ); |
| 70 | expect(error._tag).toBe("ExpoInvalidCredentialError"); |
| 71 | expect(error.message).not.toContain(saved || "abc def"); |
| 72 | }).pipe(Effect.provide(NodeServices.layer)), |
| 73 | ); |
| 74 | }); |
| 75 | |
| 76 | describe("Expo API", () => { |
| 77 | const credential: ExpoCredential = { |
| 78 | source: "eas-login", |
| 79 | header: { name: "expo-session", value: Redacted.make("session-secret") }, |
| 80 | }; |
| 81 | |
| 82 | it.effect("sends the credential and reads session endpoints once the simulator is ready", () => |
| 83 | Effect.gen(function* () { |
| 84 | const requests: Array<{ headers: Record<string, string>; body: unknown }> = []; |
| 85 | const http = HttpClient.make((request) => |
| 86 | Effect.sync(() => { |
| 87 | const body = |
| 88 | request.body._tag === "Uint8Array" |
| 89 | ? (JSON.parse(new TextDecoder().decode(request.body.body)) as { variables: unknown }) |
| 90 | : null; |
| 91 | requests.push({ headers: request.headers, body }); |
| 92 | return HttpClientResponse.fromWeb( |
| 93 | request, |
| 94 | Response.json({ |
| 95 | data: { |
| 96 | deviceRunSessions: { |
| 97 | byId: { |
| 98 | id: "session-1", |
| 99 | status: "IN_PROGRESS", |
| 100 | remoteConfig: { |
| 101 | __typename: "AgentDeviceRunSessionRemoteConfig", |
| 102 | agentDeviceRemoteSessionUrl: "https://agent.test", |
| 103 | agentDeviceRemoteSessionToken: "agent-token", |
| 104 | webPreviewToken: "preview-token", |
| 105 | previewApiUrl: "https://preview.test?token=preview-token", |
| 106 | }, |
| 107 | }, |
| 108 | }, |
| 109 | }, |
| 110 | }), |
| 111 | ); |
| 112 | }), |
| 113 | ); |
| 114 | const session = yield* makeExpoApi(http, credential).session("session-1"); |
| 115 | expect(requests[0]?.headers["expo-session"]).toBe("session-secret"); |
| 116 | expect(requests[0]?.body).toMatchObject({ variables: { id: "session-1" } }); |
| 117 | expect(session.status).toBe("IN_PROGRESS"); |
| 118 | expect(session.endpoints?.agentDevice.url).toBe("https://agent.test"); |
| 119 | expect(Redacted.value(session.endpoints!.agentDevice.token)).toBe("agent-token"); |
| 120 | expect(session.endpoints?.preview?.url).toBe("https://preview.test?token=preview-token"); |
| 121 | expect(Redacted.value(session.endpoints!.preview!.token)).toBe("preview-token"); |
| 122 | }), |
| 123 | ); |
| 124 | |
| 125 | it.effect("keeps the credential out of errors when Expo is unreachable", () => |
| 126 | Effect.gen(function* () { |
| 127 | const http = HttpClient.make((request) => |
| 128 | Effect.fail( |
| 129 | new HttpClientError.HttpClientError({ |
| 130 | reason: new HttpClientError.TransportError({ |
| 131 | request, |
| 132 | description: "connection reset", |
| 133 | }), |
| 134 | }), |
| 135 | ), |
| 136 | ); |
| 137 | const error = yield* makeExpoApi(http, credential).viewer.pipe(Effect.flip); |
| 138 | expect(error.message).toContain("Expo's API is unreachable"); |
| 139 | expect(JSON.stringify(error)).not.toContain("session-secret"); |
| 140 | expect(error.cause).toBeUndefined(); |
| 141 | // No answer: a mutation may have run. |
| 142 | expect(error.rejected).toBe(false); |
| 143 | }), |
| 144 | ); |
| 145 | |
| 146 | it.effect("reports GraphQL errors and rejected credentials as Expo failures", () => |
| 147 | Effect.gen(function* () { |
| 148 | const respond = (response: Response) => |
| 149 | HttpClient.make((request) => Effect.succeed(HttpClientResponse.fromWeb(request, response))); |
| 150 | const graphQl = yield* makeExpoApi( |
| 151 | respond(Response.json({ errors: [{ message: "Feature not enabled" }] })), |
| 152 | credential, |
| 153 | ) |
| 154 | .stop("session-1") |
| 155 | .pipe(Effect.flip); |
| 156 | expect(graphQl.message).toBe("Expo could not stop a simulator session: Feature not enabled"); |
| 157 | const rejected = yield* makeExpoApi(respond(new Response("no", { status: 401 })), credential) |
| 158 | .stop("session-1") |
| 159 | .pipe(Effect.flip); |
| 160 | expect(rejected.message).toBe( |
| 161 | "Expo could not stop a simulator session: the eas login session was rejected (HTTP 401)", |
| 162 | ); |
| 163 | const serverError = yield* makeExpoApi( |
| 164 | respond(Response.json({ errors: [{ message: "Internal server error" }] }, { status: 502 })), |
| 165 | credential, |
| 166 | ) |
| 167 | .stop("session-1") |
| 168 | .pipe(Effect.flip); |
| 169 | expect(serverError.message).toBe( |
| 170 | "Expo could not stop a simulator session: Internal server error", |
| 171 | ); |
| 172 | // What Expo answers a refused request with: Apollo's default code, the |
| 173 | // user's fault, and null data. |
| 174 | const expoRefusal = yield* makeExpoApi( |
| 175 | respond( |
| 176 | Response.json({ |
| 177 | errors: [ |
| 178 | { |
| 179 | message: "Experience with id 0000 does not exist.", |
| 180 | extensions: { |
| 181 | code: "INTERNAL_SERVER_ERROR", |
| 182 | errorCode: "EXPERIENCE_NOT_FOUND", |
| 183 | errorType: "USER", |
| 184 | isTransient: false, |
| 185 | }, |
| 186 | }, |
| 187 | ], |
| 188 | data: null, |
| 189 | }), |
| 190 | ), |
| 191 | credential, |
| 192 | ) |
| 193 | .stop("session-1") |
| 194 | .pipe(Effect.flip); |
| 195 | const internalError = yield* makeExpoApi( |
| 196 | respond( |
| 197 | Response.json({ |
| 198 | errors: [ |
| 199 | { |
| 200 | message: "Something went wrong", |
| 201 | extensions: { errorCode: "INTERNAL_SERVER_ERROR" }, |
| 202 | }, |
| 203 | ], |
| 204 | }), |
| 205 | ), |
| 206 | credential, |
| 207 | ) |
| 208 | .stop("session-1") |
| 209 | .pipe(Effect.flip); |
| 210 | const transient = yield* makeExpoApi( |
| 211 | respond( |
| 212 | Response.json({ |
| 213 | errors: [ |
| 214 | { |
| 215 | message: "Something went wrong", |
| 216 | extensions: { errorCode: "INTERNAL_SERVER_ERROR", isTransient: true }, |
| 217 | }, |
| 218 | ], |
| 219 | }), |
| 220 | ), |
| 221 | credential, |
| 222 | ) |
| 223 | .stop("session-1") |
| 224 | .pipe(Effect.flip); |
| 225 | const ran = yield* makeExpoApi( |
| 226 | respond( |
| 227 | Response.json({ |
| 228 | data: { deviceRunSession: { stopDeviceRunSession: null } }, |
| 229 | errors: [ |
| 230 | { message: "Session is already stopping", extensions: { errorCode: "CONFLICT" } }, |
| 231 | ], |
| 232 | }), |
| 233 | ), |
| 234 | credential, |
| 235 | ) |
| 236 | .stop("session-1") |
| 237 | .pipe(Effect.flip); |
| 238 | const fault = yield* makeExpoApi( |
| 239 | respond( |
| 240 | Response.json({ |
| 241 | errors: [{ message: "Something went wrong", extensions: { errorType: "INTERNAL" } }], |
| 242 | }), |
| 243 | ), |
| 244 | credential, |
| 245 | ) |
| 246 | .stop("session-1") |
| 247 | .pipe(Effect.flip); |
| 248 | const echoed = yield* makeExpoApi( |
| 249 | respond( |
| 250 | Response.json({ |
| 251 | errors: [{ message: `Session session-secret is not yours (${"x".repeat(400)})` }], |
| 252 | }), |
| 253 | ), |
| 254 | credential, |
| 255 | ) |
| 256 | .stop("session-1") |
| 257 | .pipe(Effect.flip); |
| 258 | // A message that echoes the credential loses it, and is bounded. |
| 259 | expect(echoed.message).toContain("Session [redacted] is not yours"); |
| 260 | expect(echoed.message).not.toContain("session-secret"); |
| 261 | expect(echoed.message.length).toBeLessThan(400); |
| 262 | const userError = yield* makeExpoApi( |
| 263 | respond( |
| 264 | Response.json({ |
| 265 | errors: [ |
| 266 | { message: "Not allowed", extensions: { errorType: "USER", errorCode: "FORBIDDEN" } }, |
| 267 | ], |
| 268 | }), |
| 269 | ), |
| 270 | credential, |
| 271 | ) |
| 272 | .stop("session-1") |
| 273 | .pipe(Effect.flip); |
| 274 | // Expo answered and refused the first three: nothing was done. GraphQL |
| 275 | // errors at a server error, a transient, internal or other non-user |
| 276 | // error, or errors beside data, may come from a request that ran. |
| 277 | expect([ |
| 278 | graphQl.rejected, |
| 279 | rejected.rejected, |
| 280 | userError.rejected, |
| 281 | expoRefusal.rejected, |
| 282 | serverError.rejected, |
| 283 | internalError.rejected, |
| 284 | transient.rejected, |
| 285 | fault.rejected, |
| 286 | ran.rejected, |
| 287 | ]).toEqual([true, true, true, true, false, false, false, false, false]); |
| 288 | }), |
| 289 | ); |
| 290 | }); |