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

main
ts 239 lines 8.84 KB
Raw
1 import * as Cloudflare from "@alchemy.run/cloudflare";
2 import { LOCAL_ACCOUNT_ID } from "@alchemy.run/cloudflare/LocalAccount";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as Alchemy from "alchemy";
6 import { Action } from "alchemy/Action";
7 import * as Cause from "effect/Cause";
8 import * as ConfigProvider from "effect/ConfigProvider";
9 import * as Effect from "effect/Effect";
10 import * as Exit from "effect/Exit";
11 import * as HttpClient from "effect/http/HttpClient";
12 import * as Layer from "effect/Layer";
13 import * as Result from "effect/Result";
14 import HttpBindingWorker from "./fixtures/http-binding-worker.ts";
15
16 const noCredentials = Layer.effect(
17 ConfigProvider.ConfigProvider,
18 Effect.gen(function* () {
19 const base = yield* ConfigProvider.ConfigProvider;
20 return ConfigProvider.make((path) => {
21 const key = path[0];
22 if (path.length === 1 && typeof key === "string") {
23 if (key.startsWith("CLOUDFLARE_")) return Effect.succeed(undefined);
24 if (key === "CI") return Effect.succeed(ConfigProvider.makeValue("false"));
25 if (key === "ALCHEMY_PROFILE")
26 return Effect.succeed(ConfigProvider.makeValue("cloudflare-credential-free-test"));
27 }
28 return base.load(path);
29 });
30 }),
31 );
32
33 const { test } = Test.make({
34 providers: Cloudflare.providers().pipe(Layer.provide(noCredentials)),
35 dev: true,
36 // `noCredentials` only reaches this process; the sidecar must not inherit
37 // the shell's Cloudflare credentials either.
38 sidecar: { omitEnv: ["CLOUDFLARE_"] },
39 profile: "cloudflare-credential-free-test",
40 });
41
42 test.provider(
43 "local Worker and Action storage clients work without Cloudflare credentials",
44 (stack) =>
45 Effect.gen(function* () {
46 yield* stack.destroy();
47 const program = Effect.gen(function* () {
48 const kv = yield* Cloudflare.KV.Namespace("KV");
49 const bucket = yield* Cloudflare.R2.Bucket("Bucket");
50 const db = yield* Cloudflare.D1.Database("Database");
51 const queue = yield* Cloudflare.Queues.Queue("Queue");
52 const store = yield* Cloudflare.SecretsStore.Store("Store");
53 const Seed = Action(
54 "Seed",
55 Effect.gen(function* () {
56 const namespace = yield* Cloudflare.KV.ReadWriteNamespace(kv);
57 const objects = yield* Cloudflare.R2.ReadWriteBucket(bucket);
58 const database = yield* Cloudflare.D1.QueryDatabase(db);
59 return Effect.fn(function* () {
60 yield* namespace.put("seed", "credential-free");
61 yield* objects.put("seed", "credential-free");
62 yield* database.exec("CREATE TABLE IF NOT EXISTS seed (value TEXT)");
63 yield* database.exec("DELETE FROM seed");
64 yield* database.prepare("INSERT INTO seed VALUES (?)").bind("credential-free").run();
65 return { value: yield* namespace.get("seed") };
66 });
67 }).pipe(
68 Effect.provide(
69 Layer.mergeAll(
70 Cloudflare.KV.ReadWriteNamespaceLocal,
71 Cloudflare.R2.ReadWriteBucketLocal,
72 Cloudflare.D1.QueryDatabaseLocal,
73 ),
74 ),
75 ),
76 );
77 const seeded = yield* Seed({});
78 const worker = yield* Cloudflare.Worker("Worker", {
79 main: `${import.meta.dirname}/fixtures/credential-free-worker.ts`,
80 env: { KV: kv, BUCKET: bucket, DB: db },
81 });
82 const consumer = yield* Cloudflare.Queues.Consumer("Consumer", {
83 queueId: queue.queueId,
84 scriptName: worker.workerName,
85 });
86 return { kv, bucket, db, queue, store, worker, consumer, seeded };
87 });
88 const deployed = yield* stack.deploy(program);
89 for (const resource of [
90 deployed.kv,
91 deployed.bucket,
92 deployed.db,
93 deployed.queue,
94 deployed.store,
95 deployed.worker,
96 deployed.consumer,
97 ]) {
98 expect(resource.accountId).toBe(LOCAL_ACCOUNT_ID);
99 }
100 expect(deployed.seeded.value).toBe("credential-free");
101 const http = yield* HttpClient.HttpClient;
102 const response = yield* http.get(deployed.worker.url!);
103 expect(response.status).toBe(200);
104 expect(yield* response.json).toEqual({
105 kv: "credential-free",
106 r2: "credential-free",
107 d1: "credential-free",
108 });
109 const again = yield* stack.deploy(program);
110 expect(again.kv.namespaceId).toBe(deployed.kv.namespaceId);
111 expect(again.queue.queueId).toBe(deployed.queue.queueId);
112 yield* stack.destroy();
113 }).pipe(Effect.provide(noCredentials)),
114 { tags: ["local", "provider:cloudflare"], timeout: 120_000 },
115 );
116
117 test.provider(
118 "remote Cloudflare resources still require credentials",
119 (stack) =>
120 Effect.gen(function* () {
121 yield* stack.destroy();
122 const result = yield* Effect.result(
123 stack.deploy(Cloudflare.KV.Namespace("RemoteNamespace").pipe(Alchemy.remote())),
124 );
125 expect(Result.isFailure(result)).toBe(true);
126 if (Result.isFailure(result)) {
127 expect(result.failure).toMatchObject({
128 _tag: "CredentialsRequired",
129 provider: "Cloudflare",
130 reason: "remote",
131 });
132 }
133 yield* stack.destroy();
134 }).pipe(Effect.provide(noCredentials)),
135 { tags: ["local", "provider:cloudflare"], timeout: 60_000 },
136 );
137
138 test.provider(
139 "remote bindings still require credentials before starting a local Worker",
140 (stack) =>
141 Effect.gen(function* () {
142 yield* stack.destroy();
143 const result = yield* Effect.result(
144 stack.deploy(
145 Cloudflare.Worker("RemoteBindingWorker", {
146 main: `${import.meta.dirname}/fixtures/credential-free-worker.ts`,
147 env: {
148 BROWSER: Cloudflare.Browser("BROWSER").pipe(Alchemy.remote()),
149 },
150 }),
151 ),
152 );
153 expect(Result.isFailure(result)).toBe(true);
154 if (Result.isFailure(result)) {
155 expect(result.failure).toMatchObject({
156 _tag: "CredentialsRequired",
157 provider: "Cloudflare",
158 reason: "remote-binding",
159 });
160 }
161 yield* stack.destroy();
162 }).pipe(Effect.provide(noCredentials)),
163 { tags: ["local", "provider:cloudflare"], timeout: 60_000 },
164 );
165
166 test.provider(
167 "*Http bindings on local resources fail with HttpBindingUnsupportedInDev",
168 (stack) =>
169 Effect.gen(function* () {
170 yield* stack.destroy();
171 const exit = yield* Effect.exit(stack.deploy(HttpBindingWorker));
172 yield* stack.destroy();
173 expect(Exit.isFailure(exit)).toBe(true);
174 if (Exit.isFailure(exit)) {
175 const failure = Cause.pretty(exit.cause);
176 expect(failure).toContain("Cloudflare.HttpBindingUnsupportedInDev");
177 expect(failure).toContain("Cloudflare.R2.Bucket HttpBindingBucket is emulated locally");
178 }
179 }).pipe(Effect.provide(noCredentials)),
180 { tags: ["local", "provider:cloudflare"], timeout: 60_000 },
181 );
182
183 test.provider(
184 "Vite child starts without Cloudflare credentials",
185 (stack) =>
186 Effect.gen(function* () {
187 yield* stack.destroy();
188 const site = yield* stack.deploy(
189 Cloudflare.Website.Vite("Site", {
190 rootDir: `${import.meta.dirname}/../Website/vite-queue-fixture`,
191 main: "worker.ts",
192 compatibility: { flags: ["nodejs_compat"] },
193 assets: { runWorkerFirst: true },
194 dev: { port: 0 },
195 }),
196 );
197 expect(site.accountId).toBe(LOCAL_ACCOUNT_ID);
198 const http = yield* HttpClient.HttpClient;
199 const response = yield* http.get(`${site.url}/api/received`);
200 expect(response.status).toBe(200);
201 expect(yield* response.json).toEqual({ received: [] });
202 yield* stack.destroy();
203 }).pipe(Effect.provide(noCredentials)),
204 { tags: ["local", "provider:cloudflare"], timeout: 120_000 },
205 );
206
207 const configuredAccount = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
208 const accountOnly = ConfigProvider.layer(
209 ConfigProvider.fromUnknown({
210 CI: true,
211 CLOUDFLARE_ACCOUNT_ID: configuredAccount,
212 }),
213 );
214 const configured = Test.make({
215 providers: Cloudflare.providers().pipe(Layer.provide(accountOnly)),
216 dev: true,
217 sidecar: false,
218 });
219
220 configured.test.provider(
221 "configured account propagates to local resources without credentials",
222 (stack) =>
223 Effect.gen(function* () {
224 yield* stack.destroy();
225 const outputs = yield* stack.deploy(
226 Effect.gen(function* () {
227 const kv = yield* Cloudflare.KV.Namespace("ConfiguredKV");
228 const worker = yield* Cloudflare.Worker("ConfiguredWorker", {
229 dev: { mode: "external", url: "http://localhost:4321" },
230 });
231 return { kv, worker };
232 }),
233 );
234 expect(outputs.kv.accountId).toBe(configuredAccount);
235 expect(outputs.worker.accountId).toBe(configuredAccount);
236 yield* stack.destroy();
237 }).pipe(Effect.provide(accountOnly)),
238 { tags: ["local", "provider:cloudflare"], timeout: 60_000 },
239 );