unplugin-https-reverse-proxy 4.0.0 → 4.0.2

package/dist/webpack.cjs

@@ -13859,6 +13859,17 @@ function getCaddyConfig() {
   }
   return caddyConfig;
 }
+function splitHostPort(addr) {
+  const lastColon = addr.lastIndexOf(":");
+  if (lastColon === -1)
+    return { host: addr, port: "" };
+  if (addr.startsWith("[")) {
+    const end = addr.indexOf("]");
+    if (end !== -1 && addr[end + 1] === ":")
+      return { host: addr.slice(1, end), port: addr.slice(end + 2) };
+  }
+  return { host: addr.slice(0, lastColon), port: addr.slice(lastColon + 1) };
+}
 var CaddyInstant = class {
   constructor() {
     this.inited = false;
@@ -13906,6 +13917,7 @@ var CaddyInstant = class {
    */
   async run(source, target, options) {
     source = source.replace("0.0.0.0", "127.0.0.1");
+    source = source.replace(/^localhost(?=:)/i, "127.0.0.1");
     const {
       restore = true,
       base = "/",
@@ -13917,10 +13929,11 @@ var CaddyInstant = class {
     this._target = target;
     if (!this.inited)
       await this.init();
-    if (!await addHost(source.split(":")[0], target.split(":")[0]))
+    const sourceHost = splitHostPort(source).host;
+    const targetHost = splitHostPort(target).host;
+    if (!await addHost(sourceHost, targetHost))
       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("/"))
@@ -13980,7 +13993,7 @@ var CaddyInstant = class {
         });
         const originalExit = import_node_process4.default.exit.bind(import_node_process4.default);
         import_node_process4.default.exit = async (code) => {
-          const port = Number(source.split(":")[1]);
+          const port = Number(splitHostPort(source).port);
           if (!Number.isNaN(port) && await tryPort(port))
             await kill(port);
           const pwd = import_node_process4.default.cwd();
@@ -13988,6 +14001,10 @@ var CaddyInstant = class {
           if ((0, import_node_fs3.existsSync)(viteCacheDir))
             await chmodRecursive(viteCacheDir, 511).catch(() => {
             });
+          const viteTempCacheDir = `${pwd}/node_modules/.vite-temp`;
+          if ((0, import_node_fs3.existsSync)(viteTempCacheDir))
+            await chmodRecursive(viteTempCacheDir, 511).catch(() => {
+            });
           const nuxtCacheDir = `${pwd}/.nuxt`;
           if ((0, import_node_fs3.existsSync)(nuxtCacheDir))
             await chmodRecursive(nuxtCacheDir, 511).catch(() => {
@@ -14059,7 +14076,7 @@ ${line}
     this._stopEffects.forEach((fn) => fn());
     try {
       if (restore && this._source && this._target) {
-        if (await removeHost(this._source.split(":")[0], this._target.split(":")[0]))
+        if (await removeHost(splitHostPort(this._source).host, splitHostPort(this._target).host))
           consola.success("Restore host success.\n");
         else
           consola.fail("Restore host failed.\n");
@@ -14087,9 +14104,238 @@ ${line}
   }
 };
 
+// src/hmr-sse-bridge.ts
+var SSE_PATH = "/__hmr_sse";
+var SEND_PATH = "/__hmr_send";
+var MAX_POST_BODY = 64 * 1024;
+function setupHmrSseBridge(server) {
+  const sseClients = /* @__PURE__ */ new Set();
+  const originalSend = server.ws.send.bind(server.ws);
+  server.ws.send = (...args2) => {
+    ;
+    originalSend(...args2);
+    let payload;
+    if (typeof args2[0] === "string") {
+      payload = JSON.stringify({ type: "custom", event: args2[0], data: args2[1] });
+    } else {
+      payload = JSON.stringify(args2[0]);
+    }
+    for (const res of sseClients) {
+      try {
+        res.write(`data: ${payload}
+
+`);
+      } catch {
+        sseClients.delete(res);
+      }
+    }
+  };
+  server.middlewares.use((req, res, next2) => {
+    var _a4;
+    const url2 = (_a4 = req.url) == null ? void 0 : _a4.split("?")[0];
+    if (url2 === SSE_PATH && req.method === "GET") {
+      handleSseConnection(req, res, sseClients);
+      return;
+    }
+    if (url2 === SEND_PATH && req.method === "POST") {
+      handleClientMessage(req, res, server);
+      return;
+    }
+    next2();
+  });
+}
+function handleSseConnection(_req, res, sseClients) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive"
+  });
+  res.write(`data: ${JSON.stringify({ type: "connected" })}
+
+`);
+  sseClients.add(res);
+  const keepAlive = setInterval(() => {
+    try {
+      res.write(": ping\n\n");
+    } catch {
+      cleanup();
+    }
+  }, 3e4);
+  function cleanup() {
+    clearInterval(keepAlive);
+    sseClients.delete(res);
+  }
+  res.on("close", cleanup);
+  res.on("error", cleanup);
+}
+function handleClientMessage(req, res, server) {
+  let body = "";
+  let overflow = false;
+  req.on("data", (chunk) => {
+    body += chunk.toString();
+    if (body.length > MAX_POST_BODY) {
+      overflow = true;
+      req.destroy();
+    }
+  });
+  req.on("end", () => {
+    var _a4, _b3, _c2, _d2, _e;
+    if (overflow) {
+      res.writeHead(413);
+      res.end('{"ok":false}');
+      return;
+    }
+    try {
+      const data = JSON.parse(body);
+      if (data.type === "custom" && data.event) {
+        const dummyClient = {
+          send: (...args2) => {
+            server.ws.send(...args2);
+          }
+        };
+        (_e = (_d2 = (_c2 = (_b3 = (_a4 = server.environments) == null ? void 0 : _a4.client) == null ? void 0 : _b3.hot) == null ? void 0 : _c2.api) == null ? void 0 : _d2.emit) == null ? void 0 : _e.call(_d2, data.event, data.data, dummyClient);
+      }
+      res.writeHead(200, {
+        "Content-Type": "application/json"
+      });
+      res.end('{"ok":true}');
+    } catch {
+      res.writeHead(400);
+      res.end('{"ok":false}');
+    }
+  });
+}
+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 config;
 var caddy;
+var hmrSseBridgeActive = false;
 var cwd = import_node_process5.default.cwd();
 function colorUrl(url2) {
   return import_picocolors2.default.green(url2.replace(/:(\d+)\//, (_, port) => `:${import_picocolors2.default.bold(port)}/`));
@@ -14176,6 +14422,20 @@ var unpluginFactory = (options) => ({
       }
       const base = server.config.base || "/";
       server.printUrls = () => vitePrintUrls(options, source, target, base, _printUrls);
+      if (options.https) {
+        setupHmrSseBridge(server);
+        hmrSseBridgeActive = true;
+        consola.info("HMR SSE bridge enabled for iOS Safari WSS workaround");
+      }
+    },
+    transformIndexHtml() {
+      if (!hmrSseBridgeActive)
+        return [];
+      return [{
+        tag: "script",
+        children: hmrSseBridgeClientScript,
+        injectTo: "head-prepend"
+      }];
     }
   },
   webpack(compiler) {

package/dist/webpack.js

@@ -1,6 +1,7 @@
 import {
   unpluginFactory
-} from "./chunk-K7HSLE6X.js";
+} from "./chunk-JA3D5AWS.js";
+import "./chunk-RSBXFJ3Z.js";
 import "./chunk-2P7SUCQ3.js";
 
 // src/webpack.ts

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unplugin-https-reverse-proxy",
   "type": "module",
-  "version": "4.0.0",
+  "version": "4.0.2",
   "description": "",
   "license": "MIT",
   "homepage": "https://github.com/zcf0508/unplugin-https-reverse-proxy#readme",

package/src/caddy/index.ts

@@ -114,6 +114,19 @@ function getCaddyConfig(): ReturnType<typeof useCaddyConfig> {
   return caddyConfig
 }
 
+/** Split `host:port` (IPv4 or hostname); supports `[::1]:port`. */
+function splitHostPort(addr: string): { host: string, port: string } {
+  const lastColon = addr.lastIndexOf(':')
+  if (lastColon === -1)
+    return { host: addr, port: '' }
+  if (addr.startsWith('[')) {
+    const end = addr.indexOf(']')
+    if (end !== -1 && addr[end + 1] === ':')
+      return { host: addr.slice(1, end), port: addr.slice(end + 2) }
+  }
+  return { host: addr.slice(0, lastColon), port: addr.slice(lastColon + 1) }
+}
+
 export class CaddyInstant {
   private inited = false
   private stoped = false
@@ -180,6 +193,9 @@ export class CaddyInstant {
    */
   async run(source: string, target: string, options?: Partial<RunOptions>): Promise<void> {
     source = source.replace('0.0.0.0', '127.0.0.1')
+    // Caddy dials the upstream host via DNS; `localhost` can hit lookup timeouts (VPN/DNS).
+    // Use loopback IP so the proxy never depends on resolving "localhost".
+    source = source.replace(/^localhost(?=:)/i, '127.0.0.1')
     const {
       restore = true,
       base = '/',
@@ -194,11 +210,11 @@ export class CaddyInstant {
     if (!this.inited)
       await this.init()
 
-    if (!await addHost(source.split(':')[0], target.split(':')[0]))
+    const sourceHost = splitHostPort(source).host
+    const targetHost = splitHostPort(target).host
+    if (!await addHost(sourceHost, targetHost))
       throw new Error('update host failed')
     consola.success('update host success\n')
-
-    const targetHost = target.split(':')[0]
     const normalizeBase = (b: string): string => {
       let out = b || '/'
       if (!out.startsWith('/'))
@@ -270,7 +286,7 @@ export class CaddyInstant {
 
         // @ts-expect-error override
         process.exit = async (code?: number) => {
-          const port = Number(source.split(':')[1])
+          const port = Number(splitHostPort(source).port)
           if (!Number.isNaN(port) && await tryPort(port))
             await kill(port)
 
@@ -279,6 +295,9 @@ export class CaddyInstant {
           const viteCacheDir = `${pwd}/node_modules/.vite`
           if (existsSync(viteCacheDir))
             await chmodRecursive(viteCacheDir, 0o777).catch(() => { })
+          const viteTempCacheDir = `${pwd}/node_modules/.vite-temp`
+          if (existsSync(viteTempCacheDir))
+            await chmodRecursive(viteTempCacheDir, 0o777).catch(() => { })
           const nuxtCacheDir = `${pwd}/.nuxt`
           if (existsSync(nuxtCacheDir))
             await chmodRecursive(nuxtCacheDir, 0o777).catch(() => { })
@@ -367,7 +386,7 @@ export class CaddyInstant {
 
     try {
       if (restore && this._source && this._target) {
-        if (await removeHost(this._source.split(':')[0], this._target.split(':')[0]))
+        if (await removeHost(splitHostPort(this._source).host, splitHostPort(this._target).host))
           consola.success('Restore host success.\n')
 
         else

package/src/hmr-sse-bridge.ts

@@ -0,0 +1,266 @@
+import type { Buffer } from 'node:buffer'
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { ViteDevServer } from 'vite'
+
+const SSE_PATH = '/__hmr_sse'
+const SEND_PATH = '/__hmr_send'
+const MAX_POST_BODY = 64 * 1024 // 64KB limit for client messages
+
+export function setupHmrSseBridge(server: ViteDevServer): void {
+  const sseClients = new Set<ServerResponse>()
+
+  // Monkey-patch server.ws.send to also push to SSE clients
+  const originalSend = server.ws.send.bind(server.ws)
+  server.ws.send = (...args: any[]) => {
+    // Call original WebSocket send
+    ;(originalSend as any)(...args)
+
+    // Build the payload string same as Vite does internally
+    let payload: string
+    if (typeof args[0] === 'string') {
+      // server.ws.send(event, data) — custom event, wrap it
+      payload = JSON.stringify({ type: 'custom', event: args[0], data: args[1] })
+    }
+    else {
+      // server.ws.send(payloadObject)
+      payload = JSON.stringify(args[0])
+    }
+
+    // Push to all SSE clients (skip errored ones)
+    for (const res of sseClients) {
+      try {
+        res.write(`data: ${payload}\n\n`)
+      }
+      catch {
+        sseClients.delete(res)
+      }
+    }
+  }
+
+  // Add middleware for SSE and POST endpoints
+  server.middlewares.use((req: IncomingMessage, res: ServerResponse, next: () => void) => {
+    const url = req.url?.split('?')[0]
+
+    if (url === SSE_PATH && req.method === 'GET') {
+      handleSseConnection(req, res, sseClients)
+      return
+    }
+
+    if (url === SEND_PATH && req.method === 'POST') {
+      handleClientMessage(req, res, server)
+      return
+    }
+
+    next()
+  })
+}
+
+function handleSseConnection(
+  _req: IncomingMessage,
+  res: ServerResponse,
+  sseClients: Set<ServerResponse>,
+): void {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+  })
+
+  // Send initial connected message (same as Vite's WebSocket)
+  res.write(`data: ${JSON.stringify({ type: 'connected' })}\n\n`)
+
+  sseClients.add(res)
+
+  // Keep-alive ping every 30s
+  const keepAlive = setInterval(() => {
+    try {
+      res.write(': ping\n\n')
+    }
+    catch { cleanup() }
+  }, 30000)
+
+  function cleanup(): void {
+    clearInterval(keepAlive)
+    sseClients.delete(res)
+  }
+
+  res.on('close', cleanup)
+  res.on('error', cleanup)
+}
+
+function handleClientMessage(
+  req: IncomingMessage,
+  res: ServerResponse,
+  server: ViteDevServer,
+): void {
+  let body = ''
+  let overflow = false
+  req.on('data', (chunk: Buffer) => {
+    body += chunk.toString()
+    if (body.length > MAX_POST_BODY) {
+      overflow = true
+      req.destroy()
+    }
+  })
+  req.on('end', () => {
+    if (overflow) {
+      res.writeHead(413)
+      res.end('{"ok":false}')
+      return
+    }
+    try {
+      const data = JSON.parse(body)
+      // Forward custom events to Vite's HMR server
+      // Vite client sends: { type: 'custom', event: string, data: any }
+      if (data.type === 'custom' && data.event) {
+        // Trigger listeners registered via server.ws.on(event, handler)
+        // by simulating the internal dispatch with a dummy client
+        const dummyClient = {
+          send: (...args: any[]) => { server.ws.send(...(args as [any])) },
+        }
+        // Access internal customListeners via the 'on' registered handlers
+        // We re-emit by calling the server's hot channel listener mechanism
+        ;(server as any).environments?.client?.hot?.api?.emit?.(data.event, data.data, dummyClient)
+      }
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+      })
+      res.end('{"ok":true}')
+    }
+    catch {
+      res.writeHead(400)
+      res.end('{"ok":false}')
+    }
+  })
+}
+
+/**
+ * Client-side script that patches WebSocket to use SSE+fetch on iOS Safari.
+ * This script is injected via Vite's transformIndexHtml hook.
+ */
+export const 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;
+})();
+`