@gylautorun/dev-proxy-cookie 1.0.0-beta.1

package/src/proxy/vite-cookie-plugin.ts

@@ -0,0 +1,94 @@
+import type { Plugin, ViteDevServer } from 'vite';
+import { CookieReader, watchCookieFile, shouldEnableWatch } from '../utils';
+
+export interface ViteDevProxyCookieOptions {
+  cookieFile: string;
+  debug?: boolean;
+  onCookieChange?: (cookie: string) => void;
+  /**
+   * 是否监听文件变化
+   * - true: 始终监听
+   * - false: 从不监听
+   * - 'auto': 根据环境自动判断（默认）
+   * @default 'auto'
+   */
+  watch?: boolean | 'auto';
+  /**
+   * 是否为开发环境（优先级最高）
+   * 设置此参数后，将直接决定是否启用文件监听：
+   * - true: 启用监听（开发模式）
+   * - false: 禁用监听（生产模式）
+   * 
+   * 使用示例: isDev: process.env.NODE_ENV === 'development'
+   */
+  isDev?: boolean;
+}
+
+export function viteDevProxyCookie(options: ViteDevProxyCookieOptions): Plugin {
+  const { cookieFile, debug = false, onCookieChange, watch = 'auto', isDev } = options;
+  let watcher: any = null;
+  let currentCookie: string = '';
+
+  const cookieReader = new CookieReader({ cookieFile });
+
+  return {
+    name: 'vite-dev-proxy-cookie',
+    apply: 'serve',
+
+    configureServer(server: ViteDevServer) {
+      currentCookie = cookieReader.readCookie();
+      if (debug) {
+        console.log('[vite-dev-proxy-cookie] Initial cookie loaded');
+      }
+
+      const middlewares = server.middlewares || 
+        (server as any)._middlewares || 
+        (server as any).app;
+
+      if (middlewares && typeof middlewares.use === 'function') {
+        middlewares.use((req: any, _res: any, next: any) => {
+          if (currentCookie && req.url?.startsWith('/')) {
+            req.headers = req.headers || {};
+            req.headers['cookie'] = currentCookie;
+          }
+          next();
+        });
+      } else {
+        console.warn('[vite-dev-proxy-cookie] Could not access middleware stack, cookie injection disabled');
+      }
+
+      // 判断是否应该启用监听
+      // isDev 参数优先级最高
+      let shouldWatch: boolean;
+      
+      if (isDev !== undefined) {
+        shouldWatch = isDev;
+        if (debug) {
+          console.log(`[vite-dev-proxy-cookie] isDev=${isDev}, ${shouldWatch ? 'enabling' : 'disabling'} watch`);
+        }
+      } else {
+        shouldWatch = shouldEnableWatch(watch, [], debug, '[vite-dev-proxy-cookie]');
+      }
+      
+      if (shouldWatch) {
+        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);
+          }
+        );
+      } else if (debug) {
+        console.log('[vite-dev-proxy-cookie] File watch disabled');
+      }
+    },
+
+    closeBundle() {
+      watcher?.stop();
+    },
+  };
+}

package/src/proxy/vite-plugin.ts

@@ -0,0 +1,66 @@
+import type { Plugin, ViteDevServer } from 'vite';
+import { AutoProxyCookie, createAutoProxyCookie, type AutoProxyCookieOptions } from './core';
+
+export interface ViteAutoProxyCookiePluginOptions extends AutoProxyCookieOptions {
+  name?: string;
+  /**
+   * 是否为开发环境（优先级最高）
+   * 设置此参数后，将直接决定是否启用文件监听：
+   * - true: 启用监听（开发模式）
+   * - false: 禁用监听（生产模式）
+   * 
+   * 使用示例: isDev: process.env.NODE_ENV === 'development'
+   */
+  isDev?: boolean;
+}
+
+function getHttpServer(server: ViteDevServer): any {
+  if ('httpServer' in server && server.httpServer) {
+    return server.httpServer;
+  }
+  if ('_server' in server && server._server) {
+    return server._server;
+  }
+  return null;
+}
+
+export function viteAutoProxyCookie(options: ViteAutoProxyCookiePluginOptions): Plugin {
+  const {
+    name = 'vite-auto-proxy-cookie',
+    isDev,
+    ...autoProxyOptions
+  } = options;
+
+  let autoProxy: AutoProxyCookie | null = null;
+
+  return {
+    name,
+    apply: 'serve',
+
+    async configureServer(server: ViteDevServer) {
+      autoProxy = createAutoProxyCookie({
+        ...autoProxyOptions,
+        debug: options.debug ?? false,
+        autoRestart: options.autoRestart ?? true,
+        isDev,
+      });
+
+      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();
+    },
+  };
+}
+
+export { AutoProxyCookie, createAutoProxyCookie };
+export type { AutoProxyCookieOptions };

