@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, 06:00 UTC

main
ts 273 lines 10.2 KB
Raw
1 import * as Cloudflare from "@alchemy.run/cloudflare";
2 import { CloudflareEnvironment } from "@alchemy.run/cloudflare/CloudflareEnvironment";
3 import { describe, expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as accounts from "@distilled.cloud/cloudflare/accounts";
6 import * as Credentials from "@distilled.cloud/cloudflare/Credentials";
7 import * as workers from "@distilled.cloud/cloudflare/workers";
8 import * as Output from "alchemy/Output";
9 import * as Provider from "alchemy/Provider";
10 import * as Data from "effect/Data";
11 import * as Effect from "effect/Effect";
12 import * as Redacted from "effect/Redacted";
13 import { MinimumLogLevel } from "effect/References";
14 import * as Schedule from "effect/Schedule";
15 import { testName } from "../../names.ts";
16 const { test } = Test.make({ providers: Cloudflare.providers() });
17
18 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
19
20 describe(
21 "AccountApiToken",
22 { tags: ["provider:cloudflare", "provider:cloudflare:apitoken", "live"] },
23 () => {
24 test.provider(
25 "create and delete account token with default props",
26 (stack) =>
27 Effect.gen(function* () {
28 const { accountId } = yield* yield* CloudflareEnvironment;
29
30 yield* stack.destroy();
31
32 const token = yield* stack.deploy(
33 Effect.gen(function* () {
34 return yield* Cloudflare.ApiToken.AccountApiToken("DefaultToken", {
35 policies: [
36 {
37 effect: "allow",
38 permissionGroups: ["Workers Scripts Read"],
39 resources: { [`com.cloudflare.api.account.${accountId}`]: "*" },
40 },
41 ],
42 });
43 }),
44 );
45
46 expect(token.tokenId).toBeDefined();
47 expect(token.name).toBeDefined();
48 expect(token.status).toEqual("active");
49 expect(Redacted.value(token.value)).toMatch(/.+/);
50
51 const actualToken = yield* accounts.getToken({ accountId, tokenId: token.tokenId });
52 expect(actualToken.id).toEqual(token.tokenId);
53 expect(actualToken.name).toEqual(token.name);
54
55 yield* stack.destroy();
56
57 yield* waitForTokenToBeDeleted(token.tokenId, accountId);
58 }).pipe(logLevel),
59 { tags: ["provider:cloudflare:account"] },
60 );
61
62 test.provider(
63 "create, update, delete account token",
64 (stack) =>
65 Effect.gen(function* () {
66 const { accountId } = yield* yield* CloudflareEnvironment;
67
68 yield* stack.destroy();
69
70 const token = yield* stack.deploy(
71 Effect.gen(function* () {
72 return yield* Cloudflare.ApiToken.AccountApiToken("UpdateToken", {
73 name: testName("alchemy-test-acct-update-initial"),
74 policies: [
75 {
76 effect: "allow",
77 permissionGroups: ["Workers Scripts Read"],
78 resources: { [`com.cloudflare.api.account.${accountId}`]: "*" },
79 },
80 ],
81 });
82 }),
83 );
84
85 expect(token.name).toEqual(testName("alchemy-test-acct-update-initial"));
86 const initialValue = Redacted.value(token.value);
87
88 const updated = yield* stack.deploy(
89 Effect.gen(function* () {
90 return yield* Cloudflare.ApiToken.AccountApiToken("UpdateToken", {
91 name: testName("alchemy-test-acct-update-renamed"),
92 policies: [
93 {
94 effect: "allow",
95 permissionGroups: ["Workers Scripts Read", "Workers KV Storage Read"],
96 resources: { [`com.cloudflare.api.account.${accountId}`]: "*" },
97 },
98 ],
99 });
100 }),
101 );
102
103 expect(updated.tokenId).toEqual(token.tokenId);
104 expect(updated.name).toEqual(testName("alchemy-test-acct-update-renamed"));
105 expect(Redacted.value(updated.value)).toEqual(initialValue);
106
107 const actual = yield* accounts.getToken({ accountId, tokenId: updated.tokenId });
108 expect(actual.name).toEqual(testName("alchemy-test-acct-update-renamed"));
109 expect(actual.policies?.[0]?.permissionGroups.length).toEqual(2);
110
111 yield* stack.destroy();
112
113 yield* waitForTokenToBeDeleted(token.tokenId, accountId);
114 }).pipe(logLevel),
115 { tags: ["provider:cloudflare:account"] },
116 );
117
118 test.provider("noop when account token props unchanged", (stack) =>
119 Effect.gen(function* () {
120 const { accountId } = yield* yield* CloudflareEnvironment;
121
122 yield* stack.destroy();
123
124 const props = {
125 name: "alchemy-test-acct-noop",
126 policies: [
127 {
128 effect: "allow" as const,
129 permissionGroups: ["Workers Scripts Read" as const],
130 resources: { [`com.cloudflare.api.account.${accountId}`]: "*" },
131 },
132 ],
133 };
134
135 const first = yield* stack.deploy(
136 Effect.gen(function* () {
137 return yield* Cloudflare.ApiToken.AccountApiToken("NoopToken", props);
138 }),
139 );
140
141 const second = yield* stack.deploy(
142 Effect.gen(function* () {
143 return yield* Cloudflare.ApiToken.AccountApiToken("NoopToken", props);
144 }),
145 );
146
147 expect(second.tokenId).toEqual(first.tokenId);
148 expect(Redacted.value(second.value)).toEqual(Redacted.value(first.value));
149
150 yield* stack.destroy();
151 }).pipe(logLevel),
152 );
153
154 test.provider(
155 "scopes an account token to one Worker",
156 (stack) =>
157 Effect.gen(function* () {
158 const { accountId } = yield* yield* CloudflareEnvironment;
159
160 yield* stack.destroy();
161
162 const { token, allowed, denied } = yield* stack.deploy(
163 Effect.gen(function* () {
164 const allowed = yield* Cloudflare.Worker("ScopedWorker", {
165 script: `export default { fetch: () => new Response("allowed") };`,
166 });
167 const denied = yield* Cloudflare.Worker("OtherWorker", {
168 script: `export default { fetch: () => new Response("denied") };`,
169 });
170 const token = yield* Cloudflare.ApiToken.AccountApiToken("WorkerScopedToken", {
171 policies: [
172 {
173 effect: "allow",
174 permissionGroups: ["Individual Workers Editor"],
175 resources: allowed.workerId.pipe(
176 Output.map((workerId) => ({
177 [`com.cloudflare.api.account.${accountId}`]: {
178 [`com.cloudflare.edge.worker.script.${workerId}`]: "*",
179 },
180 })),
181 ),
182 },
183 ],
184 });
185 return { token, allowed, denied };
186 }),
187 );
188
189 const actual = yield* accounts.getToken({ accountId, tokenId: token.tokenId });
190 expect(actual.policies?.[0]?.resources).toEqual({
191 [`com.cloudflare.api.account.${accountId}`]: {
192 [`com.cloudflare.edge.worker.script.${allowed.workerId}`]: "*",
193 },
194 });
195
196 // Call the Workers API as the scoped token: the Worker it is scoped
197 // to is readable, the other one is not.
198 const asToken = Effect.provide(Credentials.fromApiToken({ apiToken: token.value }));
199 const settings = yield* workers
200 .getScriptSetting({ accountId, scriptName: allowed.workerName })
201 .pipe(
202 asToken,
203 // a freshly minted token takes a few seconds to propagate
204 Effect.retry({ schedule: Schedule.exponential("500 millis"), times: 8 }),
205 );
206 expect(settings).toBeDefined();
207 const error = yield* workers
208 .getScriptSetting({ accountId, scriptName: denied.workerName })
209 .pipe(asToken, Effect.flip);
210 expect(error._tag).toEqual("Forbidden");
211
212 yield* stack.destroy();
213
214 yield* waitForTokenToBeDeleted(token.tokenId, accountId);
215 }).pipe(logLevel),
216 { tags: ["provider:cloudflare:account"] },
217 );
218
219 const waitForTokenToBeDeleted = Effect.fn(function* (tokenId: string, accountId: string) {
220 yield* accounts.getToken({ accountId, tokenId }).pipe(
221 Effect.flatMap(() => Effect.fail(new TokenStillExists())),
222 Effect.retry({
223 while: (e): e is TokenStillExists => e instanceof TokenStillExists,
224 schedule: Schedule.max([Schedule.exponential(200), Schedule.recurs(8)]),
225 }),
226 Effect.catchTag("TokenStillExists", () =>
227 Effect.die(`Cloudflare API token ${tokenId} was not deleted after retries`),
228 ),
229 Effect.catchTag("TokenNotFound", () => Effect.void),
230 Effect.catchTag("InvalidRoute", () => Effect.void),
231 );
232 });
233 },
234 );
235 class TokenStillExists extends Data.TaggedError("TokenStillExists") {}
236
237 describe(
238 "AccountApiToken list",
239 { tags: ["provider:cloudflare", "provider:cloudflare:apitoken", "live"] },
240 () => {
241 test.provider("list enumerates the deployed account token", (stack) =>
242 Effect.gen(function* () {
243 const { accountId } = yield* yield* CloudflareEnvironment;
244
245 yield* stack.destroy();
246
247 const token = yield* stack.deploy(
248 Effect.gen(function* () {
249 return yield* Cloudflare.ApiToken.AccountApiToken("ListToken", {
250 policies: [
251 {
252 effect: "allow",
253 permissionGroups: ["Workers Scripts Read"],
254 resources: { [`com.cloudflare.api.account.${accountId}`]: "*" },
255 },
256 ],
257 });
258 }),
259 );
260
261 const provider = yield* Provider.findProvider(Cloudflare.ApiToken.AccountApiToken);
262 const all = yield* provider.list();
263
264 expect(all.some((t) => t.tokenId === token.tokenId)).toBe(true);
265 const found = all.find((t) => t.tokenId === token.tokenId)!;
266 expect(found.name).toEqual(token.name);
267 expect(found.accountId).toEqual(accountId);
268
269 yield* stack.destroy();
270 }).pipe(logLevel),
271 );
272 },
273 );