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

main
ts 278 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 { describe, expect } from "@alchemy.run/test";
5 import * as Test from "@alchemy.run/test/Alchemy";
6 import * as managedTransforms from "@distilled.cloud/cloudflare/managed-transforms";
7 import * as Provider from "alchemy/Provider";
8 import * as Effect from "effect/Effect";
9 import { MinimumLogLevel } from "effect/References";
10 import * as Schedule from "effect/Schedule";
11 const { test } = Test.make({ providers: Cloudflare.providers() });
12
13 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
14
15 const zoneName = process.env.CLOUDFLARE_TEST_DNS_ZONE_NAME ?? "alchemy-test-2.us";
16
17 const resolveZoneId = Effect.gen(function* () {
18 const { accountId } = yield* yield* CloudflareEnvironment;
19 const zone = yield* findZoneByName({ accountId, name: zoneName });
20 if (!zone) {
21 return yield* Effect.die(new Error(`zone "${zoneName}" not found in account`));
22 }
23 return zone.id;
24 });
25
26 // The scoped API token the test harness mints propagates eventually-
27 // consistently across Cloudflare's edge — a fresh token intermittently 403s.
28 // Ride out the blips on the test's own out-of-band verification calls by
29 // retrying the typed `Forbidden` error (patched into the managed-transforms
30 // operations' error unions).
31 const forbiddenRetrySchedule = Schedule.exponential("500 millis");
32
33 const listTransforms = (zoneId: string) =>
34 managedTransforms.listManagedTransforms({ zoneId }).pipe(
35 Effect.retry({
36 while: (e) => e._tag === "Forbidden",
37 schedule: forbiddenRetrySchedule,
38 times: 8,
39 }),
40 );
41
42 const enabledOf = (transforms: readonly { id: string; enabled: boolean }[] | null, id: string) =>
43 (transforms ?? []).find((t) => t.id === id)?.enabled;
44
45 // The free-plan test zone exposes exactly two managed transforms — both
46 // response transforms (`managed_request_headers` is `null`: every managed
47 // request transform is plan-gated above free). The test manages one and
48 // leaves the other untouched throughout.
49 const MANAGED_ID = "remove_x-powered-by_header";
50 const UNMANAGED_ID = "add_security_headers";
51
52 /**
53 * Normalize the baseline so reruns are stable: force both transforms back
54 * to disabled before (and after) the test body runs.
55 */
56 const normalizeBaseline = (zoneId: string) =>
57 Effect.gen(function* () {
58 const live = yield* listTransforms(zoneId);
59 const delta = [MANAGED_ID, UNMANAGED_ID]
60 .filter((id) => enabledOf(live.managedResponseHeaders, id) === true)
61 .map((id) => ({ id, enabled: false }));
62 if (delta.length === 0) return;
63 yield* managedTransforms
64 .patchManagedTransform({ zoneId, managedRequestHeaders: [], managedResponseHeaders: delta })
65 .pipe(
66 Effect.retry({
67 while: (e) => e._tag === "Forbidden",
68 schedule: forbiddenRetrySchedule,
69 times: 8,
70 }),
71 );
72 });
73
74 describe.sequential(
75 "ManagedTransforms",
76 {
77 tags: [
78 "provider:cloudflare",
79 "provider:cloudflare:managedtransforms",
80 "provider:cloudflare:zone",
81 "live",
82 ],
83 },
84 () => {
85 test.provider(
86 "manages a named transform, updates in place, and restores it on destroy",
87 (stack) =>
88 Effect.gen(function* () {
89 const zoneId = yield* resolveZoneId;
90
91 yield* stack.destroy();
92 yield* normalizeBaseline(zoneId);
93
94 const baseline = yield* listTransforms(zoneId);
95 expect(enabledOf(baseline.managedResponseHeaders, MANAGED_ID)).toBe(false);
96 expect(enabledOf(baseline.managedResponseHeaders, UNMANAGED_ID)).toBe(false);
97
98 yield* Effect.gen(function* () {
99 // 1. Create (adopt the singleton) — enable one response transform.
100 const created = yield* stack.deploy(
101 Effect.gen(function* () {
102 return yield* Cloudflare.ManagedTransforms.ManagedTransforms("Transforms", {
103 zoneId,
104 responseHeaders: { [MANAGED_ID]: true },
105 });
106 }),
107 );
108 expect(created.zoneId).toEqual(zoneId);
109 expect(enabledOf(created.responseHeaders, MANAGED_ID)).toBe(true);
110 // Snapshot captured the pre-management (normalized) state.
111 expect(created.initialResponseHeaders[MANAGED_ID]).toBe(false);
112
113 const live1 = yield* listTransforms(zoneId);
114 expect(enabledOf(live1.managedResponseHeaders, MANAGED_ID)).toBe(true);
115 // The unmanaged transform is untouched.
116 expect(enabledOf(live1.managedResponseHeaders, UNMANAGED_ID)).toBe(false);
117
118 // 2. Update in place — flip the managed transform off and take over
119 // the second one. Same identity (same zoneId), and the initial
120 // snapshot must remain sticky across updates.
121 const updated = yield* stack.deploy(
122 Effect.gen(function* () {
123 return yield* Cloudflare.ManagedTransforms.ManagedTransforms("Transforms", {
124 zoneId,
125 responseHeaders: { [MANAGED_ID]: false, [UNMANAGED_ID]: true },
126 });
127 }),
128 );
129 expect(updated.zoneId).toEqual(zoneId);
130 expect(enabledOf(updated.responseHeaders, MANAGED_ID)).toBe(false);
131 expect(enabledOf(updated.responseHeaders, UNMANAGED_ID)).toBe(true);
132 expect(updated.initialResponseHeaders[MANAGED_ID]).toBe(false);
133 expect(updated.initialResponseHeaders[UNMANAGED_ID]).toBe(false);
134
135 const live2 = yield* listTransforms(zoneId);
136 expect(enabledOf(live2.managedResponseHeaders, MANAGED_ID)).toBe(false);
137 expect(enabledOf(live2.managedResponseHeaders, UNMANAGED_ID)).toBe(true);
138
139 // 3. Destroy — managed ids are restored to their snapshot values.
140 yield* stack.destroy();
141
142 const after = yield* listTransforms(zoneId);
143 expect(enabledOf(after.managedResponseHeaders, MANAGED_ID)).toBe(false);
144 expect(enabledOf(after.managedResponseHeaders, UNMANAGED_ID)).toBe(false);
145 }).pipe(Effect.ensuring(normalizeBaseline(zoneId).pipe(Effect.ignore)));
146
147 yield* stack.destroy();
148 }).pipe(logLevel),
149 { timeout: 240_000 },
150 );
151
152 test.provider(
153 "destroy restores a transform that was enabled before management",
154 (stack) =>
155 Effect.gen(function* () {
156 const zoneId = yield* resolveZoneId;
157
158 yield* stack.destroy();
159 yield* normalizeBaseline(zoneId);
160
161 yield* Effect.gen(function* () {
162 // Enable the transform out-of-band so the snapshot captures
163 // `enabled: true` as the pre-management state.
164 yield* managedTransforms
165 .patchManagedTransform({
166 zoneId,
167 managedRequestHeaders: [],
168 managedResponseHeaders: [{ id: MANAGED_ID, enabled: true }],
169 })
170 .pipe(
171 Effect.retry({
172 while: (e) => e._tag === "Forbidden",
173 schedule: forbiddenRetrySchedule,
174 times: 8,
175 }),
176 );
177
178 // Manage it to disabled.
179 const created = yield* stack.deploy(
180 Effect.gen(function* () {
181 return yield* Cloudflare.ManagedTransforms.ManagedTransforms("Transforms", {
182 zoneId,
183 responseHeaders: { [MANAGED_ID]: false },
184 });
185 }),
186 );
187 expect(created.initialResponseHeaders[MANAGED_ID]).toBe(true);
188 expect(enabledOf(created.responseHeaders, MANAGED_ID)).toBe(false);
189
190 const live = yield* listTransforms(zoneId);
191 expect(enabledOf(live.managedResponseHeaders, MANAGED_ID)).toBe(false);
192
193 // Destroy — the transform goes back to enabled (its snapshot value).
194 yield* stack.destroy();
195
196 const after = yield* listTransforms(zoneId);
197 expect(enabledOf(after.managedResponseHeaders, MANAGED_ID)).toBe(true);
198 }).pipe(Effect.ensuring(normalizeBaseline(zoneId).pipe(Effect.ignore)));
199
200 yield* stack.destroy();
201 }).pipe(logLevel),
202 { timeout: 240_000 },
203 );
204
205 test.provider(
206 "deploy with no transforms named adopts the singleton without writing",
207 (stack) =>
208 Effect.gen(function* () {
209 const zoneId = yield* resolveZoneId;
210
211 yield* stack.destroy();
212 yield* normalizeBaseline(zoneId);
213
214 const before = yield* listTransforms(zoneId);
215
216 const adopted = yield* stack.deploy(
217 Effect.gen(function* () {
218 return yield* Cloudflare.ManagedTransforms.ManagedTransforms("Transforms", {
219 zoneId,
220 });
221 }),
222 );
223 expect(adopted.zoneId).toEqual(zoneId);
224 // Attributes surface the full observed catalog. Note: a fresh zone
225 // reports `managed_request_headers: null` (normalized to `[]`) until
226 // the first PATCH materializes the catalog, so only its array shape
227 // is stable across runs.
228 expect(Array.isArray(adopted.requestHeaders)).toBe(true);
229 expect(adopted.responseHeaders.length).toBeGreaterThan(0);
230
231 // Nothing named => no PATCH => live state unchanged.
232 const afterDeploy = yield* listTransforms(zoneId);
233 for (const t of before.managedResponseHeaders ?? []) {
234 expect(enabledOf(afterDeploy.managedResponseHeaders, t.id)).toBe(t.enabled);
235 }
236
237 // Destroy of an untouched singleton restores nothing and never errors.
238 yield* stack.destroy();
239
240 const afterDestroy = yield* listTransforms(zoneId);
241 for (const t of before.managedResponseHeaders ?? []) {
242 expect(enabledOf(afterDestroy.managedResponseHeaders, t.id)).toBe(t.enabled);
243 }
244 }).pipe(logLevel),
245 { timeout: 240_000 },
246 );
247
248 // Canonical `list()` test (zone-scoped singleton): there is no account-wide
249 // API for the managed-transforms catalog, so `list()` enumerates every zone
250 // via `listAllZones` and reads the singleton in each. Assert the result is
251 // non-empty and contains the standing test zone.
252 test.provider("list enumerates managed transforms across all zones", (stack) =>
253 Effect.gen(function* () {
254 const zoneId = yield* resolveZoneId;
255
256 const provider = yield* Provider.findProvider(
257 Cloudflare.ManagedTransforms.ManagedTransforms,
258 );
259 // A freshly minted scoped token intermittently 403s — ride out the
260 // typed `Forbidden` blips like every other call in this suite.
261 const all = yield* provider.list().pipe(
262 Effect.retry({
263 while: (e) => e._tag === "Forbidden",
264 schedule: forbiddenRetrySchedule,
265 times: 8,
266 }),
267 );
268
269 expect(all.length).toBeGreaterThan(0);
270 expect(all.some((t) => t.zoneId === zoneId)).toBe(true);
271
272 // `stack` is unused here (the singleton always exists on every zone),
273 // but keep the destroy bookend so the harness state stays clean.
274 yield* stack.destroy();
275 }).pipe(logLevel),
276 );
277 },
278 );