whistle.mock-plugins 1.0.6-beta.1 → 1.0.6-beta.2

package/lib/rules-server.js

@@ -1,547 +1,284 @@
+// 引入必要的模块
 const fs = require('fs-extra');
 const path = require('path');
 const url = require('url');
-const storage = require('./storage');
 
 // 数据存储目录
-const DATA_DIR = path.join(process.env.WHISTLE_PLUGIN_DATA_DIR || storage.DATA_DIR);
-// 接口配置文件
-const INTERFACES_FILE = path.join(DATA_DIR, 'interfaces.json');
-// 添加功能模块配置文件
+const DATA_DIR = process.env.WHISTLE_PLUGIN_DATA_DIR || path.join(process.env.HOME || process.env.USERPROFILE, '.whistle.mock-plugin');
 const FEATURES_FILE = path.join(DATA_DIR, 'features.json');
+const INTERFACES_FILE = path.join(DATA_DIR, 'interfaces.json');
 
-// 配置项
+// 缓存控制
 const CONFIG = {
-  // 日志级别：0=NONE, 1=ERROR, 2=WARN, 3=INFO, 4=DEBUG
-  LOG_LEVEL: process.env.MOCK_PLUGIN_LOG_LEVEL || 3,
   // 缓存有效期（毫秒），默认 60 秒
-  CACHE_INTERVAL: process.env.MOCK_PLUGIN_CACHE_INTERVAL || 60000,
-  // 是否在控制台输出详细日志
-  VERBOSE_CONSOLE: process.env.MOCK_PLUGIN_VERBOSE === 'true'
+  CACHE_INTERVAL: process.env.MOCK_PLUGIN_CACHE_INTERVAL || 60000
 };
 
 // 缓存控制变量
 let enabledInterfacesCache = null; // 仅缓存启用状态的接口
 let cacheTime = 0;
-let cacheVersion = 1;
-
-// 正则表达式缓存
-const regexCache = new Map();
-
-// 记录日志
-const log = (message, level = 3) => {
-  // 只记录小于等于当前日志级别的日志
-  if (level <= CONFIG.LOG_LEVEL) {
-    const prefix = level === 1 ? '[ERROR] ' : 
-                   level === 2 ? '[WARN] ' : 
-                   level === 4 ? '[DEBUG] ' : '';
-    
-    console.log(`[mock-plugin:rulesServer] ${prefix}${message}`);
-  }
-};
-
-// 错误日志
-const logError = (message) => log(message, 1);
-
-// 警告日志
-const logWarn = (message) => log(message, 2);
 
