unplugin-https-reverse-proxy 3.0.0 → 4.0.1

package/dist/nuxt.cjs

@@ -13477,33 +13477,63 @@ var caddyTemplate = `{
   }
 }
 
-{% for p in proxies %}
-{{ p.target }}{{ p.portSuffix }} {
-  {{ p.tls }}
-  reverse_proxy http://{{ p.source }} {% if p.healthCheck %} {
-    health_uri {{ p.base }}
-    health_interval 2s
-    health_timeout 5s
-    fail_duration 2s
-    unhealthy_status 502 503 504 404
-    lb_try_duration 3s
-    lb_try_interval 300ms
+{% for host in hosts %}
+{{ host.host }}{{ host.portSuffix }} {
+  {{ host.tls }}
 
-    @error status 502 503 504 404
-    handle_response @error {
-      respond * 503 {
-        body "Service Unavailable"
-        close
+  {% for route in host.routes %}
+  handle {{ route.base }}* {
+    reverse_proxy http://{{ route.source }} {% if route.healthCheck %} {
+      health_uri {{ route.base }}
+      health_interval 2s
+      health_timeout 5s
+      health_headers {
+        User-Agent {http.request.header.User-Agent}
+        Accept text/html,application/json,*/*
+      }
+      fail_duration 2s
+      unhealthy_status 502 503 504 404
+      lb_try_duration 3s
+      lb_try_interval 300ms
+
+      @error status 502 503 504 404
+      handle_response @error {
+        respond * 503 {
+          body "Service Unavailable"
+          close
+        }
       }
     }
+    {% endif %}
   }
-  {% endif %}
+  {% endfor %}
 }
 {% endfor %}
 `;
 var liquid = new Liquid();
 async function genCaddyfile(ctx) {
-  return await liquid.parseAndRender(caddyTemplate, ctx);
+  const hostsMap = /* @__PURE__ */ new Map();
+  for (const proxy of ctx.proxies) {
+    const key = `${proxy.target}${proxy.portSuffix}`;
+    if (!hostsMap.has(key)) {
+      hostsMap.set(key, {
+        host: proxy.target,
+        portSuffix: proxy.portSuffix,
+        tls: proxy.tls,
+        routes: []
+      });
+    }
+    let base = proxy.base || "/";
+    if (!base.startsWith("/"))
+      base = `/${base}`;
+    if (base !== "/" && !base.endsWith("/"))
+      base = `${base}/`;
+    hostsMap.get(key).routes.push({ ...proxy, base });
+  }
+  for (const host of hostsMap.values())
+    host.routes.sort((a, b) => b.base.length - a.base.length);
+  const hosts = Array.from(hostsMap.values());
+  return await liquid.parseAndRender(caddyTemplate, { ...ctx, hosts });
 }
 
 // src/caddy/config.ts
