portless 0.3.0 → 0.4.1

package/dist/{chunk-Y5OVKUR4.js → chunk-VRBD6YAY.js}

@@ -5,8 +5,10 @@ function isErrnoException(err) {
 function escapeHtml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
-function formatUrl(hostname, proxyPort) {
-  return proxyPort === 80 ? `http://${hostname}` : `http://${hostname}:${proxyPort}`;
+function formatUrl(hostname, proxyPort, tls = false) {
+  const proto = tls ? "https" : "http";
+  const defaultPort = tls ? 443 : 80;
+  return proxyPort === defaultPort ? `${proto}://${hostname}` : `${proto}://${hostname}:${proxyPort}`;
 }
 function parseHostname(input) {
   let hostname = input.trim().replace(/^https?:\/\//, "").split("/")[0].toLowerCase();
@@ -30,24 +32,40 @@ function parseHostname(input) {
 
 // src/proxy.ts
 import * as http from "http";
+import * as http2 from "http2";
+import * as net from "net";
 var PORTLESS_HEADER = "X-Portless";
-function buildForwardedHeaders(req) {
+var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-connection",
+  "transfer-encoding",
+  "upgrade"
+]);
+function getRequestHost(req) {
+  const authority = req.headers[":authority"];
+  if (typeof authority === "string" && authority) return authority;
+  return req.headers.host || "";
+}
+function buildForwardedHeaders(req, tls) {
   const headers = {};
   const remoteAddress = req.socket.remoteAddress || "127.0.0.1";
-  const proto = "http";
-  const hostHeader = req.headers.host || "";
+  const proto = tls ? "https" : "http";
+  const defaultPort = tls ? "443" : "80";
+  const hostHeader = getRequestHost(req);
   headers["x-forwarded-for"] = req.headers["x-forwarded-for"] ? `${req.headers["x-forwarded-for"]}, ${remoteAddress}` : remoteAddress;
   headers["x-forwarded-proto"] = req.headers["x-forwarded-proto"] || proto;
   headers["x-forwarded-host"] = req.headers["x-forwarded-host"] || hostHeader;
-  headers["x-forwarded-port"] = req.headers["x-forwarded-port"] || hostHeader.split(":")[1] || "80";
+  headers["x-forwarded-port"] = req.headers["x-forwarded-port"] || hostHeader.split(":")[1] || defaultPort;
   return headers;
 }
 function createProxyServer(options) {
-  const { getRoutes, proxyPort, onError = (msg) => console.error(msg) } = options;
+  const { getRoutes, proxyPort, onError = (msg) => console.error(msg), tls } = options;
+  const isTls = !!tls;
   const handleRequest = (req, res) => {
     res.setHeader(PORTLESS_HEADER, "1");
     const routes = getRoutes();
-    const host = (req.headers.host || "").split(":")[0];
+    const host = getRequestHost(req).split(":")[0];
     if (!host) {
       res.writeHead(400, { "Content-Type": "text/plain" });
       res.end("Missing Host header");
@@ -66,7 +84,7 @@ function createProxyServer(options) {
             ${routes.length > 0 ? `
               <h2>Active apps:</h2>
               <ul>
-                ${routes.map((r) => `<li><a href="${escapeHtml(formatUrl(r.hostname, proxyPort))}">${escapeHtml(r.hostname)}</a> - localhost:${escapeHtml(String(r.port))}</li>`).join("")}
+                ${routes.map((r) => `<li><a href="${escapeHtml(formatUrl(r.hostname, proxyPort, isTls))}">${escapeHtml(r.hostname)}</a> - localhost:${escapeHtml(String(r.port))}</li>`).join("")}
               </ul>
             ` : "<p><em>No apps running.</em></p>"}
             <p>Start an app with: <code>portless ${safeHost.replace(".localhost", "")} your-command</code></p>
@@ -75,11 +93,16 @@ function createProxyServer(options) {
       `);
       return;
     }
-    const forwardedHeaders = buildForwardedHeaders(req);
+    const forwardedHeaders = buildForwardedHeaders(req, isTls);
     const proxyReqHeaders = { ...req.headers };
     for (const [key, value] of Object.entries(forwardedHeaders)) {
       proxyReqHeaders[key] = value;
     }
+    for (const key of Object.keys(proxyReqHeaders)) {
+      if (key.startsWith(":")) {
+        delete proxyReqHeaders[key];
+      }
+    }
     const proxyReq = http.request(
       {
         hostname: "127.0.0.1",
@@ -89,12 +112,18 @@ function createProxyServer(options) {
         headers: proxyReqHeaders
       },
       (proxyRes) => {
-        res.writeHead(proxyRes.statusCode || 502, proxyRes.headers);
+        const responseHeaders = { ...proxyRes.headers };
+        if (isTls) {
+          for (const h of HOP_BY_HOP_HEADERS) {
+            delete responseHeaders[h];
+          }
+        }
+        res.writeHead(proxyRes.statusCode || 502, responseHeaders);
         proxyRes.pipe(res);
       }
     );
     proxyReq.on("error", (err) => {
-      onError(`Proxy error for ${req.headers.host}: ${err.message}`);
+      onError(`Proxy error for ${getRequestHost(req)}: ${err.message}`);
       if (!res.headersSent) {
         const errWithCode = err;
         const message = errWithCode.code === "ECONNREFUSED" ? "Bad Gateway: the target app is not responding. It may have crashed." : "Bad Gateway: the target app may not be running.";
@@ -116,17 +145,22 @@ function createProxyServer(options) {
   };
   const handleUpgrade = (req, socket, head) => {
     const routes = getRoutes();
-    const host = (req.headers.host || "").split(":")[0];
+    const host = getRequestHost(req).split(":")[0];
     const route = routes.find((r) => r.hostname === host);
     if (!route) {
       socket.destroy();
       return;
     }
-    const forwardedHeaders = buildForwardedHeaders(req);
+    const forwardedHeaders = buildForwardedHeaders(req, isTls);
     const proxyReqHeaders = { ...req.headers };
     for (const [key, value] of Object.entries(forwardedHeaders)) {
       proxyReqHeaders[key] = value;
     }
+    for (const key of Object.keys(proxyReqHeaders)) {
+      if (key.startsWith(":")) {
+        delete proxyReqHeaders[key];
+      }
+    }
     const proxyReq = http.request({
       hostname: "127.0.0.1",
       port: route.port,
@@ -152,7 +186,7 @@ function createProxyServer(options) {
       socket.on("error", () => proxySocket.destroy());
     });
     proxyReq.on("error", (err) => {
-      onError(`WebSocket proxy error for ${req.headers.host}: ${err.message}`);
+      onError(`WebSocket proxy error for ${getRequestHost(req)}: ${err.message}`);
       socket.destroy();
     });
     proxyReq.on("response", (res) => {
@@ -173,6 +207,44 @@ function createProxyServer(options) {
     }
     proxyReq.end();
   };
+  if (tls) {
+    const h2Server = http2.createSecureServer({
+      cert: tls.cert,
+      key: tls.key,
+      allowHTTP1: true,
+      ...tls.SNICallback ? { SNICallback: tls.SNICallback } : {}
+    });
+    h2Server.on("request", (req, res) => {
+      handleRequest(req, res);
+    });
+    h2Server.on("upgrade", (req, socket, head) => {
+      handleUpgrade(req, socket, head);
+    });
+    const plainServer = http.createServer(handleRequest);
+    plainServer.on("upgrade", handleUpgrade);
+    const wrapper = net.createServer((socket) => {
+      socket.once("readable", () => {
+        const buf = socket.read(1);
+        if (!buf) {
+          socket.destroy();
+          return;
+        }
+        socket.unshift(buf);
+        if (buf[0] === 22) {
+          h2Server.emit("connection", socket);
+        } else {
+          plainServer.emit("connection", socket);
+        }
+      });
+    });
+    const origClose = wrapper.close.bind(wrapper);
+    wrapper.close = function(cb) {
+      h2Server.close();
+      plainServer.close();
+      return origClose(cb);
+    };
+    return wrapper;
+  }
   const httpServer = http.createServer(handleRequest);
   httpServer.on("upgrade", handleUpgrade);
   return httpServer;
@@ -190,6 +262,7 @@ function isValidRoute(value) {
   return typeof value === "object" && value !== null && typeof value.hostname === "string" && typeof value.port === "number" && typeof value.pid === "number";
 }
 var RouteStore = class _RouteStore {
+  /** The state directory path. */
   dir;
   routesPath;
   lockPath;