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

main
ts 134 lines 4.76 KB
Raw
1 // Alchemy modifications are licensed under Apache-2.0.
2 // This file includes third-party code; see /THIRD_PARTY_LICENSES.md.
3 // Vendored from `@astrojs/cloudflare` v14.4.2 (`src/utils/prerender-response.ts`).
4 /**
5 * Node-side reader for the framed prerender responses the prerender worker
6 * writes with `createFramedPrerenderResponse`. Kept out of the worker runtime
7 * so the metadata Schema never ships in the worker bundle.
8 */
9 import type { PrerenderRenderMetadata } from "astro";
10 import * as Schema from "effect/Schema";
11 import {
12 MAX_METADATA_LENGTH,
13 METADATA_LENGTH_BYTES,
14 PRERENDER_RESPONSE_CONTENT_TYPE,
15 } from "./runtime/utils/prerender-response.ts";
16
17 const NULL_BODY_STATUSES = new Set([204, 205, 304]);
18
19 const ResponseMetadata = Schema.Struct({
20 status: Schema.Int.check(Schema.isBetween({ minimum: 200, maximum: 599 })),
21 statusText: Schema.String,
22 headers: Schema.Array(Schema.Tuple([Schema.String, Schema.String])),
23 hasBody: Schema.Boolean,
24 metadata: Schema.optional(
25 Schema.Struct({
26 contentEntryKeys: Schema.Array(Schema.String),
27 staticImages: Schema.Array(Schema.Unknown),
28 referencedImages: Schema.String.pipe(Schema.Array, Schema.optional),
29 }),
30 ),
31 }).check(
32 Schema.makeFilter(({ status, hasBody }) => !(hasBody && NULL_BODY_STATUSES.has(status)), {
33 message: "a null-body status cannot carry a body",
34 }),
35 );
36
37 // oxlint-disable-next-line effecttsgo/schema-sync -- decoded inside an async, non-Effect reader
38 const decodeResponseMetadata = Schema.decodeUnknownSync(Schema.fromJsonString(ResponseMetadata));
39
40 export async function readFramedPrerenderResponse(
41 transportResponse: Response,
42 ): Promise<{ response: Response; metadata: PrerenderRenderMetadata | undefined }> {
43 if (!transportResponse.ok) {
44 throw new Error(
45 `The framed prerender request failed (${transportResponse.status}: ${transportResponse.statusText}).`,
46 );
47 }
48 if (transportResponse.headers.get("Content-Type") !== PRERENDER_RESPONSE_CONTENT_TYPE) {
49 throw new Error("The prerender response is not framed.");
50 }
51 if (!transportResponse.body) {
52 throw new Error("The framed prerender response has no body.");
53 }
54
55 const reader = transportResponse.body.getReader();
56 let chunk: Uint8Array | undefined;
57 let chunkOffset = 0;
58 const nextChunk = async (): Promise<Uint8Array> => {
59 const next = await reader.read();
60 if (next.done) throw new Error("The framed prerender response ended unexpectedly.");
61 chunk = next.value;
62 chunkOffset = 0;
63 return next.value;
64 };
65 const readExactly = async (length: number): Promise<Uint8Array> => {
66 const bytes = new Uint8Array(length);
67 let bytesRead = 0;
68 while (bytesRead < length) {
69 const current = chunk && chunkOffset < chunk.byteLength ? chunk : await nextChunk();
70 const available = current.byteLength - chunkOffset;
71 const count = Math.min(length - bytesRead, available);
72 bytes.set(current.subarray(chunkOffset, chunkOffset + count), bytesRead);
73 chunkOffset += count;
74 bytesRead += count;
75 }
76 return bytes;
77 };
78
79 try {
80 const lengthBytes = await readExactly(METADATA_LENGTH_BYTES);
81 const metadataLength = new DataView(
82 lengthBytes.buffer,
83 lengthBytes.byteOffset,
84 lengthBytes.byteLength,
85 ).getUint32(0);
86 if (metadataLength === 0 || metadataLength > MAX_METADATA_LENGTH) {
87 throw new Error("The framed prerender response metadata length is invalid.");
88 }
89 const metadataBytes = await readExactly(metadataLength);
90 const responseMetadata = decodeResponseMetadata(new TextDecoder().decode(metadataBytes));
91
92 let remainder =
93 chunk && chunkOffset < chunk.byteLength ? chunk.subarray(chunkOffset) : undefined;
94 let body: ReadableStream<Uint8Array> | null = null;
95 if (responseMetadata.hasBody) {
96 body = new ReadableStream<Uint8Array>({
97 async pull(controller) {
98 if (remainder) {
99 controller.enqueue(remainder);
100 remainder = undefined;
101 return;
102 }
103 const { done, value } = await reader.read();
104 if (done) {
105 controller.close();
106 } else {
107 controller.enqueue(value);
108 }
109 },
110 cancel(reason) {
111 return reader.cancel(reason);
112 },
113 });
114 } else {
115 await reader.cancel();
116 }
117
118 return {
119 response: new Response(body, {
120 status: responseMetadata.status,
121 statusText: responseMetadata.statusText,
122 headers: responseMetadata.headers.map(([name, value]): [string, string] => [name, value]),
123 }),
124 metadata: responseMetadata.metadata as PrerenderRenderMetadata | undefined,
125 };
126 } catch (error) {
127 try {
128 await reader.cancel(error);
129 } catch {
130 // Preserve the framing error when cancellation also fails.
131 }
132 throw error;
133 }
134 }