package/src/proxy/vue-proxy-config.ts

@@ -0,0 +1,192 @@
+import type { IncomingMessage } from 'http';
+import * as path from 'path';
+import { CookieReader, watchCookieFile, shouldEnableWatch } from '../utils';
+import { applyDevCookieHeader } from './apply-dev-cookie-header';
+
+/** Options for {@link createFileCookieGetter}. */
+export interface CreateFileCookieGetterOptions {
+  /**
+   * 是否监听文件变化
+   * - true: 始终监听
+   * - false: 从不监听
+   * - 'auto': 根据环境自动判断（默认）
+   * 
+   * Cookie 值每次代理请求时都会从磁盘读取，因此即使 watch 为 false，
+   * 修改 cookie 文件后也不需要重启开发服务器。
+   * @default 'auto'
+   */
+  watch?: boolean | 'auto';
+  /** Log when the cookie file changes (only if `watch` is true). @default false */
+  debug?: boolean;
+  /** 
+   * 自定义生产环境变量名称列表，用于判断是否禁用监听
+   * 例如: ['MY_APP_ENV', 'BUILD_TYPE']
+   */
+  productionEnvs?: string[];
+  /**
+   * 是否为开发环境（优先级最高）
+   * 设置此参数后，将直接决定是否启用文件监听：
+   * - true: 启用监听（开发模式）
+   * - false: 禁用监听（生产模式）
+   * 
+   * 使用示例: isDev: process.env.NODE_ENV === 'development'
+   */
+  isDev?: boolean;
+}
+
+export interface VueProxyConfigOptions {
+  getCookie?: () => string;
+  debug?: boolean;
+  headers?: Record<string, string>;
+  ws?: boolean;
+  changeOrigin?: boolean;
+  secure?: boolean;
+  onError?: (err: Error) => void;
+}
+
+export interface ProxyConfig {
+  ws: boolean;
+  target: string;
+  changeOrigin: boolean;
+  secure: boolean;
+  onProxyReq: (proxyReq: any, req: IncomingMessage) => void;
+  onProxyRes?: (proxyRes: any, req: IncomingMessage) => void;
+  onError: (err: Error) => void;
+  headers?: Record<string, string>;
+}
+
+export function createVueProxyConfig(
+  target: string,
+  options: VueProxyConfigOptions = {}
+): ProxyConfig {
+  const {
+    getCookie,
+    debug = false,
+    headers = {},
+    ws = false,
+    changeOrigin = true,
+    secure = false,
+    onError: customOnError,
+  } = options;
+
+  const config: ProxyConfig = {
+    ws,
+    target,
+    changeOrigin,
+    secure,
+    headers,
+    onProxyReq: (proxyReq: any, req: IncomingMessage) => {
+      const cookie = getCookie ? getCookie() : '';
+      if (cookie) {
+        applyDevCookieHeader(proxyReq, cookie);
+      }
+      if (debug) {
+        const reqPath = req.url || '/';
+        console.log('[Proxy Request]', reqPath, req.method, cookie ? '(with cookie)' : '(no cookie)');
+      }
+    },
+    onError: customOnError || ((err: Error) => {
+      console.error('\n[Proxy Error]', err.message);
+    }),
+  };
+
+  return config;
+}
+
+export function createFileCookieGetter(
+  cookieFile: string,
+  options: CreateFileCookieGetterOptions = {}
+): () => string {
+  const { 
+    watch = 'auto', 
+    debug = false,
+    productionEnvs = [],
+    isDev 
+  } = options;
+  const reader = new CookieReader({ cookieFile: path.resolve(cookieFile) });
+
+  // 判断是否应该启用监听
+  // isDev 参数优先级最高，直接决定是否启用监听
+  let shouldWatch: boolean;
+  
+  if (isDev !== undefined) {
+    // 用户显式设置了 isDev 参数
+    shouldWatch = isDev;
+    if (debug) {
+      console.log(`[CookieFile] isDev=${isDev}, ${shouldWatch ? 'enabling' : 'disabling'} watch`);
+    }
+  } else {
+    // 使用智能环境检测
+    shouldWatch = shouldEnableWatch(watch, productionEnvs, debug, '[CookieFile]');
+  }
+  
+  if (shouldWatch) {
+    watchCookieFile(
+      path.resolve(cookieFile),
+      (newCookie) => {
+        if (debug) {
+          console.log('[CookieFile] Updated:', newCookie ? '(has cookie)' : '(empty)');
+        }
+      },
+      (error) => {
+        console.error('[CookieFile] Watch error:', error.message);
+      }
+    );
+  } else if (debug) {
+    console.log('[CookieFile] File watch disabled');
+  }
+
+  return () => reader.readCookie();
+}
+
+export interface AutoProxyConfigOptions extends VueProxyConfigOptions {
+  target: string;
+  ignorePaths?: string[];
+  includePaths?: string[];
+  additionalProxies?: Record<string, string>;
+}
+
+export function createAutoProxyConfig(options: AutoProxyConfigOptions): Record<string, ProxyConfig> {
+  const { target, ignorePaths = [], includePaths = [], additionalProxies = {}, getCookie, debug, headers } = options;
+
+  const result: Record<string, ProxyConfig> = {};
+
+  if (includePaths.length > 0) {
+    for (const proxyPath of includePaths) {
+      result[proxyPath] = createVueProxyConfig(target, { getCookie, debug, headers });
+    }
+  } else {
+    const defaultProxy: ProxyConfig = {
+      ws: false,
+      target,
+      changeOrigin: true,
+      secure: false,
+      headers,
+      onProxyReq: (proxyReq: any, req: IncomingMessage) => {
+        const reqPath = req.url || '/';
+
+        if (ignorePaths.some(p => reqPath.startsWith(p))) {
+          return;
+        }
+
+        const cookie = getCookie ? getCookie() : '';
+        if (cookie) {
+          applyDevCookieHeader(proxyReq, cookie);
+        }
+        if (debug) {
+          console.log('[Proxy Request]', reqPath, req.method, cookie ? '(with cookie)' : '(no cookie)');
+        }
+      },
+      onError: (err: Error) => {
+        console.error('\n[Proxy Error]', err.message);
+      },
+    };
+    result['/'] = defaultProxy;
+  }
+
+  for (const [proxyPath, proxyTarget] of Object.entries(additionalProxies)) {
+    result[proxyPath] = createVueProxyConfig(proxyTarget, { getCookie, debug, headers });
+  }
+
+  return result;
+}

