wrangler 0.0.0-bf67bf2 → 0.0.0-bfbb0be

package/src/pages/dev.tsx

@@ -0,0 +1,948 @@
+import { execSync, spawn } from "node:child_process";
+import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { URL } from "node:url";
+import { watch } from "chokidar";
+import { getType } from "mime";
+import { FatalError } from "../errors";
+import { logger } from "../logger";
+import { getRequestContextCheckOptions } from "../miniflare-cli/request-context";
+import openInBrowser from "../open-in-browser";
+import { buildFunctions } from "./build";
+import { SECONDS_TO_WAIT_FOR_PROXY } from "./constants";
+import { CLEANUP, CLEANUP_CALLBACKS, pagesBetaWarning } from "./utils";
+import type {
+  fetch as miniflareFetch,
+  Headers as MiniflareHeaders,
+} from "@miniflare/core";
+import type { MiniflareOptions, Request as MiniflareRequest } from "miniflare";
+import type { Argv, ArgumentsCamelCase } from "yargs";
+
+type PagesDevArgs = {
+  directory?: string;
+  command?: string;
+  local: boolean;
+  port: number;
+  proxy?: number;
+  "script-path": string;
+  binding?: (string | number)[];
+  kv?: (string | number)[];
+  do?: (string | number)[];
+  "live-reload": boolean;
+  "node-compat": boolean;
+};
+
+export function Options(yargs: Argv): Argv<PagesDevArgs> {
+  return yargs
+    .positional("directory", {
+      type: "string",
+      demandOption: undefined,
+      description: "The directory of static assets to serve",
+    })
+    .positional("command", {
+      type: "string",
+      demandOption: undefined,
+      description: "The proxy command to run",
+    })
+    .options({
+      local: {
+        type: "boolean",
+        default: true,
+        description: "Run on my machine",
+      },
+      port: {
+        type: "number",
+        default: 8788,
+        description: "The port to listen on (serve from)",
+      },
+      proxy: {
+        type: "number",
+        description: "The port to proxy (where the static assets are served)",
+      },
+      "script-path": {
+        type: "string",
+        default: "_worker.js",
+        description:
+          "The location of the single Worker script if not using functions",
+      },
+      binding: {
+        type: "array",
+        description: "Bind variable/secret (KEY=VALUE)",
+        alias: "b",
+      },
+      kv: {
+        type: "array",
+        description: "KV namespace to bind",
+        alias: "k",
+      },
+      do: {
+        type: "array",
+        description: "Durable Object to bind (NAME=CLASS)",
+        alias: "o",
+      },
+      "live-reload": {
+        type: "boolean",
+        default: false,
+        description: "Auto reload HTML pages when change is detected",
+      },
+      "node-compat": {
+        describe: "Enable node.js compatibility",
+        default: false,
+        type: "boolean",
+        hidden: true,
+      },
+      //   // TODO: Miniflare user options
+    })
+    .epilogue(pagesBetaWarning);
+}
+
+export const Handler = async ({
+  local,
+  directory,
+  port,
+  proxy: requestedProxyPort,
+  "script-path": singleWorkerScriptPath,
+  binding: bindings = [],
+  kv: kvs = [],
+  do: durableObjects = [],
+  "live-reload": liveReload,
+  "node-compat": nodeCompat,
+  _: [_pages, _dev, ...remaining],
+}: ArgumentsCamelCase<PagesDevArgs>) => {
+  // Beta message for `wrangler pages <commands>` usage
+  logger.log(pagesBetaWarning);
+
+  if (!local) {
+    logger.error("Only local mode is supported at the moment.");
+    return;
+  }
+
+  const functionsDirectory = "./functions";
+  const usingFunctions = existsSync(functionsDirectory);
+
+  const command = remaining as (string | number)[];
+
+  let proxyPort: number | void;
+
+  if (directory === undefined) {
+    proxyPort = await spawnProxyProcess({
+      port: requestedProxyPort,
+      command,
+    });
+    if (proxyPort === undefined) return undefined;
+  }
+
+  let miniflareArgs: MiniflareOptions = {};
+
+  let scriptReadyResolve: () => void;
+  const scriptReadyPromise = new Promise<void>(
+    (resolve) => (scriptReadyResolve = resolve)
+  );
+
+  if (usingFunctions) {
+    const outfile = join(tmpdir(), `./functionsWorker-${Math.random()}.js`);
+
+    if (nodeCompat) {
+      console.warn(
+        "Enabling node.js compatibility mode for builtins and globals. This is experimental and has serious tradeoffs. Please see https://github.com/ionic-team/rollup-plugin-node-polyfills/ for more details."
+      );
+    }
+
+    logger.log(`Compiling worker to "${outfile}"...`);
+
+    try {
+      await buildFunctions({
+        outfile,
+        functionsDirectory,
+        sourcemap: true,
+        watch: true,
+        onEnd: () => scriptReadyResolve(),
+        buildOutputDirectory: directory,
+        nodeCompat,
+      });
+    } catch {}
+
+    watch([functionsDirectory], {
+      persistent: true,
+      ignoreInitial: true,
+    }).on("all", async () => {
+      await buildFunctions({
+        outfile,
+        functionsDirectory,
+        sourcemap: true,
+        watch: true,
+        onEnd: () => scriptReadyResolve(),
+        buildOutputDirectory: directory,
+        nodeCompat,
+      });
+    });
+
+    miniflareArgs = {
+      scriptPath: outfile,
+    };
+  } else {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    scriptReadyResolve!();
+
+    const scriptPath =
+      directory !== undefined
+        ? join(directory, singleWorkerScriptPath)
+        : singleWorkerScriptPath;
+
+    if (existsSync(scriptPath)) {
+      miniflareArgs = {
+        scriptPath,
+      };
+    } else {
+      logger.log("No functions. Shimming...");
+      miniflareArgs = {
+        // cfFetch sets the `cf` object that a function could expect
+        // If there are no functions, there's no reason to set this up (and not make that network call)
+        cfFetch: false,
+        // TODO: The fact that these request/response hacks are necessary is ridiculous.
+        // We need to eliminate them from env.ASSETS.fetch (not sure if just local or prod as well)
+        script: `
+          export default {
+            async fetch(request, env, context) {
+              const response = await env.ASSETS.fetch(request.url, request)
+              return new Response(response.body, response)
+            }
+          }`,
+      };
+    }
+  }
+
+  // Defer importing miniflare until we really need it
+  const { Miniflare, Log, LogLevel } = await import("miniflare");
+  const { Response, fetch } = await import("@miniflare/core");
+
+  // Wait for esbuild to finish building before starting Miniflare.
+  // This must be before the call to `new Miniflare`, as that will
+  // asynchronously start loading the script. `await startServer()`
+  // internally just waits for that promise to resolve.
+  await scriptReadyPromise;
+
+  // `assetsFetch()` will only be called if there is `proxyPort` defined.
+  // We only define `proxyPort`, above, when there is no `directory` defined.
+  const assetsFetch =
+    directory !== undefined
+      ? await generateAssetsFetch(directory)
+      : invalidAssetsFetch;
+
+  const requestContextCheckOptions = await getRequestContextCheckOptions();
+
+  const miniflare = new Miniflare({
+    port,
+    watch: true,
+    modules: true,
+
+    log: new Log(LogLevel.ERROR, { prefix: "pages" }),
+    logUnhandledRejections: true,
+    sourceMap: true,
+
+    kvNamespaces: kvs.map((kv) => kv.toString()),
+
+    durableObjects: Object.fromEntries(
+      durableObjects.map((durableObject) => durableObject.toString().split("="))
+    ),
+
+    // User bindings
+    bindings: {
+      ...Object.fromEntries(
+        bindings
+          .map((binding) => binding.toString().split("="))
+          .map(([key, ...values]) => [key, values.join("=")])
+      ),
+    },
+
+    // env.ASSETS.fetch
+    serviceBindings: {
+      async ASSETS(request: MiniflareRequest) {
+        if (proxyPort) {
+          try {
+            const url = new URL(request.url);
+            url.host = `localhost:${proxyPort}`;
+            return await fetch(url, request);
+          } catch (thrown) {
+            logger.error(`Could not proxy request: ${thrown}`);
+
+            // TODO: Pretty error page
+            return new Response(
+              `[wrangler] Could not proxy request: ${thrown}`,
+              { status: 502 }
+            );
+          }
+        } else {
+          try {
+            return await assetsFetch(request);
+          } catch (thrown) {
+            logger.error(`Could not serve static asset: ${thrown}`);
+
+            // TODO: Pretty error page
+            return new Response(
+              `[wrangler] Could not serve static asset: ${thrown}`,
+              { status: 502 }
+            );
+          }
+        }
+      },
+    },
+
+    kvPersist: true,
+    durableObjectsPersist: true,
+    cachePersist: true,
+    liveReload,
+
+    ...requestContextCheckOptions,
+    ...miniflareArgs,
+  });
+
+  try {
+    // `startServer` might throw if user code contains errors
+    const server = await miniflare.startServer();
+    logger.log(`Serving at http://localhost:${port}/`);
+
+    if (process.env.BROWSER !== "none") {
+      await openInBrowser(`http://localhost:${port}/`);
+    }
+
+    if (directory !== undefined && liveReload) {
+      watch([directory], {
+        persistent: true,
+        ignoreInitial: true,
+      }).on("all", async () => {
+        await miniflare.reload();
+      });
+    }
+
+    CLEANUP_CALLBACKS.push(() => {
+      server.close();
+      miniflare.dispose().catch((err) => miniflare.log.error(err));
+    });
+  } catch (e) {
+    miniflare.log.error(e as Error);
+    CLEANUP();
+    throw new FatalError("Could not start Miniflare.", 1);
+  }
+};
+
+function isWindows() {
+  return process.platform === "win32";
+}
+
+async function sleep(ms: number) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function getPids(pid: number) {
+  const pids: number[] = [pid];
+  let command: string, regExp: RegExp;
+
+  if (isWindows()) {
+    command = `wmic process where (ParentProcessId=${pid}) get ProcessId`;
+    regExp = new RegExp(/(\d+)/);
+  } else {
+    command = `pgrep -P ${pid}`;
+    regExp = new RegExp(/(\d+)/);
+  }
+
+  try {
+    const newPids = (
+      execSync(command)
+        .toString()
+        .split("\n")
+        .map((line) => line.match(regExp))
+        .filter((line) => line !== null) as RegExpExecArray[]
+    ).map((match) => parseInt(match[1]));
+
+    pids.push(...newPids.map(getPids).flat());
+  } catch {}
+
+  return pids;
+}
+
+function getPort(pid: number) {
+  let command: string, regExp: RegExp;
+
+  if (isWindows()) {
+    command = "\\windows\\system32\\netstat.exe -nao";
+    regExp = new RegExp(`TCP\\s+.*:(\\d+)\\s+.*:\\d+\\s+LISTENING\\s+${pid}`);
+  } else {
+    command = "lsof -nPi";
+    regExp = new RegExp(`${pid}\\s+.*TCP\\s+.*:(\\d+)\\s+\\(LISTEN\\)`);
+  }
+
+  try {
+    const matches = execSync(command)
+      .toString()
+      .split("\n")
+      .map((line) => line.match(regExp))
+      .filter((line) => line !== null) as RegExpExecArray[];
+
+    const match = matches[0];
+    if (match) return parseInt(match[1]);
+  } catch (thrown) {
+    logger.error(
+      `Error scanning for ports of process with PID ${pid}: ${thrown}`
+    );
+  }
+}
+
+async function spawnProxyProcess({
+  port,
+  command,
+}: {
+  port?: number;
+  command: (string | number)[];
+}): Promise<void | number> {
+  if (command.length === 0) {
+    CLEANUP();
+    throw new FatalError(
+      "Must specify a directory of static assets to serve or a command to run.",
+      1
+    );
+  }
+
+  logger.log(`Running ${command.join(" ")}...`);
+  const proxy = spawn(
+    command[0].toString(),
+    command.slice(1).map((value) => value.toString()),
+    {
+      shell: isWindows(),
+      env: {
+        BROWSER: "none",
+        ...process.env,
+      },
+    }
+  );
+  CLEANUP_CALLBACKS.push(() => {
+    proxy.kill();
+  });
+
+  proxy.stdout.on("data", (data) => {
+    logger.log(`[proxy]: ${data}`);
+  });
+
+  proxy.stderr.on("data", (data) => {
+    logger.error(`[proxy]: ${data}`);
+  });
+
+  proxy.on("close", (code) => {
+    logger.error(`Proxy exited with status ${code}.`);
+  });
+
+  // Wait for proxy process to start...
+  while (!proxy.pid) {}
+
+  if (port === undefined) {
+    logger.log(
+      `Sleeping ${SECONDS_TO_WAIT_FOR_PROXY} seconds to allow proxy process to start before attempting to automatically determine port...`
+    );
+    logger.log("To skip, specify the proxy port with --proxy.");
+    await sleep(SECONDS_TO_WAIT_FOR_PROXY * 1000);
+
+    port = getPids(proxy.pid)
+      .map(getPort)
+      .filter((nr) => nr !== undefined)[0];
+
+    if (port === undefined) {
+      CLEANUP();
+      throw new FatalError(
+        "Could not automatically determine proxy port. Please specify the proxy port with --proxy.",
+        1
+      );
+    } else {
+      logger.log(`Automatically determined the proxy port to be ${port}.`);
+    }
+  }
+
+  return port;
+}
+
+function escapeRegex(str: string) {
+  return str.replace(/[-/\\^$*+?.()|[]{}]/g, "\\$&");
+}
+
+type Replacements = Record<string, string>;
+
+function replacer(str: string, replacements: Replacements) {
+  for (const [replacement, value] of Object.entries(replacements)) {
+    str = str.replace(`:${replacement}`, value);
+  }
+  return str;
+}
+
+function generateRulesMatcher<T>(
+  rules?: Record<string, T>,
+  replacerFn: (match: T, replacements: Replacements) => T = (match) => match
+) {
+  // TODO: How can you test cross-host rules?
+  if (!rules) return () => [];
+
+  const compiledRules = Object.entries(rules)
+    .map(([rule, match]) => {
+      const crossHost = rule.startsWith("https://");
+
+      rule = rule.split("*").map(escapeRegex).join("(?<splat>.*)");
+
+      const host_matches = rule.matchAll(
+        /(?<=^https:\\\/\\\/[^/]*?):([^\\]+)(?=\\)/g
+      );
+      for (const hostMatch of host_matches) {
+        rule = rule.split(hostMatch[0]).join(`(?<${hostMatch[1]}>[^/.]+)`);
+      }
+
+      const path_matches = rule.matchAll(/:(\w+)/g);
+      for (const pathMatch of path_matches) {
+        rule = rule.split(pathMatch[0]).join(`(?<${pathMatch[1]}>[^/]+)`);
+      }
+
+      rule = "^" + rule + "$";
+
+      try {
+        const regExp = new RegExp(rule);
+        return [{ crossHost, regExp }, match];
+      } catch {}
+    })
+    .filter((value) => value !== undefined) as [
+    { crossHost: boolean; regExp: RegExp },
+    T
+  ][];
+
+  return ({ request }: { request: MiniflareRequest }) => {
+    const { pathname, host } = new URL(request.url);
+
+    return compiledRules
+      .map(([{ crossHost, regExp }, match]) => {
+        const test = crossHost ? `https://${host}${pathname}` : pathname;
+        const result = regExp.exec(test);
+        if (result) {
+          return replacerFn(match, result.groups || {});
+        }
+      })
+      .filter((value) => value !== undefined) as T[];
+  };
+}
+
+function generateHeadersMatcher(headersFile: string) {
+  if (existsSync(headersFile)) {
+    const contents = readFileSync(headersFile).toString();
+
+    // TODO: Log errors
+    const lines = contents
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => !line.startsWith("#") && line !== "");
+
+    const rules: Record<string, Record<string, string>> = {};
+    let rule: { path: string; headers: Record<string, string> } | undefined =
+      undefined;
+
+    for (const line of lines) {
+      if (/^([^\s]+:\/\/|^\/)/.test(line)) {
+        if (rule && Object.keys(rule.headers).length > 0) {
+          rules[rule.path] = rule.headers;
+        }
+
+        const path = validateURL(line);
+        if (path) {
+          rule = {
+            path,
+            headers: {},
+          };
+          continue;
+        }
+      }
+
+      if (!line.includes(":")) continue;
+
+      const [rawName, ...rawValue] = line.split(":");
+      const name = rawName.trim().toLowerCase();
+      const value = rawValue.join(":").trim();
+
+      if (name === "") continue;
+      if (!rule) continue;
+
+      const existingValues = rule.headers[name];
+      rule.headers[name] = existingValues
+        ? `${existingValues}, ${value}`
+        : value;
+    }
+
+    if (rule && Object.keys(rule.headers).length > 0) {
+      rules[rule.path] = rule.headers;
+    }
+
+    const rulesMatcher = generateRulesMatcher(rules, (match, replacements) =>
+      Object.fromEntries(
+        Object.entries(match).map(([name, value]) => [
+          name,
+          replacer(value, replacements),
+        ])
+      )
+    );
+
+    return (request: MiniflareRequest) => {
+      const matches = rulesMatcher({
+        request,
+      });
+      if (matches) return matches;
+    };
+  } else {
+    return () => undefined;
+  }
+}
+
+function generateRedirectsMatcher(redirectsFile: string) {
+  if (existsSync(redirectsFile)) {
+    const contents = readFileSync(redirectsFile).toString();
+
+    // TODO: Log errors
+    const lines = contents
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => !line.startsWith("#") && line !== "");
+
+    const rules = Object.fromEntries(
+      lines
+        .map((line) => line.split(" "))
+        .filter((tokens) => tokens.length === 2 || tokens.length === 3)
+        .map((tokens) => {
+          const from = validateURL(tokens[0], true, false, false);
+          const to = validateURL(tokens[1], false, true, true);
+          let status: number | undefined = parseInt(tokens[2]) || 302;
+          status = [301, 302, 303, 307, 308].includes(status)
+            ? status
+            : undefined;
+
+          return from && to && status ? [from, { to, status }] : undefined;
+        })
+        .filter((rule) => rule !== undefined) as [
+        string,
+        { to: string; status?: number }
+      ][]
+    );
+
+    const rulesMatcher = generateRulesMatcher(
+      rules,
+      ({ status, to }, replacements) => ({
+        status,
+        to: replacer(to, replacements),
+      })
+    );
+
+    return (request: MiniflareRequest) => {
+      const match = rulesMatcher({
+        request,
+      })[0];
+      if (match) return match;
+    };
+  } else {
+    return () => undefined;
+  }
+}
+
+function extractPathname(
+  path = "/",
+  includeSearch: boolean,
+  includeHash: boolean
+) {
+  if (!path.startsWith("/")) path = `/${path}`;
+  const url = new URL(`//${path}`, "relative://");
+  return `${url.pathname}${includeSearch ? url.search : ""}${
+    includeHash ? url.hash : ""
+  }`;
+}
+
+function validateURL(
+  token: string,
+  onlyRelative = false,
+  includeSearch = false,
+  includeHash = false
+) {
+  const host = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/.exec(token);
+  if (host && host.groups && host.groups.host) {
+    if (onlyRelative) return;
+
+    return `https://${host.groups.host}${extractPathname(
+      host.groups.path,
+      includeSearch,
+      includeHash
+    )}`;
+  } else {
+    if (!token.startsWith("/") && onlyRelative) token = `/${token}`;
+
+    const path = /^\//.exec(token);
+    if (path) {
+      try {
+        return extractPathname(token, includeSearch, includeHash);
+      } catch {}
+    }
+  }
+  return "";
+}
+
+function hasFileExtension(pathname: string) {
+  return /\/.+\.[a-z0-9]+$/i.test(pathname);
+}
+
+async function generateAssetsFetch(
+  directory: string
+): Promise<typeof miniflareFetch> {
+  // Defer importing miniflare until we really need it
+  const { Headers, Request, Response } = await import("@miniflare/core");
+
+  const headersFile = join(directory, "_headers");
+  const redirectsFile = join(directory, "_redirects");
+  const workerFile = join(directory, "_worker.js");
+
+  const ignoredFiles = [headersFile, redirectsFile, workerFile];
+
+  const assetExists = (path: string) => {
+    path = join(directory, path);
+    return (
+      existsSync(path) &&
+      lstatSync(path).isFile() &&
+      !ignoredFiles.includes(path)
+    );
+  };
+
+  const getAsset = (path: string) => {
+    if (assetExists(path)) {
+      return join(directory, path);
+    }
+  };
+
+  let redirectsMatcher = generateRedirectsMatcher(redirectsFile);
+  let headersMatcher = generateHeadersMatcher(headersFile);
+
+  watch([headersFile, redirectsFile], {
+    persistent: true,
+  }).on("change", (path) => {
+    switch (path) {
+      case headersFile: {
+        logger.log("_headers modified. Re-evaluating...");
+        headersMatcher = generateHeadersMatcher(headersFile);
+        break;
+      }
+      case redirectsFile: {
+        logger.log("_redirects modified. Re-evaluating...");
+        redirectsMatcher = generateRedirectsMatcher(redirectsFile);
+        break;
+      }
+    }
+  });
+
+  const serveAsset = (file: string) => {
+    return readFileSync(file);
+  };
+
+  const generateResponse = (request: MiniflareRequest) => {
+    const url = new URL(request.url);
+
+    const deconstructedResponse: {
+      status: number;
+      headers: MiniflareHeaders;
+      body?: Buffer;
+    } = {
+      status: 200,
+      headers: new Headers(),
+      body: undefined,
+    };
+
+    const match = redirectsMatcher(request);
+    if (match) {
+      const { status, to } = match;
+
+      let location = to;
+      let search;
+
+      if (to.startsWith("/")) {
+        search = new URL(location, "http://fakehost").search;
+      } else {
+        search = new URL(location).search;
+      }
+
+      location = `${location}${search ? "" : url.search}`;
+
+      if (status && [301, 302, 303, 307, 308].includes(status)) {
+        deconstructedResponse.status = status;
+      } else {
+        deconstructedResponse.status = 302;
+      }
+
+      deconstructedResponse.headers.set("Location", location);
+      return deconstructedResponse;
+    }
+
+    if (!request.method?.match(/^(get|head)$/i)) {
+      deconstructedResponse.status = 405;
+      return deconstructedResponse;
+    }
+
+    const notFound = () => {
+      let cwd = url.pathname;
+      while (cwd) {
+        cwd = cwd.slice(0, cwd.lastIndexOf("/"));
+
+        if ((asset = getAsset(`${cwd}/404.html`))) {
+          deconstructedResponse.status = 404;
+          deconstructedResponse.body = serveAsset(asset);
+          deconstructedResponse.headers.set(
+            "Content-Type",
+            getType(asset) || "application/octet-stream"
+          );
+          return deconstructedResponse;
+        }
+      }
+
+      if ((asset = getAsset(`/index.html`))) {
+        deconstructedResponse.body = serveAsset(asset);
+        deconstructedResponse.headers.set(
+          "Content-Type",
+          getType(asset) || "application/octet-stream"
+        );
+        return deconstructedResponse;
+      }
+
+      deconstructedResponse.status = 404;
+      return deconstructedResponse;
+    };
+
+    let asset;
+
+    if (url.pathname.endsWith("/")) {
+      if ((asset = getAsset(`${url.pathname}/index.html`))) {
+        deconstructedResponse.body = serveAsset(asset);
+        deconstructedResponse.headers.set(
+          "Content-Type",
+          getType(asset) || "application/octet-stream"
+        );
+        return deconstructedResponse;
+      } else if (
+        (asset = getAsset(`${url.pathname.replace(/\/$/, ".html")}`))
+      ) {
+        deconstructedResponse.status = 301;
+        deconstructedResponse.headers.set(
+          "Location",
+          `${url.pathname.slice(0, -1)}${url.search}`
+        );
+        return deconstructedResponse;
+      }
+    }
+
+    if (url.pathname.endsWith("/index")) {
+      deconstructedResponse.status = 301;
+      deconstructedResponse.headers.set(
+        "Location",
+        `${url.pathname.slice(0, -"index".length)}${url.search}`
+      );
+      return deconstructedResponse;
+    }
+
+    if ((asset = getAsset(url.pathname))) {
+      if (url.pathname.endsWith(".html")) {
+        const extensionlessPath = url.pathname.slice(0, -".html".length);
+        if (getAsset(extensionlessPath) || extensionlessPath === "/") {
+          deconstructedResponse.body = serveAsset(asset);
+          deconstructedResponse.headers.set(
+            "Content-Type",
+            getType(asset) || "application/octet-stream"
+          );
+          return deconstructedResponse;
+        } else {
+          deconstructedResponse.status = 301;
+          deconstructedResponse.headers.set(
+            "Location",
+            `${extensionlessPath}${url.search}`
+          );
+          return deconstructedResponse;
+        }
+      } else {
+        deconstructedResponse.body = serveAsset(asset);
+        deconstructedResponse.headers.set(
+          "Content-Type",
+          getType(asset) || "application/octet-stream"
+        );
+        return deconstructedResponse;
+      }
+    } else if (hasFileExtension(url.pathname)) {
+      notFound();
+      return deconstructedResponse;
+    }
+
+    if ((asset = getAsset(`${url.pathname}.html`))) {
+      deconstructedResponse.body = serveAsset(asset);
+      deconstructedResponse.headers.set(
+        "Content-Type",
+        getType(asset) || "application/octet-stream"
+      );
+      return deconstructedResponse;
+    }
+
+    if ((asset = getAsset(`${url.pathname}/index.html`))) {
+      deconstructedResponse.status = 301;
+      deconstructedResponse.headers.set(
+        "Location",
+        `${url.pathname}/${url.search}`
+      );
+      return deconstructedResponse;
+    } else {
+      notFound();
+      return deconstructedResponse;
+    }
+  };
+
+  const attachHeaders = (
+    request: MiniflareRequest,
+    deconstructedResponse: {
+      status: number;
+      headers: MiniflareHeaders;
+      body?: Buffer;
+    }
+  ) => {
+    const headers = deconstructedResponse.headers;
+    const newHeaders = new Headers({});
+    const matches = headersMatcher(request) || [];
+
+    matches.forEach((match) => {
+      Object.entries(match).forEach(([name, value]) => {
+        newHeaders.append(name, `${value}`);
+      });
+    });
+
+    const combinedHeaders = {
+      ...Object.fromEntries(headers.entries()),
+      ...Object.fromEntries(newHeaders.entries()),
+    };
+
+    deconstructedResponse.headers = new Headers({});
+    Object.entries(combinedHeaders).forEach(([name, value]) => {
+      if (value) deconstructedResponse.headers.set(name, value);
+    });
+  };
+
+  return async (input, init) => {
+    const request = new Request(input, init);
+    const deconstructedResponse = generateResponse(request);
+    attachHeaders(request, deconstructedResponse);
+
+    const headers = new Headers();
+
+    [...deconstructedResponse.headers.entries()].forEach(([name, value]) => {
+      if (value) headers.set(name, value);
+    });
+
+    return new Response(deconstructedResponse.body, {
+      headers,
+      status: deconstructedResponse.status,
+    });
+  };
+}
+
+const invalidAssetsFetch: typeof miniflareFetch = () => {
+  throw new Error(
+    "Trying to fetch assets directly when there is no `directory` option specified, and not in `local` mode."
+  );
+};