// One Worker serves Hex under /hex on its host: the site, /hex/files (the // installers and appcast built with the site, the dev notes, and the frozen // 2.3.1 feeds and artifacts in the read-only files bucket), and // /hex/download/dev, the latest dev channel Mac download, /hex/dev, the dev // builds' changelog, and // /hex/download/, the release every download button names, and /hex/ios, // Hex for iPhone on the App Store. Other hosts and // plain HTTP redirect to the canonical host. `cf dev` with ANY_HOST set turns // the redirect off for local testing. import { BASE_PATH, DEV_DOWNLOAD_PATH, DEV_NOTES_PATH, DEV_NOTES_URL, DOWNLOAD_PATH, FILES_PATH, RELEASE_SERVICE, stripBase, withBase } from "./src/base" import { parseDevNotes, renderDevNotes } from "./src/dev-notes" type Env = { ASSETS: { fetch(request: Request): Promise } FILES: R2Bucket CANONICAL_HOST: string ANY_HOST?: string } export default { async fetch(request: Request, env: Env): Promise { const url = new URL(request.url) if (!env.ANY_HOST && (url.hostname !== env.CANONICAL_HOST || url.protocol !== "https:")) { url.protocol = "https:" url.hostname = env.CANONICAL_HOST url.port = "" return Response.redirect(url.toString(), 301) } if (url.pathname === BASE_PATH) { url.pathname = `${BASE_PATH}/` return Response.redirect(url.toString(), 301) } if (url.pathname === IOS_PATH || url.pathname === `${IOS_PATH}/`) return Response.redirect(APP_STORE_URL, 302) if (url.pathname.startsWith(`${FILES_PATH}/`)) return file(request, env, decodeURIComponent(url.pathname.slice(FILES_PATH.length + 1))) if (url.pathname === DEV_DOWNLOAD_PATH) return devDownload(request) if (url.pathname === DEV_NOTES_PATH || url.pathname === `${DEV_NOTES_PATH}/`) return devNotes(request, env) if (url.pathname.startsWith(`${DOWNLOAD_PATH}/`)) return download(request, url.pathname.slice(DOWNLOAD_PATH.length + 1)) // The route also matches paths like /hexagon, which are not ours. const path = stripBase(url.pathname) if (path === undefined) return new Response("Not found", { status: 404 }) const assetUrl = new URL(url) // Docs are Markdown files served at clean paths, for agents to fetch. const doc = DOCS.get(path) assetUrl.pathname = doc ?? path const assetRequest = new Request(assetUrl, request) const response = await env.ASSETS.fetch(assetRequest) const headers = new Headers(response.headers) // Asset redirects (trailing slashes, /index.html) point at root-relative paths. const location = headers.get("Location") if (location?.startsWith("/")) headers.set("Location", withBase(location)) if (path.startsWith("/assets/")) { headers.set("Cache-Control", "public, max-age=31536000, immutable") } if (doc) headers.set("Content-Type", "text/markdown; charset=utf-8") secure(headers) if (path.endsWith(".mp4")) return ranged(request, request.method === "HEAD" ? await env.ASSETS.fetch(new Request(assetUrl, { headers: request.headers })) : response, headers) return new Response(response.body, { status: response.status, statusText: response.statusText, headers, }) }, } // /hex/ios, the short link to Hex for iPhone on the App Store. const IOS_PATH = withBase("/ios") const APP_STORE_URL = "https://apps.apple.com/us/app/hex-voice-dictation-keyboard/id6836837368" const DOCS = new Map([ ["/docs/transforms", "/docs/transforms.md"], ["/docs/admin", "/docs/admin.md"], ]) function secure(headers: Headers) { headers.set("Strict-Transport-Security", "max-age=31536000") headers.set("X-Content-Type-Options", "nosniff") headers.set("Referrer-Policy", "strict-origin-when-cross-origin") } const DOWNLOAD_TARGETS = new Set([ "macos-arm64-dmg", "windows-x64-setup", "windows-arm64-setup", "linux-x64", "linux-arm64", "linux-x64-deb", "linux-arm64-deb", "linux-x64-rpm", "linux-arm64-rpm", // The bare updater files. "macos-arm64", "windows-x64", "windows-arm64", ]) // Redirects /hex/download/ to the release service's alias for // on the stable channel (the dev channel while there is no stable // release, decided per request), and /hex/download/dev/ to the dev // channel's. async function download(request: Request, path: string): Promise { if (request.method !== "GET" && request.method !== "HEAD") { return new Response("Method not allowed", { status: 405, headers: { Allow: "GET, HEAD" } }) } const dev = path.startsWith("dev/") const target = dev ? path.slice("dev/".length) : path if (!DOWNLOAD_TARGETS.has(target)) return new Response("Not found", { status: 404 }) let channel = "dev" if (!dev) { try { const stable = await fetch(`${RELEASE_SERVICE}/hex/desktop/stable.json`, { headers: { "User-Agent": "hex-site" }, cache: "no-store" }) if (stable.ok) channel = "stable" } catch { // The service is unreachable: the dev alias fails the same way, visibly. } } const headers = new Headers({ Location: `${RELEASE_SERVICE}/hex/desktop/${channel}/${target}`, "Cache-Control": "no-store" }) secure(headers) return new Response(null, { status: 302, headers }) } // Redirects to the DMG of the release service's latest dev channel build, so // one link always names the newest Mac dev build on both site environments. The service // is another Worker on this zone; the compatibility flag // global_fetch_strictly_public lets this fetch reach it. async function devDownload(request: Request): Promise { if (request.method !== "GET" && request.method !== "HEAD") { return new Response("Method not allowed", { status: 405, headers: { Allow: "GET, HEAD" } }) } const manifestUrl = `${RELEASE_SERVICE}/hex/desktop/dev.json` const text = (body: string, status: number) => { const headers = new Headers({ "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" }) secure(headers) return new Response(`${body}\n`, { status, headers }) } let response: Response try { response = await fetch(manifestUrl, { headers: { "User-Agent": "hex-site" }, cache: "no-store" }) } catch { return text("Hex's release service did not answer. Try again in a minute.", 502) } if (response.status === 404) return text("No dev build of Hex has been published yet.", 404) if (!response.ok) return text(`Hex's release service answered ${response.status}. Try again in a minute.`, 502) type Manifest = { app?: string; artifact?: string; channel?: string; release?: { version?: string; targets?: Record } } let manifest: Manifest try { manifest = (await response.json()) as Manifest } catch { return text("Hex's dev release manifest is not valid JSON.", 502) } if (manifest.app !== "hex" || manifest.artifact !== "desktop" || manifest.channel !== "dev") { return text("Hex's dev release manifest names another release.", 502) } const version = manifest.release?.version ?? "unknown" const dmg = manifest.release?.targets?.["macos-arm64-dmg"]?.url if (!dmg) return text(`The latest dev build of Hex (${version}) has no Mac download.`, 404) // Target URLs resolve against the manifest's URL (anomalyco/release docs/protocol.md). // Only redirect to the service's own files, never to another origin. let location: URL try { location = new URL(dmg, manifestUrl) } catch { return text("Hex's dev release manifest has an invalid Mac download URL.", 502) } if (location.origin !== new URL(manifestUrl).origin || !location.pathname.startsWith("/release/hex/files/")) { return text("Hex's dev release manifest points the Mac download outside the release service.", 502) } const headers = new Headers({ Location: location.toString(), "Cache-Control": "no-store" }) secure(headers) return new Response(null, { status: 302, headers }) } // The dev builds' changelog: dev-notes.json on the Release workflow's // one-commit dev-notes branch, so a new dev build shows without a site deploy // and nothing needs a bucket credential. const DEV_NOTES_KEY = "dev-notes.json" // The branch's file, or the bucket's copy from before the branch existed. The // fallback only covers the first deploy of a commit that predates the branch; // the next dev release creates it. async function devNotesResponse(env: Env): Promise { try { const response = await fetch(DEV_NOTES_URL, { headers: { "User-Agent": "hex-site" }, cf: { cacheTtl: 60, cacheEverything: true }, }) if (response.ok) return response } catch { // GitHub is unreachable: a stale copy still answers. } const object = await env.FILES.get(DEV_NOTES_KEY) if (!object) return undefined const headers = new Headers() object.writeHttpMetadata(headers) headers.set("Content-Length", String(object.size)) return new Response(object.body, { headers }) } async function devNotes(request: Request, env: Env): Promise { if (request.method !== "GET" && request.method !== "HEAD") { return new Response("Method not allowed", { status: 405, headers: { Allow: "GET, HEAD" } }) } let value: unknown = undefined try { const response = await devNotesResponse(env) if (response) value = await response.json() } catch { value = undefined } const headers = new Headers({ "Content-Type": "text/html; charset=utf-8", "Cache-Control": "public, max-age=60", "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'; img-src 'self'", }) secure(headers) const body = request.method === "HEAD" ? null : renderDevNotes(parseDevNotes(value), DEV_DOWNLOAD_PATH, new URL(request.url).searchParams.get("since")) return new Response(body, { headers }) } // Files built with the site rather than stored in the bucket. They keep the // URLs, Content-Type, and Cache-Control the bucket objects had, so install // commands and old clients see no change. const STATIC_FILES = new Map([ [ "install-linux.sh", { asset: "/install-linux.sh", contentType: "text/x-shellscript", cacheControl: "public, max-age=300" }, ], [ "install-windows.ps1", { asset: "/install-windows.ps1", contentType: "text/plain; charset=utf-8", cacheControl: "public, max-age=300" }, ], ["appcast.xml", { asset: "/appcast.xml", contentType: "application/xml", cacheControl: "no-cache" }], ]) async function staticFile(request: Request, env: Env, file: { asset: string; contentType: string; cacheControl: string }): Promise { const url = new URL(request.url) url.pathname = file.asset // No conditional or Range headers: the asset is a plain 200, and ranged() // answers the client's Range (or HEAD) from it. const response = await env.ASSETS.fetch(new Request(url)) if (!response.ok) return new Response("Not found", { status: 404 }) const headers = new Headers(response.headers) headers.set("Content-Type", file.contentType) headers.set("Cache-Control", file.cacheControl) secure(headers) return ranged(request, response, headers) } // The dev notes as JSON, for the app's Restart to update and scripts. async function devNotesFile(request: Request, env: Env): Promise { const response = await devNotesResponse(env) if (!response) return new Response("Not found", { status: 404 }) const headers = new Headers({ "Content-Type": "application/json; charset=utf-8", "Cache-Control": "public, max-age=60", }) secure(headers) // Not Content-Length: a subrequest may be decoded after the origin set it. const etag = response.headers.get("ETag") if (etag) headers.set("ETag", etag) return new Response(request.method === "HEAD" ? null : response.body, { headers }) } // Serves one bucket object with its stored Content-Type, Cache-Control, and // Content-Disposition, honouring Range and conditional requests. async function file(request: Request, env: Env, key: string): Promise { if (request.method !== "GET" && request.method !== "HEAD") { return new Response("Method not allowed", { status: 405, headers: { Allow: "GET, HEAD" } }) } if (!key || key.endsWith("/")) return new Response("Not found", { status: 404 }) if (key === DEV_NOTES_KEY) return devNotesFile(request, env) const fixed = STATIC_FILES.get(key) if (fixed) return staticFile(request, env, fixed) const object = request.method === "HEAD" ? await env.FILES.head(key) : await env.FILES.get(key, { range: request.headers, onlyIf: request.headers }) if (!object) return new Response("Not found", { status: 404 }) const headers = new Headers() object.writeHttpMetadata(headers) headers.set("ETag", object.httpEtag) headers.set("Accept-Ranges", "bytes") secure(headers) if (request.method === "HEAD") { headers.set("Content-Length", String(object.size)) return new Response(null, { headers }) } if (!("body" in object)) return new Response(null, { status: 304, headers }) const range = object.range as { offset?: number; length?: number; suffix?: number } | undefined if (range && request.headers.has("Range")) { const offset = range.suffix !== undefined ? object.size - range.suffix : (range.offset ?? 0) const length = range.length ?? object.size - offset headers.set("Content-Range", `bytes ${offset}-${offset + length - 1}/${object.size}`) headers.set("Content-Length", String(length)) return new Response(object.body, { status: 206, headers }) } headers.set("Content-Length", String(object.size)) return new Response(object.body, { headers }) } // Static assets ignore Range, but Safari and AVFoundation need byte ranges to play video. // A HEAD is answered from the full GET so its headers match. async function ranged(request: Request, response: Response, headers: Headers): Promise { headers.set("Accept-Ranges", "bytes") const match = /^bytes=(\d*)-(\d*)$/.exec(request.headers.get("Range") ?? "") if (response.status !== 200 || !match || (!match[1] && !match[2])) { return new Response(request.method === "HEAD" ? null : response.body, { status: response.status, statusText: response.statusText, headers }) } const body = await response.arrayBuffer() const size = body.byteLength const start = match[1] ? Number(match[1]) : Math.max(0, size - Number(match[2])) const end = match[1] && match[2] ? Math.min(Number(match[2]), size - 1) : size - 1 if (start > end) { headers.set("Content-Range", `bytes */${size}`) return new Response(null, { status: 416, headers }) } headers.set("Content-Range", `bytes ${start}-${end}/${size}`) headers.set("Content-Length", String(end - start + 1)) return new Response(request.method === "HEAD" ? null : body.slice(start, end + 1), { status: 206, headers }) }