jacky-proxy 1.0.0 → 1.0.1

package/bin/jacky-proxy.js

@@ -38,7 +38,7 @@ program
   .option('-p, --port <port>', '监听端口', '5000')
   .option('-m, --mock-id <id>', '接口集 ID（如果未在命令中指定）')
   .option('-c, --config <path>', '配置文件路径', 'proxy.config.json')
-  .option('-s, --scenario <name>', '场景名称（当启动 Raw 文件夹时使用）', '场景1')
+  .option('-s, --scenario <name>', '场景名称（当启动 Raw 文件夹时使用）', '默认场景')
   .option('-t, --target <path>', '目标文件夹路径（当启动 Raw 文件夹时使用）', 'mocks/test-folder')
   .option('--ignore <interfaces>', '要忽略的接口（逗号分隔，当启动 Raw 文件夹时使用）', '')
   .option('--no-migrate', '不自动迁移，直接启动（如果指定的是 Raw 文件夹）')
@@ -132,6 +132,75 @@ rulesCommand
     await rulesTestCommand(options);
   });
 
+// 在解析之前，检查第一个参数是否是 Raw 文件夹路径
+// 如果是，自动调用 start 命令
+const args = process.argv.slice(2);
+if (args.length > 0) {
+  const firstArg = args[0];
+  const fs = require('fs');
+  const path = require('path');
+  
+  // 检查是否是已知命令
+  const knownCommands = ['migrate', 'start', 'config', 'rules'];
+  const isKnownCommand = knownCommands.includes(firstArg);
+  
+  // 如果不是已知命令，检查是否是 Raw 文件夹路径
+  if (!isKnownCommand) {
+    // 规范化路径，确保正确处理相对路径（包括 ./ 开头的路径）
+    const fullPath = path.isAbsolute(firstArg) 
+      ? path.resolve(firstArg)
+      : path.resolve(process.cwd(), firstArg);
+    
+    // 检查是否是 Raw 文件夹路径：路径必须以 .folder 结尾，且路径存在且是目录
+    const isRawFolderPath = (firstArg.endsWith('.folder') || path.basename(fullPath).endsWith('.folder')) &&
+      fs.existsSync(fullPath) && 
+      fs.statSync(fullPath).isDirectory();
+    
+    if (isRawFolderPath) {
+      // 将路径作为 start 命令的参数（使用规范化后的路径）
+      const startCommand = require('../src/commands/start');
+      const startOptions = {};
+      
+      // 解析其他选项（使用 commander 的选项解析逻辑）
+      for (let i = 1; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--port' || arg === '-p') {
+          startOptions.port = args[++i];
+        } else if (arg === '--scenario' || arg === '-s') {
+          startOptions.scenario = args[++i];
+        } else if (arg === '--target' || arg === '-t') {
+          startOptions.target = args[++i];
+        } else if (arg === '--ignore') {
+          startOptions.ignore = args[++i];
+        } else if (arg === '--debug') {
+          startOptions.debug = true;
+        } else if (arg === '--no-migrate') {
+          startOptions.noMigrate = true;
+        } else if (arg === '--config' || arg === '-c') {
+          startOptions.config = args[++i];
+        } else if (arg.startsWith('--port=')) {
+          startOptions.port = arg.split('=')[1];
+        } else if (arg.startsWith('--scenario=')) {
+          startOptions.scenario = arg.split('=')[1];
+        } else if (arg.startsWith('--target=')) {
+          startOptions.target = arg.split('=')[1];
+        } else if (arg.startsWith('--ignore=')) {
+          startOptions.ignore = arg.split('=')[1];
+        } else if (arg.startsWith('--config=')) {
+          startOptions.config = arg.split('=')[1];
+        }
+      }
+      
+      // 调用 start 命令，传递原始参数（startCommand 内部会再次解析）
+      startCommand(firstArg, startOptions).catch((error) => {
+        console.error('启动失败:', error);
+        process.exit(1);
+      });
+      return;
+    }
+  }
+}
+
 // 解析命令行参数
 program.parse();
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "jacky-proxy",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "通用 Mock 服务器 - 适用于任意网站的 HTTP 请求拦截和 Mock 响应系统",
   "main": "server.js",
   "bin": {
-    "jacky-proxy": "bin/jacky-proxy.js"
+    "jacky-proxy": "./bin/jacky-proxy.js"
   },
   "scripts": {
     "start": "npm run config:generate && node server.js",
@@ -29,7 +29,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/wangjs-jacky/jacky-proxy.git"
+    "url": "https://github.com/wangjs-jacky/jacky-proxy.git"
   },
   "bugs": {
     "url": "https://github.com/wangjs-jacky/jacky-proxy/issues"
@@ -49,16 +49,17 @@
     "README.md"
   ],
   "dependencies": {
+    "chokidar": "^3.5.3",
     "commander": "^14.0.2",
     "express": "^4.18.2",
-    "lodash": "^4.17.21"
+    "lodash": "^4.17.21",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
     "@types/lodash": "^4.14.202",
     "@types/node": "^20.10.0",
-    "nodemon": "^3.0.1",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.3.3"
+    "nodemon": "^3.0.1"
   }
 }

package/server.js

@@ -6,6 +6,7 @@
 const express = require('express');
 const fs = require('fs');
 const path = require('path');