package/src/utils/cookie-reader.ts

@@ -0,0 +1,54 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface CookieReaderOptions {
+  cookieFile: string;
+  encoding?: BufferEncoding;
+}
+
+export class CookieReader {
+  protected options: CookieReaderOptions;
+
+  constructor(options: CookieReaderOptions) {
+    this.options = {
+      encoding: 'utf-8',
+      ...options,
+    };
+  }
+
+  readCookie(): string {
+    try {
+      const filePath = path.resolve(this.options.cookieFile);
+      if (fs.existsSync(filePath)) {
+        const content = fs.readFileSync(filePath, this.options.encoding || 'utf-8');
+        // 过滤注释行（以 # 开头）和空行，然后合并成一行
+        const lines = content.split('\n');
+        const cookieLines = lines
+          .map(line => line.trim())
+          .filter(line => line && !line.startsWith('#'));
+        return cookieLines.join('; ');
+      }
+      return '';
+    } catch {
+      return '';
+    }
+  }
+
+  ensureCookieFile(): void {
+    const filePath = path.resolve(this.options.cookieFile);
+    const dir = path.dirname(filePath);
+    
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    
+    if (!fs.existsSync(filePath)) {
+      fs.writeFileSync(filePath, '');
+    }
+  }
+}
+
+export function createCookieGetter(cookieFile: string): () => string {
+  const reader = new CookieReader({ cookieFile });
+  return () => reader.readCookie();
+}

package/src/utils/cookie-watcher.ts

