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

main
ts 229 lines 8.09 KB
Raw
1 import * as Cloudflare from "@alchemy.run/cloudflare";
2 import { CloudflareEnvironment } from "@alchemy.run/cloudflare/CloudflareEnvironment";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as rulesets from "@distilled.cloud/cloudflare/rulesets";
6 import * as Provider from "alchemy/Provider";
7 import * as Effect from "effect/Effect";
8 import { MinimumLogLevel } from "effect/References";
9 import * as Result from "effect/Result";
10 import * as Schedule from "effect/Schedule";
11
12 const { test } = Test.make({ providers: Cloudflare.providers() });
13
14 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
15
16 // A freshly minted scoped token propagates eventually-consistently across
17 // Cloudflare's edge — retry the typed `Forbidden` blips on out-of-band calls.
18 const forbiddenRetrySchedule = Schedule.exponential("500 millis");
19
20 const phase = "http_request_firewall_custom";
21
22 const resolveAccountId = Effect.gen(function* () {
23 const { accountId } = yield* yield* CloudflareEnvironment;
24 return accountId;
25 });
26
27 const getEntrypointRules = (accountId: string) =>
28 rulesets.getPhasForAccount({ accountId, rulesetPhase: phase }).pipe(
29 Effect.retry({
30 while: (e) => e._tag === "Forbidden",
31 schedule: forbiddenRetrySchedule,
32 times: 8,
33 }),
34 Effect.map((entrypoint) => entrypoint.rules ?? []),
35 Effect.catchTag("RulesetNotFound", () => Effect.succeed([])),
36 );
37
38 // Account-level phase entrypoints require an Enterprise plan. On the
39 // standard testing account every PUT fails with the typed `PhaseNotEntitled`
40 // error (code 50002). The test probes once: unentitled accounts assert the
41 // typed tag; entitled accounts run the full lifecycle.
42 test.provider(
43 "account entrypoint lifecycle (typed PhaseNotEntitled on unentitled accounts)",
44 (stack) =>
45 Effect.gen(function* () {
46 const accountId = yield* resolveAccountId;
47
48 yield* stack.destroy();
49
50 // Probing with an empty rules PUT is a harmless baseline on entitled
51 // accounts (the entrypoint is a singleton; empty = "no rules").
52 const probe = yield* rulesets
53 .putPhasForAccount({
54 accountId,
55 rulesetPhase: phase,
56 rules: [],
57 })
58 .pipe(
59 Effect.retry({
60 while: (e) => e._tag === "Forbidden",
61 schedule: forbiddenRetrySchedule,
62 times: 8,
63 }),
64 Effect.result,
65 );
66
67 if (Result.isFailure(probe)) {
68 // Unentitled — the distilled call must fail with the typed
69 // entitlement tag, never an untyped catch-all.
70 expect(probe.failure._tag).toEqual("PhaseNotEntitled");
71 yield* stack.destroy();
72 return;
73 }
74
75 // Entitled — deploy a custom ruleset plus the entrypoint that
76 // executes it (the Enterprise WAF deployment workflow).
77 const deployed = yield* stack.deploy(
78 Effect.gen(function* () {
79 const ruleset = yield* Cloudflare.Ruleset.CustomRuleset("SharedRules", {
80 phase,
81 rules: [
82 {
83 description: "Block exploit probes",
84 expression: `lower(http.request.uri.path) contains "/.env"`,
85 action: "block",
86 },
87 ],
88 });
89 const entrypoint = yield* Cloudflare.Ruleset.AccountEntrypoint("WafDeployment", {
90 phase,
91 description: "alchemy account entrypoint v1",
92 rules: [
93 {
94 description: "Deploy shared WAF rules",
95 expression: "true",
96 action: "execute",
97 actionParameters: { id: ruleset.rulesetId },
98 },
99 ],
100 });
101 return { entrypoint, ruleset };
102 }),
103 );
104 expect(deployed.entrypoint.accountId).toEqual(accountId);
105 expect(deployed.entrypoint.phase).toEqual(phase);
106 expect(deployed.entrypoint.rules).toHaveLength(1);
107
108 // Out-of-band verification via the distilled API.
109 const liveRules = yield* getEntrypointRules(accountId);
110 expect(liveRules).toHaveLength(1);
111 expect(liveRules[0]).toMatchObject({ action: "execute" });
112
113 // Update the description in place — same singleton entrypoint.
114 const updated = yield* stack.deploy(
115 Effect.gen(function* () {
116 const ruleset = yield* Cloudflare.Ruleset.CustomRuleset("SharedRules", {
117 phase,
118 rules: [
119 {
120 description: "Block exploit probes",
121 expression: `lower(http.request.uri.path) contains "/.env"`,
122 action: "block",
123 },
124 ],
125 });
126 return yield* Cloudflare.Ruleset.AccountEntrypoint("WafDeployment", {
127 phase,
128 description: "alchemy account entrypoint v2",
129 rules: [
130 {
131 description: "Deploy shared WAF rules",
132 expression: "true",
133 action: "execute",
134 actionParameters: { id: ruleset.rulesetId },
135 },
136 ],
137 });
138 }),
139 );
140 expect(updated.rulesetId).toEqual(deployed.entrypoint.rulesetId);
141 expect(updated.description).toEqual("alchemy account entrypoint v2");
142
143 // Destroy and verify the entrypoint was emptied in Cloudflare.
144 yield* stack.destroy();
145 const remaining = yield* getEntrypointRules(accountId);
146 expect(remaining).toEqual([]);
147 }).pipe(logLevel),
148 {
149 tags: ["provider:cloudflare", "provider:cloudflare:ruleset", "live"],
150 timeout: 120_000,
151 },
152 );
153
154 test.provider(
155 "list enumerates the account phase entrypoints",
156 (stack) =>
157 Effect.gen(function* () {
158 const accountId = yield* resolveAccountId;
159
160 yield* stack.destroy();
161
162 // Probe entitlement: an empty-rules PUT is a harmless baseline on
163 // entitled accounts, but fails with the typed `PhaseNotEntitled` tag
164 // on the standard testing account.
165 const probe = yield* rulesets
166 .putPhasForAccount({ accountId, rulesetPhase: phase, rules: [] })
167 .pipe(
168 Effect.retry({
169 while: (e) => e._tag === "Forbidden",
170 schedule: forbiddenRetrySchedule,
171 times: 8,
172 }),
173 Effect.result,
174 );
175
176 const provider = yield* Provider.findProvider(Cloudflare.Ruleset.AccountEntrypoint);
177
178 if (Result.isFailure(probe)) {
179 // Unentitled — list must still succeed (typed-skip gated phases) and
180 // return a well-typed array rather than throwing.
181 expect(probe.failure._tag).toEqual("PhaseNotEntitled");
182 const all = yield* provider.list();
183 expect(Array.isArray(all)).toBe(true);
184 yield* stack.destroy();
185 return;
186 }
187
188 // Entitled — deploy the entrypoint and assert list() surfaces it in the
189 // exhaustively-enumerated result.
190 const deployed = yield* stack.deploy(
191 Effect.gen(function* () {
192 const ruleset = yield* Cloudflare.Ruleset.CustomRuleset("SharedRules", {
193 phase,
194 rules: [
195 {
196 description: "Block exploit probes",
197 expression: `lower(http.request.uri.path) contains "/.env"`,
198 action: "block",
199 },
200 ],
201 });
202 return yield* Cloudflare.Ruleset.AccountEntrypoint("WafDeployment", {
203 phase,
204 description: "alchemy account entrypoint list",
205 rules: [
206 {
207 description: "Deploy shared WAF rules",
208 expression: "true",
209 action: "execute",
210 actionParameters: { id: ruleset.rulesetId },
211 },
212 ],
213 });
214 }),
215 );
216
217 const all = yield* provider.list();
218 expect(all.some((e) => e.rulesetId === deployed.rulesetId)).toBe(true);
219 const found = all.find((e) => e.rulesetId === deployed.rulesetId)!;
220 expect(found.accountId).toEqual(accountId);
221 expect(found.phase).toEqual(phase);
222
223 yield* stack.destroy();
224 }).pipe(logLevel),
225 {
226 tags: ["provider:cloudflare", "provider:cloudflare:ruleset", "live"],
227 timeout: 120_000,
228 },
229 );