+const chokidar = require('chokidar');
 
 // 使用 ts-node 支持 TypeScript 文件
 require('ts-node').register({
@@ -160,12 +161,24 @@ function loadMockConfig() {
       configPath = path.join(workDir, 'proxy.config.json');
     }
     
+    // 确保路径是绝对路径
+    if (!path.isAbsolute(configPath)) {
+      configPath = path.resolve(configPath);
+    }
+    
     if (fs.existsSync(configPath)) {
       const configContent = fs.readFileSync(configPath, 'utf-8');
       mockConfig = JSON.parse(configContent);
+      console.log(`✅ 已加载配置文件: ${configPath}`);
       return mockConfig;
     } else {
       console.warn(`配置文件不存在: ${configPath}`);
+      if (process.env.CONFIG_PATH) {
+        console.warn(`  CONFIG_PATH 环境变量: ${process.env.CONFIG_PATH}`);
+      }
+      if (process.env.WORK_DIR) {
+        console.warn(`  WORK_DIR 环境变量: ${process.env.WORK_DIR}`);
+      }
       return null;
     }
   } catch (error) {
@@ -290,6 +303,204 @@ let mockScenarios = {};
 // 格式: Set(['getProductInfo', 'productSearch']) 表示这些接口被禁用
 let disabledInterfaces = new Set();
 
+// 文件监听器
+let fileWatcher = null;
+
+/**
+ * 清除模块及其所有依赖的缓存
+ */
+function clearModuleCache(modulePath) {
+  const resolvedPath = require.resolve(modulePath);
+  
+  // 清除该模块的缓存
+  if (require.cache[resolvedPath]) {
+    const module = require.cache[resolvedPath];
+    
+    // 递归清除所有子模块的缓存
+    if (module.children) {
+      module.children.forEach(child => {
+        if (child.filename && (child.filename.endsWith('.json') || child.filename.includes('base-data'))) {
+          delete require.cache[child.filename];
+        }
+      });
+    }
+    
+    delete require.cache[resolvedPath];
+  }
+}
+
+/**
+ * 清除 base-data 目录下所有 JSON 文件的缓存
+ */
+function clearBaseDataCache(interfaceName) {
+  const workDir = getWorkDir();
+  const baseDataDir = path.join(workDir, 'base-data', interfaceName);
+  
+  if (fs.existsSync(baseDataDir)) {
+    const files = fs.readdirSync(baseDataDir);
+    files.forEach(file => {
+      if (file.endsWith('.json')) {
+        const jsonPath = path.join(baseDataDir, file);
+        try {
+          const resolvedPath = require.resolve(jsonPath);
+          delete require.cache[resolvedPath];
+        } catch (e) {
+          // 如果文件还未被 require，忽略错误
+        }
+      }
+    });
+  }
+}
+
+/**
+ * 重新加载单个 Mock 文件
+ */
+function reloadMockFile(filePath, interfaceName) {
+  try {
+    // 清除 base-data 中该接口的所有 JSON 文件缓存
+    clearBaseDataCache(interfaceName);
+    
+    // 清除 Mock 文件及其所有依赖的缓存
+    clearModuleCache(filePath);
+    
+    // 清除 ts-node 的编译缓存（如果存在）
+    if (require.extensions['.ts']) {
+      // ts-node 可能会缓存编译结果，清除相关缓存
+      const tsNodeCache = require.cache;
+      Object.keys(tsNodeCache).forEach(key => {
+        if (key.includes(filePath) || key.includes(interfaceName)) {
+          delete tsNodeCache[key];
+        }
+      });
+    }
+    
+    // 重新加载
+    const mockModule = require(filePath);
+    const mockHandler = mockModule.default || mockModule;
+    
+    if (typeof mockHandler === 'function') {
+      cachedMockFiles[interfaceName] = mockHandler;
+      mockFilePaths[interfaceName] = filePath;
+      console.log(`${colors.green}🔄${colors.reset} ${colors.dim}热更新 Mock 文件:${colors.reset} ${colors.cyan}${path.basename(filePath)}${colors.reset} ${colors.gray}->${colors.reset} ${colors.bright}${interfaceName}${colors.reset}`);
+      return true;
+    } else {
+      console.warn(`${colors.yellow}⚠${colors.reset} ${colors.yellow}Mock 文件 ${colors.cyan}${path.basename(filePath)}${colors.yellow} 未导出函数${colors.reset}`);
+      return false;
+    }
+  } catch (error) {
+    console.error(`${colors.red}✗${colors.reset} ${colors.red}热更新 Mock 文件失败:${colors.reset} ${colors.cyan}${path.basename(filePath)}${colors.reset} ${colors.red}${error.message}${colors.reset}`);
+    if (error.stack) {
+      console.error(error.stack);
+    }
+    return false;
+  }
+}
+
+/**
+ * 重新加载所有 Mock 文件（当 base-data 变化时）
+ */
+function reloadAllMockFiles() {
+  if (!cachedMockId) return;
+  
+  const folderPath = getMockFolderPath(cachedMockId);
+  if (!folderPath) return;
+  
+  console.log(`\n${colors.blue}🔄${colors.reset} ${colors.bright}热更新所有 Mock 文件...${colors.reset}`);
+  cachedMockFiles = loadMockFiles(folderPath);
+  console.log(`${colors.green}✅${colors.reset} ${colors.bright}热更新完成，共 ${colors.green}${Object.keys(cachedMockFiles).length}${colors.reset} ${colors.bright}个 Mock 接口${colors.reset}\n`);
+}
+
+/**
+ * 设置文件监听
+ */
+function setupFileWatcher(mockId) {
+  // 清除旧的监听器
+  if (fileWatcher) {
+    fileWatcher.close();
+    fileWatcher = null;
+  }
+  
+  const folderPath = getMockFolderPath(mockId);
+  if (!folderPath) return;
+  
+  const workDir = getWorkDir();
+  const baseDataPath = path.join(workDir, 'base-data');
+  const mocksPath = folderPath;
+  
+  // 要监听的路径
+  const watchPaths = [];
+  if (fs.existsSync(baseDataPath)) {
+    watchPaths.push(baseDataPath);
+  }
+  if (fs.existsSync(mocksPath)) {
+    watchPaths.push(mocksPath);
+  }
+  
+  if (watchPaths.length === 0) return;
+  
+  // 使用 chokidar 监听文件变化
+  fileWatcher = chokidar.watch(watchPaths, {
+    ignored: /(^|[\/\\])\../, // 忽略隐藏文件
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 200,
+      pollInterval: 100
+    }
+  });
+  
+  fileWatcher
+    .on('change', (filePath) => {
+      // 延迟处理，避免文件写入未完成
+      setTimeout(() => {
+        const ext = path.extname(filePath);
+        const fileName = path.basename(filePath);
+        
+        // 如果是 Mock 文件变化
+        if (filePath.endsWith('.mock.ts') || filePath.endsWith('.mock.js')) {
+          const interfaceName = fileName.replace(/\.mock\.(ts|js)$/, '');
+          reloadMockFile(filePath, interfaceName);
+        }
+        // 如果是 base-data 中的 JSON 文件变化
+        else if (ext === '.json' && filePath.includes('base-data')) {
+          // 找到对应的接口名（从路径中提取）
+          const baseDataMatch = filePath.match(/base-data[\/\\]([^\/\\]+)/);
+          if (baseDataMatch) {
+            const interfaceName = baseDataMatch[1];
+            
+            // 先清除该 JSON 文件的缓存
+            try {
+              const resolvedPath = require.resolve(filePath);
+              delete require.cache[resolvedPath];
+            } catch (e) {
+              // 如果文件还未被 require，忽略错误
+            }
+            
+            // 清除该接口的所有 base-data 缓存
+            clearBaseDataCache(interfaceName);
+            
+            // 重新加载该接口的 Mock 文件（因为 Mock 文件会 import base-data）
+            const mockFilePath = path.join(mocksPath, `${interfaceName}.mock.ts`);
+            if (fs.existsSync(mockFilePath)) {
+              reloadMockFile(mockFilePath, interfaceName);
+            } else {
+              // 如果找不到对应的 Mock 文件，重新加载所有（以防有依赖关系）
+              reloadAllMockFiles();
+            }
+          } else {
+            // 无法确定接口名，重新加载所有
+            reloadAllMockFiles();
+          }
+        }
+      }, 100);
+    })
+    .on('error', (error) => {
+      console.error(`${colors.red}✗${colors.reset} ${colors.red}文件监听错误:${colors.reset} ${error.message}`);
+    });
+  
+  console.log(`${colors.blue}👁️${colors.reset} ${colors.dim}已启用文件热更新监听${colors.reset}`);
+}
+
 /**
  * 获取或加载 Mock 文件
  */
@@ -309,6 +520,10 @@ function getMockFiles(mockId) {
   cachedMockId = mockId;
 
   console.log(`${colors.green}✅${colors.reset} ${colors.bright}共加载 ${colors.green}${Object.keys(cachedMockFiles).length}${colors.reset} ${colors.bright}个 Mock 接口${colors.reset}\n`);
+  
+  // 设置文件监听
+  setupFileWatcher(mockId);
+  
   return cachedMockFiles;
 }
 
@@ -473,7 +688,10 @@ async function handleRequest(req, res) {
 
 
     // 检查是否匹配失败
-    if (result && result.body && result.body.error) {
+    // matchResponse 返回错误时的格式：{ error: true, message: '...', ... }
+    // 需要检查 error 是否为布尔值 true，而不是仅仅检查 error 字段是否存在
+    // 因为响应数据中可能包含 error 字段（如 { error: { code: '', message: '' } }）
+    if (result && result.body && result.body.error === true) {
       console.log(`${getTimestamp()} ${colors.red}❌ ${actualInterfaceName} 匹配失败${colors.reset}`);
       return res.status(404).json(result.body);
     }

package/src/commands/migrate.js

@@ -39,30 +39,194 @@ const SOA_FILE_PATTERN = /.*soa2_\d+_\w+\.txt$/;
 const SOA_EXTRACT_PATTERN = /soa2_(\d+)_(\w+)/;
 const INDEX_PATTERN = /^\[(\d+)\]\s+(Request|Response)/;
 
+// Proxyman 标准格式文件模式
+const PROXYMAN_FILE_PATTERN = /^\[\d+\]\s+(Request|Response)\s+-\s+.+\.txt$/;
+const PROXYMAN_EXTRACT_PATTERN = /^\[(\d+)\]\s+(Request|Response)\s+-\s+(.+?)\.txt$/;
+
 /**
  * 从文件中提取 JSON 数据
+ * 支持 Request 和 Response 文件
  */
 function extractJsonFromFile(filePath) {
   try {
     const content = fs.readFileSync(filePath, 'utf-8');
     const lines = content.split('\n');
+    const filename = path.basename(filePath);
+
+    // 判断是 Request 还是 Response 文件
+    const isRequest = filename.includes('Request');
+    const isResponse = filename.includes('Response');
+
+    // 对于 Request 文件，检查是否是 GET 请求（没有 body）
+    if (isRequest) {
+      const firstLine = lines[0] || '';
+      const methodMatch = firstLine.match(/^(GET|POST|PUT|DELETE|PATCH)\s+/);
+      
+      if (methodMatch) {
+        const method = methodMatch[1];
+        
+        // GET 请求通常没有 body，从 URL query 参数中提取
+        if (method === 'GET') {
+          const urlMatch = firstLine.match(/\s+([^\s?]+)\??([^\s]*)/);
+          if (urlMatch) {
+            const queryString = urlMatch[2];
+            if (queryString) {
+              // 解析 query 参数
+              const params = {};
+              queryString.split('&').forEach(param => {
+                const [key, value] = param.split('=');
+                if (key) {
+                  try {
+                    params[key] = value ? decodeURIComponent(value) : '';
+                  } catch (e) {
+                    params[key] = value || '';
+                  }
+                }
+              });
+              return Object.keys(params).length > 0 ? params : {};
+            }
+          }
+          // GET 请求没有 query 参数，返回空对象
+          return {};
+        }
+        
+        // POST/PUT/DELETE/PATCH 请求，尝试从 body 中提取 JSON
+        // 找到第一个空行后的第一个 {
+        let jsonStartIndex = -1;
+        for (let i = 0; i < lines.length; i++) {
+          if (lines[i].trim() === '' && i + 1 < lines.length) {
+            const nextLine = lines[i + 1].trim();
+            if (nextLine.startsWith('{') || nextLine.startsWith('[')) {
+              jsonStartIndex = i + 1;
+              break;
+            }
+          }
+        }
+
+        // 如果没找到空行，直接找第一个 { 或 [
+        if (jsonStartIndex === -1) {
+          for (let i = 0; i < lines.length; i++) {
+            const trimmed = lines[i].trim();
+            if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+              jsonStartIndex = i;
+              break;
+            }
+          }
+        }
+
+        if (jsonStartIndex === -1) {
+          // POST/PUT/DELETE/PATCH 请求没有 body，返回空对象
+          return {};
+        }
+
+        // 从 jsonStartIndex 开始提取 JSON
+        const jsonContent = lines.slice(jsonStartIndex).join('\n').trim();
+
+        // 验证 JSON 格式
+        try {
+          return JSON.parse(jsonContent);
+        } catch (e) {
+          console.error(`错误: 文件 ${filePath} 的 JSON 格式无效:`, e.message);
+          return {};
+        }
+      } else {
+        // Request 文件但无法识别 HTTP 方法，尝试通用提取
+        // 找到第一个空行后的第一个 {
+        let jsonStartIndex = -1;
+        for (let i = 0; i < lines.length; i++) {
+          if (lines[i].trim() === '' && i + 1 < lines.length) {
+            const nextLine = lines[i + 1].trim();
+            if (nextLine.startsWith('{') || nextLine.startsWith('[')) {
+              jsonStartIndex = i + 1;
+              break;
+            }
+          }
+        }
+
+        if (jsonStartIndex === -1) {
+          for (let i = 0; i < lines.length; i++) {
+            const trimmed = lines[i].trim();
+            if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+              jsonStartIndex = i;
+              break;
+            }
+          }
+        }
+
+        if (jsonStartIndex === -1) {
+          // 无法提取，返回空对象
+          return {};
+        }
+
+        const jsonContent = lines.slice(jsonStartIndex).join('\n').trim();
+        try {
+          return JSON.parse(jsonContent);
+        } catch (e) {
+          return {};
+        }
+      }
+    }
+
+    // 对于 Response 文件，提取 JSON body
+    if (isResponse) {
+      // 找到第一个空行后的第一个 {
+      let jsonStartIndex = -1;
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() === '' && i + 1 < lines.length) {
+          const nextLine = lines[i + 1].trim();
+          if (nextLine.startsWith('{') || nextLine.startsWith('[')) {
+            jsonStartIndex = i + 1;
+            break;
+          }
+        }
+      }
+
+      // 如果没找到空行，直接找第一个 { 或 [
+      if (jsonStartIndex === -1) {
+        for (let i = 0; i < lines.length; i++) {
+          const trimmed = lines[i].trim();
+          if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+            jsonStartIndex = i;
+            break;
+          }
+        }
+      }
+
+      if (jsonStartIndex === -1) {
+        console.warn(`警告: 在文件 ${filePath} 中未找到 JSON 数据`);
+        return null;
+      }
+
+      // 从 jsonStartIndex 开始提取 JSON
+      const jsonContent = lines.slice(jsonStartIndex).join('\n').trim();
+
+      // 验证 JSON 格式
+      try {
+        return JSON.parse(jsonContent);
+      } catch (e) {
+        console.error(`错误: 文件 ${filePath} 的 JSON 格式无效:`, e.message);
+        return null;
+      }
+    }
 
