@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, 04:45 UTC

main
ts 290 lines 10.6 KB
Raw
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 });