-// 信息日志
-const logInfo = (message) => log(message, 3);
-
-// 调试日志
-const logDebug = (message) => log(message, 4);
-
-// 获取文件最后修改时间
-const getFileModTime = (filePath) => {
-  try {
-    const stats = fs.statSync(filePath);
-    return stats.mtimeMs;
-  } catch (err) {
-    return 0;
+/**
+ * 生成随机值
+ * @param {string} pattern 模式
+ * @returns {string} 生成的值
+ */
+const generateRandomValue = (pattern) => {
+  // 如果不是以@开头的模式，直接返回原值
+  if (!pattern || !pattern.startsWith('@')) {
+    return pattern;
   }
+  
+  const formatPattern = pattern.substring(1); // 去掉@前缀
+  // 使用单次正则替换优化性能
+  return formatPattern.replace(/x/g, () => {
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    return chars.charAt(Math.floor(Math.random() * chars.length));
+  });
 };
 
-// 加载所有启用的接口（整合了功能模块和接口的加载逻辑）
-const loadEnabledInterfaces = () => {
+/**
+ * 验证目标URL是否有效
+ * @param {string} url 要验证的URL
+ * @returns {boolean} URL是否有效
+ */
+const isValidTargetUrl = (url) => {
+  if (!url) return false;
+  
   try {
-    const currentTime = Date.now();
-    const interfacesFileModTime = getFileModTime(INTERFACES_FILE);
-    const featuresFileModTime = getFileModTime(FEATURES_FILE);
-    
-    // 取两个文件的最后修改时间的最大值
-    const lastModTime = Math.max(interfacesFileModTime, featuresFileModTime);
-    
-    // 如果缓存有效且文件未被修改，直接返回缓存
-    if (enabledInterfacesCache && 
-        currentTime - cacheTime < CONFIG.CACHE_INTERVAL && 
-        lastModTime <= cacheTime) {
-      logDebug('使用已启用接口的缓存');
-      return enabledInterfacesCache;
-    }
-    
-    logDebug('缓存无效或文件已修改，重新加载接口');
-    
-    // 1. 读取并解析所有功能模块
-    let enabledFeatureIds = [];
-    if (fs.existsSync(FEATURES_FILE)) {
-      try {
-        const featuresData = fs.readJsonSync(FEATURES_FILE);
-        let features = [];
-        
-        if (featuresData && Array.isArray(featuresData)) {
-          features = featuresData;
-        } else if (featuresData && featuresData.features && Array.isArray(featuresData.features)) {
-          features = featuresData.features;
-        }
-        
-        // 过滤出启用状态的功能ID
-        enabledFeatureIds = features
-          .filter(feature => feature.active === true)
-          .map(feature => feature.id);
-        
-        logDebug(`找到 ${enabledFeatureIds.length} 个启用的功能模块`);
-      } catch (err) {
-        logError(`读取功能模块失败: ${err.message}`);
-      }
-    }
-    
-    // 2. 读取并解析所有接口
-    let enabledInterfaces = [];
-    if (fs.existsSync(INTERFACES_FILE)) {
-      try {
-        const interfacesData = fs.readJsonSync(INTERFACES_FILE);
-        let interfaces = [];
-        
-        if (interfacesData && Array.isArray(interfacesData)) {
-          interfaces = interfacesData;
-        } else if (interfacesData && interfacesData.interfaces && Array.isArray(interfacesData.interfaces)) {
-          interfaces = interfacesData.interfaces;
-        }
-        
-        // 过滤出启用状态的接口
-        enabledInterfaces = interfaces.filter(intf => {
-          // 首先检查接口本身是否启用
-          const isInterfaceEnabled = intf.active !== false; // 默认为true
-          
-          if (!isInterfaceEnabled) {
-            return false;
-          }
-          
-          // 如果接口有关联功能，检查功能是否启用
-          if (intf.featureId) {
-            return enabledFeatureIds.includes(intf.featureId);
-          }
-          
-          // 如果接口没有关联功能，只要接口本身启用就可以
-          return true;
-        });
-        
-        logInfo(`找到 ${enabledInterfaces.length} 个启用的接口`);
-      } catch (err) {
-        logError(`读取接口配置失败: ${err.message}`);
-      }
-    }
-    
-    // 更新缓存
-    enabledInterfacesCache = enabledInterfaces;
-    cacheTime = currentTime;
-    
-    return enabledInterfaces;
+    // 检查URL是否以http://或https://开头
+    return url.startsWith('http://') || url.startsWith('https://');
   } catch (err) {
-    logError(`加载启用接口失败: ${err.message}`);
-    return enabledInterfacesCache || [];
+    console.error('[isValidTargetUrl] 验证URL出错:', err);
+    return false;
   }
 };
 
-// 匹配URL是否符合模式
-const isUrlMatch = (url, pattern, proxyType, fullUrl) => {
-  if (!pattern) return false;
+/**
+ * 检查URL是否匹配模式
+ * @param {string} url 要检查的URL
+ * @param {string} pattern 匹配模式
+ * @param {string} proxyType 代理类型
+ * @returns {boolean} 是否匹配
+ */
+const isUrlMatch = (url, pattern, proxyType) => {
+  if (!url || !pattern) return false;
   
   try {
-    // 针对不同的代理类型采用不同的匹配策略
-    
-    // 对于url_redirect类型，需要完全匹配fullPath才命中
+    // 对于url_redirect类型，需要完全匹配
     if (proxyType === 'url_redirect') {
-      // 精确匹配完整路径，这是最快的比较方式
-      return pattern === fullUrl;
+      return url === pattern;
     }
     
     // 对于redirect类型，只要url以pattern开头即可命中（前缀匹配）
     if (proxyType === 'redirect') {
-      // 使用字符串原生的startsWith方法更高效
-      return fullUrl.startsWith(pattern);
+      return url.startsWith(pattern);
     }
     
-    // 以下是默认的匹配逻辑（用于response类型等）
-    
-    // 精确匹配 - 最高效的匹配方式
+    // 默认的匹配逻辑（用于response类型等）
+    // 精确匹配
     if (pattern === url) {
       return true;
     }
-
-    // 通配符匹配
-    if (pattern.includes('*')) {
-      // 使用缓存的正则表达式
-      const cacheKey = `wildcard:${pattern}`;
-      let regex = regexCache.get(cacheKey);
-      
-      if (!regex) {
-        // 需要转换为正则表达式，处理特殊字符
-        const regexPattern = pattern
-          .replace(/[-\/\\^$+?.()|[\]{}]/g, '\\$&') // 转义特殊字符
-          .replace(/\*/g, '.*'); // 将 * 替换为 .*
-        
-        regex = new RegExp('^' + regexPattern + '$');
-        regexCache.set(cacheKey, regex);
-      }
-      
+    
+    // 正则表达式
+    if (pattern.startsWith('/') && pattern.length > 2 && pattern.endsWith('/')) {
+      const regex = new RegExp(pattern.slice(1, -1));
       return regex.test(url);
     }
-
-    // 正则表达式匹配
-    if (pattern.startsWith('/') && pattern.length > 2 && pattern.endsWith('/')) {
-      // 使用缓存的正则表达式
-      const cacheKey = `regex:${pattern}`;
-      let regex = regexCache.get(cacheKey);
-      
-      if (!regex) {
-        const regexStr = pattern.slice(1, -1);
-        regex = new RegExp(regexStr);
-        regexCache.set(cacheKey, regex);
-      }
-      
+    
+    // 通配符模式
+    if (pattern.includes('*')) {
+      const regexPattern = pattern
+        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*');
+      const regex = new RegExp(`^${regexPattern}$`);
       return regex.test(url);
     }
+    
+    return false;
   } catch (e) {
-    log(`正则表达式匹配错误: ${e.message}`);
+    console.error('URL匹配检查失败:', e);
+    return false;
   }
-
-  return false;
 };
 
-// 验证目标URL是否有效
-const isValidTargetUrl = (url) => {
-  if (!url) return false;
-  
+/**
+ * 加载启用的接口数据
+ * @returns {Promise<Array>} 启用的接口列表
+ */
+const loadEnabledInterfaces = async () => {
   try {
-    // 检查是否是合法的URL格式
-    new URL(url);
-    return true;
-  } catch (e) {
-    log(`URL验证错误: ${e.message}`);
-    return false;
+    const currentTime = Date.now();
+    
+    // 使用缓存
+    if (enabledInterfacesCache && 
+        currentTime - cacheTime < CONFIG.CACHE_INTERVAL) {
+      return enabledInterfacesCache;
+    }
+    
+    // 从数据管理器获取启用的接口
+    const dataManager = require('./dataManager');
+    const enabledInterfaces = await dataManager.getEnabledInterfaces();
+    
+    // 更新缓存
+    enabledInterfacesCache = enabledInterfaces;
+    cacheTime = currentTime;
+    
+    return enabledInterfaces;
+  } catch (err) {
+    console.error('[loadEnabledInterfaces] 加载启用接口失败:', err);
+    return enabledInterfacesCache || [];
   }
 };
 
-// 验证重定向规则的有效性
-const validateRedirectRule = (interface) => {
-  if (!interface) return false;
-  
-  const { proxyType, targetUrl } = interface;
-  
-  // 对于redirect和url_redirect类型，必须有有效的目标URL
-  if ((proxyType === 'redirect' || proxyType === 'url_redirect') && !isValidTargetUrl(targetUrl)) {
-    log(`接口 ${interface.id || interface.name || '未知'} 的目标URL无效: ${targetUrl}`);
-    return false;
+/**
+ * 查找匹配的接口
+ * @param {Array} interfaces 接口列表
+ * @param {string} url 请求URL
+ * @returns {object|null} 匹配的接口，如果没有匹配则返回null
+ */
+const findMatchingInterface = (interfaces, url) => {
+  if (!interfaces || !Array.isArray(interfaces) || interfaces.length === 0 || !url) {
+    return null;
   }
   
-  return true;
-};
-
-// 生成随机数工具函数
-const generateRandomValue = (pattern) => {
-  // 如果不是以@开头的模式，直接返回原值
-  if (!pattern || !pattern.startsWith('@')) {
-    return pattern;
+  try {
+    // 尝试查找匹配的接口
+    for (const intf of interfaces) {
+      const { pattern, proxyType } = intf;
+      
+      // 检查URL是否匹配
+      if (isUrlMatch(url, pattern, proxyType)) {
+        return intf;
+      }
+    }
+    
+    // 没有找到匹配的接口
+    return null;
+  } catch (err) {
+    console.error('[findMatchingInterface] 查找匹配接口出错:', err);
+    return null;
   }
-  
-  const formatPattern = pattern.substring(1); // 去掉@前缀
-  // 使用单次正则替换代替每个字符的遍历
-  return formatPattern.replace(/x/g, () => {
-    // 使用一个固定的字符集，避免生成不兼容的字符
-    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
-    return chars.charAt(Math.floor(Math.random() * chars.length));
-  });
 };
 
-// 构建重定向规则
-const buildRedirectRule = (fullUrl, targetUrl, customHeaders, pattern, isUrlRedirect = 0) => {
-  // 构建目标URL
-  let finalTargetUrl;
-  if(!isUrlRedirect){
-    finalTargetUrl = fullUrl.replace(pattern, targetUrl);
-  }else{
-    finalTargetUrl = `redirect://${targetUrl}`;
-  }
-
-  // 定义结果数组，避免多次字符串拼接
-  const rules = [`${fullUrl} ${finalTargetUrl}`];
+/**
+ * 获取Whistle规则
+ * @param {string} fullUrl 完整URL
+ * @param {string} pattern URL匹配模式
+ * @param {string} proxyType 代理类型
+ * @param {object} options 选项
+ * @returns {string} Whistle规则
+ */
+const getWhistleRules = (fullUrl, pattern, proxyType, options = {}) => {
+  // 记录调用参数
+  console.log(`[getWhistleRules] fullUrl=${fullUrl}, pattern=${pattern}, proxyType=${proxyType}`);
   
-  // 如果有自定义请求头，添加到规则中
-  if (customHeaders && Object.keys(customHeaders).length > 0) {
-    // 为每个请求头创建一个规则行
-    Object.entries(customHeaders).forEach(([key, value]) => {
-      // 处理随机值
-      const processedValue = generateRandomValue(value);
-      
-      // 添加到规则数组
-      rules.push(`${fullUrl} headerReplace://req.${key}:/(.*)/=${processedValue}`);
-    });
+  // 验证参数
+  if (!fullUrl || !pattern || !proxyType) {
+    console.log('[getWhistleRules] 参数无效，返回空规则');
+    return '';
   }
   
-  // 最后才将所有规则合并为一个字符串，减少字符串操作
-  return rules.join('\n');
-};
-
-// 缓存管理接口 - 简化版本
-const cacheManager = {
-  // 清除缓存
-  clearCache: () => {
-    logInfo('主动清除接口缓存');
-    enabledInterfacesCache = null;
-    cacheTime = 0;
-    cacheVersion++;
-  },
-  
-  // 获取当前缓存状态
-  getStatus: () => {
-    return {
-      enabled: {
-        cached: !!enabledInterfacesCache,
-        cacheTime: cacheTime,
-        itemCount: enabledInterfacesCache ? enabledInterfacesCache.length : 0
-      },
-      cacheVersion,
-      configInterval: CONFIG.CACHE_INTERVAL
-    };
+  try {
+    // 根据代理类型生成不同的规则
+    switch (proxyType) {
+      case 'response':
+        // 使用插件处理响应
+        return `${fullUrl} whistle.mock-plugin://\n${fullUrl} resCors://enable`;
+        
+      case 'redirect':
+        // 验证目标URL
+        const targetUrl = options.targetUrl;
+        if (!isValidTargetUrl(targetUrl)) {
+          console.log(`[getWhistleRules] 无效的目标URL: ${targetUrl}`);
+          return '';
+        }
+        
+        // 自定义请求头
+        const customHeaders = options.customHeaders || {};
+        
+        // 构建重定向规则，包括自定义请求头
+        return `${fullUrl} ${targetUrl}\n${fullUrl} resCors://enable`;
+        
+      case 'url_redirect':
+        // 验证目标URL
+        const urlRedirectTarget = options.targetUrl;
+        if (!isValidTargetUrl(urlRedirectTarget)) {
+          console.log(`[getWhistleRules] 无效的URL重定向目标: ${urlRedirectTarget}`);
+          return '';
+        }
+        
+        // 自定义请求头
+        const urlRedirectHeaders = options.customHeaders || {};
+        
+        // 对于url_redirect，使用redirect://前缀
+        return `${fullUrl} redirect://${urlRedirectTarget}\n${fullUrl} resCors://enable`;
+        
+      default:
+        console.log(`[getWhistleRules] 不支持的代理类型: ${proxyType}`);
+        return '';
+    }
+  } catch (err) {
+    console.error('[getWhistleRules] 生成规则时出错:', err);
+    return '';
   }
 };
 
-// Whistle 规则服务器实现
-module.exports = (server, options) => {
-  // 优化：缓存常用路径匹配
-  const debugConfigPath = '/_debug/config';
-  const debugEnabledInterfacesPath = '/_debug/enabled-interfaces';
-  const clearCachePath = '/_flush_cache';
+/**
+ * 处理请求
+ * @param {object} ctx 上下文
+ * @returns {Promise<void>}
+ */
+const handleRequest = async (ctx) => {
+  const { req, res } = ctx;
   
-  server.on('request', (req, res) => {
-    const oReq = req.originalReq;
-    
-    // 提取请求相关信息
-    const fullUrl = oReq.url;
-    logDebug(`原始URL: ${fullUrl}`);
-    
-    // 处理缓存刷新请求
-    if (fullUrl.startsWith(clearCachePath)) {
-      cacheManager.clearCache();
-      
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ 
-        success: true, 
-        message: '缓存已刷新',
-        cacheStatus: cacheManager.getStatus()
-      }));
-      return;
-    }
-    
-    // 特殊调试路径，查看缓存状态
-    if (fullUrl.endsWith('/_cache_status')) {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(cacheManager.getStatus()));
-      return;
-    }
+  try {
+    // 获取请求URL
+    const fullUrl = req.url;
     
-    // 特殊调试路径，使用更高效的匹配
-    if (fullUrl.endsWith(debugConfigPath)) {
-      try {
-        const configs = {
-          interfaces: fs.existsSync(INTERFACES_FILE) ? fs.readJsonSync(INTERFACES_FILE) : null,
-          features: fs.existsSync(FEATURES_FILE) ? fs.readJsonSync(FEATURES_FILE) : null
-        };
-        res.end(JSON.stringify(configs, null, 2));
-        return;
-      } catch (err) {
-        logError(`读取配置文件失败: ${err.message}`);
-        res.end(`读取配置文件失败: ${err.message}`);
-        return;
-      }
-    }
+    // 记录请求
+    console.log(`[规则服务器] 收到请求: ${fullUrl}`);
     
-    // 调试路径，查看启用的接口
-    if (fullUrl.endsWith(debugEnabledInterfacesPath)) {
-      try {
-        const enabledInterfaces = loadEnabledInterfaces();
-        res.end(JSON.stringify({
-          count: enabledInterfaces.length,
-          interfaces: enabledInterfaces
-        }, null, 2));
-        return;
-      } catch (err) {
-        logError(`获取启用接口失败: ${err.message}`);
-        res.end(`获取启用接口失败: ${err.message}`);
-        return;
-      }
-    }
+    // 加载启用的接口
+    const enabledInterfaces = await loadEnabledInterfaces();
     
-    // 解析URL
-    let parsedUrl;
-    try {
-      parsedUrl = url.parse(fullUrl);
-    } catch (err) {
-      logError(`解析URL失败: ${err.message}`);
-      // 解析失败时，不处理请求
+    if (!enabledInterfaces || enabledInterfaces.length === 0) {
+      console.log('[规则服务器] 没有启用的接口');
       res.end('');
       return;
     }
     
-    // 尝试获取 pathname 或 path，用于匹配
-    const method = oReq.method;
-    const path = parsedUrl.pathname || '';
-    
-    logDebug(`请求方法: ${method}, 请求路径: ${path}`);
+    // 查找匹配的接口
+    const matchedInterface = findMatchingInterface(enabledInterfaces, fullUrl);
     
-    // 加载启用的接口配置（使用缓存优化）
-    const enabledInterfaces = loadEnabledInterfaces();
-    
-    if (enabledInterfaces.length === 0) {
-      logDebug('没有找到启用的接口配置，跳过处理');
+    if (!matchedInterface) {
+      console.log(`[规则服务器] 没有找到匹配的接口: ${fullUrl}`);
       res.end('');
       return;
     }
     
-    // 优化：使用 find 查找匹配的接口，只遍历一次数组
-    const matchedInterface = enabledInterfaces.find(intf => {
-      // 获取URL模式
-      const pattern = intf.urlPattern || '';
-      const proxyType = intf.proxyType || 'response';
-      
-      if (!pattern) {
-        logDebug(`接口 ${intf.id || intf.name || '未知'} 缺少URL模式`);
-        return false;
-      }
-      
-      // 检查URL模式匹配，根据proxyType选择适当的匹配策略
-      const urlMatches = isUrlMatch(path, pattern, proxyType, fullUrl);
-      
-      if (!urlMatches) {
-        // 不记录每个失败的匹配，以减少日志量
-        return false;
-      }
-      
-      logDebug(`URL模式匹配成功: ${fullUrl} 匹配 ${pattern} (${proxyType}模式)`);
-      
-      // 检查HTTP方法匹配
-      const methodField = intf.httpMethod || intf.method || '';
-      const methodValue = methodField.toUpperCase();
-      const methodMatches = !methodValue || 
-                            methodValue === 'ALL' || 
-                            methodValue === 'ANY' || 
-                            methodValue === method;
-      
-      if (!methodMatches) {
-        logDebug(`方法不匹配: 请求方法 ${method}, 接口方法 ${methodValue}`);
-        return false;
-      }
-      
-      logDebug(`方法匹配成功: ${method} 匹配 ${methodValue || 'ALL'}`);
-      
-      return true;
+    // 获取接口信息
+    const { pattern, proxyType, targetUrl, customHeaders } = matchedInterface;
+    
+    // 生成Whistle规则
+    const rule = getWhistleRules(fullUrl, pattern, proxyType, {
+      targetUrl,
+      customHeaders
     });
     
-    // 如果找到匹配的接口，处理对应的规则
-    if (matchedInterface) {
-      logInfo(`找到匹配接口 "${matchedInterface.name || matchedInterface.id || '未知'}" 用于 ${method} ${path}`);
-      
-      // 处理不同的代理类型
-      const proxyType = matchedInterface.proxyType || 'response';
-      
-      // 优先级判断：首先处理 response 类型
-      if (proxyType === 'response') {
-        // 返回指向插件服务的规则
-        logDebug(`接口 "${matchedInterface.name}" 使用模拟响应模式`);
-        res.end(`${fullUrl} mock-plugins://`);
-        return;
-      }
-      
-      // 对于redirect和url_redirect类型，验证规则有效性
-      if ((proxyType === 'redirect' || proxyType === 'url_redirect') && !validateRedirectRule(matchedInterface)) {
-        logWarn(`接口 "${matchedInterface.name}" 的重定向规则无效，跳过处理`);
-        res.end('');
-        return;
-      }
-      
-      // 处理 redirect 类型：将请求的 url 中的源 url 部分替换为目标 url
-      if (proxyType === 'redirect') {
-        const targetUrl = matchedInterface.targetUrl.trim();
-        const pattern = matchedInterface.urlPattern.trim();
-        logDebug(`接口 "${matchedInterface.name}" 使用重定向模式，模式: ${pattern}, 目标URL: ${targetUrl}`);
-        
-        // 确保目标URL合法
-        if (!isValidTargetUrl(targetUrl)) {
-          logWarn(`目标URL不合法: ${targetUrl}，跳过处理`);
-          res.end('');
-          return;
-        }
-        
-        // 执行重定向：将fullUrl中匹配的pattern替换为targetUrl
-        // 使用startsWith优化匹配效率
-        if (fullUrl.startsWith(pattern)) {
-          // 获取自定义请求头
-          const customHeaders = matchedInterface.customHeaders || {};
-          
-          // 构建重定向规则，包括自定义请求头
-          const redirectRule = buildRedirectRule(fullUrl, targetUrl, customHeaders, pattern, 0);
-          
-          // 返回规则
-          res.end(redirectRule);
-          logDebug(`重定向规则: ${redirectRule}`);
-          return;
-        } else {
-          logDebug(`URL ${fullUrl} 不以 ${pattern} 开头，跳过处理`);
-          res.end('');
-          return;
-        }
-      }
-      
-      // 处理 url_redirect 类型：完全匹配 fullPath 并直接返回目标URL
-      if (proxyType === 'url_redirect') {
-        const targetUrl = matchedInterface.targetUrl.trim();
-        logDebug(`接口 "${matchedInterface.name}" 使用URL重定向模式，目标URL: ${targetUrl}`);
-        
-        // 确保目标URL合法
-        if (!isValidTargetUrl(targetUrl)) {
-          logWarn(`目标URL不合法: ${targetUrl}，跳过处理`);
-          res.end('');
-          return;
-        }
-        
-        // 对于url_redirect，我们需要完全匹配
-        if (fullUrl === matchedInterface.urlPattern) {
-          // 获取自定义请求头
-          const customHeaders = matchedInterface.customHeaders || {};
-          
-          // 构建重定向规则，包括自定义请求头
-          const redirectRule = buildRedirectRule(fullUrl, targetUrl, customHeaders, pattern, 1);
-          
-          // 返回规则
-          res.end(redirectRule);
-          logDebug(`URL重定向规则: ${redirectRule}`);
-          return;
-        } else {
-          logDebug(`URL ${fullUrl} 不完全匹配 ${matchedInterface.urlPattern}，跳过处理`);
-          res.end('');
-          return;
-        }
-      }
-      
-      // 默认情况下使用mock-plugins处理
-      logDebug(`接口 "${matchedInterface.name}" 使用默认处理模式`);
-      res.end(`${fullUrl} mock-plugins://`);
-    } else {
-      // 如果没有匹配的接口，返回空字符串，Whistle 会继续处理下一个规则
-      logDebug(`未找到匹配接口，跳过处理 ${method} ${path}`);
-      res.end('');
-    }
-  });
+    // 记录生成的规则
+    console.log(`[规则服务器] 生成规则: ${rule}`);
+    
+    // 返回规则
+    res.end(rule);
+  } catch (err) {
+    console.error('[规则服务器] 处理请求出错:', err);
+    res.end('');
+  }
+};
+
+// 导出规则服务器
+module.exports = {
+  handleRequest
 }; 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whistle.mock-plugins",
-  "version": "1.0.6-beta.1",
+  "version": "1.0.6-beta.2",
   "description": "Whistle 插件，用于快速创建 API 模拟数据",
   "main": "lib/index.js",
   "scripts": {