whistle.mockbubu 2.2.7 → 2.2.9-beta.1

package/lib/core/server-entry/response-handler.js

@@ -1,298 +1,18 @@
 /**
  * 文件名: response-handler.js
- * 功能: Mock 响应返回逻辑
+ * 功能: Mock 响应返回逻辑（薄封装，实现已抽取到 shared）
  * 职责:
- * - 返回 Mock 数据 (源数据或版本数据)
- * - 条件匹配模式下匹配规则并返回对应数据
- * - 处理版本切换
- * - 处理响应头
- */
-
-const { MATCH_MODE_VALUE } = require('../../config/const')
-
-/**
- * 返回 Mock 响应数据
- * @param {Object} res - Whistle 响应对象
- * @param {string} sourceData - 源数据 (file.json 的字符串内容)
- * @param {Object} options - 配置选项
- * @param {string} options.mockVersion - Mock 版本名称 (null 表示使用源数据)
- * @param {Object} options.groupManager - 组管理器实例
- * @param {string} options.currentGroupId - 当前组ID
- * @param {string} options.filename - 文件名
- * @param {Object} options.originalReq - Whistle 原始请求对象（用于条件匹配）
- */
-async function sendMockResponse(res, sourceData, options = {}) {
-  const { mockVersion, groupManager, currentGroupId, filename, originalReq } = options
-
-  // 解析源数据 (storageAdapter.readFile 返回的是 session 对象的 JSON 字符串)
-  const session = JSON.parse(sourceData)
-  const sourceResponse = session?.res
-  const { statusCode, statusMessage } = sourceResponse
-
-  // 浅拷贝 headers，避免直接修改 session 对象（若未来引入缓存会产生副作用）
-  const headers = { ...sourceResponse.headers }
-  headers['from-mockbubu-source'] = 'true'
-  headers['x-mockbubu-mocked'] = 'true'
-  delete headers['content-encoding']
-  delete headers['content-length']
-
-  // 【条件匹配模式】
-  if (mockVersion === MATCH_MODE_VALUE) {
-    const matchResult = await matchByConditions({
-      groupManager,
-      currentGroupId,
-      filename,
-      originalReq,
-    })
-
-    headers['x-mockbubu-match-mode'] = 'match'
-
-    if (matchResult.matched) {
-      // header 值必须为 ASCII，对中文规则名做 encodeURIComponent 编码
-      headers['x-mockbubu-match-rule'] = encodeURIComponent(matchResult.ruleName || '')
-      headers['x-mockbubu-match-params'] = encodeURIComponent(matchResult.paramsSummary || '')
-      res.writeHead(statusCode, statusMessage, headers)
-      res.end(JSON.stringify(matchResult.content ?? {}))
-      return
-    }
-
-    // 全不命中 → 通知调用方透传请求，不返回 mock 数据
-    return { action: 'passthrough' }
-  }
-
-  // 【版本直选模式】先确认版本数据是否存在，再统一调用 writeHead
-  if (mockVersion && groupManager && currentGroupId && filename) {
-    const versionData = await groupManager.getGroupVersionContent(currentGroupId, filename, mockVersion)
-    if (versionData) {
-      res.writeHead(statusCode, statusMessage, headers)
-      res.end(JSON.stringify(versionData))
-      return
-    }
-    // 版本不存在时降级到源数据
-  }
-
-  res.writeHead(statusCode, statusMessage, headers)
-  res.end(sourceResponse.body)
-}
-
-/**
- * 条件匹配核心逻辑
- *
- * 匹配规则：
- * 1. 按条件数量降序（条件越多优先级越高）
- * 2. 条件数量相同时按 priority 字段升序（数字越小越优先）
- * 3. 空条件规则作为兜底，最后匹配
- * 4. 全不命中时返回 matched: false，由调用方降级到 source
+ * - 保留 checkShouldCapture（仅 server 钩子使用）
+ * - sendMockResponse / matchByConditions / handleConcurrentCapture 重新导出自 shared
  *
- * @param {Object} params
- * @param {Object} params.groupManager - 组管理器
- * @param {string} params.currentGroupId - 当前组ID
- * @param {string} params.filename - 文件名（URL）
- * @param {Object} params.originalReq - Whistle 原始请求对象
- * @returns {{ matched: boolean, content?, ruleName?, paramsSummary? }}
+ * 实现位置:
+ * - lib/core/shared/mock-response.js: sendMockResponse + matchByConditions + 辅助函数
+ * - lib/core/shared/concurrent.js: handleConcurrentCapture
  */
