@xysfe/vite-plugin-dev-proxy 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 aiwa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,193 @@
+# vite-plugin-dev-proxy
+
+A Vite plugin for development environment proxy that automatically proxies remote server requests and handles HTML responses.
+
+## Features
+
+- 🚀 Automatically proxy remote server requests
+- 📦 Smart HTML response handling, replacing remote scripts and stylesheets with local development versions
+- 🍪 Automatic cookie rewriting, removing Secure and Domain attributes
+- 🔀 Redirect handling with protocol mismatch fixes
+- ⚙️ Support for custom static resource prefixes
+- 🐛 Debug logging support
+- 🔗 Merge with other proxy configurations
+- 🔧 TypeScript support with full type definitions
+
+## Installation
+
+```bash
+npm install vite-plugin-dev-proxy --save-dev
+```
+
+```bash
+yarn add vite-plugin-dev-proxy --dev
+```
+
+```bash
+pnpm add vite-plugin-dev-proxy --save-dev
+```
+
+## Usage
+
+### Basic Usage
+
+```js
+// vite.config.js
+import { defineConfig } from "vite";
+import viteDevProxy from "vite-plugin-dev-proxy";
+
+export default defineConfig({
+  plugins: [
+    viteDevProxy({
+      appHost: "example.com",
+    }),
+  ],
+});
+```
+
+### Full Configuration
+
+```js
+// vite.config.js
+import { defineConfig } from "vite";
+import viteDevProxy from "vite-plugin-dev-proxy";
+
+export default defineConfig({
+  plugins: [
+    viteDevProxy({
+      appHost: "example.com",
+      https: true,
+      staticPrefix: "/dev/static",
+      bypassPrefixes: ["/static"],
+      scriptCssPrefix: "/static/global",
+      entry: "/src/main.js",
+      debug: true,
+    }),
+  ],
+});
+```
+
+### Coexisting with Other Proxy Configurations
+
+```js
+// vite.config.js
+export default defineConfig({
+  plugins: [
+    viteDevProxy({
+      appHost: "example.com",
+    }),
+  ],
+  server: {
+    proxy: {
+      "/api": {
+        target: "http://localhost:8080",
+      },
+    },
+  },
+});
+```
+
+## API
+
+### `viteDevProxy(options?)`
+
+#### Options
+
+| Parameter         | Type       | Default          | Required | Description                                                                                     |
+| ----------------- | ---------- | ---------------- | -------- | ----------------------------------------------------------------------------------------------- |
+| `appHost`         | `string`   | -                | ✅       | Target server address                                                                           |
+| `https`           | `boolean`  | `true`           | -        | Whether to use HTTPS for the target server                                                      |
+| `staticPrefix`    | `string`   | `''`             | -        | Static resource prefix, used to build local entry path                                          |
+| `bypassPrefixes`  | `string[]` | `['/static']`    | -        | List of prefixes to bypass proxy, requests matching these prefixes will access remote resources |
+| `scriptCssPrefix` | `string`   | `''`             | -        | Script/CSS prefix, used to precisely match remote scripts and stylesheets to remove             |
+| `entry`           | `string`   | `'/src/main.js'` | -        | Local development entry file path                                                               |
+| `isLib`           | `boolean`  | `false`          | -        | Whether in component library mode, returns local HTML file when true                            |
+| `localIndexHtml`  | `string`   | `'index.html'`   | -        | Local HTML file path (only used when isLib=true)                                                |
+| `debug`           | `boolean`  | `false`          | -        | Whether to enable debug logging                                                                 |
+
+## How It Works
+
+### 1. Proxy Configuration
+
+The plugin injects `server.proxy` configuration through Vite's `config` hook, proxying all requests to the target server.
+
+### 2. HTML Processing
+
+When detecting a browser page navigation request and the response is HTML:
+
+- Removes remote `type="module" crossorigin` script tags
+- Removes remote `crossorigin` stylesheet link tags
+- Inserts local development script entry
+
+### 3. Cookie Rewriting
+
+Automatically removes `Secure`, `Domain`, and `SameSite` attributes from cookies to ensure proper functioning in the local development environment.
+
+### 4. Redirect Handling
+
+- Replaces remote domain names in redirect URLs with local domain names
+- Fixes protocol mismatch issues (https://localhost -> http://localhost)
+
+## Debugging
+
+Enable the `debug` option to view detailed logs:
+
+```js
+viteDevProxy({
+  appHost: "example.com",
+  debug: true,
+});
+```
+
+Log output example:
+
+```
+vite-plugin-dev-proxy: staticPrefix /dev/static
+vite-plugin-dev-proxy: scriptCssPrefix /static/global
+Proxy request: /admin/index (5ms)
+HTML processed: /admin/index (23ms)
+Bypass proxy: /static/js/app.js
+Redirect handled: https://example.com/login -> http://localhost:3003/login (3ms)
+```
+
+## TypeScript Support
+
+This plugin is written in TypeScript and provides full type definitions. You can import types for better development experience:
+
+```typescript
+import viteDevProxy, { ProxyOptions } from "vite-plugin-dev-proxy";
+
+const config: ProxyOptions = {
+  appHost: "example.com",
+  https: true,
+  debug: true,
+};
+
+export default defineConfig({
+  plugins: [viteDevProxy(config)],
+});
+```
+
+## Notes
+
+1. `appHost` is a required parameter, not providing it will throw an error
+2. The plugin will override `server.proxy` configuration in `vite.config.js`
+3. Ensure the local development server port matches the port in redirect handling
+4. Use `scriptCssPrefix` to precisely control which remote scripts and stylesheets to remove
+
+## Requirements
+
+- Vite 5.0+
+- Node.js 18+
+
+## License
+
+MIT © [aiwa](https://cnlhb.github.io/blog/)
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Issues
+
+If you encounter any issues, please report them on [GitHub Issues](https://github.com/CNLHB/vite-plugin-dev-proxy/issues).

package/dist/index.cjs

@@ -0,0 +1,236 @@
+'use strict';
+
+const zlib = require('zlib');
+const path = require('path');
+const fs = require('fs');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const zlib__default = /*#__PURE__*/_interopDefaultCompat(zlib);
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+function createProxyConfig(options) {
+  const {
+    https = true,
+    appHost = "",
+    isLib = false,
+    localIndexHtml = "index.html",
+    staticPrefix = "",
+    bypassPrefixes = ["/static"],
+    // scriptCssPrefix = "",
+    developmentAgentOccupancy = "",
+    clearScriptCssPrefixes = "",
+    entry = "/src/main.js",
+    debug = false
+  } = options;
+  if (!appHost) {
+    throw new Error("vite-plugin-dev-proxy: appHost is required");
+  }
+  if (!Array.isArray(bypassPrefixes)) {
+    throw new Error("vite-plugin-dev-proxy: bypassPrefixes must be an array");
+  }
+  const log = debug ? console.log : () => {
+  };
+  const logError = debug ? console.error : () => {
+  };
+  const normalizedStaticPrefix = staticPrefix.endsWith("/") ? staticPrefix.slice(0, -1) : staticPrefix;
+  log("vite-plugin-dev-proxy: staticPrefix", normalizedStaticPrefix);
+  const fullEntry = normalizedStaticPrefix + entry;
+  const scriptLinkRegex = /<(?:script[^>]*>.*?<\/script>|link[^>]*>)/g;
+  const assetRegex = /\.(js|mjs|ts|tsx|jsx|css|scss|sass|less|vue|json|woff2?|ttf|eot|ico|png|jpe?g|gif|svg|webp)(\?.*)?$/i;
+  const staticPathRegex = /^\/(static|assets|public|images|css|js)\//i;
+  const bypassRegex = /\.(vue|js|mjs|ts|tsx|jsx|css|scss|sass|less|json|png|jpe?g|gif|svg|webp|ico|woff2?|ttf|eot)$/i;
+  return {
+    "/": {
+      target: `${https ? "https" : "http"}://${appHost}`,
+      changeOrigin: true,
+      secure: false,
+      cookieDomainRewrite: { "*": "localhost" },
+      selfHandleResponse: true,
+      configure: (proxy, options2) => {
+        const rewriteCookies = (headers) => {
+          const setCookie = headers["set-cookie"];
+          if (setCookie) {
+            headers["set-cookie"] = setCookie.map((cookie) => {
+              let rewrittenCookie = cookie.replace(/;\s*secure\s*(;|$)/gi, "$1").replace(/;\s*domain\s*=[^;]+(;|$)/gi, "$1").replace(/;\s*samesite\s*=[^;]+(;|$)/gi, "$1").replace(/;+/g, ";").replace(/;\s*$/g, "");
+              log("vite-plugin-dev-proxy: rewrittenCookie", rewrittenCookie);
+              return rewrittenCookie;
+            });
+          }
+          return headers;
+        };
+        proxy.on(
+          "proxyRes",
+          (proxyRes, req, res) => {
+            const startTime = Date.now();
+            const contentType = proxyRes.headers["content-type"] || "";
+            const redirectUrl = proxyRes.headers.location;
+            const requestUrl = req.url || "";
+            const acceptHeader = req.headers.accept || "";
+            const isRedirect = proxyRes.statusCode >= 300 && proxyRes.statusCode < 400 && redirectUrl;
+            if (isRedirect) {
+              const host = req.headers.host;
+              const regex = new RegExp(appHost, "gi");
+              let location = redirectUrl.replace(regex, host || "");
+              location = location.replace(
+                /https:\/\/(localhost|127\.0\.0\.1)(:\d+)?/gi,
+                "http://$1$2"
+              );
+              const headers2 = rewriteCookies({ ...proxyRes.headers });
+              headers2.location = location;
+              res.writeHead(proxyRes.statusCode, headers2);
+              res.end();
+              log(
+                `Redirect handled: ${redirectUrl} -> ${location} (${Date.now() - startTime}ms)`
+              );
+              return;
+            }
+            const isNavigationRequest = acceptHeader.includes("text/html");
+            const isAssetRequest = assetRegex.test(requestUrl);
+            const isStaticPath = staticPathRegex.test(requestUrl);
+            const shouldProcessHtml = contentType.includes("text/html") && isNavigationRequest && !isAssetRequest && !isStaticPath && !isRedirect;
+            if (shouldProcessHtml) {
+              if (isLib) {
+                try {
+                  const indexHtml = fs__default.readFileSync(
+                    path.resolve(__dirname, localIndexHtml),
+                    "utf-8"
+                  );
+                  res.writeHead(200, {
+                    "Content-Type": "text/html; charset=utf-8"
+                  });
+                  res.end(indexHtml);
+                  log(
+                    `Local HTML served: ${localIndexHtml}\uFF09 (${Date.now() - startTime}ms)`
+                  );
+                } catch (err) {
+                  logError("Failed to read local HTML:", err);
+                  res.writeHead(500);
+                  res.end("Failed to read local HTML");
+                }
+                return;
+              }
+              const encoding = proxyRes.headers["content-encoding"];
+              const chunks = [];
+              proxyRes.on(
+                "data",
+                (chunk) => {
+                  if (chunk) {
+                    chunks.push(chunk);
+                  }
+                }
+              );
+              proxyRes.on("end", () => {
+                try {
+                  let buffer = Buffer.concat(chunks);
+                  const decompress = () => {
+                    if (encoding === "gzip") {
+                      return zlib__default.gunzipSync(buffer);
+                    } else if (encoding === "deflate") {
+                      return zlib__default.inflateSync(buffer);
+                    } else if (encoding === "br") {
+                      return zlib__default.brotliDecompressSync(buffer);
+                    }
+                    return buffer;
+                  };
+                  const decompressed = decompress();
+                  let html = decompressed.toString("utf-8");
+                  if (developmentAgentOccupancy) {
+                    html = html.replace(
+                      developmentAgentOccupancy,
+                      `<script crossorigin type="module" src="${fullEntry}"><\/script>`
+                    );
+                  } else {
+                    html = html.replace(
+                      /<div[^>]*id=["']app["'][^>]*><\/div>/g,
+                      (match) => `${match}<script crossorigin type="module" src="${fullEntry}"><\/script>`
+                    );
+                  }
+                  clearScriptCssPrefixes;
+                  html = html.replace(scriptLinkRegex, (match) => {
+                    const srcMatch = match.match(/src="([^"]+)"/i);
+                    const hrefMatch = match.match(/href="([^"]+)"/i);
+                    const srcOrHref = srcMatch ? srcMatch[1] : hrefMatch ? hrefMatch[1] : null;
+                    if (typeof clearScriptCssPrefixes === "string") {
+                      if (srcOrHref?.startsWith(clearScriptCssPrefixes)) {
+                        return "";
+                      }
+                    }
+                    if (Array.isArray(clearScriptCssPrefixes)) {
+                      if (clearScriptCssPrefixes.some(
+                        (prefix) => srcOrHref?.startsWith(prefix)
+                      )) {
+                        return "";
+                      }
+                    }
+                    if (clearScriptCssPrefixes instanceof RegExp) {
+                      return clearScriptCssPrefixes.test(match) ? "" : match;
+                    }
+                    if (typeof clearScriptCssPrefixes === "function") {
+                      return clearScriptCssPrefixes(match) ? "" : match;
+                    }
+                    return match;
+                  });
+                  if (html.indexOf(fullEntry) === -1) {
+                    html = html.replace(
+                      /<!--\sS 公共组件 提示信息\s-->/g,
+                      `<script crossorigin type="module" src="${fullEntry}"><\/script>`
+                    );
+                  }
+                  const headers2 = rewriteCookies({ ...proxyRes.headers });
+                  headers2["content-type"] = "text/html; charset=utf-8";
+                  delete headers2["content-encoding"];
+                  delete headers2["content-length"];
+                  res.writeHead(200, headers2);
+                  res.end(html);
+                  log(
+                    `HTML processed: ${requestUrl} (${Date.now() - startTime}ms)`
+                  );
+                } catch (err) {
+                  logError("Decompress error:", err);
+                  logError("Request URL:", requestUrl);
+                  logError("Response headers:", proxyRes.headers);
+                  res.writeHead(500);
+                  res.end("Decompress error");
+                }
+              });
+              return;
+            }
+            const headers = rewriteCookies({ ...proxyRes.headers });
+            res.writeHead(proxyRes.statusCode, headers);
+            proxyRes.pipe(res);
+            log(`Proxy request: ${requestUrl} (${Date.now() - startTime}ms)`);
+          }
+        );
+      },
+      bypass: (req) => {
+        const url = req.url || "";
+        const pathname = url.split("?")[0];
+        if ((normalizedStaticPrefix && url.startsWith(`${normalizedStaticPrefix}`) || url.startsWith("/@") || url.startsWith("/src") || url.startsWith("/node_modules") || url.includes(".hot-update.") || url === "/" || bypassRegex.test(pathname)) && !bypassPrefixes.some((prefix) => url.startsWith(prefix))) {
+          log(`Bypass proxy: ${url}`);
+          return url;
+        }
+      }
+    }
+  };
+}
+function viteDevProxy(options = {}) {
+  return {
+    name: "vite-plugin-dev-proxy",
+    config: (viteConfig) => {
+      const pluginProxy = createProxyConfig(options);
+      const existingProxy = viteConfig.server?.proxy || {};
+      const mergedProxy = {
+        ...existingProxy,
+        ...pluginProxy
+      };
+      return {
+        server: {
+          proxy: mergedProxy
+        }
+      };
+    }
+  };
+}
+
+module.exports = viteDevProxy;

package/dist/index.d.cts

@@ -0,0 +1,17 @@
+import { Plugin } from 'vite';
+
+interface ProxyOptions {
+    https?: boolean;
+    appHost?: string;
+    isLib?: boolean;
+    localIndexHtml?: string;
+    staticPrefix?: string;
+    bypassPrefixes?: string[];
+    clearScriptCssPrefixes?: string | string[] | Function | RegExp;
+    developmentAgentOccupancy?: string;
+    entry?: string;
+    debug?: boolean;
+}
+declare function viteDevProxy(options?: ProxyOptions): Plugin;
+
+export { viteDevProxy as default };

package/dist/index.d.mts

@@ -0,0 +1,17 @@
+import { Plugin } from 'vite';
+
+interface ProxyOptions {
+    https?: boolean;
+    appHost?: string;
+    isLib?: boolean;
+    localIndexHtml?: string;
+    staticPrefix?: string;
+    bypassPrefixes?: string[];
+    clearScriptCssPrefixes?: string | string[] | Function | RegExp;
+    developmentAgentOccupancy?: string;
+    entry?: string;
+    debug?: boolean;
+}
+declare function viteDevProxy(options?: ProxyOptions): Plugin;
+
+export { viteDevProxy as default };

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { Plugin } from 'vite';
+
+interface ProxyOptions {
+    https?: boolean;
+    appHost?: string;
+    isLib?: boolean;
+    localIndexHtml?: string;
+    staticPrefix?: string;
+    bypassPrefixes?: string[];
+    clearScriptCssPrefixes?: string | string[] | Function | RegExp;
+    developmentAgentOccupancy?: string;
+    entry?: string;
+    debug?: boolean;
+}
+declare function viteDevProxy(options?: ProxyOptions): Plugin;
+
+export { viteDevProxy as default };

package/dist/index.mjs

@@ -0,0 +1,229 @@
+import zlib from 'zlib';
+import { resolve } from 'path';
+import fs from 'fs';
+
+function createProxyConfig(options) {
+  const {
+    https = true,
+    appHost = "",
+    isLib = false,
+    localIndexHtml = "index.html",
+    staticPrefix = "",
+    bypassPrefixes = ["/static"],
+    // scriptCssPrefix = "",
+    developmentAgentOccupancy = "",
+    clearScriptCssPrefixes = "",
+    entry = "/src/main.js",
+    debug = false
+  } = options;
+  if (!appHost) {
+    throw new Error("vite-plugin-dev-proxy: appHost is required");
+  }
+  if (!Array.isArray(bypassPrefixes)) {
+    throw new Error("vite-plugin-dev-proxy: bypassPrefixes must be an array");
+  }
+  const log = debug ? console.log : () => {
+  };
+  const logError = debug ? console.error : () => {
+  };
+  const normalizedStaticPrefix = staticPrefix.endsWith("/") ? staticPrefix.slice(0, -1) : staticPrefix;
+  log("vite-plugin-dev-proxy: staticPrefix", normalizedStaticPrefix);
+  const fullEntry = normalizedStaticPrefix + entry;
+  const scriptLinkRegex = /<(?:script[^>]*>.*?<\/script>|link[^>]*>)/g;
+  const assetRegex = /\.(js|mjs|ts|tsx|jsx|css|scss|sass|less|vue|json|woff2?|ttf|eot|ico|png|jpe?g|gif|svg|webp)(\?.*)?$/i;
+  const staticPathRegex = /^\/(static|assets|public|images|css|js)\//i;
+  const bypassRegex = /\.(vue|js|mjs|ts|tsx|jsx|css|scss|sass|less|json|png|jpe?g|gif|svg|webp|ico|woff2?|ttf|eot)$/i;
+  return {
+    "/": {
+      target: `${https ? "https" : "http"}://${appHost}`,
+      changeOrigin: true,
+      secure: false,
+      cookieDomainRewrite: { "*": "localhost" },
+      selfHandleResponse: true,
+      configure: (proxy, options2) => {
+        const rewriteCookies = (headers) => {
+          const setCookie = headers["set-cookie"];
+          if (setCookie) {
+            headers["set-cookie"] = setCookie.map((cookie) => {
+              let rewrittenCookie = cookie.replace(/;\s*secure\s*(;|$)/gi, "$1").replace(/;\s*domain\s*=[^;]+(;|$)/gi, "$1").replace(/;\s*samesite\s*=[^;]+(;|$)/gi, "$1").replace(/;+/g, ";").replace(/;\s*$/g, "");
+              log("vite-plugin-dev-proxy: rewrittenCookie", rewrittenCookie);
+              return rewrittenCookie;
+            });
+          }
+          return headers;
+        };
+        proxy.on(
+          "proxyRes",
+          (proxyRes, req, res) => {
+            const startTime = Date.now();
+            const contentType = proxyRes.headers["content-type"] || "";
+            const redirectUrl = proxyRes.headers.location;
+            const requestUrl = req.url || "";
+            const acceptHeader = req.headers.accept || "";
+            const isRedirect = proxyRes.statusCode >= 300 && proxyRes.statusCode < 400 && redirectUrl;
+            if (isRedirect) {
+              const host = req.headers.host;
+              const regex = new RegExp(appHost, "gi");
+              let location = redirectUrl.replace(regex, host || "");
+              location = location.replace(
+                /https:\/\/(localhost|127\.0\.0\.1)(:\d+)?/gi,
+                "http://$1$2"
+              );
+              const headers2 = rewriteCookies({ ...proxyRes.headers });
+              headers2.location = location;
+              res.writeHead(proxyRes.statusCode, headers2);
+              res.end();
+              log(
+                `Redirect handled: ${redirectUrl} -> ${location} (${Date.now() - startTime}ms)`
+              );
+              return;
+            }
+            const isNavigationRequest = acceptHeader.includes("text/html");
+            const isAssetRequest = assetRegex.test(requestUrl);
+            const isStaticPath = staticPathRegex.test(requestUrl);
+            const shouldProcessHtml = contentType.includes("text/html") && isNavigationRequest && !isAssetRequest && !isStaticPath && !isRedirect;
+            if (shouldProcessHtml) {
+              if (isLib) {
+                try {
+                  const indexHtml = fs.readFileSync(
+                    resolve(__dirname, localIndexHtml),
+                    "utf-8"
+                  );
+                  res.writeHead(200, {
+                    "Content-Type": "text/html; charset=utf-8"
+                  });
+                  res.end(indexHtml);
+                  log(
+                    `Local HTML served: ${localIndexHtml}\uFF09 (${Date.now() - startTime}ms)`
+                  );
+                } catch (err) {
+                  logError("Failed to read local HTML:", err);
+                  res.writeHead(500);
+                  res.end("Failed to read local HTML");
+                }
+                return;
+              }
+              const encoding = proxyRes.headers["content-encoding"];
+              const chunks = [];
+              proxyRes.on(
+                "data",
+                (chunk) => {
+                  if (chunk) {
+                    chunks.push(chunk);
+                  }
+                }
+              );
+              proxyRes.on("end", () => {
+                try {
+                  let buffer = Buffer.concat(chunks);
+                  const decompress = () => {
+                    if (encoding === "gzip") {
+                      return zlib.gunzipSync(buffer);
+                    } else if (encoding === "deflate") {
+                      return zlib.inflateSync(buffer);
+                    } else if (encoding === "br") {
+                      return zlib.brotliDecompressSync(buffer);
+                    }
+                    return buffer;
+                  };
+                  const decompressed = decompress();
+                  let html = decompressed.toString("utf-8");
+                  if (developmentAgentOccupancy) {
+                    html = html.replace(
+                      developmentAgentOccupancy,
+                      `<script crossorigin type="module" src="${fullEntry}"><\/script>`
+                    );
+                  } else {
+                    html = html.replace(
+                      /<div[^>]*id=["']app["'][^>]*><\/div>/g,
+                      (match) => `${match}<script crossorigin type="module" src="${fullEntry}"><\/script>`
+                    );
+                  }
+                  clearScriptCssPrefixes;
+                  html = html.replace(scriptLinkRegex, (match) => {
+                    const srcMatch = match.match(/src="([^"]+)"/i);
+                    const hrefMatch = match.match(/href="([^"]+)"/i);
+                    const srcOrHref = srcMatch ? srcMatch[1] : hrefMatch ? hrefMatch[1] : null;
+                    if (typeof clearScriptCssPrefixes === "string") {
+                      if (srcOrHref?.startsWith(clearScriptCssPrefixes)) {
+                        return "";
+                      }
+                    }
+                    if (Array.isArray(clearScriptCssPrefixes)) {
+                      if (clearScriptCssPrefixes.some(
+                        (prefix) => srcOrHref?.startsWith(prefix)
+                      )) {
+                        return "";
+                      }
+                    }
+                    if (clearScriptCssPrefixes instanceof RegExp) {
+                      return clearScriptCssPrefixes.test(match) ? "" : match;
+                    }
+                    if (typeof clearScriptCssPrefixes === "function") {
+                      return clearScriptCssPrefixes(match) ? "" : match;
+                    }
+                    return match;
+                  });
+                  if (html.indexOf(fullEntry) === -1) {
+                    html = html.replace(
+                      /<!--\sS 公共组件 提示信息\s-->/g,
+                      `<script crossorigin type="module" src="${fullEntry}"><\/script>`
+                    );
+                  }
+                  const headers2 = rewriteCookies({ ...proxyRes.headers });
+                  headers2["content-type"] = "text/html; charset=utf-8";
+                  delete headers2["content-encoding"];
+                  delete headers2["content-length"];
+                  res.writeHead(200, headers2);
+                  res.end(html);
+                  log(
+                    `HTML processed: ${requestUrl} (${Date.now() - startTime}ms)`
+                  );
+                } catch (err) {
+                  logError("Decompress error:", err);
+                  logError("Request URL:", requestUrl);
+                  logError("Response headers:", proxyRes.headers);
+                  res.writeHead(500);
+                  res.end("Decompress error");
+                }
+              });
+              return;
+            }
+            const headers = rewriteCookies({ ...proxyRes.headers });
+            res.writeHead(proxyRes.statusCode, headers);
+            proxyRes.pipe(res);
+            log(`Proxy request: ${requestUrl} (${Date.now() - startTime}ms)`);
+          }
+        );
+      },
+      bypass: (req) => {
+        const url = req.url || "";
+        const pathname = url.split("?")[0];
+        if ((normalizedStaticPrefix && url.startsWith(`${normalizedStaticPrefix}`) || url.startsWith("/@") || url.startsWith("/src") || url.startsWith("/node_modules") || url.includes(".hot-update.") || url === "/" || bypassRegex.test(pathname)) && !bypassPrefixes.some((prefix) => url.startsWith(prefix))) {
+          log(`Bypass proxy: ${url}`);
+          return url;
+        }
+      }
+    }
+  };
+}
+function viteDevProxy(options = {}) {
+  return {
+    name: "vite-plugin-dev-proxy",
+    config: (viteConfig) => {
+      const pluginProxy = createProxyConfig(options);
+      const existingProxy = viteConfig.server?.proxy || {};
+      const mergedProxy = {
+        ...existingProxy,
+        ...pluginProxy
+      };
+      return {
+        server: {
+          proxy: mergedProxy
+        }
+      };
+    }
+  };
+}
+
+export { viteDevProxy as default };

package/package.json

@@ -0,0 +1,56 @@
+{
+	"name": "@xysfe/vite-plugin-dev-proxy",
+	"version": "1.0.0",
+	"description": "A Vite plugin for development environment proxy that automatically proxies remote server requests and handles HTML responses",
+	"files": [
+		"dist"
+	],
+	"type": "module",
+	"main": "./dist/index.mjs",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"require": {
+				"types": "./dist/index.d.cts",
+				"default": "./dist/index.cjs"
+			},
+			"import": {
+				"types": "./dist/index.d.mts",
+				"default": "./dist/index.mjs"
+			},
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.mjs"
+		}
+	},
+	"scripts": {
+		"build": "npx unbuild",
+		"prepack": "npm run build"
+	},
+	"repository": {
+		"type": "git",
+		"url": ""
+	},
+	"keywords": [
+		"vite",
+		"vite-plugin",
+		"proxy",
+		"dev-proxy",
+		"development",
+		"html-proxy",
+		"cookie",
+		"redirect"
+	],
+	"author": "aiwa",
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"devDependencies": {
+		"@types/node": "^20.11.5",
+		"typescript": "^5.3.3",
+		"unbuild": "^2.0.0",
+		"vite": "^5.0.12"
+	},
+	"packageManager": "pnpm"
+}