@gylautorun/dev-proxy-cookie 1.0.0 → 1.0.2

package/dist/index.js

@@ -36,13 +36,12 @@ __export(index_exports, {
   createAutoProxyConfig: () => createAutoProxyConfig,
   createAutoProxyCookie: () => createAutoProxyCookie,
   createCookieGetter: () => createCookieGetter,
-  createDevProxyCookie: () => createDevProxyCookie,
   createFileCookieGetter: () => createFileCookieGetter,
   createVueProxyConfig: () => createVueProxyConfig,
-  getViteMajorVersion: () => getViteMajorVersion,
-  getViteVersion: () => getViteVersion,
-  viteAutoProxyCookie: () => viteAutoProxyCookie,
-  viteDevProxyCookie: () => viteDevProxyCookie,
+  detectProductionEnvironment: () => detectProductionEnvironment,
+  isProductionValue: () => isProductionValue,
+  shouldEnableWatch: () => shouldEnableWatch,
+  viteMiddlewareProxy: () => viteMiddlewareProxy,
   watchCookieFile: () => watchCookieFile
 });
 module.exports = __toCommonJS(index_exports);
@@ -57,26 +56,62 @@ var import_http_proxy = __toESM(require("http-proxy"));
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var CookieReader = class {
-  constructor(options) {
+  /**
+   * 构造函数
+   * @param options - 配置选项
+   * @param debug - 是否启用调试模式
+   */
+  constructor(options, debug = false) {
     this.options = {
       encoding: "utf-8",
       ...options
     };
+    this.debug = debug;
   }
+  /**
+   * 读取 Cookie 文件内容
+   * 
+   * 支持过滤注释行（以 # 开头）和空行，将有效行用分号连接。
+   * 
+   * @returns Cookie 字符串
+   */
   readCookie() {
     try {
       const filePath = path.resolve(this.options.cookieFile);
+      if (this.debug) {
+        console.log("[CookieReader] Resolved cookie file path:", filePath);
+        console.log("[CookieReader] File exists:", fs.existsSync(filePath));
+      }
       if (fs.existsSync(filePath)) {
         const content = fs.readFileSync(filePath, this.options.encoding || "utf-8");
+        if (this.debug) {
+          console.log("[CookieReader] File content length:", content.length);
+        }
         const lines = content.split("\n");
         const cookieLines = lines.map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
-        return cookieLines.join("; ");
+        const result = cookieLines.join("; ");
+        if (this.debug) {
+          console.log("[CookieReader] Parsed cookie:", result ? "(has cookie)" : "(empty)");
+        }
+        return result;
+      }
+      if (this.debug) {
+        console.log("[CookieReader] Cookie file not found:", filePath);
       }
       return "";
-    } catch {
+    } catch (err) {
+      if (this.debug) {
+        console.error("[CookieReader] Error reading cookie file:", err.message);
+      }
       return "";
     }
   }
+  /**
+   * 确保 Cookie 文件存在
+   * 
+   * 如果文件不存在，会自动创建空文件。
+   * 如果父目录不存在，会自动创建目录。
+   */
   ensureCookieFile() {
     const filePath = path.resolve(this.options.cookieFile);
     const dir = path.dirname(filePath);
@@ -97,9 +132,20 @@ function createCookieGetter(cookieFile) {
 var path2 = __toESM(require("path"));
 var import_chokidar = __toESM(require("chokidar"));
 var CookieWatcher = class {
+  /**
+   * 构造函数
+   * @param options - 配置选项
+   */
   constructor(options) {
+    /** 文件监听器实例 */
     this.watcher = null;
+    /** 上次读取的 Cookie 内容 */
     this.lastContent = "";
+    /**
+     * 文件变化处理函数
+     * 
+     * 读取新的 Cookie 内容，如果与上次不同则触发回调。
+     */
     this.handleChange = () => {
       const newContent = this.cookieReader.readCookie();
       if (newContent !== this.lastContent) {
@@ -114,6 +160,9 @@ var CookieWatcher = class {
     };
     this.cookieReader = new CookieReader({ cookieFile: options.cookieFile });
   }
+  /**
+   * 启动文件监听
+   */
   start() {
     if (this.options.autoCreateFile) {
       this.cookieReader.ensureCookieFile();
@@ -139,6 +188,9 @@ var CookieWatcher = class {
       this.options.onError?.(error);
     }
   }
+  /**
+   * 停止文件监听
+   */
   stop() {
     if (this.watcher) {
       this.watcher.close();
@@ -146,6 +198,10 @@ var CookieWatcher = class {
       console.log(`[CookieWatcher] Stopped watching: ${this.options.cookieFile}`);
     }
   }
+  /**
+   * 获取当前 Cookie 值
+   * @returns 当前 Cookie 字符串
+   */
   getCurrentCookie() {
     return this.lastContent;
   }
@@ -160,21 +216,145 @@ function watchCookieFile(cookieFile, onCookieChange, onError) {
   return watcher;
 }
 
+// src/utils/env-detector.ts
+function isProductionValue(value) {
+  const productionValues = [
+    "production",
+    // 生产环境
+    "prod",
+    // 生产环境
+    "prd",
+    // 生产环境
+    "release",
+    // 发布环境
+    "staging",
+    // 预发布环境
+    "uat"
+    // 预发布环境
+  ];
+  return productionValues.includes(value.toLowerCase().trim());
+}
+function detectProductionEnvironment(customEnvs = [], debug = false, loggerPrefix = "[env-detector]") {
+  const env = process.env;
+  if (customEnvs.length > 0) {
+    for (const envName of customEnvs) {
+      const envValue = env[envName];
+      if (envValue && isProductionValue(envValue)) {
+        if (debug) {
+          console.log(`${loggerPrefix} Detected production via custom env: ${envName}=${envValue}`);
+        }
+        return true;
+      }
+    }
+  }
+  const commonEnvNames = [
+    "NODE_ENV",
+    "BUILD_MODE",
+    "VUE_APP_ENV",
+    "VITE_NODE_ENV",
+    "WEBPACK_MODE",
+    "CI_ENV",
+    "APP_ENV",
+    "ENV",
+    "DEPLOY_ENV",
+    "RUN_MODE"
+  ];
+  for (const envName of commonEnvNames) {
+    const envValue = env[envName];
+    if (envValue && isProductionValue(envValue)) {
+      if (debug) {
+        console.log(`${loggerPrefix} Detected production via env: ${envName}=${envValue}`);
+      }
+      return true;
+    }
+  }
+  if (env.CI === "true" || env.CI === "1" || env.CI === "yes") {
+    if (debug) {
+      console.log(`${loggerPrefix} Detected production via CI env`);
+    }
+    return true;
+  }
+  if (env.npm_lifecycle_event) {
+    const lifecycleEvent = env.npm_lifecycle_event.toLowerCase();
+    if (lifecycleEvent.includes("build") || lifecycleEvent.includes("prod") || lifecycleEvent.includes("prd") || lifecycleEvent.includes("release")) {
+      if (debug) {
+        console.log(`${loggerPrefix} Detected production via lifecycle event: ${env.npm_lifecycle_event}`);
+      }
+      return true;
+    }
+  }
+  const processArgs = process.argv.join("").toLowerCase();
+  if (processArgs.includes("build") || processArgs.includes("production") || processArgs.includes("--mode=production") || processArgs.includes("--prod") || processArgs.includes("--release")) {
+    if (debug) {
+      console.log(`${loggerPrefix} Detected production via process arguments`);
+    }
+    return true;
+  }
+  return false;
+}
+function shouldEnableWatch(watch, customEnvs = [], debug = false, loggerPrefix = "[env-detector]") {
+  if (typeof watch === "boolean") {
+    if (debug && !watch) {
+      console.log(`${loggerPrefix} Watch disabled by user setting`);
+    }
+    return watch;
+  }
+  const isProduction = detectProductionEnvironment(customEnvs, debug, loggerPrefix);
+  if (isProduction) {
+    if (debug) {
+      console.log(`${loggerPrefix} Auto-detected production mode - disabling watch`);
+    }
+    return false;
+  }
+  if (debug) {
+    console.log(`${loggerPrefix} Auto-detected development mode - enabling watch`);
+  }
+  return true;
+}
+
 // src/proxy/apply-dev-cookie-header.ts
 function applyDevCookieHeader(proxyReq, cookie) {
-  if (!cookie) return;
+  console.log("[applyDevCookieHeader] === START ===");
+  console.log("[applyDevCookieHeader] Cookie to apply:", cookie ? `(length: ${cookie.length})` : "(empty)");
+  if (!cookie) {
+    console.log("[applyDevCookieHeader] Cookie is empty, returning");
+    console.log("[applyDevCookieHeader] === END ===");
+    return;
+  }
+  const existingCookie = proxyReq.getHeader?.("Cookie");
+  console.log("[applyDevCookieHeader] Cookie current:", existingCookie ? `(length: ${String(existingCookie).length})` : "(none)");
+  if (existingCookie === cookie) {
+    console.log("[applyDevCookieHeader] Cookie is already set, skipping");
+    console.log("[applyDevCookieHeader] === END ===");
+    return;
+  }
   proxyReq.removeHeader("cookie");
   proxyReq.removeHeader("Cookie");
   proxyReq.setHeader("Cookie", cookie);
+  const newCookie = proxyReq.getHeader?.("Cookie");
+  console.log("[applyDevCookieHeader] Cookie new:", newCookie ? `(length: ${String(newCookie).length})` : "(failed)");
+  console.log("[applyDevCookieHeader] === END ===");
 }
 
 // src/proxy/core.ts
 var AutoProxyCookie = class {
+  /**
+   * 构造函数
+   * @param options - 配置选项
+   */
   constructor(options) {
+    /** 当前 Cookie 值 */
     this.currentCookie = "";
+    /** Vite 开发服务器实例 */
     this.server = null;
+    /** HTTP 代理服务器实例 */
     this.proxyServer = null;
+    /** Cookie 文件监听器 */
     this.watcher = null;
+    /**
+     * Cookie 变化处理函数
+     * @param newCookie - 新的 Cookie 值
+     */
     this.handleCookieChange = (newCookie) => {
       if (newCookie !== this.currentCookie) {
         this.currentCookie = newCookie;
@@ -190,9 +370,23 @@ var AutoProxyCookie = class {
         }
       }
     };
+    /**
+     * 代理请求处理函数
+     * @param proxyReq - 代理请求对象
+     * @param req - 原始请求对象
+     * @param res - 响应对象
+     * @param _options - 服务器选项
+     */
     this.handleOnProxyReq = (proxyReq, req, res, _options) => {
+      console.log("[AutoProxyCookie] === handleOnProxyReq START ===");
+      console.log("[AutoProxyCookie] Request URL:", req.method, req.url);
+      console.log("[AutoProxyCookie] Current cookie:", this.currentCookie ? `(length: ${this.currentCookie.length})` : "(empty)");
       if (this.currentCookie) {
+        console.log("[AutoProxyCookie] Applying cookie header...");
         applyDevCookieHeader(proxyReq, this.currentCookie);
+        console.log("[AutoProxyCookie] Cookie header applied successfully");
+      } else {
+        console.log("[AutoProxyCookie] No cookie to apply - currentCookie is empty!");
       }
       this.log("debug", "[AutoProxyCookie] Proxy Request:", req.method, req.url);
       if (this.options.hooks.onProxyReq) {
@@ -202,7 +396,14 @@ var AutoProxyCookie = class {
           this.log("error", "[AutoProxyCookie] onProxyReq hook error:", err.message);
         }
       }
+      console.log("[AutoProxyCookie] === handleOnProxyReq END ===");
     };
+    /**
+     * 代理响应处理函数
+     * @param proxyRes - 代理响应对象
+     * @param req - 原始请求对象
+     * @param res - 响应对象
+     */
     this.handleOnProxyRes = (proxyRes, req, res) => {
       const allowedHeaders = [
         "Content-Type",
@@ -226,6 +427,12 @@ var AutoProxyCookie = class {
         }
       }
     };
+    /**
+     * HTTP 代理错误处理函数
+     * @param err - 错误对象
+     * @param req - 请求对象
+     * @param res - 响应对象或 Socket
+     */
     this.handleOnError = (err, req, res) => {
       this.log("error", "[AutoProxyCookie] Proxy Error:", err.message);
       this.log("error", "[AutoProxyCookie] URL:", req.url);
@@ -245,6 +452,12 @@ var AutoProxyCookie = class {
         }
       }
     };
+    /**
+     * WebSocket 代理错误处理函数
+     * @param err - 错误对象
+     * @param req - 请求对象
+     * @param socket - WebSocket 连接的 Socket
+     */
     this.handleOnWsError = (err, req, socket) => {
       this.log("error", "[AutoProxyCookie] WebSocket Proxy Error:", err.message);
       this.log("error", "[AutoProxyCookie] WebSocket URL:", req.url);
@@ -281,6 +494,7 @@ var AutoProxyCookie = class {
       autoRestart: false,
       restartMarkerFile: ".cookie-restart-marker",
       proxyMap: {},
+      proxyPaths: [],
       ignorePaths: [],
       ws: true,
       changeOrigin: true,
@@ -294,27 +508,60 @@ var AutoProxyCookie = class {
       headers: {},
       ...mergedOptions
     };
-    this.cookieReader = new CookieReader({ cookieFile: options.cookieFile });
+    this.cookieReader = new CookieReader({ cookieFile: options.cookieFile }, options.debug ?? false);
   }
+  /**
+   * 根据请求路径获取代理目标 URL
+   * @param req - HTTP 请求对象
+   * @returns 代理目标 URL
+   */
   getProxyUrl(req) {
-    const pathname = req.url?.split("?")[0] || "/";
+    const fullUrl = req.url || "/";
+    const pathname = new URL(fullUrl, "http://localhost").pathname;
     const proxyMap = this.options.proxyMap || {};
+    const proxyPaths = this.options.proxyPaths || [];
+    this.log("debug", "[AutoProxyCookie] getProxyUrl - Request path:", pathname);
+    this.log("debug", "[AutoProxyCookie] getProxyUrl - Available proxyMap paths:", Object.keys(proxyMap));
+    this.log("debug", "[AutoProxyCookie] getProxyUrl - Available proxyPaths:", proxyPaths);
     for (const [prefix, target] of Object.entries(proxyMap)) {
-      if (pathname.startsWith(prefix)) {
+      const matches = pathname.startsWith(prefix);
+      this.log("debug", "[AutoProxyCookie] getProxyUrl - Checking proxyMap:", prefix, "- matches:", matches);
+      if (matches) {
+        this.log("debug", "[AutoProxyCookie] getProxyUrl - Matched proxyMap:", prefix, "->", target);
         return target;
       }
     }
+    for (const prefix of proxyPaths) {
+      const matches = pathname.startsWith(prefix);
+      this.log("debug", "[AutoProxyCookie] getProxyUrl - Checking proxyPaths:", prefix, "- matches:", matches);
+      if (matches) {
+        this.log("debug", "[AutoProxyCookie] getProxyUrl - Matched proxyPaths:", prefix, "->", this.options.target);
+        return this.options.target;
+      }
+    }
+    this.log("debug", "[AutoProxyCookie] getProxyUrl - No match found, using default target:", this.options.target);
     return this.options.target;
   }
+  /**
+   * 判断路径是否应该被忽略（不代理）
+   * @param pathname - 请求路径
+   * @returns 是否忽略
+   */
   isIgnoredPath(pathname) {
     const ignorePaths = this.options.ignorePaths || [];
     return ignorePaths.some(
       (ignored) => pathname.startsWith(ignored)
     );
   }
+  /**
+   * 日志输出函数
+   * @param level - 日志级别
+   * @param args - 日志参数
+   */
   log(level, ...args) {
     const levels = { debug: 0, info: 1, warn: 2, error: 3 };
-    const currentLevel = levels[this.options.logLevel || "info"];
+    const effectiveLogLevel = this.options.debug ? "debug" : this.options.logLevel || "info";
+    const currentLevel = levels[effectiveLogLevel];
     const msgLevel = levels[level];
     if (msgLevel >= currentLevel) {
       if (level === "error") {
@@ -326,6 +573,11 @@ var AutoProxyCookie = class {
       }
     }
   }
+  /**
+   * 创建代理服务器配置选项
+   * @param target - 代理目标地址
+   * @returns 代理服务器配置
+   */
   createProxyOptions(target) {
     const {
       ws,
@@ -354,6 +606,10 @@ var AutoProxyCookie = class {
       ignorePath: false
     };
   }
+  /**
+   * 初始化代理中间件
+   * @param server - Vite 开发服务器实例
+   */
   async setup(server) {
     this.server = server;
     this.currentCookie = this.cookieReader.readCookie();
@@ -381,25 +637,42 @@ var AutoProxyCookie = class {
       this.log("warn", "[AutoProxyCookie] http-proxy create failed, using basic mode:", err.message);
     }
     server.middlewares.use((req, res, next) => {
-      const pathname = new URL(req.url || "/", "http://localhost").pathname;
+      const fullUrl = req.url || "/";
+      const pathname = new URL(fullUrl, "http://localhost").pathname;
+      console.log("[AutoProxyCookie] === Incoming Request ===");
+      console.log("[AutoProxyCookie] Method:", req.method);
+      console.log("[AutoProxyCookie] Full URL:", fullUrl);
+      console.log("[AutoProxyCookie] Pathname:", pathname);
+      console.log("[AutoProxyCookie] Headers:", JSON.stringify(req.headers, null, 2));
       if (this.isIgnoredPath(pathname)) {
+        console.log("[AutoProxyCookie] Path ignored, passing to next middleware");
         next();
         return;
       }
       this.currentCookie = this.cookieReader.readCookie();
+      console.log("[AutoProxyCookie] Current cookie:", this.currentCookie ? `(length: ${this.currentCookie.length})` : "(empty)");
+      if (this.currentCookie) {
+        console.log("[AutoProxyCookie] Cookie preview:", this.currentCookie);
+      }
+      const proxyMapKeys = Object.keys(this.options.proxyMap || {});
+      const proxyPaths = this.options.proxyPaths || [];
+      const allProxyPrefixes = [...proxyMapKeys, ...proxyPaths];
+      const matched = allProxyPrefixes.some((prefix) => pathname.startsWith(prefix));
+      console.log("[AutoProxyCookie] Path matches proxy rules:", matched);
       if (this.proxyServer) {
         const target = this.getProxyUrl(req);
-        if (this.options.debug || this.options.logLevel === "debug") {
-          this.log("info", `[AutoProxyCookie] ${pathname} -> ${target}`);
-        }
+        console.log(`[AutoProxyCookie] Proxying ${req.method} ${pathname} -> ${target}`);
         const proxyOptions = this.createProxyOptions(target);
         try {
+          console.log("[AutoProxyCookie] Calling proxyServer.web...");
           this.proxyServer.web(req, res, proxyOptions);
+          console.log("[AutoProxyCookie] proxyServer.web called successfully");
         } catch (err) {
-          this.log("error", "[AutoProxyCookie] Proxy web error:", err.message);
+          console.error("[AutoProxyCookie] Proxy web error:", err.message);
           next(err);
         }
       } else {
+        console.log("[AutoProxyCookie] No proxy server, passing to next middleware");
         next();
       }
     });
@@ -431,15 +704,37 @@ var AutoProxyCookie = class {
       this.log("info", "[AutoProxyCookie] WebSocket support enabled");
     }
   }
+  /**
+   * 启动 Cookie 文件监听
+   */
   startFileWatch() {
-    this.watcher = watchCookieFile(
-      this.options.cookieFile,
-      this.handleCookieChange,
-      (error) => {
-        this.log("error", "[AutoProxyCookie] File watch error:", error.message);
+    let shouldWatch;
+    if (this.options.isDev !== void 0) {
+      shouldWatch = this.options.isDev;
+      if (this.options.debug) {
+        console.log(`[AutoProxyCookie] isDev=${this.options.isDev}, ${shouldWatch ? "enabling" : "disabling"} watch`);
       }
-    );
+    } else {
+      shouldWatch = true;
+      if (this.options.debug) {
+        console.log("[AutoProxyCookie] Default behavior: enabling watch (dev mode)");
+      }
+    }
+    if (shouldWatch) {
+      this.watcher = watchCookieFile(
+        this.options.cookieFile,
+        this.handleCookieChange,
+        (error) => {
+          this.log("error", "[AutoProxyCookie] File watch error:", error.message);
+        }
+      );
+    } else if (this.options.debug) {
+      console.log("[AutoProxyCookie] File watch disabled");
+    }
   }
+  /**
+   * 停止代理服务
+   */
   stop() {
     if (this.watcher) {
       this.watcher.stop();
@@ -451,6 +746,10 @@ var AutoProxyCookie = class {
     }
     this.log("info", "[AutoProxyCookie] Stopped");
   }
+  /**
+   * 获取当前 Cookie 值
+   * @returns 当前 Cookie 字符串
+   */
   getCurrentCookie() {
     return this.currentCookie;
   }
@@ -459,77 +758,80 @@ function createAutoProxyCookie(options) {
   return new AutoProxyCookie(options);
 }
 
-// src/proxy/vite-plugin.ts
-function viteAutoProxyCookie(options) {
-  const {
-    name = "vite-auto-proxy-cookie",
-    ...autoProxyOptions
-  } = options;
-  let autoProxy = null;
-  return {
-    name,
-    apply: "serve",
-    async configureServer(server) {
-      autoProxy = createAutoProxyCookie({
-        ...autoProxyOptions,
-        debug: options.debug ?? false,
-        autoRestart: options.autoRestart ?? true
-      });
-      try {
-        await autoProxy.setup(server);
-      } catch (error) {
-        console.error("[vite-auto-proxy-cookie] Failed to setup proxy:", error);
-        if (options.debug) {
-          console.log("[vite-auto-proxy-cookie] Falling back to middleware mode");
-        }
-      }
-    },
-    closeBundle() {
-      autoProxy?.stop();
+// src/proxy/vite-middleware-plugin.ts
+function isIgnoredPath(pathname, ignorePaths) {
+  return ignorePaths.some((ignored) => pathname.startsWith(ignored));
+}
+function shouldProxy(pathname, proxyPrefixes) {
+  return proxyPrefixes.some((prefix) => pathname.startsWith(prefix));
+}
+function getProxyTarget(pathname, proxyMap, defaultTarget) {
+  for (const [prefix, target] of Object.entries(proxyMap)) {
+    if (pathname.startsWith(prefix)) {
+      return target;
     }
-  };
+  }
+  return defaultTarget;
 }
-
-// src/proxy/vite-cookie-plugin.ts
-function viteDevProxyCookie(options) {
-  const { cookieFile, debug = false, onCookieChange } = options;
-  let watcher = null;
-  let currentCookie = "";
-  const cookieReader = new CookieReader({ cookieFile });
+function viteMiddlewareProxy(options) {
+  const {
+    cookieFile,
+    target,
+    debug = false,
+    proxyMap = {},
+    proxyPaths = [],
+    ignorePaths = []
+  } = options;
+  const cookieReader = new CookieReader({ cookieFile }, debug);
+  let currentCookie = cookieReader.readCookie();
+  const allProxyPrefixes = [
+    ...Object.keys(proxyMap),
+    ...proxyPaths
+  ];
   return {
-    name: "vite-dev-proxy-cookie",
+    name: "vite-middleware-proxy",
     apply: "serve",
     configureServer(server) {
-      currentCookie = cookieReader.readCookie();
+      const httpProxy2 = require("http-proxy");
+      const proxyServer = httpProxy2.createProxyServer({});
       if (debug) {
-        console.log("[vite-dev-proxy-cookie] Initial cookie loaded");
-      }
-      const middlewares = server.middlewares || server._middlewares || server.app;
-      if (middlewares && typeof middlewares.use === "function") {
-        middlewares.use((req, _res, next) => {
-          if (currentCookie && req.url?.startsWith("/")) {
-            req.headers = req.headers || {};
-            req.headers["cookie"] = currentCookie;
+        console.log("[ViteMiddlewareProxy] Watching cookie file:", cookieFile);
+      }
+      server.middlewares.use((req, res, next) => {
+        const pathname = new URL(req.url || "/", "http://localhost").pathname;
+        if (isIgnoredPath(pathname, ignorePaths)) {
+          if (debug) {
+            console.log("[ViteMiddlewareProxy] Ignoring:", pathname);
           }
           next();
-        });
-      } else {
-        console.warn("[vite-dev-proxy-cookie] Could not access middleware stack, cookie injection disabled");
-      }
-      watcher = watchCookieFile(
-        cookieFile,
-        (newCookie) => {
-          currentCookie = newCookie;
-          onCookieChange?.(newCookie);
-          console.log("[vite-dev-proxy-cookie] Cookie changed, please restart server for full effect");
-        },
-        (error) => {
-          console.error("[vite-dev-proxy-cookie] Watch error:", error.message);
+          return;
         }
-      );
-    },
-    closeBundle() {
-      watcher?.stop();
+        if (!shouldProxy(pathname, allProxyPrefixes)) {
+          next();
+          return;
+        }
+        const proxyTarget = getProxyTarget(pathname, proxyMap, target);
+        if (debug) {
+          console.log("[ViteMiddlewareProxy] Proxying:", req.method, pathname, "->", proxyTarget);
+        }
+        currentCookie = cookieReader.readCookie();
+        if (currentCookie) {
+          if (debug) {
+            console.log("[ViteMiddlewareProxy] Injecting cookie:", `(length: ${currentCookie.length})`);
+          }
+          req.headers["cookie"] = currentCookie;
+          req.headers["Cookie"] = currentCookie;
+        }
+        proxyServer.web(req, res, {
+          target: proxyTarget,
+          changeOrigin: true,
+          secure: false,
+          ignorePath: false
+        });
+      });
+      proxyServer.on("error", (err, req) => {
+        console.error("[ViteMiddlewareProxy] Proxy error:", err.message, "for", req.url);
+      });
     }
   };
 }
@@ -569,9 +871,23 @@ function createVueProxyConfig(target, options = {}) {
   return config;
 }
 function createFileCookieGetter(cookieFile, options = {}) {
-  const { watch = true, debug = false } = options;
-  const reader = new CookieReader({ cookieFile: path4.resolve(cookieFile) });
-  if (watch) {
+  const {
+    watch = "auto",
+    debug = true,
+    productionEnvs = [],
+    isDev
+  } = options;
+  const reader = new CookieReader({ cookieFile: path4.resolve(cookieFile) }, debug);
+  let shouldWatch;
+  if (isDev !== void 0) {
+    shouldWatch = isDev;
+    if (debug) {
+      console.log(`[CookieFile] isDev=${isDev}, ${shouldWatch ? "enabling" : "disabling"} watch`);
+    }
+  } else {
+    shouldWatch = shouldEnableWatch(watch, productionEnvs, debug, "[CookieFile]");
+  }
+  if (shouldWatch) {
     watchCookieFile(
       path4.resolve(cookieFile),
       (newCookie) => {
@@ -583,6 +899,8 @@ function createFileCookieGetter(cookieFile, options = {}) {
         console.error("[CookieFile] Watch error:", error.message);
       }
     );
+  } else if (debug) {
+    console.log("[CookieFile] File watch disabled");
   }
   return () => reader.readCookie();
 }
@@ -624,57 +942,6 @@ function createAutoProxyConfig(options) {
   }
   return result;
 }
-
-// src/proxy/vite-adapter.ts
-var viteVersion = "";
-var majorVersion = null;
-function detectViteVersion() {
-  if (majorVersion !== null) {
-    return majorVersion;
-  }
-  try {
-    const pkg = require("vite/package.json");
-    viteVersion = pkg.version;
-    majorVersion = parseInt(viteVersion.split(".")[0], 10);
-  } catch {
-    majorVersion = 5;
-  }
-  return majorVersion;
-}
-function createDevProxyCookie(options) {
-  const {
-    mode = "auto",
-    ...restOptions
-  } = options;
-  const version = detectViteVersion();
-  if (options.debug) {
-    console.log(`[dev-proxy-cookie] Detected Vite ${version}.x`);
-  }
-  if (mode === "cookie" || mode === "auto" && !options.target) {
-    return viteDevProxyCookie({
-      cookieFile: options.cookieFile,
-      debug: options.debug,
-      onCookieChange: options.onCookieChange
-    });
-  }
-  const pluginOptions = {
-    cookieFile: options.cookieFile,
-    target: options.target,
-    debug: options.debug,
-    autoRestart: options.autoRestart ?? true,
-    restartMarkerFile: options.restartMarkerFile,
-    proxyMap: options.proxyMap,
-    ignorePaths: options.ignorePaths
-  };
-  return viteAutoProxyCookie(pluginOptions);
-}
-function getViteVersion() {
-  detectViteVersion();
-  return viteVersion;
-}
-function getViteMajorVersion() {
-  return detectViteVersion();
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AutoProxyCookie,
@@ -683,12 +950,11 @@ function getViteMajorVersion() {
   createAutoProxyConfig,
   createAutoProxyCookie,
   createCookieGetter,
-  createDevProxyCookie,
   createFileCookieGetter,
   createVueProxyConfig,
-  getViteMajorVersion,
-  getViteVersion,
-  viteAutoProxyCookie,
-  viteDevProxyCookie,
+  detectProductionEnvironment,
+  isProductionValue,
+  shouldEnableWatch,
+  viteMiddlewareProxy,
   watchCookieFile
 });