@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, 04:45 UTC

main
ts 249 lines 9.19 KB
Raw
1 // Alchemy modifications are licensed under Apache-2.0.
2 // This file includes third-party code; see /THIRD_PARTY_LICENSES.md.
3 /**
4 * CloudFront Function injection code ported from SST's Router component.
5 * These are JavaScript code strings that get injected into CloudFront Function handlers.
6 */
7
8 /**
9 * Host-based 301 handling injected at the very top of a generated
10 * viewer-request handler (before route matching). Redirects requests whose
11 * `Host` is one of the configured redirect hostnames — and, when
12 * `cloudfrontUrl: false`, requests arriving via the distribution's default
13 * `*.cloudfront.net` domain (the default domain is not knowable inside its
14 * own function config before the distribution exists, but only requests
15 * served via the default domain ever carry a `.cloudfront.net` Host;
16 * alternate domain names never do) — to the canonical hostname with path
17 * and query preserved.
18 *
19 * Relies on `buildHostRedirectResponse` declared by
20 * {@link CF_ROUTER_INJECTION} (function declarations hoist within the
21 * handler). Returns an empty string when there is nothing to redirect.
22 */
23 export const buildHostRedirectInjection = ({
24 to,
25 hosts,
26 cloudfrontDefault,
27 }: {
28 /** Canonical hostname redirected to. */
29 to: string | undefined;
30 /** Exact redirect hostnames. */
31 hosts: string[];
32 /** Also redirect the distribution's default `*.cloudfront.net` domain. */
33 cloudfrontDefault: boolean;
34 }): string => {
35 if (!to || (hosts.length === 0 && !cloudfrontDefault)) return "";
36 const conditions = [
37 ...(hosts.length > 0 ? [`${JSON.stringify(hosts)}.indexOf(redirectHost) !== -1`] : []),
38 ...(cloudfrontDefault ? [`redirectHost.endsWith(".cloudfront.net")`] : []),
39 ];
40 return `
41 var redirectHost = event.request.headers.host.value;
42 if (${conditions.join(" || ")}) {
43 return buildHostRedirectResponse(${JSON.stringify(to)});
44 }`;
45 };
46
47 const CLOUDFRONT_FUNCTION_SAFE_HEADER_LIMIT = 10240 - 512;
48
49 /**
50 * The viewer-request router shared by every site. Requests resolve to an S3
51 * file, an asset route, the custom 404 page, the image optimizer, or the
52 * server, in that order. When the site has a server, only GET and HEAD look
53 * in S3: the bucket grants CloudFront read-only access, so any other method
54 * (a form POST to a prerendered page, say) must reach the server.
55 *
56 * Comments belong here rather than in the string, which ships inside the
57 * CloudFront Function and counts toward its 10 KB size limit.
58 */
59 export const CF_ROUTER_INJECTION = `
60 async function routeSite(kvNamespace, metadata) {
61 if (metadata.redirect && metadata.redirect.hosts.indexOf(event.request.headers.host.value) !== -1) {
62 return buildHostRedirectResponse(metadata.redirect.to);
63 }
64
65 var baselessUri = metadata.base
66 ? event.request.uri.replace(metadata.base, "")
67 : event.request.uri;
68
69 if (!metadata.servers || event.request.method === "GET" || event.request.method === "HEAD") {
70 try {
71 var u = decodeURIComponent(baselessUri);
72 var postfixes = u.endsWith("/")
73 ? ["index.html"]
74 : ["", ".html", "/index.html"];
75 var v = await Promise.any(postfixes.map(function(p) { return cf.kvs().get(kvNamespace + ":" + u + p).then(function() { return p; }); }));
76 event.request.uri = metadata.s3.dir + event.request.uri + v;
77 setS3Origin(metadata.s3.domain);
78 return;
79 } catch (e) {}
80
81 if (metadata.s3 && metadata.s3.routes) {
82 for (var i=0, l=metadata.s3.routes.length; i<l; i++) {
83 var route = metadata.s3.routes[i];
84 if (baselessUri.startsWith(route)) {
85 event.request.uri = metadata.s3.dir + event.request.uri;
86 if (event.request.uri.endsWith("/")) {
87 event.request.uri += "index.html";
88 } else if (!event.request.uri.split("/").pop().includes(".")) {
89 event.request.uri += "/index.html";
90 }
91 setS3Origin(metadata.s3.domain);
92 return;
93 }
94 }
95 }
96
97 if (metadata.custom404 && !metadata.errorResponseCode) {
98 event.request.uri = metadata.s3.dir + (metadata.base ? metadata.base : "") + metadata.custom404;
99 setS3Origin(metadata.s3.domain);
100 return;
101 }
102 }
103
104 if (metadata.s3 && !metadata.servers) {
105 event.request.uri = metadata.s3.dir + event.request.uri;
106 setS3Origin(metadata.s3.domain);
107 return;
108 }
109
110 if (metadata.image && baselessUri.startsWith(metadata.image.route)) {
111 setForwardedHost();
112 if (isRequestHeaderTooLarge()) return buildOversizedHeadersResponse();
113 setUrlOrigin(metadata.image.host, metadata.image.originAccessControlConfig ? { originAccessControlConfig: metadata.image.originAccessControlConfig } : undefined);
114 return;
115 }
116
117 if (metadata.servers) {
118 setForwardedHost();
119 for (var key in event.request.querystring) {
120 if (key.includes("/")) {
121 event.request.querystring[encodeURIComponent(key)] = event.request.querystring[key];
122 delete event.request.querystring[key];
123 }
124 }
125 if (isRequestHeaderTooLarge()) return buildOversizedHeadersResponse();
126 setUrlOrigin(findNearestServer(metadata.servers), metadata.origin);
127 }
128
129 function findNearestServer(servers) {
130 if (servers.length === 1) return servers[0][0];
131 var h = event.request.headers;
132 var lat = h["cloudfront-viewer-latitude"] && h["cloudfront-viewer-latitude"].value;
133 var lon = h["cloudfront-viewer-longitude"] && h["cloudfront-viewer-longitude"].value;
134 if (!lat || !lon) return servers[0][0];
135 return servers.map(function(s) { return { distance: haversineDistance(lat, lon, s[1], s[2]), host: s[0] }; }).sort(function(a,b) { return a.distance - b.distance; })[0].host;
136 }
137
138 function haversineDistance(lat1, lon1, lat2, lon2) {
139 var toRad = function(a) { return a * Math.PI / 180; };
140 var dLat = toRad(lat2 - lat1);
141 var dLon = toRad(lon2 - lon1);
142 var a = Math.sin(dLat/2)*Math.sin(dLat/2) + Math.cos(toRad(lat1))*Math.cos(toRad(lat2))*Math.sin(dLon/2)*Math.sin(dLon/2);
143 return 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
144 }
145
146 function isRequestHeaderTooLarge() {
147 return getRequestHeaderSize() > ${CLOUDFRONT_FUNCTION_SAFE_HEADER_LIMIT};
148 }
149
150 function buildOversizedHeadersResponse() {
151 return {
152 statusCode: 431,
153 statusDescription: "Request Header Fields Too Large",
154 headers: { "cache-control": { value: "no-store" }, "content-type": { value: "text/plain; charset=utf-8" } },
155 body: { encoding: "text", data: "Request headers are too large. Reduce cookie size and try again." },
156 };
157 }
158
159 function getRequestHeaderSize() {
160 var size = 0;
161 for (var key in event.request.headers) {
162 var header = event.request.headers[key];
163 if (header.multiValue) {
164 for (var i=0; i<header.multiValue.length; i++) size += key.length + header.multiValue[i].value.length + 4;
165 } else if (header.value) {
166 size += key.length + header.value.length + 4;
167 }
168 }
169 var cookies = [];
170 for (var key in event.request.cookies) {
171 var cookie = event.request.cookies[key];
172 if (cookie.multiValue) {
173 for (var i=0; i<cookie.multiValue.length; i++) cookies.push(key + "=" + cookie.multiValue[i].value);
174 } else {
175 cookies.push(key + "=" + cookie.value);
176 }
177 }
178 if (cookies.length) size += 10 + cookies.join("; ").length;
179 return size;
180 }
181 }
182
183 function setForwardedHost() {
184 event.request.headers["x-forwarded-host"] = event.request.headers.host;
185 }
186
187 function serializeQuerystring() {
188 var parts = [];
189 for (var key in event.request.querystring) {
190 var q = event.request.querystring[key];
191 if (q.multiValue) {
192 for (var i = 0; i < q.multiValue.length; i++) parts.push(key + "=" + q.multiValue[i].value);
193 } else {
194 parts.push(q.value === "" ? key : key + "=" + q.value);
195 }
196 }
197 return parts.length ? "?" + parts.join("&") : "";
198 }
199
200 function buildHostRedirectResponse(toHost) {
201 return {
202 statusCode: 301,
203 statusDescription: "Moved Permanently",
204 headers: {
205 location: { value: "https://" + toHost + event.request.uri + serializeQuerystring() },
206 "cache-control": { value: "no-store" },
207 },
208 };
209 }
210
211 function setUrlOrigin(urlHost, override) {
212 setForwardedHost();
213 var origin = {
214 domainName: urlHost,
215 customOriginConfig: {
216 port: 443,
217 protocol: "https",
218 sslProtocols: ["TLSv1.2"],
219 },
220 originAccessControlConfig: {
221 enabled: false,
222 }
223 };
224 override = override || {};
225 if (override.protocol === "http") delete origin.customOriginConfig;
226 if (override.connectionAttempts) origin.connectionAttempts = override.connectionAttempts;
227 if (override.timeouts) origin.timeouts = override.timeouts;
228 if (override.originAccessControlConfig) origin.originAccessControlConfig = override.originAccessControlConfig;
229 cf.updateRequestOrigin(origin);
230 }
231
232 function setS3Origin(s3Domain, override) {
233 delete event.request.headers["Cookies"];
234 delete event.request.headers["cookies"];
235 delete event.request.cookies;
236 var origin = {
237 domainName: s3Domain,
238 originAccessControlConfig: {
239 enabled: true,
240 signingBehavior: "always",
241 signingProtocol: "sigv4",
242 originType: "s3",
243 }
244 };
245 override = override || {};
246 if (override.connectionAttempts) origin.connectionAttempts = override.connectionAttempts;
247 if (override.timeouts) origin.timeouts = override.timeouts;
248 cf.updateRequestOrigin(origin);
249 }`;