nitro-nightly 3.1.0-20251028-090722-437659e4 → 3.1.0-20251028-131831-fe9fd554

package/dist/_chunks/app.mjs

@@ -0,0 +1,600 @@
+import { existsSync } from 'node:fs';
+import { rm, readFile } from 'node:fs/promises';
+import { Worker } from 'node:worker_threads';
+import consola from 'consola';
+import { a, T } from './_deps/std-env.mjs';
+import { fromNodeHandler, HTTPError, defineHandler, getRequestIP, getRequestURL, H3, toEventHandler, withBase } from 'h3';
+import { s as serveStatic } from './_deps/serve-static.mjs';
+import { joinURL } from 'ufo';
+import { c as createProxyServer } from './_deps/httpxy.mjs';
+import { Agent } from 'undici';
+import { resolve, dirname } from 'node:path';
+import { ErrorParser } from 'youch-core';
+import { Youch } from 'youch';
+import { SourceMapConsumer } from 'source-map';
+import { FastResponse } from 'srvx';
+
+function createHTTPProxy(defaults = {}) {
+  const proxy = createProxyServer(defaults);
+  proxy.on("proxyReq", (proxyReq, req) => {
+    if (!proxyReq.hasHeader("x-forwarded-for")) {
+      const address = req.socket.remoteAddress;
+      if (address) {
+        proxyReq.appendHeader("x-forwarded-for", address);
+      }
+    }
+    if (!proxyReq.hasHeader("x-forwarded-port")) {
+      const localPort = req?.socket?.localPort;
+      if (localPort) {
+        proxyReq.setHeader("x-forwarded-port", req.socket.localPort);
+      }
+    }
+    if (!proxyReq.hasHeader("x-forwarded-Proto")) {
+      const encrypted = req?.connection?.encrypted;
+      proxyReq.setHeader("x-forwarded-proto", encrypted ? "https" : "http");
+    }
+  });
+  return {
+    proxy,
+    async handleEvent(event, opts) {
+      try {
+        return await fromNodeHandler(
+          (req, res) => proxy.web(req, res, opts)
+        )(event);
+      } catch (error) {
+        event.res.headers.set("refresh", "3");
+        throw new HTTPError({
+          status: 503,
+          message: "Dev server is unavailable.",
+          cause: error
+        });
+      }
+    }
+  };
+}
+function fetchAddress(addr, input, inputInit) {
+  let url;
+  let init;
+  if (input instanceof Request) {
+    url = new URL(input.url);
+    init = {
+      method: input.method,
+      headers: input.headers,
+      body: input.body,
+      ...inputInit
+    };
+  } else {
+    url = new URL(input);
+    init = inputInit;
+  }
+  init = {
+    duplex: "half",
+    redirect: "manual",
+    ...init
+  };
+  if (addr.socketPath) {
+    url.protocol = "http:";
+    return fetch(url, {
+      ...init,
+      ...fetchSocketOptions(addr.socketPath)
+    });
+  }
+  const origin = `http://${addr.host}${addr.port ? `:${addr.port}` : ""}`;
+  const outURL = new URL(url.pathname + url.search, origin);
+  return fetch(outURL, init);
+}
+function fetchSocketOptions(socketPath) {
+  if ("Bun" in globalThis) {
+    return { unix: socketPath };
+  }
+  if ("Deno" in globalThis) {
+    return {
+      // @ts-ignore
+      client: Deno.createHttpClient({
+        // @ts-ignore Missing types?
+        transport: "unix",
+        path: socketPath
+      })
+    };
+  }
+  return {
+    dispatcher: new Agent({ connect: { socketPath } })
+  };
+}
+
+class NodeDevWorker {
+  closed = false;
+  #name;
+  #entry;
+  #data;
+  #hooks;
+  #worker;
+  #address;
+  #proxy;
+  #messageListeners;
+  constructor(opts) {
+    this.#name = opts.name;
+    this.#entry = opts.entry;
+    this.#data = opts.data;
+    this.#hooks = opts.hooks;
+    this.#proxy = createHTTPProxy();
+    this.#messageListeners = /* @__PURE__ */ new Set();
+    this.#initWorker();
+  }
+  get ready() {
+    return Boolean(
+      !this.closed && this.#address && this.#proxy && this.#worker
+    );
+  }
+  // #region Public methods
+  async fetch(input, init) {
+    for (let i = 0; i < 5 && !(this.#address && this.#proxy); i++) {
+      await new Promise((r) => setTimeout(r, 100 * Math.pow(2, i)));
+    }
+    if (!(this.#address && this.#proxy)) {
+      return new Response("Dev worker is unavailable", { status: 503 });
+    }
+    return fetchAddress(this.#address, input, init);
+  }
+  upgrade(req, socket, head) {
+    if (!this.ready) {
+      return;
+    }
+    return this.#proxy.proxy.ws(
+      req,
+      socket,
+      { target: this.#address, xfwd: true },
+      head
+    );
+  }
+  sendMessage(message) {
+    if (!this.#worker) {
+      throw new Error(
+        "Dev worker should be initialized before sending messages."
+      );
+    }
+    this.#worker.postMessage(message);
+  }
+  onMessage(listener) {
+    this.#messageListeners.add(listener);
+  }
+  offMessage(listener) {
+    this.#messageListeners.delete(listener);
+  }
+  async close(cause) {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.#hooks.onClose?.(this, cause);
+    this.#hooks = {};
+    const onError = (error) => consola.error(error);
+    await this.#closeWorker().catch(onError);
+    await this.#closeProxy().catch(onError);
+    await this.#closeSocket().catch(onError);
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    const status = this.closed ? "closed" : this.ready ? "ready" : "pending";
+    return `NodeDevWorker#${this.#name}(${status})`;
+  }
+  // #endregion
+  // #region Private methods
+  #initWorker() {
+    if (!existsSync(this.#entry)) {
+      this.close(`worker entry not found in "${this.#entry}".`);
+      return;
+    }
+    const worker = new Worker(this.#entry, {
+      env: {
+        ...process.env
+      },
+      workerData: {
+        name: this.#name,
+        ...this.#data
+      }
+    });
+    worker.once("exit", (code) => {
+      worker._exitCode = code;
+      this.close(`worker exited with code ${code}`);
+    });
+    worker.once("error", (error) => {
+      consola.error(`Worker error:`, error);
+      this.close(error);
+    });
+    worker.on("message", (message) => {
+      if (message?.address) {
+        this.#address = message.address;
+        this.#hooks.onReady?.(this, this.#address);
+      }
+      for (const listener of this.#messageListeners) {
+        listener(message);
+      }
+    });
+    this.#worker = worker;
+  }
+  async #closeProxy() {
+    this.#proxy?.proxy?.close(() => {
+    });
+    this.#proxy = void 0;
+  }
+  async #closeSocket() {
+    const socketPath = this.#address?.socketPath;
+    if (socketPath && socketPath[0] !== "\0" && !socketPath.startsWith(String.raw`\\.\pipe`)) {
+      await rm(socketPath).catch(() => {
+      });
+    }
+    this.#address = void 0;
+  }
+  async #closeWorker() {
+    if (!this.#worker) {
+      return;
+    }
+    this.#worker.postMessage({ event: "shutdown" });
+    if (!this.#worker._exitCode && !a && !T) {
+      await new Promise((resolve) => {
+        const gracefulShutdownTimeoutMs = Number.parseInt(process.env.NITRO_SHUTDOWN_TIMEOUT || "", 10) || 5e3;
+        const timeout = setTimeout(() => {
+          if (process.env.DEBUG) {
+            consola.warn(`force closing dev worker...`);
+          }
+        }, gracefulShutdownTimeoutMs);
+        this.#worker?.on("message", (message) => {
+          if (message.event === "exit") {
+            clearTimeout(timeout);
+            resolve();
+          }
+        });
+      });
+    }
+    this.#worker.removeAllListeners();
+    await this.#worker.terminate().catch((error) => {
+      consola.error(error);
+    });
+    this.#worker = void 0;
+  }
+  // #endregion
+}
+
+function createVFSHandler(nitro) {
+  return defineHandler(async (event) => {
+    const { socket } = event.runtime?.node?.req || {};
+    const isUnixSocket = (
+      // No network addresses
+      !socket?.remoteAddress && !socket?.localAddress && // Empty address object
+      Object.keys(socket?.address?.() || {}).length === 0 && // Socket is readable/writable but has no port info
+      socket?.readable && socket?.writable && !socket?.remotePort
+    );
+    const ip = getRequestIP(event, { xForwardedFor: isUnixSocket });
+    const isLocalRequest = ip && /^::1$|^127\.\d+\.\d+\.\d+$/.test(ip);
+    if (!isLocalRequest) {
+      throw new HTTPError({
+        statusText: `Forbidden IP: "${ip || "?"}"`,
+        status: 403
+      });
+    }
+    const vfsEntries = {
+      ...nitro.vfs,
+      ...nitro.options.virtual
+    };
+    const url = event.context.params?._ || "";
+    const isJson = url.endsWith(".json") || event.req.headers.get("accept")?.includes("application/json");
+    const id = decodeURIComponent(url.replace(/^(\.json)?\/?/, "") || "");
+    if (id && !(id in vfsEntries)) {
+      throw new HTTPError({ message: "File not found", status: 404 });
+    }
+    let content = id ? vfsEntries[id] : void 0;
+    if (typeof content === "function") {
+      content = await content();
+    }
+    if (isJson) {
+      return {
+        rootDir: nitro.options.rootDir,
+        entries: Object.keys(vfsEntries).map((id2) => ({
+          id: id2,
+          path: "/_vfs.json/" + encodeURIComponent(id2)
+        })),
+        current: id ? {
+          id,
+          content
+        } : null
+      };
+    }
+    const directories = { [nitro.options.rootDir]: {} };
+    const fpaths = Object.keys(vfsEntries);
+    for (const item of fpaths) {
+      const segments = item.replace(nitro.options.rootDir, "").split("/").filter(Boolean);
+      let currentDir = item.startsWith(nitro.options.rootDir) ? directories[nitro.options.rootDir] : directories;
+      for (const segment of segments) {
+        if (!currentDir[segment]) {
+          currentDir[segment] = {};
+        }
+        currentDir = currentDir[segment];
+      }
+    }
+    const generateHTML = (directory, path = []) => Object.entries(directory).map(([fname, value = {}]) => {
+      const subpath = [...path, fname];
+      const key = subpath.join("/");
+      const encodedUrl = encodeURIComponent(key);
+      const linkClass = url === `/${encodedUrl}` ? "bg-gray-700 text-white" : "hover:bg-gray-800 text-gray-200";
+      return Object.keys(value).length === 0 ? `
+            <li class="flex flex-nowrap">
+              <a href="/_vfs/${encodedUrl}" class="w-full text-sm px-2 py-1 border-b border-gray-10 ${linkClass}">
+                ${fname}
+              </a>
+            </li>
+            ` : `
+            <li>
+              <details ${url.startsWith(`/${encodedUrl}`) ? "open" : ""}>
+                <summary class="w-full text-sm px-2 py-1 border-b border-gray-10 hover:bg-gray-800 text-gray-200">
+                  ${fname}
+                </summary>
+                <ul class="ml-4">
+                  ${generateHTML(value, subpath)}
+                </ul>
+              </details>
+            </li>
+            `;
+    }).join("");
+    const rootDirectory = directories[nitro.options.rootDir];
+    delete directories[nitro.options.rootDir];
+    const items = generateHTML(rootDirectory, [nitro.options.rootDir]) + generateHTML(directories);
+    const files = `
+      <div class="h-full overflow-auto border-r border-gray:10">
+        <p class="text-white text-bold text-center py-1 opacity-50">Virtual Files</p>
+        <ul class="flex flex-col">${items}</ul>
+      </div>
+      `;
+    const file = id ? editorTemplate({
+      readOnly: true,
+      language: id.endsWith("html") ? "html" : "javascript",
+      theme: "vs-dark",
+      value: content,
+      wordWrap: "wordWrapColumn",
+      wordWrapColumn: 80
+    }) : `
+        <div class="w-full h-full flex opacity-50">
+          <h1 class="text-white m-auto">Select a virtual file to inspect</h1>
+        </div>
+      `;
+    event.res.headers.set("Content-Type", "text/html; charset=utf-8");
+    return (
+      /* html */
+      `
+<!doctype html>
+<html>
+<head>
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@unocss/reset/tailwind.min.css" />
+  <link rel="stylesheet" data-name="vs/editor/editor.main" href="${vsUrl}/editor/editor.main.min.css">
+  <script src="https://cdn.jsdelivr.net/npm/@unocss/runtime"><\/script>
+  <style>
+    html {
+      background: #1E1E1E;
+      color: white;
+    }
+    [un-cloak] {
+      display: none;
+    }
+  </style>
+</head>
+<body class="bg-[#1E1E1E]">
+  <div un-cloak class="h-screen grid grid-cols-[300px_1fr]">
+    ${files}
+    ${file}
+  </div>
+</body>
+</html>`
+    );
+  });
+}
+const monacoVersion = "0.30.0";
+const monacoUrl = `https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/${monacoVersion}/min`;
+const vsUrl = `${monacoUrl}/vs`;
+const editorTemplate = (options) => `
+<div id="editor" class="min-h-screen w-full h-full"></div>
+<script src="${vsUrl}/loader.min.js"><\/script>
+<script>
+  require.config({ paths: { vs: '${vsUrl}' } })
+
+  const proxy = URL.createObjectURL(new Blob([\`
+    self.MonacoEnvironment = { baseUrl: '${monacoUrl}' }
+    importScripts('${vsUrl}/base/worker/workerMain.min.js')
+  \`], { type: 'text/javascript' }))
+  window.MonacoEnvironment = { getWorkerUrl: () => proxy }
+
+  setTimeout(() => {
+    require(['vs/editor/editor.main'], function () {
+      monaco.editor.create(document.getElementById('editor'), ${JSON.stringify(
+  options
+)})
+    })
+  }, 0);
+<\/script>
+`;
+
+function defineNitroErrorHandler(handler) {
+  return handler;
+}
+
+const devErrorHandler = defineNitroErrorHandler(
+  async function defaultNitroErrorHandler(error, event) {
+    const res = await defaultHandler(error, event);
+    return new FastResponse(
+      typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2),
+      res
+    );
+  }
+);
+async function defaultHandler(error, event, opts) {
+  const isSensitive = error.unhandled;
+  const status = error.status || 500;
+  const url = getRequestURL(event, { xForwardedHost: true, xForwardedProto: true });
+  if (status === 404) {
+    const baseURL = import.meta.baseURL || "/";
+    if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) {
+      const redirectTo = `${baseURL}${url.pathname.slice(1)}${url.search}`;
+      return {
+        status: 302,
+        statusText: "Found",
+        headers: { location: redirectTo },
+        body: `Redirecting...`
+      };
+    }
+  }
+  await loadStackTrace(error).catch(consola.error);
+  const youch = new Youch();
+  if (isSensitive && !opts?.silent) {
+    const tags = [error.unhandled && "[unhandled]"].filter(Boolean).join(" ");
+    const ansiError = await (await youch.toANSI(error)).replaceAll(process.cwd(), ".");
+    consola.error(
+      `[request error] ${tags} [${event.req.method}] ${url}
+
+`,
+      ansiError
+    );
+  }
+  const useJSON = opts?.json || !event.req.headers.get("accept")?.includes("text/html");
+  const headers = {
+    "content-type": useJSON ? "application/json" : "text/html",
+    // Prevent browser from guessing the MIME types of resources.
+    "x-content-type-options": "nosniff",
+    // Prevent error page from being embedded in an iframe
+    "x-frame-options": "DENY",
+    // Prevent browsers from sending the Referer header
+    "referrer-policy": "no-referrer",
+    // Disable the execution of any js
+    "content-security-policy": "script-src 'self' 'unsafe-inline'; object-src 'none'; base-uri 'self';"
+  };
+  if (status === 404 || !event.res.headers.has("cache-control")) {
+    headers["cache-control"] = "no-cache";
+  }
+  const body = useJSON ? {
+    error: true,
+    url,
+    status,
+    statusText: error.statusText,
+    message: error.message,
+    data: error.data,
+    stack: error.stack?.split("\n").map((line) => line.trim())
+  } : await youch.toHTML(error, {
+    request: {
+      url: url.href,
+      method: event.req.method,
+      headers: Object.fromEntries(event.req.headers.entries())
+    }
+  });
+  return {
+    status,
+    statusText: error.statusText,
+    headers,
+    body
+  };
+}
+async function loadStackTrace(error) {
+  if (!(error instanceof Error)) {
+    return;
+  }
+  const parsed = await new ErrorParser().defineSourceLoader(sourceLoader).parse(error);
+  const stack = error.message + "\n" + parsed.frames.map((frame) => fmtFrame(frame)).join("\n");
+  Object.defineProperty(error, "stack", { value: stack });
+  if (error.cause) {
+    await loadStackTrace(error.cause).catch(consola.error);
+  }
+}
+async function sourceLoader(frame) {
+  if (!frame.fileName || frame.fileType !== "fs" || frame.type === "native") {
+    return;
+  }
+  if (frame.type === "app") {
+    const rawSourceMap = await readFile(`${frame.fileName}.map`, "utf8").catch(() => {
+    });
+    if (rawSourceMap) {
+      const consumer = await new SourceMapConsumer(rawSourceMap);
+      const originalPosition = consumer.originalPositionFor({ line: frame.lineNumber, column: frame.columnNumber });
+      if (originalPosition.source && originalPosition.line) {
+        frame.fileName = resolve(dirname(frame.fileName), originalPosition.source);
+        frame.lineNumber = originalPosition.line;
+        frame.columnNumber = originalPosition.column || 0;
+      }
+    }
+  }
+  const contents = await readFile(frame.fileName, "utf8").catch(() => {
+  });
+  return contents ? { contents } : void 0;
+}
+function fmtFrame(frame) {
+  if (frame.type === "native") {
+    return frame.raw;
+  }
+  const src = `${frame.fileName || ""}:${frame.lineNumber}:${frame.columnNumber})`;
+  return frame.functionName ? `at ${frame.functionName} (${src}` : `at ${src}`;
+}
+
+class NitroDevApp {
+  nitro;
+  fetch;
+  constructor(nitro, catchAllHandler) {
+    this.nitro = nitro;
+    const app = this.#createApp(catchAllHandler);
+    this.fetch = app.fetch.bind(app);
+  }
+  #createApp(catchAllHandler) {
+    const app = new H3({
+      debug: true,
+      onError: async (error, event) => {
+        const errorHandler = this.nitro.options.devErrorHandler || devErrorHandler;
+        await loadStackTrace(error).catch(() => {
+        });
+        return errorHandler(error, event, {
+          defaultHandler: defaultHandler
+        });
+      }
+    });
+    for (const h of this.nitro.options.devHandlers) {
+      const handler = toEventHandler(h.handler);
+      if (!handler) {
+        this.nitro.logger.warn("Invalid dev handler:", h);
+        continue;
+      }
+      if (h.middleware || !h.route) {
+        if (h.route) {
+          app.use(h.route, handler, { method: h.method });
+        } else {
+          app.use(handler, { method: h.method });
+        }
+      } else {
+        app.on(h.method || "", h.route, handler, { meta: h.meta });
+      }
+    }
+    app.get("/_vfs/**", createVFSHandler(this.nitro));
+    for (const asset of this.nitro.options.publicAssets) {
+      const assetRoute = joinURL(
+        this.nitro.options.runtimeConfig.app.baseURL,
+        asset.baseURL || "/",
+        "**"
+      );
+      let handler = fromNodeHandler(
+        // @ts-expect-error (HTTP2 types)
+        serveStatic(asset.dir, { dotfiles: "allow" })
+      );
+      if (asset.baseURL?.length || 0 > 1) {
+        handler = withBase(asset.baseURL, handler);
+      }
+      app.use(assetRoute, handler);
+    }
+    const routes = Object.keys(this.nitro.options.devProxy).sort().reverse();
+    for (const route of routes) {
+      let opts = this.nitro.options.devProxy[route];
+      if (typeof opts === "string") {
+        opts = { target: opts };
+      }
+      const proxy = createHTTPProxy(opts);
+      app.all(route, proxy.handleEvent);
+    }
+    if (catchAllHandler) {
+      app.all("/**", catchAllHandler);
+    }
+    return app;
+  }
+}
+
+export { NitroDevApp as N, NodeDevWorker as a };