@@ -13668,8 +13698,13 @@ function useCaddyConfig() {
   function writeCaddyConfig(_proxies) {
     const proxies = configJsonRef() || {};
     _proxies.forEach((p) => {
-      const index = `${p.target}${p.portSuffix}`;
-      proxies[index] = p;
+      let base = p.base || "/";
+      if (!base.startsWith("/"))
+        base = `/${base}`;
+      if (base !== "/" && !base.endsWith("/"))
+        base = `${base}/`;
+      const index = `${p.target}${p.portSuffix}${base}`;
+      proxies[index] = { ...p, base };
     });
     const content = JSON.stringify(proxies, null, 2);
     configContentRef(content);
@@ -13887,13 +13922,22 @@ var CaddyInstant = class {
       throw new Error("update host failed");
     consola.success("update host success\n");
     const targetHost = target.split(":")[0];
+    const normalizeBase = (b) => {
+      let out = b || "/";
+      if (!out.startsWith("/"))
+        out = `/${out}`;
+      if (out !== "/" && !out.endsWith("/"))
+        out = `${out}/`;
+      return out;
+    };
+    const baseNormalized = normalizeBase(base);
     const proxies = [
       {
         target: targetHost,
         portSuffix: https ? "" : ":80",
         tls: https ? "tls internal" : "",
         source,
-        base,
+        base: baseNormalized,
         healthCheck
       }
     ];
@@ -13903,14 +13947,12 @@ var CaddyInstant = class {
       effect(async () => {
         const { configJsonRef } = getCaddyConfig();
         const proxies2 = Object.values(configJsonRef() || {});
-        if (!(this.caddyfile || "").includes(`${target.split(":")[0]}${https ? "" : ":80"}`)) {
-          const ctx = validateTemplateContext({
-            caddy_root: this.caddyRoot,
-            proxies: proxies2
-          });
-          this.caddyfile = await genCaddyfile(ctx);
-          await this.writeCaddyfile();
-        }
+        const ctx = validateTemplateContext({
+          caddy_root: this.caddyRoot,
+          proxies: proxies2
+        });
+        this.caddyfile = await genCaddyfile(ctx);
+        await this.writeCaddyfile();
       })
     );
     if (!(0, import_node_fs3.existsSync)(caddyLockFilePath))
@@ -14046,6 +14088,137 @@ ${line}
   }
 };
 
+// src/hmr-sse-bridge.ts
+var SSE_PATH = "/__hmr_sse";
+var SEND_PATH = "/__hmr_send";
+var MAX_POST_BODY = 64 * 1024;
+var hmrSseBridgeClientScript = `
+(function() {
+  // Activate when served over HTTPS to bypass WSS self-signed cert issues
+  if (location.protocol !== 'https:') return;
+
+  var OriginalWebSocket = window.WebSocket;
+
+  function SseWebSocket(originalUrl) {
+    var self = this;
+    // WebSocket readyState constants on instance
+    self.CONNECTING = 0;
+    self.OPEN = 1;
+    self.CLOSING = 2;
+    self.CLOSED = 3;
+    self.readyState = 0;
+    self.onopen = null;
+    self.onmessage = null;
+    self.onclose = null;
+    self.onerror = null;
+    self.bufferedAmount = 0;
+    self.extensions = '';
+    self.binaryType = 'blob';
+    self.protocol = 'vite-hmr';
+    self.url = originalUrl;
+    self._listeners = {};
+    self._opened = false;
+
+    var sseUrl = location.origin + '${SSE_PATH}';
+    var sendUrl = location.origin + '${SEND_PATH}';
+    self._sendUrl = sendUrl;
+
+    var es = new EventSource(sseUrl);
+    self._es = es;
+
+    es.onopen = function() {
+      if (self._opened) return;
+      self._opened = true;
+      self.readyState = 1;
+      var evt = new Event('open');
+      if (self.onopen) self.onopen(evt);
+      self._emit('open', evt);
+    };
+
+    es.onmessage = function(e) {
+      var evt = new MessageEvent('message', { data: e.data });
+      if (self.onmessage) self.onmessage(evt);
+      self._emit('message', evt);
+    };
+
+    es.onerror = function() {
+      // EventSource auto-reconnects on error; don't treat as fatal close
+      // Only emit error event, never close event (SSE handles reconnect internally)
+      if (self.readyState >= 2) return;
+      // EventSource auto-reconnects; no action needed
+    };
+  }
+
+  SseWebSocket.prototype.send = function(data) {
+    if (this.readyState !== 1) return;
+    fetch(this._sendUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: data
+    }).catch(function() {});
+  };
+
+  SseWebSocket.prototype.close = function() {
+    if (this.readyState >= 2) return;
+    this.readyState = 3;
+    if (this._es) this._es.close();
+    var evt = new CloseEvent('close', { code: 1000, reason: '', wasClean: true });
+    if (this.onclose) this.onclose(evt);
+    this._emit('close', evt);
+  };
+
+  SseWebSocket.prototype.addEventListener = function(type, fn, options) {
+    if (!this._listeners[type]) this._listeners[type] = [];
+    var entry = { fn: fn, once: !!(options && options.once) };
+    this._listeners[type].push(entry);
+  };
+
+  SseWebSocket.prototype.removeEventListener = function(type, fn) {
+    var list = this._listeners[type];
+    if (!list) return;
+    this._listeners[type] = list.filter(function(e) { return e.fn !== fn; });
+  };
+
+  SseWebSocket.prototype.dispatchEvent = function(evt) {
+    this._emit(evt.type, evt);
+    return true;
+  };
+
+  SseWebSocket.prototype._emit = function(type, evt) {
+    var list = this._listeners[type];
+    if (!list) return;
+    var remaining = [];
+    list.forEach(function(entry) {
+      entry.fn(evt);
+      if (!entry.once) remaining.push(entry);
+    });
+    this._listeners[type] = remaining;
+  };
+
+  function PatchedWebSocket(url, protocols) {
+    // Only intercept Vite HMR connections (protocol 'vite-hmr')
+    var isViteHmr = protocols === 'vite-hmr'
+      || (Array.isArray(protocols) && protocols.indexOf('vite-hmr') !== -1);
+    if (!isViteHmr) {
+      if (protocols !== undefined) {
+        return new OriginalWebSocket(url, protocols);
+      }
+      return new OriginalWebSocket(url);
+    }
+    return new SseWebSocket(url);
+  }
+
+  PatchedWebSocket.CONNECTING = 0;
+  PatchedWebSocket.OPEN = 1;
+  PatchedWebSocket.CLOSING = 2;
+  PatchedWebSocket.CLOSED = 3;
+  PatchedWebSocket.prototype = Object.create(OriginalWebSocket.prototype);
+  PatchedWebSocket.prototype.constructor = PatchedWebSocket;
+
+  window.WebSocket = PatchedWebSocket;
+})();
+`;
+
 // src/index.ts
 var caddy;
 var cwd = import_node_process5.default.cwd();

package/dist/nuxt.js

@@ -1,6 +1,7 @@
 import {
   vitePrintUrls
-} from "./chunk-5MC5SB7O.js";
+} from "./chunk-QURDG7SD.js";
+import "./chunk-RSBXFJ3Z.js";
 import {
   consola,
   isAdmin