@@ -0,0 +1,91 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import chokidar, { FSWatcher } from 'chokidar';
+import { CookieReader } from './cookie-reader';
+
+export interface CookieWatcherOptions {
+  cookieFile: string;
+  onCookieChange: (cookie: string) => void;
+  onError?: (error: Error) => void;
+  autoCreateFile?: boolean;
+}
+
+export class CookieWatcher {
+  private watcher: FSWatcher | null = null;
+  private options: CookieWatcherOptions;
+  private cookieReader: CookieReader;
+  private lastContent: string = '';
+
+  constructor(options: CookieWatcherOptions) {
+    this.options = {
+      autoCreateFile: true,
+      ...options,
+    };
+    this.cookieReader = new CookieReader({ cookieFile: options.cookieFile });
+  }
+
+  private handleChange = (): void => {
+    const newContent = this.cookieReader.readCookie();
+    if (newContent !== this.lastContent) {
+      this.lastContent = newContent;
+      this.options.onCookieChange(newContent);
+      console.log(`[CookieWatcher] Cookie updated from file: ${this.options.cookieFile}`);
+    }
+  };
+
+  start(): void {
+    if (this.options.autoCreateFile) {
+      this.cookieReader.ensureCookieFile();
+    }
+
+    const watchPath = path.resolve(this.options.cookieFile);
+    this.lastContent = this.cookieReader.readCookie();
+    console.log(`[CookieWatcher] Started watching: ${watchPath}`);
+
+    try {
+      this.watcher = chokidar.watch(watchPath, {
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+          stabilityThreshold: 100,
+          pollInterval: 50,
+        },
+      });
+
+      // "add" covers atomic replace (unlink + rename) used by some editors; "change" covers in-place writes
+      this.watcher.on('change', this.handleChange);
+      this.watcher.on('add', this.handleChange);
+      this.watcher.on('error', (error) => {
+        this.options.onError?.(error);
+      });
+    } catch (error) {
+      this.options.onError?.(error as Error);
+    }
+  }
+
+  stop(): void {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+      console.log(`[CookieWatcher] Stopped watching: ${this.options.cookieFile}`);
+    }
+  }
+
+  getCurrentCookie(): string {
+    return this.lastContent;
+  }
+}
+
+export function watchCookieFile(
+  cookieFile: string,
+  onCookieChange: (cookie: string) => void,
+  onError?: (error: Error) => void
+): CookieWatcher {
+  const watcher = new CookieWatcher({
+    cookieFile,
+    onCookieChange,
+    onError,
+  });
+  watcher.start();
+  return watcher;
+}

package/src/utils/env-detector.ts

@@ -0,0 +1,155 @@
+/**
+ * 环境检测工具函数
+ * 用于智能判断当前是否为生产构建环境
+ */
+
+/**
+ * 判断环境变量值是否表示生产环境
+ */
+export function isProductionValue(value: string): boolean {
+  const productionValues = [
+    'production', // 生产环境
+    'prod', // 生产环境
+    'prd', // 生产环境
+    'release', // 发布环境
+    'staging', // 预发布环境
+    'uat', // 预发布环境
+  ];
+  return productionValues.includes(value.toLowerCase().trim());
+}
+
+/**
+ * 智能检测当前是否为生产构建环境
+ * 通过多种方式综合判断，避免依赖单一环境变量
+ * 
+ * @param customEnvs 用户自定义的环境变量名称列表
+ * @param debug 是否输出调试日志
+ * @param loggerPrefix 日志前缀，用于区分不同模块
+ * @returns 是否为生产环境
+ */
+export function detectProductionEnvironment(
+  customEnvs: string[] = [],
+  debug: boolean = false,
+  loggerPrefix: string = '[env-detector]'
+): boolean {
+  const env = process.env;
+  
+  // 1. 检查自定义环境变量
+  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;
+      }
+    }
+  }
+
+  // 2. 检查常见的环境变量
+  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;
+    }
+  }
+
+  // 3. 检查 CI/CD 环境标识
+  if (env.CI === 'true' || env.CI === '1' || env.CI === 'yes') {
+    if (debug) {
+      console.log(`${loggerPrefix} Detected production via CI env`);
+    }
+    return true;
+  }
+
+  // 4. 检查 npm 生命周期事件（构建命令）
+  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;
+    }
+  }
+
+  // 5. 检查进程参数（构建工具通常会传入特定参数）
+  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;
+}
+
+/**
+ * 判断是否应该启用文件监听
+ * 
+ * 注意：此函数仅在 isDev 参数未设置时调用，用于智能判断环境
+ * 如果用户已通过 isDev 参数明确指定环境，则不会调用此函数
+ * 
+ * @param watch 用户设置的 watch 选项
+ * @param customEnvs 用户自定义的环境变量列表
+ * @param debug 是否输出调试日志
+ * @param loggerPrefix 日志前缀
+ * @returns 是否应该启用监听
+ */
+export function shouldEnableWatch(
+  watch: boolean | 'auto',
+  customEnvs: string[] = [],
+  debug: boolean = false,
+  loggerPrefix: string = '[env-detector]'
+): boolean {
+  // 用户显式设置为 true 或 false，直接返回
+  if (typeof watch === 'boolean') {
+    if (debug && !watch) {
+      console.log(`${loggerPrefix} Watch disabled by user setting`);
+    }
+    return watch;
+  }
+
+  // 'auto' 模式：智能检测环境
+  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;
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './cookie-reader';
+export * from './cookie-watcher';
+export * from './env-detector';