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

main
ts 181 lines 6.68 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 images from "@distilled.cloud/cloudflare/images";
6 import * as queues from "@distilled.cloud/cloudflare/queues";
7 import * as Effect from "effect/Effect";
8 import * as Schedule from "effect/Schedule";
9 import * as Schema from "effect/Schema";
10 import {
11 makeSubscriptionCleanup,
12 matchesSubscriptionEvent,
13 SubscriptionEvent,
14 } from "../Queue/SubscriptionSources.ts";
15
16 const { test } = Test.make({ providers: Cloudflare.providers() });
17 const canUpload = process.env.CLOUDFLARE_TEST_IMAGES_UPLOAD === "1";
18
19 test.provider.skipIf(canUpload)(
20 "image uploads expose the typed entitlement rejection",
21 (stack) =>
22 Effect.gen(function* () {
23 yield* stack.destroy();
24 const { accountId } = yield* yield* CloudflareEnvironment;
25 const cleanup = makeSubscriptionCleanup();
26 const error = yield* Effect.acquireRelease(
27 images.createV1({
28 accountId,
29 id: "alchemy-subscription-entitlement-probe",
30 url: "https://developers.cloudflare.com/og-docs.png",
31 }),
32 (image) =>
33 image.id ? images.deleteV1({ accountId, imageId: image.id }).pipe(cleanup) : Effect.void,
34 ).pipe(Effect.scoped, Effect.flip);
35 expect(error).toMatchObject({ _tag: "ImagesAccessNotEnabled", code: 5403 });
36 yield* stack.destroy();
37 }).pipe(
38 Effect.ensuring(
39 stack.destroy().pipe(Effect.timeout("15 seconds"), Effect.orDie, Effect.interruptible),
40 ),
41 ),
42 { tags: ["provider:cloudflare", "provider:cloudflare:images", "live"] },
43 );
44
45 // Uploads require Images entitlement; the testing account returns ImagesAccessNotEnabled (5403).
46 test.provider.skipIf(!canUpload)(
47 "an Images variant reference receives an account-wide upload event",
48 (stack) =>
49 Effect.gen(function* () {
50 yield* stack.destroy();
51 const { accountId } = yield* yield* CloudflareEnvironment;
52 const cleanup = makeSubscriptionCleanup();
53 const variant = Cloudflare.Images.Variant("Variant", {
54 fit: "contain",
55 width: 100,
56 height: 100,
57 });
58 yield* stack.deploy(variant);
59 const deployed = yield* stack.deploy(
60 Effect.gen(function* () {
61 const source = yield* variant;
62 const queue = yield* Cloudflare.Queues.Queue("ImageEvents");
63 const subscription = yield* Cloudflare.Queues.Subscription("Uploads", {
64 source: yield* Cloudflare.Images.Variant.ref("Variant"),
65 events: ["image.uploaded"],
66 queueId: queue.queueId,
67 });
68 return { source, queue, subscription };
69 }),
70 );
71 yield* queues.createConsumer({
72 accountId,
73 queueId: deployed.queue.queueId,
74 type: "http_pull",
75 });
76 yield* Effect.gen(function* () {
77 const upload = (suffix: string) =>
78 Effect.acquireRelease(
79 images.createV1({
80 accountId,
81 id: `${deployed.subscription.subscriptionId}-${suffix}`,
82 url: "https://developers.cloudflare.com/og-docs.png",
83 }),
84 (image) =>
85 image.id
86 ? images.deleteV1({ accountId, imageId: image.id }).pipe(
87 Effect.catchTag("ImageNotFound", () => Effect.void),
88 cleanup,
89 )
90 : Effect.void,
91 ).pipe(
92 Effect.flatMap((image) =>
93 image.id
94 ? Effect.succeed(image.id)
95 : Effect.fail(new Error("Image upload returned no identity")),
96 ),
97 );
98 const events: SubscriptionEvent[] = [];
99 const delivered = (imageId: string) =>
100 events.some((event) =>
101 matchesSubscriptionEvent(event, {
102 source: "images",
103 type: "image.uploaded",
104 accountId,
105 subscriptionId: deployed.subscription.subscriptionId,
106 identity: imageId,
107 }),
108 );
109 const pull = Effect.gen(function* () {
110 const pulled = yield* queues
111 .pullMessage({
112 accountId,
113 queueId: deployed.queue.queueId,
114 batchSize: 100,
115 visibilityTimeoutMs: 30_000,
116 })
117 .pipe(
118 Effect.retry({
119 while: (error) => error._tag === "QueueHttpPullNotEnabled",
120 schedule: Schedule.spaced("2 seconds"),
121 times: 8,
122 }),
123 );
124 const decoded = yield* Effect.forEach(pulled.messages ?? [], ({ body }) =>
125 Schema.decodeUnknownEffect(SubscriptionEvent)(body),
126 );
127 events.push(...decoded);
128 if (decoded.length) yield* Effect.logInfo("Image subscription receipts", decoded);
129 const acks = (pulled.messages ?? []).flatMap(({ leaseId }) =>
130 leaseId ? [{ leaseId }] : [],
131 );
132 if (acks.length) {
133 const result = yield* queues.ackMessage({
134 accountId,
135 queueId: deployed.queue.queueId,
136 acks,
137 });
138 expect(result.ackCount).toBe(acks.length);
139 expect(Object.keys(result.warnings ?? {})).toHaveLength(0);
140 }
141 });
142 yield* pull;
143 const probes: string[] = [];
144 const ready = () => probes.some(delivered);
145 yield* Effect.gen(function* () {
146 probes.push(yield* upload(`probe-${probes.length}`));
147 yield* pull;
148 }).pipe(Effect.repeat({ schedule: Schedule.spaced("3 seconds"), times: 8, until: ready }));
149 expect(ready()).toBe(true);
150 // A readiness probe must not satisfy the final upload assertion.
151 const imageId = yield* upload("final");
152 expect(probes).not.toContain(imageId);
153 yield* pull.pipe(
154 Effect.repeat({
155 schedule: Schedule.spaced("3 seconds"),
156 times: 8,
157 until: () => delivered(imageId),
158 }),
159 );
160 expect(delivered(imageId)).toBe(true);
161 }).pipe(Effect.timeout("60 seconds"), Effect.scoped);
162 yield* stack.deploy(variant);
163 yield* images.getV1Variant({ accountId, variantId: deployed.source.variantName });
164 yield* stack.destroy();
165 }).pipe(
166 Effect.scoped,
167 Effect.ensuring(
168 stack.destroy().pipe(Effect.timeout("15 seconds"), Effect.orDie, Effect.interruptible),
169 ),
170 ),
171 {
172 tags: [
173 "provider:cloudflare",
174 "provider:cloudflare:images",
175 "provider:cloudflare:queue",
176 "live",
177 ],
178 timeout: 120_000,
179 exclusive: "cloudflare:event-subscriptions",
180 },
181 );