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

main
ts 113 lines 4.89 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 Effect from "effect/Effect";
6 import * as FileSystem from "effect/FileSystem";
7 import { MinimumLogLevel } from "effect/References";
8 import * as Schedule from "effect/Schedule";
9 import * as pathe from "pathe";
10 import { cloneFixture } from "../Utils/Fixture.ts";
11 import { expectWorkerExists, waitForWorkerToBeDeleted } from "../Utils/Worker.ts";
12
13 // Streamed responses from a `Website.Vite` Worker, mirroring
14 // `@cloudflare/vite-plugin`'s `streaming` playground: each chunk reaches the
15 // client as the Worker writes it, deployed, under `alchemy dev`, and with the
16 // dev server on HTTPS.
17
18 const { test } = Test.make({ providers: Cloudflare.providers() });
19 const { test: devTest } = Test.make({ providers: Cloudflare.providers(), dev: true });
20
21 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
22 const tempRoot = pathe.resolve(import.meta.dirname, "../../../.tmp");
23 const fixtureDir = pathe.resolve(import.meta.dirname, "vite-streaming-fixture");
24
25 // Reads the response, noting when each marker first arrives.
26 const readStream = (url: string) =>
27 Effect.tryPromise(async () => {
28 const start = Date.now();
29 const response = await fetch(url, {
30 // The HTTPS dev server's certificate is self-signed.
31 tls: { rejectUnauthorized: false },
32 } as RequestInit);
33 if (response.status !== 200 || !response.body) {
34 throw new Error(`status ${response.status}: ${await response.text()}`);
35 }
36 const decoder = new TextDecoder();
37 const arrivals: Record<string, number> = {};
38 let body = "";
39 for await (const chunk of response.body) {
40 body += decoder.decode(chunk, { stream: true });
41 for (const marker of ["<h1>Streaming example</h1>", `<p id="one">`, `<p id="two">`]) {
42 if (body.includes(marker)) arrivals[marker] ??= Date.now() - start;
43 }
44 }
45 return { body, arrivals };
46 }).pipe(Effect.retry({ times: 10, schedule: Schedule.spaced("2 seconds") }));
47
48 const variants = [
49 { mode: "live", config: undefined },
50 { mode: "dev", config: undefined },
51 { mode: "dev", config: "https" },
52 ] as const;
53
54 describe("Website.Vite streaming", () => {
55 for (const { mode, config } of variants) {
56 const id = `ViteStreaming${mode}${config ?? ""}`;
57 (mode === "live" ? test : devTest).provider(
58 `Vite streaming: renders an HTML stream chunk by chunk${mode === "dev" ? ` (dev${config ? `, ${config}` : ""})` : ""}`,
59 (stack) =>
60 Effect.gen(function* () {
61 yield* stack.destroy();
62 const rootDir = yield* cloneFixture(fixtureDir, {
63 prefix: "alchemy-vite-streaming-",
64 tempRoot,
65 entries: ["package.json", "configs", "src"],
66 });
67 if (config) {
68 const fs = yield* FileSystem.FileSystem;
69 yield* fs.copyFile(
70 pathe.join(rootDir, `configs/${config}.ts`),
71 pathe.join(rootDir, "vite.config.ts"),
72 );
73 }
74 const site = yield* stack.deploy(
75 Cloudflare.Website.Vite(id, {
76 rootDir,
77 main: "./src/index.ts",
78 workersDev: true,
79 compatibility: { date: "2024-12-30" },
80 memo: { include: ["**/*"] },
81 ...(mode === "dev" ? { dev: { port: 0 } } : {}),
82 }),
83 );
84 const url = site.url!;
85 if (config === "https") expect(url).toMatch(/^https:/);
86 const { body, arrivals } = yield* readStream(url);
87 expect(body).toContain(`<p id="two">Chunk after 2 seconds</p>`);
88 if (mode === "dev") {
89 // The heading arrives a second before the next chunk is written,
90 // and that chunk a second before the last. (Deployed, the edge
91 // delivers this stream in one piece, as it does for Wrangler's.)
92 const heading = arrivals["<h1>Streaming example</h1>"]!;
93 const one = arrivals[`<p id="one">`]!;
94 const two = arrivals[`<p id="two">`]!;
95 expect(one - heading).toBeGreaterThan(500);
96 expect(two - one).toBeGreaterThan(500);
97 } else {
98 const { accountId } = yield* yield* CloudflareEnvironment;
99 yield* expectWorkerExists(site.workerName, accountId);
100 yield* stack.destroy();
101 yield* waitForWorkerToBeDeleted(site.workerName, accountId);
102 }
103 }).pipe(Effect.ensuring(stack.destroy().pipe(Effect.ignore)), logLevel),
104 {
105 tags: ["provider:cloudflare:worker", mode === "dev" ? "local" : "live"],
106 timeout: 300_000,
107 // The chunk timing must not absorb event-loop stalls from tests
108 // running alongside in this process.
109 exclusive: mode === "dev",
110 },
111 );
112 }
113 });