-async function matchByConditions(params) {
-  const { groupManager, currentGroupId, filename, originalReq } = params
 
-  // 获取所有匹配规则（storage 层已按 priority 排序）
-  const matchVersions = await groupManager.getMatchVersions(currentGroupId, filename)
-  if (!matchVersions || matchVersions.length === 0) {
-    return { matched: false }
-  }
-
-  // 提取当前请求参数
-  const queryParams = extractQueryParams(originalReq)
-  const payloadParams = extractPayloadParams(originalReq)
-
-  // 按条件数量降序 + priority 升序排序（条件越多越具体，优先匹配）
-  // storage 层已按 priority 排序，这里再按 conditions.length 降序叠加
-  const sorted = [...matchVersions].sort((a, b) => {
-    const condDiff = (b.conditions?.length || 0) - (a.conditions?.length || 0)
-    if (condDiff !== 0) return condDiff
-    return (a.priority || 0) - (b.priority || 0)
-  })
-
-  let fallbackRule = null
-
-  // 逐条匹配（AND 关系：所有条件必须同时满足）
-  for (const rule of sorted) {
-    if (!rule.conditions || rule.conditions.length === 0) {
-      // 空条件规则作为兜底，记录备用
-      if (!fallbackRule) fallbackRule = rule
-      continue
-    }
-
-    const allMatch = rule.conditions.every((cond) => {
-      const sourceParams = cond.source === 'query' ? queryParams : payloadParams
-      return matchCondition(sourceParams, cond)
-    })
-
-    if (allMatch) {
-      return {
-        matched: true,
-        content: rule.content ?? {},
-        ruleName: rule.name,
-        paramsSummary: rule.conditions
-          .map(c => `${c.source}.${c.key}[${c.operator || 'eq'}]${c.value ?? ''}`)
-          .join(', '),
-      }
-    }
-  }
-
-  // 尝试兜底规则（空条件规则）
-  if (fallbackRule) {
-    return {
-      matched: true,
-      content: fallbackRule.content ?? {},
-      ruleName: fallbackRule.name,
-      paramsSummary: '(default)',
-    }
-  }
-
-  return { matched: false }
-}
-
-/**
- * 单条件匹配：根据 operator 执行对应的比较
- * operator 缺省时向后兼容旧数据（等同 eq）
- *
- * @param {Object} sourceParams - 请求参数 key-value 对
- * @param {{ key: string, operator?: string, value?: string }} cond
- * @returns {boolean}
- */
-function matchCondition(sourceParams, cond) {
-  const { key, value = '' } = cond
-  const operator = cond.operator || 'eq'
-
-  // 条件不完整时跳过（视为满足），避免空值产生意外的匹配行为
-  if (!key) return true
-  const VALUELESS_OPS = new Set(['exists', 'not_exists'])
-  if (!VALUELESS_OPS.has(operator) && !value) return true
-
-  const exists = Object.prototype.hasOwnProperty.call(sourceParams, key)
-  const actual = exists ? String(sourceParams[key]) : undefined
-  const expected = String(value)
-
-  switch (operator) {
-    case 'eq':
-      return actual === expected
-    case 'neq':
-      return actual !== expected
-    case 'contains':
-      return actual !== undefined && actual.includes(expected)
-    case 'regex': {
-      if (!actual) return false
-      try {
-        return new RegExp(expected).test(actual)
-      } catch {
-        return false
-      }
-    }
-    case 'exists':
-      return exists
-    case 'not_exists':
-      return !exists
-    default:
-      return actual === expected
-  }
-}
-
-/**
- * 从原始请求中提取 query 参数
- * 来源：req.originalReq.url，fallback 到 x-whistle-full-url header
- *
- * @param {Object} originalReq - Whistle 原始请求对象
- * @returns {Object} query 参数 key-value 对
- */
-function extractQueryParams(originalReq) {
-  if (!originalReq) return {}
-
-  try {
-    // 某些 Whistle 代理场景（tunnel/HTTP2）下 originalReq.url 可能不含 query，
-    // 完整 URL 会在 x-whistle-full-url header 里（URL 编码格式）
-    const fullUrlHeader = originalReq.headers?.['x-whistle-full-url']
-    const rawUrl = originalReq.url ||
-      (fullUrlHeader ? decodeURIComponent(fullUrlHeader) : '') ||
-      ''
-    const url = new URL(rawUrl)
-    const params = {}
-    url.searchParams.forEach((value, key) => {
-      params[key] = value
-    })
-    return params
-  } catch {
-    return {}
-  }
-}
-
-/**
- * 从原始请求中提取 payload 参数（支持 JSON 和 x-www-form-urlencoded，只提取第一层 key-value）
- * 来源：req.originalReq.body
- *
- * @param {Object} originalReq - Whistle 原始请求对象
- * @returns {Object} payload 参数 key-value 对（值统一转为字符串）
- */
-function extractPayloadParams(originalReq) {
-  if (!originalReq) return {}
-
-  try {
-    // 优先使用 mock 路径预缓冲的请求体，fallback 到 Whistle 预解析的 body
-    let body = originalReq._reqBody || originalReq.body || ''
-
-    // Buffer 转字符串
-    if (Buffer.isBuffer(body)) {
-      body = body.toString('utf8')
-    }
-
-    // body 可能已被 Whistle 预解析为对象，直接提取
-    if (typeof body === 'object' && body !== null) {
-      return extractFlatParams(body)
-    }
-
-    if (typeof body !== 'string' || !body.trim()) {
-      return {}
-    }
-
-    // 尝试 JSON 格式
-    try {
-      const parsed = JSON.parse(body)
-      if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
-        return extractFlatParams(parsed)
-      }
-    } catch {
-      // 不是 JSON，继续尝试
-    }
-
-    // 尝试 application/x-www-form-urlencoded 格式
-    if (body.includes('=')) {
-      const result = {}
-      new URLSearchParams(body).forEach((value, key) => {
-        result[key] = value
-      })
-      if (Object.keys(result).length > 0) return result
-    }
-
-    return {}
-  } catch {
-    return {}
-  }
-}
-
-/**
- * 从对象中提取第一层 string/number/boolean 类型的 key-value（统一转为字符串）
- * @param {Object} obj
- * @returns {Object}
- */
-function extractFlatParams(obj) {
-  const params = {}
-  Object.keys(obj).forEach((key) => {
-    const val = obj[key]
-    if (typeof val === 'string' || typeof val === 'number' || typeof val === 'boolean') {
-      params[key] = String(val)
-    }
-  })
-  return params
-}
+// 重新导出共用实现（保持 server.js 调用链不变）
+const { sendMockResponse } = require('../shared/mock-response')
+const { handleConcurrentCapture } = require('../shared/concurrent')
 
 /**
  * 检查是否需要捕获源数据
@@ -329,65 +49,6 @@ async function checkShouldCapture(params) {
   }
 }
 
-/**
- * 处理并发捕获时的等待逻辑
- * @param {Map} capturingFiles - 捕获中的文件 Map
- * @param {string} captureKey - 捕获 key
- * @param {Object} params - 参数对象
- * @returns {Promise<Object>} { handled, response }
- */
-async function handleConcurrentCapture(capturingFiles, captureKey, params) {
-  const {
-    res,
-    storageAdapter,
-    groupManager,
-    currentGroupId,
-    filename,
-    mockVersion,
-    filePath,
-    originalReq,
-  } = params
-
-  if (!capturingFiles.has(captureKey)) {
-    return { handled: false }
-  }
-
-  // 正在捕获源数据中，等待捕获完成
-  console.log(`[mockbubu] ⏳ 检测到并发请求，等待源数据捕获完成: ${filename}`)
-
-  try {
-    // 等待第一个请求捕获完成（最多等待10秒）
-    await Promise.race([
-      capturingFiles.get(captureKey),
-      new Promise((_resolve, reject) => setTimeout(() => reject(new Error('捕获超时')), 10000)),
-    ])
-
-    // 捕获完成，重新读取源数据
-    const freshSourceData = await storageAdapter.readFile(filePath)
-    if (freshSourceData) {
-      console.log(`[mockbubu] ✅ 等待成功，返回捕获的源数据: ${filename}`)
-
-      await sendMockResponse(res, freshSourceData, {
-        mockVersion,
-        groupManager,
-        currentGroupId,
-        filename,
-        originalReq,
-      })
-
-      return { handled: true, response: 'success' }
-    } else {
-      // 等待后仍无源数据，降级到透传
-      console.warn(`[mockbubu] ⚠️  等待后仍无源数据，降级透传: ${filename}`)
-      return { handled: true, response: 'passthrough' }
-    }
-  } catch (err) {
-    // 等待超时或失败，降级到透传
-    console.error(`[mockbubu] ❌ 等待捕获失败，降级透传: ${filename}`, err.message)
-    return { handled: true, response: 'passthrough' }
-  }
-}
-
 module.exports = {
   sendMockResponse,
   checkShouldCapture,

package/lib/core/server-entry/server.js

@@ -22,19 +22,7 @@ const {
   captureResponse,
 } = require('./capture-handler')
 const pluginModeManager = require('../plugin-mode-manager')
-
-/**
- * 从 req 流缓冲请求体，供条件匹配使用
- * 仅在 mock 路径调用，此时 req 流未被 pipe，可安全读取
- */
-function bufferReqBody(req) {
-  return new Promise((resolve) => {
-    const chunks = []
-    req.on('data', chunk => chunks.push(chunk))
-    req.on('end', () => resolve(Buffer.concat(chunks)))
-    req.on('error', () => resolve(Buffer.alloc(0)))
-  })
-}
+const { bufferReqBody } = require('../shared/buffer')
 
 module.exports = (server, options) => {
   console.log('[mockbubu] 🚀 server.js 模块已加载!')
@@ -69,6 +57,10 @@ module.exports = (server, options) => {
       await new Promise(resolve => setTimeout(resolve, 100))
     }
 
+    // 【互斥标志】标记此请求已由 server 钩子处理
+    // resWrite 钩子见此标志直接 passThrough，不重复处理
+    req._mockbubuServerHandled = true
+
     // 判断是否需要拦截该请求（使用模式管理器获取当前模式）
     const interceptResult = shouldInterceptRequest(req, storage, pluginModeManager.getMode())
 

package/lib/core/shared/buffer.js

@@ -0,0 +1,23 @@
+/**
+ * 文件名: buffer.js
+ * 功能: 请求体缓冲工具（共用模块）
+ * 职责:
+ * - 从 req 流缓冲请求体，供条件匹配使用
+ * - 仅在 mock 路径调用，此时 req 流未被 pipe，可安全读取
+ */
+
+/**
+ * 从 req 流缓冲请求体
+ * @param {Object} req - Whistle 请求对象
+ * @returns {Promise<Buffer>} 请求体 Buffer
+ */
+function bufferReqBody(req) {
+  return new Promise((resolve) => {
+    const chunks = []
+    req.on('data', chunk => chunks.push(chunk))
+    req.on('end', () => resolve(Buffer.concat(chunks)))
+    req.on('error', () => resolve(Buffer.alloc(0)))
+  })
+}
+
+module.exports = { bufferReqBody }

package/lib/core/shared/capture.js

@@ -0,0 +1,203 @@
+/**
+ * 文件名: capture.js
+ * 功能: 源数据捕获逻辑（共用模块）
+ * 职责:
+ * - 捕获真实 API 响应数据
+ * - 处理响应体解压缩
+ * - 保存源数据到存储 (file.json)
+ * - 更新文件配置
+ * - 并发控制
+ *
+ * 从 lib/core/server-entry/capture-handler.js 抽取，供 server / resWrite 钩子共用
+ *
+ * 注意:
+ * - captureResponse 用于「server 钩子接管请求」场景：主动 req.request 发起上游请求
+ * - resWrite 钩子「不接管请求」场景应使用 captureAndPassthrough（见 res-write/response-rewriter.js）
+ */
+
+const {
+  setApiListUpdated,
+  handleBuffer2String,
+  withTryCatch,
+} = require('../../utils/utils')
+
+/**
+ * 捕获真实 API 响应数据
+ *
+ * @param {Object} params - 参数对象
+ * @param {Object} params.req - Whistle 请求对象
+ * @param {Object} params.res - Whistle 响应对象
+ * @param {Object} params.storageAdapter - 存储适配器
+ * @param {Object} params.groupManager - 组管理器
+ * @param {Object} params.memoryBuffer - 内存缓冲区
+ * @param {string} params.currentGroupId - 当前组ID
+ * @param {string} params.filename - 文件名
+ * @param {boolean} params.isFirstCapture - 是否首次捕获
+ * @param {boolean} params.mock - Mock 状态
+ * @param {Object} params.requestInfo - 请求信息 { method, rule, pattern, ruleValue, url }
+ * @param {Map} params.capturingFiles - 捕获中的文件 Map
+ * @param {Object} params.storage - Whistle storage 对象
+ */
+async function captureResponse(params) {
+  const {
+    req,
+    res,
+    storageAdapter,
+    groupManager,
+    memoryBuffer,
+    currentGroupId,
+    filename,
+    isFirstCapture,
+    mock,
+    requestInfo,
+    capturingFiles,
+    storage,
+  } = params
+
+  const { method, rule, pattern, ruleValue, url } = requestInfo
+  const captureKey = `${currentGroupId}/${filename}`
+
+  console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] 🚀 captureResponse 函数开始执行: ${filename}`)
+
+  // 设置捕获标志
+  let resolveCapture
+  const capturePromise = new Promise(resolve => { resolveCapture = resolve })
+  capturingFiles.set(captureKey, capturePromise)
+
+  console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] 🌐 准备调用 req.request(): ${filename}`)
+
+  // 发起真实请求
+  const client = req.request((svrRes) => {
+    console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] 🔵 req.request 回调已执行: ${filename}`)
+    const encoding = svrRes.headers['content-encoding']
+    let body
+
+    svrRes.on('data', (data) => {
+      console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] 📥 接收数据块: ${filename}, 大小: ${data?.length || 0}`)
+      body = body ? Buffer.concat([body, data]) : data
+    })
+
+    svrRes.on('end', withTryCatch(async () => {
+      try {
+        if (!body) {
+          console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] ⚠️  响应体为空，跳过捕获: ${filename}`)
+          return
+        }
+
+        const resContentType = svrRes.headers['content-type'] || ''
+        if (!resContentType.includes('application/json')) {
+          console.log(`[mockbubu] ⏭️  非 JSON 响应，跳过捕获: ${filename} (Content-Type: ${resContentType})`)
+          return
+        }
+
+        console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] 📦 响应接收完成，开始解压: ${filename}`)
+        // 解压响应体
+        const content = await handleBuffer2String({ body, encoding })
+        console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] ✅ 解压完成，调用 req.getSession(): ${filename}`)
+
+        // 获取完整的请求响应数据 (用于构建源数据)
+        req.getSession(async (session) => {
+          console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] 🔍 getSession 回调已触发: ${filename}`)
+          console.log('[mockbubu DEBUG] session.req.body存在:', !!session?.req?.body)
+          console.log('[mockbubu DEBUG] session.req.body类型:', typeof session?.req?.body)
+          if (session?.req?.body) {
+            console.log('[mockbubu DEBUG] session.req.body前200字符:', String(session.req.body).substring(0, 200))
+          }
+          try {
+            // 如果设置了 enable://hide 会获取到空数据
+            if (!session) {
+              console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] ⚠️  session 为空（可能设置了 enable://hide）: ${filename}`)
+              return
+            }
+
+            console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] 💾 开始保存源数据: ${filename}`)
+            // 保存源数据和文件配置
+            await saveSourceData({
+              session,
+              content,
+              storageAdapter,
+              groupManager,
+              memoryBuffer,
+              currentGroupId,
+              filename,
+              isFirstCapture,
+              mock,
+              method,
+              rule,
+              pattern,
+              ruleValue,
+              url,
+              storage,
+            })
+
+            console.log(`[mockbubu] ✅ 捕获完成: ${filename}`)
+          } finally {
+            // 捕获完成，清除标志并通知等待的请求
+            resolveCapture()
+            capturingFiles.delete(captureKey)
+          }
+        })
+      } catch (err) {
+        console.error(`[mockbubu] ❌ 捕获过程出错: ${filename}`, err)
+        // 出错也要清除标志
+        resolveCapture()
+        capturingFiles.delete(captureKey)
+      }
+    }))
+
+    // 将响应透传给客户端
+    svrRes.pipe(res)
+  })
+
+  console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] ✅ req.request() 已调用，准备 pipe 数据: ${filename}`)
+
+  req.pipe(client)
+
+  console.log(`[mockbubu 2025/12/8 ${new Date().toLocaleTimeString()}] ✅ req.pipe(client) 已完成: ${filename}`)
+}
+
+/**
+ * 保存源数据到内存缓冲区
+ *
+ * 职责：
+ * - 不写入文件系统（文件仅在用户点击"保存"时创建）
+ * - 将完整会话数据添加到内存缓冲区（供前端轮询拉取）
+ * - 刷新页面后，memoryBuffer 自动清空，未保存的数据消失
+ *
+ * @param {Object} params - 参数对象
+ */
+async function saveSourceData(params) {
+  const {
+    session,
+    content,
+    memoryBuffer,
+    currentGroupId,
+    url,
+    method,
+    storage,
+  } = params
+
+  // 1. 构建完整会话数据
+  const sourceDataToSave = JSON.parse(JSON.stringify(session))
+  sourceDataToSave.res.body = content
+
+  // 2. 添加到内存缓冲区（供前端轮询拉取）
+  // MemoryBuffer 内部会检查暂存区是否已存在，已存在则跳过
+  memoryBuffer.add(currentGroupId, url, {
+    method,
+    status: session.res.statusCode,
+    session: sourceDataToSave,
+  })
+
+  // 3. ⚠️ 不要在捕获时创建文件配置
+  //    只有用户明确点击"保存"按钮后，才会创建 file.json + versions/
+  //    捕获的数据仅保存在 memoryBuffer 中，刷新后自动清空
+
+  // 4. 标记 API 列表已更新
+  await setApiListUpdated(storage, true)
+}
+
+module.exports = {
+  captureResponse,
+  saveSourceData,
+}