+    // 如果无法判断文件类型，使用原来的逻辑
     // 找到第一个空行后的第一个 {
     let jsonStartIndex = -1;
     for (let i = 0; i < lines.length; i++) {
       if (lines[i].trim() === '' && i + 1 < lines.length) {
         const nextLine = lines[i + 1].trim();
-        if (nextLine.startsWith('{')) {
+        if (nextLine.startsWith('{') || nextLine.startsWith('[')) {
           jsonStartIndex = i + 1;
           break;
         }
       }
     }
 
-    // 如果没找到空行，直接找第一个 {
+    // 如果没找到空行，直接找第一个 { 或 [
     if (jsonStartIndex === -1) {
       for (let i = 0; i < lines.length; i++) {
-        if (lines[i].trim().startsWith('{')) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
           jsonStartIndex = i;
           break;
         }
@@ -92,8 +256,12 @@ function extractJsonFromFile(filePath) {
 
 /**
  * 从文件名中提取接口信息
+ * 支持两种格式：
+ * 1. SOA2 格式: soa2_数字_接口名.txt
+ * 2. Proxyman 格式: [序号] Request/Response - 域名_路径.txt
  */
-function extractInterfaceInfo(filename) {
+function extractInterfaceInfo(filePath) {
+  const filename = path.basename(filePath);
   const indexMatch = filename.match(INDEX_PATTERN);
   if (!indexMatch) {
     return null;
@@ -102,48 +270,166 @@ function extractInterfaceInfo(filename) {
   const index = parseInt(indexMatch[1], 10);
   const type = indexMatch[2].toLowerCase();
 
+  // 尝试 SOA2 格式
   const soaMatch = filename.match(SOA_EXTRACT_PATTERN);
-  if (!soaMatch) {
-    return null;
+  if (soaMatch) {
+    const interfaceId = soaMatch[1];
+    let interfaceName = soaMatch[2];
+    
+    if (interfaceName.startsWith('json_')) {
+      interfaceName = interfaceName.substring(5);
+    }
+
+    return { index, type, interfaceId, interfaceName };
   }
 
-  const interfaceId = soaMatch[1];
-  let interfaceName = soaMatch[2];
-  
-  if (interfaceName.startsWith('json_')) {
-    interfaceName = interfaceName.substring(5);
+  // 尝试 Proxyman 格式或其他通用格式
+  const proxymanMatch = filename.match(PROXYMAN_EXTRACT_PATTERN);
+  if (proxymanMatch) {
+    // 从文件名中提取路径部分（域名_路径）
+    const pathPart = proxymanMatch[3];
+    
+    // 尝试从请求文件中读取 URL 路径来提取接口名（更准确）
+    let interfaceName = null;
+    
+    // 对于 Request 文件，直接从文件内容提取
+    if (type === 'request' && fs.existsSync(filePath)) {
+      interfaceName = extractInterfaceNameFromRequestFile(filePath);
+    }
+    
+    // 对于 Response 文件，尝试找到对应的 Request 文件来提取接口名
+    if (!interfaceName && type === 'response') {
+      // 查找对应的 Request 文件（相同序号）
+      const requestFileName = filename.replace('Response', 'Request');
+      const requestFilePath = path.join(path.dirname(filePath), requestFileName);
+      if (fs.existsSync(requestFilePath)) {
+        interfaceName = extractInterfaceNameFromRequestFile(requestFilePath);
+      }
+    }
+    
+    // 如果从文件内容中无法提取，则从文件名中提取
+    if (!interfaceName) {
+      // 从文件名中提取路径部分（域名_路径）
+      // 例如: www.klook.cn_v1_experiencesrv_activity_package_service_get_activity_right_price_sources
+      // -> get_activity_right_price_sources
+      const parts = pathPart.split('_');
+      
+      // 查找包含 "service" 或 "api" 的部分，取后面的部分
+      const serviceIndex = parts.findIndex(p => p.includes('service') || p.includes('api'));
+      if (serviceIndex !== -1 && serviceIndex < parts.length - 1) {
+        interfaceName = parts.slice(serviceIndex + 1).join('_');
+      } else if (parts.length > 3) {
+        // 如果路径较长，取最后几部分作为接口名
+        interfaceName = parts.slice(-3).join('_');
+      } else {
+        // 默认取最后一部分
+        interfaceName = parts[parts.length - 1];
+      }
+    }
+
+    return { index, type, interfaceId: null, interfaceName };
+  }
+
+  // 如果都不匹配，但文件名符合 [序号] Request/Response 格式，尝试通用提取
+  // 这可以处理其他格式，只要文件名包含 [序号] Request/Response
+  if (indexMatch) {
+    // 尝试从文件内容中提取接口名
+    let interfaceName = null;
+    
+    if (type === 'request' && fs.existsSync(filePath)) {
+      interfaceName = extractInterfaceNameFromRequestFile(filePath);
+    } else if (type === 'response') {
+      // 对于 Response 文件，尝试找到对应的 Request 文件
+      const requestFileName = filename.replace('Response', 'Request');
+      const requestFilePath = path.join(path.dirname(filePath), requestFileName);
+      if (fs.existsSync(requestFilePath)) {
+        interfaceName = extractInterfaceNameFromRequestFile(requestFilePath);
+      }
+    }
+    
+    // 如果无法从文件内容提取，尝试从文件名中提取（去掉序号和类型后的部分）
+    if (!interfaceName) {
+      // 移除 [序号] Request/Response - 前缀，取剩余部分作为接口名
+      const remaining = filename
+        .replace(INDEX_PATTERN, '')
+        .replace(/^\s*-\s*/, '')
+        .replace(/\.txt$/, '')
+        .trim();
+      
+      if (remaining) {
+        // 如果剩余部分包含路径，提取最后一部分
+        const parts = remaining.split(/[_\-\/]/).filter(p => p);
+        if (parts.length > 0) {
+          interfaceName = parts[parts.length - 1];
+        }
+      }
+    }
+    
+    if (interfaceName) {
+      return { index, type, interfaceId: null, interfaceName };
+    }
   }
 
-  return { index, type, interfaceId, interfaceName };
+  return null;
+}
+
+/**
+ * 从请求文件中提取接口名
+ */
+function extractInterfaceNameFromRequestFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const firstLine = content.split('\n')[0];
+    // 匹配 HTTP 请求行，例如: GET /v1/experiencesrv/activity/package_service/get_activity_right_price_sources?...
+    const urlMatch = firstLine.match(/^(GET|POST|PUT|DELETE|PATCH)\s+([^\s?]+)/);
+    if (urlMatch) {
+      const urlPath = urlMatch[2];
+      // 从路径中提取接口名：取最后一个斜杠后的部分
+      const pathParts = urlPath.split('/').filter(p => p);
+      if (pathParts.length > 0) {
+        return pathParts[pathParts.length - 1];
+      }
+    }
+  } catch (e) {
+    // 如果读取失败，返回 null
+  }
+  return null;
 }
 
 /**
- * 扫描 Raw 文件夹，提取所有 SOA2 接口文件
+ * 扫描 Raw 文件夹，提取所有接口文件
+ * 支持多种格式：
+ * 1. SOA2 格式: soa2_数字_接口名.txt（必须包含 [序号] Request/Response）
+ * 2. Proxyman 标准格式: [序号] Request/Response - 域名_路径.txt
+ * 3. 通用格式: [序号] Request/Response - 任意内容.txt（会尝试从文件内容提取接口名）
  */
 function scanRawFolder(rawFolderPath) {
   const files = fs.readdirSync(rawFolderPath);
-  const soaFiles = [];
+  const interfaceFiles = [];
 
   for (const file of files) {
-    if (!SOA_FILE_PATTERN.test(file)) {
+    // 检查文件名是否包含 [序号] Request/Response 格式
+    // 这是最通用的格式要求，可以匹配多种文件命名方式
+    if (!INDEX_PATTERN.test(file)) {
       continue;
     }
 
-    const info = extractInterfaceInfo(file);
+    const filePath = path.join(rawFolderPath, file);
+    const info = extractInterfaceInfo(filePath);
     if (!info) {
-      console.warn(`警告: 无法解析文件 ${file}`);
+      console.warn(`警告: 无法解析文件 ${file}（文件名需包含 [序号] Request/Response 格式）`);
       continue;
     }
 
-    soaFiles.push({
+    interfaceFiles.push({
       index: info.index,
       type: info.type,
       interfaceName: info.interfaceName,
-      filePath: path.join(rawFolderPath, file),
+      filePath: filePath,
     });
   }
 
-  return soaFiles;
+  return interfaceFiles;
 }
 
 /**
@@ -641,10 +927,14 @@ async function executeMigration(scenarioName, targetFolder, rawFolderPath, rl =
 
   console.log('扫描 Raw 文件夹...');
   const files = scanRawFolder(rawFolderPath);
-  console.log(`找到 ${files.length} 个 SOA2 接口文件`);
+  console.log(`找到 ${files.length} 个接口文件`);
 
   if (files.length === 0) {
-    console.error('错误: 未找到任何 SOA2 接口文件');
+    console.error('错误: 未找到任何接口文件');
+    console.error('提示: 文件名需包含 [序号] Request/Response 格式，例如:');
+    console.error('  - [1] Request - api.example.com_get_user_info.txt');
+    console.error('  - [1] Response - api.example.com_get_user_info.txt');
+    console.error('  - soa2_123_getUserInfo.txt（需包含 [序号] Request/Response）');
     process.exit(1);
   }
 
@@ -705,8 +995,16 @@ async function executeMigration(scenarioName, targetFolder, rawFolderPath, rl =
       const requestData = extractJsonFromFile(filePair.request);
       const responseData = extractJsonFromFile(filePair.response);
 
-      if (!requestData || !responseData) {
+      // 对于 GET 请求，requestData 可能是空对象 {}，这是有效的
+      // 只有 responseData 是必需的
+      if (requestData === null || responseData === null) {
         console.warn(`警告: 序号 ${index} 的数据提取失败，跳过`);
+        if (requestData === null) {
+          console.warn(`  请求数据提取失败: ${filePair.request}`);
+        }
+        if (responseData === null) {
+          console.warn(`  响应数据提取失败: ${filePair.response}`);
+        }
         continue;
       }
 

package/src/commands/start.js

@@ -39,10 +39,10 @@ function findProjectRoot() {
 function isRawFolder(pathStr) {
   if (!pathStr) return false;
   
-  // 检查是否是绝对路径或相对路径
+  // 使用 path.resolve 规范化路径（处理 ./ 和 ../ 等相对路径）
   const fullPath = path.isAbsolute(pathStr) 
-    ? pathStr 
-    : path.join(process.cwd(), pathStr);
+    ? path.resolve(pathStr)
+    : path.resolve(process.cwd(), pathStr);
   
   // 检查路径是否存在且是目录
   if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isDirectory()) {
@@ -74,79 +74,146 @@ function findDefaultRawFolder() {
   return null;
 }
 
+/**
+ * 检查 Raw 文件夹下是否已有生成的文件
+ */
+function checkRawFolderFiles(rawFolderPath) {
+  const baseDataPath = path.join(rawFolderPath, 'base-data');
+  const mocksPath = path.join(rawFolderPath, 'mocks');
+  const configPath = path.join(rawFolderPath, 'proxy.config.json');
+  
+  return {
+    hasBaseData: fs.existsSync(baseDataPath) && fs.statSync(baseDataPath).isDirectory(),
+    hasMocks: fs.existsSync(mocksPath) && fs.statSync(mocksPath).isDirectory(),
+    hasConfig: fs.existsSync(configPath),
+    allExist: fs.existsSync(baseDataPath) && fs.existsSync(mocksPath) && fs.existsSync(configPath)
+  };
+}
+
 /**
  * start 命令主函数
  */
 async function startCommand(mockIdOrPath, options) {
   let finalMockId = mockIdOrPath;
+  let workDir = process.cwd(); // 默认工作目录
   
   // 检查是否是 Raw 文件夹路径
   if (isRawFolder(mockIdOrPath)) {
-    console.log('🔍 检测到 Raw 文件夹，将自动转换后启动...');
-    
+    // 规范化路径，确保正确处理相对路径（包括 ./ 开头的路径）
     const rawFolderPath = path.isAbsolute(mockIdOrPath)
-      ? mockIdOrPath
-      : path.join(process.cwd(), mockIdOrPath);
+      ? path.resolve(mockIdOrPath)
+      : path.resolve(process.cwd(), mockIdOrPath);
     
-    // 如果设置了 --no-migrate，直接报错
-    if (options.noMigrate) {
-      console.error('错误: 指定了 --no-migrate，但提供的是 Raw 文件夹路径');
-      console.error('提示: 请先使用 jacky-proxy migrate 命令转换，或移除 --no-migrate 参数');
-      process.exit(1);
-    }
-    
-    // 执行迁移
-    const migrateCommand = require('./migrate');
-    const scenarioName = options.scenario || '场景1';
-    const targetFolder = options.target || 'mocks/test-folder';
-    const ignoreInterfaces = options.ignore
-      ? options.ignore.split(',').map(s => s.trim()).filter(s => s)
-      : [];
-    
-    console.log('');
-    console.log('═══════════════════════════════════════════════════════');
-    console.log('  自动迁移 Raw 文件夹');
-    console.log('═══════════════════════════════════════════════════════');
-    console.log(`场景名称: ${scenarioName}`);
-    console.log(`目标文件夹: ${targetFolder}`);
-    console.log(`Raw 文件夹: ${rawFolderPath}`);
-    if (ignoreInterfaces.length > 0) {
-      console.log(`忽略接口: ${ignoreInterfaces.join(', ')}`);
-    }
-    console.log('');
-    
-    // 调用迁移命令（非交互式）
-    const migrateOptions = {
-      scenario: scenarioName,
-      target: targetFolder,
-      raw: rawFolderPath,
-      ignore: options.ignore || '',
-      interactive: false
-    };
+    // 检查 Raw 文件夹下是否已有生成的文件
+    const filesCheck = checkRawFolderFiles(rawFolderPath);
     
-    try {
-      await migrateCommand(migrateOptions);
+    if (filesCheck.allExist) {
+      // 文件已存在，直接启动
+      console.log('🔍 检测到 Raw 文件夹，且已存在生成的文件，直接启动...');
+      console.log(`  base-data: ${filesCheck.hasBaseData ? '✓' : '✗'}`);
+      console.log(`  mocks: ${filesCheck.hasMocks ? '✓' : '✗'}`);
+      console.log(`  proxy.config.json: ${filesCheck.hasConfig ? '✓' : '✗'}`);
+      console.log('');
       
-      // 从配置文件中读取新创建的 mock-id（配置文件在工作目录）
-      const workDir = process.cwd();
-      const configPath = path.join(workDir, options.config || 'proxy.config.json');
+      // 从 Raw 文件夹下的配置文件中读取 mock-id
+      const configPath = path.join(rawFolderPath, options.config || 'proxy.config.json');
       if (fs.existsSync(configPath)) {
-        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-        const folder = config.folders.list.find(f => f.path === targetFolder);
-        if (folder) {
-          finalMockId = String(folder.id);
-          console.log(`\n✅ 迁移完成，将使用场景 ID: ${finalMockId}`);
-        } else {
-          console.warn('警告: 无法在配置文件中找到新创建的场景，使用默认 ID: 1');
+        try {
+          const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+          // 获取第一个场景的 ID，或者使用默认值
+          if (config.folders && config.folders.list && config.folders.list.length > 0) {
+            finalMockId = String(config.folders.list[0].id);
+            console.log(`✅ 从配置文件读取场景 ID: ${finalMockId}`);
+          } else {
+            console.warn('警告: 配置文件中没有场景配置，使用默认 ID: 1');
+            finalMockId = '1';
+          }
+        } catch (error) {
+          console.warn(`警告: 读取配置文件失败: ${error.message}，使用默认 ID: 1`);
           finalMockId = '1';
         }
       } else {
         console.warn('警告: 配置文件不存在，使用默认 ID: 1');
         finalMockId = '1';
       }
-    } catch (error) {
-      console.error('迁移失败:', error.message);
-      process.exit(1);
+      
+      // 设置工作目录为 Raw 文件夹
+      workDir = rawFolderPath;
+    } else {
+      // 文件不存在，需要生成
+      console.log('🔍 检测到 Raw 文件夹，将自动转换后启动...');
+      
+      // 如果设置了 --no-migrate，直接报错
+      if (options.noMigrate) {
+        console.error('错误: 指定了 --no-migrate，但 Raw 文件夹下还没有生成的文件');
+        console.error('提示: 请先使用 jacky-proxy migrate 命令转换，或移除 --no-migrate 参数');
+        process.exit(1);
+      }
+      
+      // 保存原始工作目录
+      const originalCwd = process.cwd();
+      
+      try {
+        // 切换到 Raw 文件夹目录，这样 migrate 会在 Raw 文件夹下创建文件
+        process.chdir(rawFolderPath);
+        
+        // 执行迁移
+        const migrateCommand = require('./migrate');
+        const scenarioName = options.scenario || '默认场景';
+        const targetFolder = options.target || 'mocks/test-folder';
+        const ignoreInterfaces = options.ignore
+          ? options.ignore.split(',').map(s => s.trim()).filter(s => s)
+          : [];
+        
+        console.log('');
+        console.log('═══════════════════════════════════════════════════════');
+        console.log('  自动迁移 Raw 文件夹');
+        console.log('═══════════════════════════════════════════════════════');
+        console.log(`场景名称: ${scenarioName}`);
+        console.log(`目标文件夹: ${targetFolder}`);
+        console.log(`Raw 文件夹: ${rawFolderPath}`);
+        if (ignoreInterfaces.length > 0) {
+          console.log(`忽略接口: ${ignoreInterfaces.join(', ')}`);
+        }
+        console.log('');
+        
+        // 调用迁移命令（非交互式）
+        // 注意：raw 参数应该是相对于当前工作目录的路径，或者使用绝对路径
+        const migrateOptions = {
+          scenario: scenarioName,
+          target: targetFolder,
+          raw: rawFolderPath, // 使用绝对路径
+          ignore: options.ignore || '',
+          interactive: false
+        };
+        
+        await migrateCommand(migrateOptions);
+        
+        // 从配置文件中读取新创建的 mock-id（配置文件在 Raw 文件夹下）
+        const configPath = path.join(rawFolderPath, options.config || 'proxy.config.json');
+        if (fs.existsSync(configPath)) {
+          const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+          const folder = config.folders.list.find(f => f.path === targetFolder);
+          if (folder) {
+            finalMockId = String(folder.id);
+            console.log(`\n✅ 迁移完成，将使用场景 ID: ${finalMockId}`);
+          } else {
+            console.warn('警告: 无法在配置文件中找到新创建的场景，使用默认 ID: 1');
+            finalMockId = '1';
+          }
+        } else {
+          console.warn('警告: 配置文件不存在，使用默认 ID: 1');
+          finalMockId = '1';
+        }
+        
+        // 设置工作目录为 Raw 文件夹
+        workDir = rawFolderPath;
+      } catch (error) {
+        // 恢复原始工作目录
+        process.chdir(originalCwd);
+        console.error('迁移失败:', error.message);
+        process.exit(1);
+      }
     }
   } else {
     // 检查是否是数字（mock-id）
@@ -158,12 +225,22 @@ async function startCommand(mockIdOrPath, options) {
   }
   
   // 设置环境变量
-  const workDir = process.cwd(); // 保存当前工作目录
   process.env.MOCK_ID = finalMockId;
   process.env.PORT = options.port || '5001';
-  process.env.WORK_DIR = workDir; // 设置工作目录环境变量
-  process.env.CONFIG_PATH = path.join(workDir, options.config || 'proxy.config.json');
+  // 确保 workDir 是绝对路径
+  const absoluteWorkDir = path.isAbsolute(workDir) ? workDir : path.resolve(workDir);
+  process.env.WORK_DIR = absoluteWorkDir; // 设置工作目录环境变量（可能是 Raw 文件夹）
+  // 确保 CONFIG_PATH 是绝对路径
+  const configFileName = options.config || 'proxy.config.json';
+  const configPath = path.isAbsolute(configFileName) 
+    ? configFileName 
+    : path.join(absoluteWorkDir, configFileName);
+  process.env.CONFIG_PATH = path.resolve(configPath); // 确保是绝对路径
   process.env.DEBUG = options.debug ? 'true' : 'false'; // 设置 Debug 模式
+  
+  // 调试信息
+  console.log(`📁 工作目录: ${process.env.WORK_DIR}`);
+  console.log(`📄 配置文件: ${process.env.CONFIG_PATH}`);
 
   console.log('');
   console.log('═══════════════════════════════════════════════════════');

package/utils/common/match-response.ts

@@ -309,6 +309,39 @@ export function formatDiffInfo(diffs: DiffInfo[]): string {
   return sections.join('\n');
 }
 
+/**
+ * 规范化 query 参数中的数组值
+ * Express 会将同名 query 参数解析为数组（如 ?preview=&preview=0 -> ["", "0"]）
+ * 为了匹配，需要将数组转换为字符串：取最后一个非空值，或如果都是空字符串则取最后一个值
+ */
+function normalizeQueryArrayValues(obj: any): any {
+  if (!obj || typeof obj !== 'object') {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map(item => normalizeQueryArrayValues(item));
+  }
+
+  const result: any = {};
+  for (const key in obj) {
+    const value = obj[key];
+    if (Array.isArray(value)) {
+      // 如果是数组，取最后一个非空值，或如果都是空字符串则取最后一个值
+      const nonEmptyValues = value.filter(v => v !== '' && v !== null && v !== undefined);
+      result[key] = nonEmptyValues.length > 0 
+        ? nonEmptyValues[nonEmptyValues.length - 1] 
+        : value[value.length - 1];
+    } else if (typeof value === 'object' && value !== null) {
+      // 递归处理嵌套对象
+      result[key] = normalizeQueryArrayValues(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
 /**
  * 处理请求对象（应用忽略、排序等规则）
  */
@@ -354,6 +387,34 @@ function processRequest(
     processed.body = body;
   }
 
+  // 处理 query 参数（GET 请求通常使用 query 参数）
+  // 如果请求没有 body，query 参数也会参与匹配
+  if (processed.query && typeof processed.query === 'object') {
+    let query = { ...processed.query };
+
+    // 规范化数组值（Express 会将同名 query 参数解析为数组）
+    query = normalizeQueryArrayValues(query);
+
+    // 深度忽略属性
+    if (deepIgnore) {
+      query = deepIgnoreProps(query, ignoreProps);
+    } else {
+      // 浅层忽略属性
+      for (const prop of ignoreProps) {
+        if (!essentialProps.includes(prop)) {
+          delete query[prop];
+        }
+      }
+    }
+
+    // 排序数组属性
+    if (sortProps.length > 0) {
+      query = sortArrayProps(query, sortProps);
+    }
+
+    processed.query = query;
+  }
+
   return processed;
 }
 
@@ -399,6 +460,15 @@ export function matchResponse(
 
   const finalSortProps = interfaceConfig?.sortProps || sortProps;
 
+  // 先提取原始请求数据（在过滤之前），用于后续比较
+  // 优先级：body > query
+  let originalRequestData: any;
+  if (request.body !== undefined && request.body !== null && request.body !== '') {
+    originalRequestData = request.body;
+  } else if (request.query && typeof request.query === 'object' && Object.keys(request.query).length > 0) {
+    originalRequestData = request.query;
+  }
+
   // 处理真实请求
   let processedRequest = processRequest(
     request,
@@ -418,10 +488,50 @@ export function matchResponse(
   }
 
   // 提取实际请求的 body 部分用于比较
-  // 如果请求有 body 字段，则使用 body；否则使用整个请求对象
-  let requestBodyForCompare = processedRequest.body !== undefined 
-    ? processedRequest.body 
-    : processedRequest;
+  // 优先级：body > query > 整个请求对象
+  // GET 请求通常使用 query 参数，POST 请求使用 body
+  let requestBodyForCompare: any;
+  
+  // 检查 body 是否存在且不为空
+  const hasBody = processedRequest.body !== undefined && 
+                  processedRequest.body !== null && 
+                  processedRequest.body !== '' &&
+                  (typeof processedRequest.body !== 'object' || Object.keys(processedRequest.body).length > 0);
+  
+  // 检查 query 是否存在且不为空
+  const hasQuery = processedRequest.query && 
+                   typeof processedRequest.query === 'object' && 
+                   Object.keys(processedRequest.query).length > 0;
+  
+  if (hasBody) {
+    requestBodyForCompare = processedRequest.body;
+  } else if (hasQuery) {
+    // GET 请求：使用 query 参数（已经在 processRequest 中规范化了数组值）
+    requestBodyForCompare = processedRequest.query;
+  } else if (originalRequestData) {
+    // 如果过滤后都为空，使用原始数据（但需要应用过滤规则）
+    // 先规范化数组值
+    let normalizedData = normalizeQueryArrayValues(originalRequestData);
+    
+    // 对原始数据应用过滤规则
+    if (finalDeepIgnore) {
+      requestBodyForCompare = deepIgnoreProps(normalizedData, ignoreProps);
+    } else {
+      requestBodyForCompare = { ...normalizedData };
+      for (const prop of ignoreProps) {
+        if (!essentialProps.includes(prop)) {
+          delete requestBodyForCompare[prop];
+        }
+      }
+    }
+    // 应用排序
+    if (finalSortProps.length > 0) {
+      requestBodyForCompare = sortArrayProps(requestBodyForCompare, finalSortProps);
+    }
+  } else {
+    // 最后兜底：使用处理后的请求对象（可能包含其他字段）
+    requestBodyForCompare = processedRequest;
+  }
 
   // 检查必需属性
   if (needContainProps.length > 0) {
@@ -438,6 +548,9 @@ export function matchResponse(
   }
 
   // 遍历 Mock 请求列表，找到匹配的请求
+  // 同时保存处理后的 mock 请求，用于错误信息显示
+  const processedMockRequests: any[] = [];
+  
   for (let i = 0; i < requestList.length; i++) {
     const mockRequest = requestList[i];
     
@@ -455,9 +568,46 @@ export function matchResponse(
     );
 
     // 提取 mock 请求的 body 部分用于比较
-    let mockBodyForCompare = processedMockRequest.body !== undefined 
-      ? processedMockRequest.body 
-      : processedMockRequest;
+    // 优先级：body > query > 整个请求对象（与真实请求保持一致）
+    let mockBodyForCompare: any;
+    
+    // 检查 body 是否存在且不为空
+    const hasMockBody = processedMockRequest.body !== undefined && 
+                        processedMockRequest.body !== null && 
+                        processedMockRequest.body !== '' &&
+                        (typeof processedMockRequest.body !== 'object' || Object.keys(processedMockRequest.body).length > 0);
+    
+    // 检查 query 是否存在且不为空
+    const hasMockQuery = processedMockRequest.query && 
+                         typeof processedMockRequest.query === 'object' && 
+                         Object.keys(processedMockRequest.query).length > 0;
+    
+    if (hasMockBody) {
+      mockBodyForCompare = processedMockRequest.body;
+    } else if (hasMockQuery) {
+      // GET 请求：使用 query 参数
+      mockBodyForCompare = processedMockRequest.query;
+    } else {
+      // 兜底：Mock 请求通常是纯对象格式（没有 body/query 字段）
+      // 如果 processedRequest.body 存在但为空对象，说明原始 mockRequest 被包装成了 { body: mockRequest }
+      // 此时应该使用原始 mockRequest（但需要应用相同的过滤规则）
+      // 由于 mockRequest 是纯对象，它已经被包装为 { body: mockRequest } 并处理过了
+      // 如果 body 是空对象，说明所有属性都被过滤了，但原始 mockRequest 可能还有数据
+      // 这里需要重新处理原始 mockRequest，应用相同的过滤规则
+      if (mockRequest && typeof mockRequest === 'object' && !mockRequest.body && !mockRequest.query) {
+        // 纯对象格式，需要重新处理（应用过滤规则）
+        // 创建一个临时对象来应用过滤规则
+        const tempRequest = { body: mockRequest };
+        const tempProcessed = processRequest(tempRequest, ignoreProps, essentialProps, finalDeepIgnore, finalSortProps);
+        mockBodyForCompare = tempProcessed.body || mockRequest;
+      } else {
+        // 使用处理后的请求对象
+        mockBodyForCompare = processedMockRequest;
+      }
+    }
+
+    // 保存处理后的 mock 请求（已去除忽略的属性），用于错误信息显示
+    processedMockRequests.push(mockBodyForCompare);
 
     // 使用 lodash 的 isEqualWith 进行深度比较（只比较 body 部分）
     const isMatch = _.isEqualWith(
@@ -477,12 +627,13 @@ export function matchResponse(
 
   // 没有找到匹配的请求，返回错误信息
   // 注意：详细差异信息不再打印到控制台，避免终端输出过多信息
+  // 错误信息中的 request 和 mockRequests 都已去除忽略的属性，便于对比
 
   return {
     error: true,
     message: '未找到匹配的 Mock 请求',
     request: JSON.stringify(requestBodyForCompare),
-    mockRequests: JSON.stringify(requestList.map((req, index) => ({
+    mockRequests: JSON.stringify(processedMockRequests.map((req, index) => ({
       index,
       request: req
     })))