Advance M7 workflows and release operations

tools/web/deployment-http-server.mjs

@@ -0,0 +1,166 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+
+export function loadDeploymentContract(
+  contractPath = path.join(repoRoot, "docs/web/deployment-contract.json"),
+) {
+  return JSON.parse(fs.readFileSync(contractPath, "utf8"));
+}
+
+function cacheControl(pathname, routes) {
+  for (const route of routes) {
+    for (const pattern of route.patterns) {
+      if (pattern === "*" || pattern === pathname ||
+          (pattern.endsWith("*") && pathname.startsWith(pattern.slice(0, -1)))) {
+        return route.cacheControl;
+      }
+    }
+  }
+  return "no-cache";
+}
+
+function resolvedFile(root, pathname) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(pathname);
+  }
+  catch {
+    return null;
+  }
+  if (decoded.includes("\0")) return null;
+  const relative = decoded === "/" ? "index.html" : decoded.replace(/^\/+/, "");
+  const filePath = path.resolve(root, relative);
+  const rootPrefix = `${path.resolve(root)}${path.sep}`;
+  if (!filePath.startsWith(rootPrefix)) return null;
+  return filePath;
+}
+
+function strongEtag(filePath) {
+  const hash = crypto.createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+  return `"sha256-${hash}"`;
+}
+
+function matchesIfNoneMatch(value, etag) {
+  if (typeof value !== "string") return false;
+  return value === "*" || value.split(",").some((candidate) => candidate.trim() === etag);
+}
+
+function parseRange(value, size) {
+  if (typeof value !== "string" || !value.startsWith("bytes=") || value.includes(",")) return null;
+  const match = value.match(/^bytes=(\d*)-(\d*)$/);
+  if (!match || (!match[1] && !match[2])) return null;
+  if (!match[1]) {
+    const suffixLength = Number(match[2]);
+    if (!Number.isSafeInteger(suffixLength) || suffixLength <= 0 || suffixLength > size) return null;
+    return { start: size - suffixLength, end: size - 1 };
+  }
+  const start = Number(match[1]);
+  const end = match[2] ? Number(match[2]) : size - 1;
+  if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) ||
+      start < 0 || start >= size || end < start || end >= size) return null;
+  return { start, end };
+}
+
+function responseHeaders(contract, pathname, filePath, stat) {
+  const extension = path.extname(filePath).toLowerCase();
+  const mime = contract.mimeTypes[extension];
+  if (!mime) return null;
+  return {
+    ...contract.responseHeaders.allResponses,
+    "Cache-Control": cacheControl(pathname, contract.responseHeaders.routes),
+    "Content-Type": mime,
+    "Content-Length": String(stat.size),
+  };
+}
+
+export function createDeploymentHttpServer({ root, contract = loadDeploymentContract() }) {
+  const staticRoot = path.resolve(root);
+  return http.createServer((request, response) => {
+    const requestUrl = new URL(request.url ?? "/", "http://deployment.local");
+    const pathname = requestUrl.pathname;
+    const commonHeaders = { ...contract.responseHeaders.allResponses, "Cache-Control": "no-cache" };
+    if (!contract.methods.includes(request.method)) {
+      response.writeHead(405, { ...commonHeaders, Allow: contract.methods.join(", "), "Content-Length": "0" });
+      response.end();
+      return;
+    }
+
+    const filePath = resolvedFile(staticRoot, pathname);
+    if (!filePath || !fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+      response.writeHead(404, { ...commonHeaders, "Content-Length": "0" });
+      response.end();
+      return;
+    }
+    const stat = fs.statSync(filePath);
+    const headers = responseHeaders(contract, pathname, filePath, stat);
+    if (!headers) {
+      response.writeHead(415, { ...commonHeaders, "Content-Length": "0" });
+      response.end();
+      return;
+    }
+
+    const extension = path.extname(filePath).toLowerCase();
+    const rangeEnabled = contract.rangeRequests.extensions.includes(extension);
+    const etag = strongEtag(filePath);
+    headers.ETag = etag;
+    if (rangeEnabled) headers["Accept-Ranges"] = contract.rangeRequests.unit;
+    if (matchesIfNoneMatch(request.headers["if-none-match"], etag)) {
+      response.writeHead(304, { ...headers, "Content-Length": "0" });
+      response.end();
+      return;
+    }
+    const requestedRange = request.headers.range;
+    const ifRangeMatches = !request.headers["if-range"] || request.headers["if-range"] === etag;
+    if (requestedRange && rangeEnabled && ifRangeMatches) {
+      const range = parseRange(requestedRange, stat.size);
+      if (!range) {
+        response.writeHead(contract.rangeRequests.unsatisfiedStatus, {
+          ...headers,
+          "Content-Range": `bytes */${stat.size}`,
+          "Content-Length": "0",
+        });
+        response.end();
+        return;
+      }
+      const length = range.end - range.start + 1;
+      response.writeHead(contract.rangeRequests.satisfiedStatus, {
+        ...headers,
+        "Content-Range": `bytes ${range.start}-${range.end}/${stat.size}`,
+        "Content-Length": String(length),
+      });
+      if (request.method === "HEAD") response.end();
+      else fs.createReadStream(filePath, { start: range.start, end: range.end }).pipe(response);
+      return;
+    }
+
+    response.writeHead(200, headers);
+    if (request.method === "HEAD") response.end();
+    else fs.createReadStream(filePath).pipe(response);
+  });
+}
+
+export async function listenDeploymentHttpServer(server, { host = "127.0.0.1", port = 0 } = {}) {
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") throw new Error("deployment server did not bind a TCP port");
+  return `http://${host}:${address.port}`;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+  const root = path.resolve(process.argv[2] ?? path.join(repoRoot, "web/dist"));
+  const port = Number.parseInt(process.env.BLENDER_WEB_HTTP_PORT ?? "8080", 10);
+  const server = createDeploymentHttpServer({ root });
+  const origin = await listenDeploymentHttpServer(server, { port });
+  process.stdout.write(`deployment-http-server ${origin} root=${root}\n`);
+}