package/lib/core/shared/concurrent.js

@@ -0,0 +1,72 @@
+/**
+ * 文件名: concurrent.js
+ * 功能: 并发捕获控制（共用模块）
+ * 职责:
+ * - 处理并发捕获时的等待逻辑
+ * - 同一文件并发请求时，后续请求等待首个捕获完成
+ *
+ * 从 lib/core/server-entry/response-handler.js 抽取，供 server / resWrite 钩子共用
+ */
+
+const { sendMockResponse } = require('./mock-response')
+
+/**
+ * 处理并发捕获时的等待逻辑
+ * @param {Map} capturingFiles - 捕获中的文件 Map
+ * @param {string} captureKey - 捕获 key
+ * @param {Object} params - 参数对象
+ * @returns {Promise<Object>} { handled, response }
+ */
+async function handleConcurrentCapture(capturingFiles, captureKey, params) {
+  const {
+    res,
+    storageAdapter,
+    groupManager,
+    currentGroupId,
+    filename,
+    mockVersion,
+    filePath,
+    originalReq,
+  } = params
+
+  if (!capturingFiles.has(captureKey)) {
+    return { handled: false }
+  }
+
+  // 正在捕获源数据中，等待捕获完成
+  console.log(`[mockbubu] ⏳ 检测到并发请求，等待源数据捕获完成: ${filename}`)
+
+  try {
+    // 等待第一个请求捕获完成（最多等待10秒）
+    await Promise.race([
+      capturingFiles.get(captureKey),
+      new Promise((_resolve, reject) => setTimeout(() => reject(new Error('捕获超时')), 10000)),
+    ])
+
+    // 捕获完成，重新读取源数据
+    const freshSourceData = await storageAdapter.readFile(filePath)
+    if (freshSourceData) {
+      console.log(`[mockbubu] ✅ 等待成功，返回捕获的源数据: ${filename}`)
+
+      await sendMockResponse(res, freshSourceData, {
+        mockVersion,
+        groupManager,
+        currentGroupId,
+        filename,
+        originalReq,
+      })
+
+      return { handled: true, response: 'success' }
+    } else {
+      // 等待后仍无源数据，降级到透传
+      console.warn(`[mockbubu] ⚠️  等待后仍无源数据，降级透传: ${filename}`)
+      return { handled: true, response: 'passthrough' }
+    }
+  } catch (err) {
+    // 等待超时或失败，降级到透传
+    console.error(`[mockbubu] ❌ 等待捕获失败，降级透传: ${filename}`, err.message)
+    return { handled: true, response: 'passthrough' }
+  }
+}
+
+module.exports = { handleConcurrentCapture }