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

main
ts 169 lines 6.25 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 logs from "@distilled.cloud/cloudflare/logs";
6 import * as Provider from "alchemy/Provider";
7 import * as Effect from "effect/Effect";
8 import { MinimumLogLevel } from "effect/References";
9 import * as Schedule from "effect/Schedule";
10
11 const { test } = Test.make({ providers: Cloudflare.providers() });
12
13 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
14
15 // The Customer Metadata Boundary is part of the Data Localization Suite and
16 // requires an Enterprise plan. On the standard testing account every
17 // `/logs/control/cmb/config` call fails with Cloudflare error code 10000
18 // ("Unauthorized"), surfaced as the typed `LogsControlNotAuthorized` error.
19 // The full lifecycle test below is gated behind an entitled account
20 // supplied via env.
21 const entitled = !!process.env.CLOUDFLARE_TEST_LOGS_CONTROL;
22
23 // The scoped API token the test harness mints propagates eventually-
24 // consistently across Cloudflare's edge — ride out 403 blips (`Forbidden`,
25 // declared in the distilled error union via patches) on out-of-band calls.
26 const getCmb = (accountId: string) =>
27 logs.getControlCmbConfig({ accountId }).pipe(
28 Effect.retry({
29 while: (e) => e._tag === "Forbidden",
30 schedule: Schedule.exponential("500 millis"),
31 times: 8,
32 }),
33 );
34
35 test.provider.skipIf(entitled)(
36 "surfaces the typed LogsControlNotAuthorized error on unentitled accounts",
37 (stack) =>
38 Effect.gen(function* () {
39 const { accountId } = yield* yield* CloudflareEnvironment;
40
41 yield* stack.destroy();
42
43 // The testing account has no CMB / Data Localization entitlement —
44 // both reads and writes must fail with the typed authorization tag
45 // (Cloudflare error code 10000).
46 const readError = yield* logs.getControlCmbConfig({ accountId }).pipe(Effect.flip);
47 expect(readError._tag).toEqual("LogsControlNotAuthorized");
48
49 const writeError = yield* logs
50 .createControlCmbConfig({ accountId, regions: "eu" })
51 .pipe(Effect.flip);
52 expect(writeError._tag).toEqual("LogsControlNotAuthorized");
53
54 yield* stack.destroy();
55 }).pipe(logLevel),
56 { tags: ["provider:cloudflare", "provider:cloudflare:logscontrol", "live"] },
57 );
58
59 test.provider.skipIf(!entitled)(
60 "create, verify out-of-band, update in place, destroy, and wait until gone",
61 (stack) =>
62 Effect.gen(function* () {
63 const { accountId } = yield* yield* CloudflareEnvironment;
64
65 yield* stack.destroy();
66
67 // Create — pin the CMB region.
68 const created = yield* stack.deploy(
69 Cloudflare.LogsControl.CmbConfig("Cmb", {
70 regions: "eu",
71 }),
72 );
73 expect(created.accountId).toEqual(accountId);
74 expect(created.regions).toEqual("eu");
75
76 const live = yield* getCmb(accountId);
77 expect(live.regions).toEqual("eu");
78
79 // Update in place — POST is a full upsert.
80 const updated = yield* stack.deploy(
81 Cloudflare.LogsControl.CmbConfig("Cmb", {
82 regions: "eu",
83 allowOutOfRegionAccess: true,
84 }),
85 );
86 expect(updated.regions).toEqual("eu");
87 expect(updated.allowOutOfRegionAccess).toEqual(true);
88
89 const liveUpdated = yield* getCmb(accountId);
90 expect(liveUpdated.allowOutOfRegionAccess).toEqual(true);
91
92 yield* stack.destroy();
93
94 // Destroy removed the config — the account reads back unconfigured,
95 // surfaced either as an empty result or the typed CmbConfigNotFound.
96 const gone = yield* getCmb(accountId).pipe(
97 Effect.map((config) => config.regions ?? undefined),
98 Effect.catchTag("CmbConfigNotFound", () => Effect.succeed(undefined)),
99 Effect.repeat({
100 schedule: Schedule.spaced("2 seconds"),
101 until: (regions) => regions === undefined,
102 times: 10,
103 }),
104 );
105 expect(gone).toBeUndefined();
106 }).pipe(logLevel),
107 {
108 tags: ["provider:cloudflare", "provider:cloudflare:logscontrol", "live"],
109 timeout: 120_000,
110 },
111 );
112
113 // Account-singleton `list()`: there is no account-wide collection API, so
114 // `list()` reads the single CMB config and returns a one-element array when
115 // set, `[]` when unconfigured. On unentitled accounts the underlying GET
116 // fails with the typed `LogsControlNotAuthorized` error (Cloudflare code
117 // 10000), which `list()` deliberately tolerates (returns `[]`) so that
118 // account-wide enumeration / `nuke` never blows up on an unentitled account.
119 // The raw-op probe test above already pins the typed tag; here we assert the
120 // nuke-safe empty result.
121 test.provider.skipIf(entitled)(
122 "list tolerates the typed LogsControlNotAuthorized error on unentitled accounts",
123 (stack) =>
124 Effect.gen(function* () {
125 yield* stack.destroy();
126
127 const provider = yield* Provider.findProvider(Cloudflare.LogsControl.CmbConfig);
128 const all = yield* provider.list();
129 expect(all).toEqual([]);
130
131 yield* stack.destroy();
132 }).pipe(logLevel),
133 { tags: ["provider:cloudflare", "provider:cloudflare:logscontrol", "live"] },
134 );
135
136 // Live `list()` on an entitled account: deploy the singleton, then assert
137 // it appears in the enumerated result as a well-typed Attributes array.
138 test.provider.skipIf(!entitled)(
139 "list enumerates the account CMB config singleton",
140 (stack) =>
141 Effect.gen(function* () {
142 const { accountId } = yield* yield* CloudflareEnvironment;
143
144 yield* stack.destroy();
145
146 yield* stack.deploy(
147 Cloudflare.LogsControl.CmbConfig("Cmb", {
148 regions: "eu",
149 }),
150 );
151
152 const provider = yield* Provider.findProvider(Cloudflare.LogsControl.CmbConfig);
153 const all = yield* provider.list();
154
155 expect(all.length).toEqual(1);
156 expect(all[0]?.accountId).toEqual(accountId);
157 expect(all[0]?.regions).toEqual("eu");
158
159 yield* stack.destroy();
160
161 // After destroy the singleton is unconfigured — `list()` returns `[]`.
162 const empty = yield* provider.list();
163 expect(empty).toEqual([]);
164 }).pipe(logLevel),
165 {
166 tags: ["provider:cloudflare", "provider:cloudflare:logscontrol", "live"],
167 timeout: 120_000,
168 },
169 );