The best way to control Claude Code, Codex and more from any computer or phone

main
ts 322 lines 11.2 KB
Raw
1 import * as Cloudflare from "@alchemy.run/cloudflare";
2 import { CloudflareEnvironment } from "@alchemy.run/cloudflare/CloudflareEnvironment";
3 import { findZoneByName } from "@alchemy.run/cloudflare/Zone/lookup";
4 import { expect } from "@alchemy.run/test";
5 import * as Test from "@alchemy.run/test/Alchemy";
6 import * as workers from "@distilled.cloud/cloudflare/workers";
7 import { adopt, OwnedBySomeoneElse } from "alchemy/AdoptPolicy";
8 import * as Provider from "alchemy/Provider";
9 import * as Cause from "effect/Cause";
10 import * as Effect from "effect/Effect";
11 import { MinimumLogLevel } from "effect/References";
12 import * as Schedule from "effect/Schedule";
13 import * as Stream from "effect/Stream";
14 import * as pathe from "pathe";
15 import { testName } from "../../names.ts";
16
17 const { test } = Test.make({ providers: Cloudflare.providers() });
18
19 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
20
21 const zoneName = process.env.CLOUDFLARE_TEST_DNS_ZONE_NAME ?? "alchemy-test-2.us";
22
23 const main = pathe.resolve(import.meta.dirname, "fixtures", "route-worker.ts");
24
25 // Deterministic per-test route patterns. Each test owns a disjoint
26 // subdomain so reruns and parallel runs never collide, and the same
27 // pattern is reused on every run (never derive physical names from
28 // Date.now()/random).
29 const PATTERN_DEFAULT = `${testName("alchemy-route-default")}.${zoneName}/*`;
30 const PATTERN_UPDATE_V1 = `${testName("alchemy-route-update")}.${zoneName}/*`;
31 const PATTERN_UPDATE_V2 = `${testName("alchemy-route-update")}.${zoneName}/api/*`;
32 const PATTERN_ADOPT = `${testName("alchemy-route-adopt")}.${zoneName}/*`;
33
34 const resolveZoneId = Effect.gen(function* () {
35 const { accountId } = yield* yield* CloudflareEnvironment;
36 const zone = yield* findZoneByName({ accountId, name: zoneName });
37 if (!zone) {
38 return yield* Effect.die(new Error(`zone "${zoneName}" not found in account`));
39 }
40 return zone.id;
41 });
42
43 // The scoped API token the test harness mints propagates eventually-
44 // consistently across Cloudflare's edge — a fresh token intermittently
45 // 403s with "Unable to authenticate request". Ride out the blips on the
46 // test's own out-of-band verification calls by retrying the typed
47 // `Forbidden` error (part of each route operation's error union via
48 // distilled patches).
49 const forbiddenRetrySchedule = Schedule.exponential("500 millis");
50
51 const listByPattern = (zoneId: string, pattern: string) =>
52 workers.listRoutes.items({ zoneId }).pipe(
53 Stream.filter((r) => r.pattern === pattern),
54 Stream.runCollect,
55 Effect.map((chunk) => Array.from(chunk)),
56 Effect.retry({
57 while: (e) => e._tag === "Forbidden",
58 schedule: forbiddenRetrySchedule,
59 times: 8,
60 }),
61 );
62
63 const findRoute = (zoneId: string, pattern: string) =>
64 listByPattern(zoneId, pattern).pipe(Effect.map((rs) => rs[0]));
65
66 const getRoute = (zoneId: string, routeId: string) =>
67 workers.getRoute({ zoneId, routeId }).pipe(
68 Effect.retry({
69 while: (e) => e._tag === "Forbidden",
70 schedule: forbiddenRetrySchedule,
71 times: 8,
72 }),
73 );
74
75 // Delete every route matching the pattern — used to purge leftovers from
76 // interrupted runs so tests start from a clean slate (Cloudflare enforces
77 // one route per pattern per zone, so a leaked route would conflict).
78 const purgeRoutes = (zoneId: string, pattern: string) =>
79 listByPattern(zoneId, pattern).pipe(
80 Effect.flatMap(
81 Effect.forEach((r) =>
82 workers.deleteRoute({ zoneId, routeId: r.id }).pipe(Effect.catch(() => Effect.void)),
83 ),
84 ),
85 );
86
87 test.provider(
88 "create and delete an opt-out route (no script)",
89 (stack) =>
90 Effect.gen(function* () {
91 const zoneId = yield* resolveZoneId;
92
93 yield* stack.destroy();
94 yield* purgeRoutes(zoneId, PATTERN_DEFAULT);
95
96 const route = yield* stack.deploy(
97 Effect.gen(function* () {
98 return yield* Cloudflare.Workers.WorkerRoute("DefaultRoute", {
99 zoneId,
100 pattern: PATTERN_DEFAULT,
101 }).pipe(adopt(true));
102 }),
103 );
104
105 expect(route.routeId).toBeDefined();
106 expect(route.zoneId).toEqual(zoneId);
107 expect(route.pattern).toEqual(PATTERN_DEFAULT);
108 // No script — the route opts matching requests out of Workers.
109 expect(route.script).toBeUndefined();
110
111 const live = yield* getRoute(zoneId, route.routeId);
112 expect(live.id).toEqual(route.routeId);
113 expect(live.pattern).toEqual(PATTERN_DEFAULT);
114
115 yield* stack.destroy();
116
117 const gone = yield* findRoute(zoneId, PATTERN_DEFAULT);
118 expect(gone).toBeUndefined();
119 }).pipe(logLevel),
120 {
121 tags: ["provider:cloudflare", "provider:cloudflare:worker", "provider:cloudflare:zone", "live"],
122 timeout: 300_000,
123 },
124 );
125
126 test.provider(
127 "route to a Worker, then update pattern and script in place",
128 (stack) =>
129 Effect.gen(function* () {
130 const zoneId = yield* resolveZoneId;
131
132 yield* stack.destroy();
133 yield* purgeRoutes(zoneId, PATTERN_UPDATE_V1);
134 yield* purgeRoutes(zoneId, PATTERN_UPDATE_V2);
135
136 const initial = yield* stack.deploy(
137 Effect.gen(function* () {
138 const worker = yield* Cloudflare.Worker("RouteWorker", {
139 main,
140 compatibility: { date: "2024-01-01" },
141 });
142 const route = yield* Cloudflare.Workers.WorkerRoute("Route", {
143 zoneId,
144 pattern: PATTERN_UPDATE_V1,
145 script: worker.workerName,
146 }).pipe(adopt(true));
147 return { worker, route };
148 }),
149 );
150
151 expect(initial.route.pattern).toEqual(PATTERN_UPDATE_V1);
152 expect(initial.route.script).toEqual(initial.worker.workerName);
153
154 const liveInitial = yield* getRoute(zoneId, initial.route.routeId);
155 expect(liveInitial.pattern).toEqual(PATTERN_UPDATE_V1);
156 expect(liveInitial.script).toEqual(initial.worker.workerName);
157
158 // Pattern and script are both mutable — the same physical route is
159 // updated in place (PUT), not replaced.
160 const updated = yield* stack.deploy(
161 Effect.gen(function* () {
162 const worker = yield* Cloudflare.Worker("RouteWorker", {
163 main,
164 compatibility: { date: "2024-01-01" },
165 });
166 const route = yield* Cloudflare.Workers.WorkerRoute("Route", {
167 zoneId,
168 pattern: PATTERN_UPDATE_V2,
169 // Drop the script — the route becomes an opt-out route.
170 }).pipe(adopt(true));
171 return { worker, route };
172 }),
173 );
174
175 expect(updated.route.routeId).toEqual(initial.route.routeId);
176 expect(updated.route.pattern).toEqual(PATTERN_UPDATE_V2);
177 expect(updated.route.script).toBeUndefined();
178
179 const liveUpdated = yield* getRoute(zoneId, updated.route.routeId);
180 expect(liveUpdated.pattern).toEqual(PATTERN_UPDATE_V2);
181
182 yield* stack.destroy();
183
184 const gone = yield* findRoute(zoneId, PATTERN_UPDATE_V2);
185 expect(gone).toBeUndefined();
186 }).pipe(logLevel),
187 {
188 tags: ["provider:cloudflare", "provider:cloudflare:worker", "provider:cloudflare:zone", "live"],
189 timeout: 300_000,
190 },
191 );
192
193 test.provider(
194 "adoption — existing route errors without adopt, takes over with adopt(true)",
195 (stack) =>
196 Effect.gen(function* () {
197 const zoneId = yield* resolveZoneId;
198
199 yield* stack.destroy();
200 yield* purgeRoutes(zoneId, PATTERN_ADOPT);
201
202 // Create the route out-of-band so the stack has no state of its own
203 // for it — exactly the "the route already exists" scenario.
204 const pre = yield* workers.createRoute({ zoneId, pattern: PATTERN_ADOPT }).pipe(
205 Effect.retry({
206 while: (e) => e._tag === "Forbidden",
207 schedule: forbiddenRetrySchedule,
208 times: 8,
209 }),
210 );
211 expect(pre.id).toBeDefined();
212
213 // Without `adopt`: routes carry no ownership markers, so the engine
214 // cannot prove we created it and refuses to take it over.
215 const error = yield* stack
216 .deploy(
217 Effect.gen(function* () {
218 return yield* Cloudflare.Workers.WorkerRoute("AdoptedRoute", {
219 zoneId,
220 pattern: PATTERN_ADOPT,
221 });
222 }),
223 )
224 .pipe(
225 Effect.as(undefined),
226 Effect.catchCause((cause) => Effect.succeed(findOwnedError(cause))),
227 );
228 expect(error).toBeInstanceOf(OwnedBySomeoneElse);
229
230 // With `adopt(true)`: the engine takes over the pre-existing route
231 // (same physical id).
232 const adopted = yield* stack.deploy(
233 Effect.gen(function* () {
234 return yield* Cloudflare.Workers.WorkerRoute("AdoptedRoute", {
235 zoneId,
236 pattern: PATTERN_ADOPT,
237 }).pipe(adopt(true));
238 }),
239 );
240
241 expect(adopted.routeId).toEqual(pre.id);
242 expect(adopted.pattern).toEqual(PATTERN_ADOPT);
243
244 yield* stack.destroy();
245
246 const gone = yield* findRoute(zoneId, PATTERN_ADOPT);
247 expect(gone).toBeUndefined();
248 }).pipe(logLevel),
249 {
250 tags: ["provider:cloudflare", "provider:cloudflare:worker", "provider:cloudflare:zone", "live"],
251 timeout: 300_000,
252 },
253 );
254
255 const PATTERN_LIST = `${testName("alchemy-route-list")}.${zoneName}/*`;
256
257 // Canonical `list()` test (zone-scoped collection): routes have no account-
258 // wide enumeration API, so `list()` fans out over every zone via
259 // `listAllZones`, paginates `listRoutes` per zone, and hydrates each into the
260 // `read` Attributes shape. Deploy a real route and assert it appears in the
261 // exhaustively-enumerated result.
262 test.provider(
263 "list enumerates the deployed route across all zones",
264 (stack) =>
265 Effect.gen(function* () {
266 const zoneId = yield* resolveZoneId;
267
268 yield* stack.destroy();
269 yield* purgeRoutes(zoneId, PATTERN_LIST);
270
271 const deployed = yield* stack.deploy(
272 Effect.gen(function* () {
273 const worker = yield* Cloudflare.Worker("ListRouteWorker", {
274 main,
275 compatibility: { date: "2024-01-01" },
276 });
277 const route = yield* Cloudflare.Workers.WorkerRoute("ListRoute", {
278 zoneId,
279 pattern: PATTERN_LIST,
280 script: worker.workerName,
281 }).pipe(adopt(true));
282 return { worker, route };
283 }),
284 );
285
286 const provider = yield* Provider.findProvider(Cloudflare.Workers.WorkerRoute);
287 const all = yield* provider.list();
288
289 expect(
290 all.some(
291 (r) =>
292 r.routeId === deployed.route.routeId &&
293 r.zoneId === zoneId &&
294 r.pattern === PATTERN_LIST,
295 ),
296 ).toBe(true);
297
298 yield* stack.destroy();
299
300 const gone = yield* findRoute(zoneId, PATTERN_LIST);
301 expect(gone).toBeUndefined();
302 }).pipe(logLevel),
303 {
304 tags: ["provider:cloudflare", "provider:cloudflare:worker", "provider:cloudflare:zone", "live"],
305 timeout: 300_000,
306 },
307 );
308
309 /**
310 * Pull the {@link OwnedBySomeoneElse} value out of a Cause regardless of
311 * whether the engine raised it as a typed failure or a defect.
312 */
313 const findOwnedError = (cause: Cause.Cause<unknown>): OwnedBySomeoneElse | undefined =>
314 cause.reasons
315 .map((reason) =>
316 Cause.isFailReason(reason)
317 ? reason.error
318 : Cause.isDieReason(reason)
319 ? reason.defect
320 : undefined,
321 )
322 .find((value): value is OwnedBySomeoneElse => value instanceof OwnedBySomeoneElse);