whistle.mockbubu 2.2.7 → 2.2.9-beta.1

package/index.js

@@ -8,7 +8,7 @@ exports.server = require('./lib/core/server-entry/server')
 // exports.reqRead = require('./lib/reqRead')
 // exports.reqWrite = require('./lib/reqWrite');
 // exports.resRead = require('./lib/resRead')
-// exports.resWrite = require('./lib/resWrite')
+exports.resWrite = require('./lib/core/res-write')
 // exports.wsReqRead = require('./lib/wsReqRead');
 // exports.wsReqWrite = require('./lib/wsReqWrite');
 // exports.wsResRead = require('./lib/wsResRead');

package/lib/config/rule-collector.js

@@ -15,7 +15,7 @@ class RuleCollector {
 
   /**
    * 添加一条生效的规则
-   * @param {string} rule - 规则字符串，如 "*.shein.com mockbubu://pathname"
+   * @param {string} rule - 规则字符串，如 "* mockbubu://pathname"
    */
   addRule(rule) {
     this.activeRules.add(rule)

package/lib/core/res-write/index.js

@@ -0,0 +1,151 @@
+/**
+ * 文件名: index.js
+ * 功能: Whistle resWrite 钩子入口
+ * 职责:
+ * - 接管走了 * whistle.mockbubu:// + * pipe://mockbubu 的请求（响应阶段介入）
+ * - 默认只记录请求（透传 + 捕获），请求响应不可改变
+ * - 仅当该请求在插件内开启 mock 开关命中时，改写响应体
+ *
+ * 互斥机制：
+ * - 能走 server 钩子的请求，server 钩子打标 req._mockbubuServerHandled = true
+ * - resWrite 钩子见此标志直接 req.pipe(res) 放行，不重复处理
+ */
+
+const {
+  getFilename,
+  getRule,
+} = require('../../utils/utils')
+const ruleCollector = require('../../config/rule-collector')
+const { PLUGIN_MODE } = require('../../config/const')
+const { awaitShared } = require('../shared/initializers')
+const { captureAndPassthrough, rewriteResponse } = require('./response-rewriter')
+
+module.exports = (server, options) => {
+  console.log('[mockbubu] 🚀 resWrite 钩子已加载')
+  const { storage } = options
+
+  // 共享初始化（与 server 钩子幂等，已初始化则直接返回缓存）
+  let shared = null
+  awaitShared(options).then((s) => {
+    shared = s
+  }).catch((err) => {
+    console.error('[mockbubu][resWrite] ❌ 共享初始化失败:', err)
+    shared = { _initialized: true, _initError: true }
+  })
+
+  server.on('request', async (req, res) => {
+    // 等待初始化完成
+    // eslint-disable-next-line no-unmodified-loop-condition
+    while (!shared || !shared._initialized) {
+      await new Promise((resolve) => setTimeout(resolve, 100))
+    }
+
+    // 初始化失败，安全降级透传
+    if (shared._initError) {
+      return req.pipe(res)
+    }
+
+    // 【互斥放行】能走 server 钩子的请求，resWrite 直接放行不重复处理
+    if (req._mockbubuServerHandled) {
+      return req.pipe(res)
+    }
+
+    const { storageAdapter, groupManager, memoryBuffer, pluginModeManager } = shared
+
+    // resWrite 钩子中 req.headers / req.originalReq.headers 均为上游响应头
+    // （见 whistle getOptions isResRules 分支 + setContext oReq.headers = headers）
+    // 不能用 shouldInterceptRequest 的请求头 isJsonReq 判断，改用响应头 content-type
+    // 注意：JSON 过滤只在"透传+捕获"分支生效——mock 命中时即便上游返回非 JSON
+    // 错误响应（如 HTML 错误页、空 body）也必须改写为 mock，不再因非 JSON 提前放行
+    const originalReq = req.originalReq
+
+    // 从 originalReq 提取请求信息（setContext 已注入 url/ruleValue/pattern/method）
+    const filename = getFilename(originalReq)
+    const rule = getRule(originalReq)
+    const { ruleValue, pattern } = originalReq
+    const url = filename
+    const method = req.method || originalReq.method
+    const mode = pluginModeManager.getMode()
+
+    // 收集生效规则（用于 UI 帮助提示）
+    ruleCollector.addRule(rule)
+
+    try {
+      const currentGroupId = await groupManager.getCurrentGroupId()
+      const fileConfig = await groupManager.getGroupFileConfig(currentGroupId, filename)
+      const { mock, mockVersion } = fileConfig
+      const sourceData = await storageAdapter.readFile(`${currentGroupId}/${filename}`)
+
+      // 透传 + 捕获的公共参数
+      const captureParams = {
+        req,
+        res,
+        memoryBuffer,
+        currentGroupId,
+        filename,
+        method,
+        url,
+        rule,
+        pattern,
+        ruleValue,
+        storage,
+        isFirstCapture: true,
+        mock,
+      }
+
+      console.log(`[mockbubu] 🚀 resWrite 进入流程 | mode=${mode}, mock=${mock}, 有数据=${!!sourceData} | URL: ${url}`)
+
+      // 【Mock-Only 模式】对齐 server 钩子语义
+      if (mode === PLUGIN_MODE.MOCK_ONLY) {
+        // 无 mock / 无数据 → 透传不捕获
+        if (!mock || !sourceData) {
+          console.log(`[mockbubu][resWrite] Mock-Only 透传（mock=${mock}, 有数据=${!!sourceData}）| URL: ${url}`)
+          return req.pipe(res)
+        }
+        // 有 mock + 有数据 → 改写响应体（不捕获）
+        console.log(`[mockbubu][resWrite] Mock-Only 改写响应体 | URL: ${url}`)
+        return rewriteResponse({
+          req,
+          res,
+          sourceData,
+          mockVersion,
+          groupManager,
+          currentGroupId,
+          filename,
+          originalReq,
+          captureParams,
+        })
+      }
+
+      // 【default 模式】
+      // mock 开启 + 有源数据 → 改写响应体
+      if (mock && sourceData) {
+        console.log(`[mockbubu][resWrite] 改写响应体 | URL: ${url}`)
+        return rewriteResponse({
+          req,
+          res,
+          sourceData,
+          mockVersion,
+          groupManager,
+          currentGroupId,
+          filename,
+          originalReq,
+          captureParams,
+        })
+      }
+
+      // mock 未开启 / 无源数据 → 透传 + 捕获（请求响应不可改变）
+      // 仅捕获 JSON 响应；非 JSON（图片/CSS/HTML 等）直接放行不捕获
+      const resContentType = (req.headers || {})['content-type'] || ''
+      if (!resContentType.includes('application/json')) {
+        console.log(`[mockbubu][resWrite] ⏭️  非 JSON 响应放行 | Content-Type: ${resContentType}`)
+        return req.pipe(res)
+      }
+      console.log(`[mockbubu][resWrite] 透传+捕获（mock=${mock}, 有数据=${!!sourceData}）| URL: ${url}`)
+      return captureAndPassthrough(captureParams)
+    } catch (err) {
+      console.error('[mockbubu][resWrite] ❌ 处理失败，降级透传:', err)
+      try { req.pipe(res) } catch (e) {}
+    }
+  })
+}

package/lib/core/res-write/response-rewriter.js

@@ -0,0 +1,258 @@
+/**
+ * 文件名: response-rewriter.js
+ * 功能: resWrite 钩子的响应处理逻辑
+ * 职责:
+ * - captureAndPassthrough: 透传响应 + 旁路捕获源数据（不改写响应）
+ * - rewriteResponse: 改写响应体（mock 命中时）
+ *
+ * resWrite 钩子 req/res 语义（基于 whistle 源码 + 运行时验证）:
+ * - req 是可读流，流数据 = 上游响应体
+ * - req.headers = 上游响应头（含 content-type / content-encoding），与 res.headers 同引用
+ *   （见 whistle inspectors/res.js: res.headers = req.resHeaders = headers）
+ * - req.originalReq = 原始请求对象（拿 url / ruleValue / pattern / body）
+ * - req.getSession(cb) = 拿完整 session（响应结束后回调）
+ * - res = 写回客户端的 encoder Transform 流（objectMode）
+ *
+ * 透传：req.pipe(res)（响应头由 whistle 外层处理）
+ * 改写：按上游 content-encoding 压缩 mock body 后 res.end(body) 写回客户端
+ *       （resWrite 钩子改不了响应头，必须使头体匹配，见 sendMockBody / compressBody）。
+ */
+
+const zlib = require('zlib')
+const {
+  handleBuffer2String,
+  withTryCatch,
+} = require('../../utils/utils')
+const { matchByConditions } = require('../shared/mock-response')
+const { saveSourceData } = require('../shared/capture')
+const { MATCH_MODE_VALUE } = require('../../config/const')
+
+/**
+ * 透传响应 + 旁路捕获源数据（不改写响应）
+ *
+ * 适用场景：
+ * - mock 未开启
+ * - 无源数据
+ * - 条件匹配模式全不命中
+ *
+ * @param {Object} params
+ */
+function captureAndPassthrough(params) {
+  const {
+    req, res,
+    memoryBuffer, currentGroupId, filename,
+    method, url, rule, pattern, ruleValue,
+    storage, isFirstCapture, mock,
+  } = params
+
+  const headers = req.headers || {}
+  const contentType = headers['content-type'] || ''
+  const encoding = headers['content-encoding']
+  const isJson = contentType.includes('application/json')
+
+  // 旁路 buffer 响应体（pipe 同时透传，on('data') 不影响 pipe）
+  const chunks = []
+  if (isJson) {
+    req.on('data', (c) => chunks.push(c))
+  }
+
+  // 透传响应给客户端（响应头由 whistle 外层处理）
+  req.pipe(res)
+
+  // 响应结束后旁路捕获
+  req.on('end', withTryCatch(async () => {
+    if (!isJson) return
+
+    const body = chunks.length ? Buffer.concat(chunks) : null
+    if (!body) {
+      console.log(`[mockbubu][resWrite] ⚠️  响应体为空，跳过捕获: ${filename}`)
+      return
+    }
+
+    let content
+    try {
+      content = await handleBuffer2String({ body, encoding })
+    } catch (err) {
+      console.error(`[mockbubu][resWrite] ❌ 解压失败: ${filename}`, err.message)
+      return
+    }
+
+    req.getSession(async (session) => {
+      if (!session) {
+        console.log(`[mockbubu][resWrite] ⚠️  session 为空，跳过: ${filename}`)
+        return
+      }
+      try {
+        await saveSourceData({
+          session,
+          content,
+          memoryBuffer,
+          currentGroupId,
+          filename,
+          isFirstCapture,
+          mock,
+          method,
+          rule,
+          pattern,
+          ruleValue,
+          url,
+          storage,
+        })
+        console.log(`[mockbubu][resWrite] ✅ 捕获完成: ${filename}`)
+      } catch (err) {
+        console.error(`[mockbubu][resWrite] ❌ 保存失败: ${filename}`, err.message)
+      }
+    })
+  }))
+
+  req.on('error', (err) => {
+    console.error(`[mockbubu][resWrite] ❌ 响应流错误: ${filename}`, err.message)
+    try { res.end() } catch (e) {}
+  })
+}
+
+/**
+ * 消费上游响应体（改写场景，不需要上游 body，但要 drain 防止 backpressure）
+ *
+ * 上游响应体可能很大，若不消费会涨满 decoder readable buffer，backpressure 传回
+ * 隧道 socket，影响 encoder 写回 mock body。drain 到 end 即可释放。
+ *
+ * @param {Object} req - 上游响应体可读流（decoder）
+ * @returns {Promise<void>} 上游响应体结束
+ */
+function drainReq(req) {
+  return new Promise((resolve) => {
+    let resolved = false
+    const done = () => {
+      if (resolved) return
+      resolved = true
+      resolve()
+    }
+    req.on('data', () => {})
+    req.on('end', done)
+    req.on('error', (err) => {
+      console.error(`[mockbubu][resWrite] ❌ drain 错误: ${err.message}`)
+      done()
+    })
+    req.on('close', done)
+  })
+}
+
+/**
+ * 按上游 content-encoding 压缩 mock body
+ *
+ * resWrite 钩子改不了响应头（CONNECT 隧道只传 body），客户端收到的 content-encoding
+ * 仍是上游的（如 br/gzip）。若写回明文 mock body，客户端按压缩格式解压会失败 → 0 bytes。
+ * 因此把明文 mock body 按上游编码重新压缩，使头体匹配，客户端正常解压。
+ *
+ * @param {Buffer} body - 明文 mock body
+ * @param {string} encoding - 上游 content-encoding（br/gzip/deflate）
+ * @returns {Buffer} 压缩后的 body（失败或无编码时返回原 body）
+ */
+function compressBody(body, encoding) {
+  if (!encoding) return body
+  try {
+    if (encoding === 'br') return zlib.brotliCompressSync(body)
+    if (encoding === 'gzip') return zlib.gzipSync(body)
+    if (encoding === 'deflate') return zlib.deflateSync(body)
+  } catch (err) {
+    console.error(`[mockbubu][resWrite] ❌ 压缩失败（encoding=${encoding}），降级明文: ${err.message}`)
+  }
+  return body
+}
+
+/**
+ * 写回 mock body 给客户端
+ *
+ * res 是 whistle transproto 的 encoder Transform 流（objectMode）：
+ * res.end(body) → _transform → pack(body) + pack() 终止帧 → pipe 到 socket。
+ *
+ * 响应头改不了（CONNECT 隧道只传 body），上游 content-encoding 会被原样发给客户端，
+ * 故 mock body 必须按上游编码压缩使头体匹配（见 compressBody）。
+ *
+ * @param {Object} req - 上游响应流（decoder），req.headers 含上游 content-encoding
+ * @param {Object} res - encoder Transform 流
+ * @param {string|Buffer} body - 明文 mock 响应体
+ * @param {string} filename - 文件名（日志用）
+ * @param {string} label - 版本/匹配标签（日志用）
+ */
+function sendMockBody(req, res, body, filename, label) {
+  try {
+    const bodyBuf = Buffer.isBuffer(body) ? body : Buffer.from(String(body ?? ''))
+    const encoding = (req.headers || {})['content-encoding']
+    const outBuf = compressBody(bodyBuf, encoding)
+    res.end(outBuf)
+    console.log(`[mockbubu][resWrite] ✅ mock body 已写入: ${filename} (label=${label}, ${bodyBuf.length} bytes${encoding ? ` → ${encoding}=${outBuf.length}` : ''})`)
+  } catch (err) {
+    console.error(`[mockbubu][resWrite] ❌ 写回 mock body 失败: ${filename}`, err.message, err.stack)
+    try { res.end() } catch (e) {}
+  }
+}
+
+/**
+ * 改写响应体（mock 命中时）
+ *
+ * 流程：
+ * 1. 条件匹配模式：先判断命中（不消费 req 流）
+ *    - 命中 → drain 上游 + 写回 mock body
+ *    - 全不命中 → 退回 captureAndPassthrough
+ * 2. 版本直选 / 源数据 → drain 上游 + 写回 mock body
+ *
+ * @param {Object} params
+ */
+async function rewriteResponse(params) {
+  const {
+    req, res,
+    sourceData, mockVersion,
+    groupManager, currentGroupId, filename, originalReq,
+    captureParams,
+  } = params
+
+  console.log(`[mockbubu][resWrite] 🔧 rewriteResponse 进入 | mockVersion=${mockVersion || 'source'} | ${filename}`)
+
+  // 【条件匹配模式】先判断命中（不消费上游响应流）
+  if (mockVersion === MATCH_MODE_VALUE) {
+    const matchResult = await matchByConditions({
+      groupManager,
+      currentGroupId,
+      filename,
+      originalReq,
+    })
+
+    // 全不命中 → 退回透传 + 捕获
+    if (!matchResult.matched) {
+      console.log(`[mockbubu][resWrite] 条件匹配全不命中，退回透传+捕获: ${filename}`)
+      return captureAndPassthrough(captureParams)
+    }
+
+    // 命中 → drain 上游 + 写回 mock body
+    console.log(`[mockbubu][resWrite] 🔧 条件命中，准备 drain | ${filename}`)
+    await drainReq(req)
+    const body = JSON.stringify(matchResult.content ?? {})
+    sendMockBody(req, res, body, filename, `match:${matchResult.ruleName}`)
+    return
+  }
+
+  // 【版本直选 / 源数据】drain 上游 + 写回 mock body
+  console.log(`[mockbubu][resWrite] 🔧 版本/源数据，准备 drain | ${filename}`)
+  await drainReq(req)
+
+  let body = JSON.parse(sourceData)?.res?.body
+
+  // 版本直选：优先用版本数据
+  if (mockVersion && groupManager && currentGroupId && filename) {
+    const versionData = await groupManager.getGroupVersionContent(currentGroupId, filename, mockVersion)
+    if (versionData) {
+      body = JSON.stringify(versionData)
+    }
+    // 版本不存在时降级到源数据
+  }
+
+  sendMockBody(req, res, body, filename, mockVersion || 'source')
+}
+
+module.exports = {
+  captureAndPassthrough,
+  rewriteResponse,
+  drainReq,
+}

package/lib/core/rulesServer.js

@@ -1,6 +1,14 @@
 /**
  * rulesServer 钩子
  * 动态返回 mockbubu 规则，根据启用状态控制
+ *
+ * 三条规则分工：
+ * 1) * mockbubu://         → server 钩子（能走 server 钩子的请求，原完整逻辑）
+ * 2) * whistle.mockbubu:// → plugin 上下文（让 resWrite 能拿请求详情）
+ * 3) * pipe://mockbubu     → resWrite 钩子（走了 whistle.mockbubu:// 的请求，响应阶段介入）
+ *
+ * 互斥保证：server 钩子处理请求时打标 req._mockbubuServerHandled，
+ * resWrite 钩子见此标志直接 passThrough，不重复处理。
  */
 module.exports = (server, options) => {
   server.on('request', (req, res) => {
@@ -17,12 +25,15 @@ module.exports = (server, options) => {
     }
 
     // 启用时返回 mockbubu 规则
-    // 这里返回通配规则，让所有请求都经过 server 钩子判断
     const rules = `
 # mockbubu 插件规则
-# 所有请求都会经过 mockbubu server 钩子处理
-# 具体是否 mock 由 server 钩子中的 mock 开关决定
-* mockbubu://
+# 1) * mockbubu://         → server 钩子（未命中 host 转发的请求，原捕获 + mock 改写）
+# 2) * whistle.mockbubu:// → plugin 上下文（让 resWrite 能拿请求详情）
+# 3) * pipe://mockbubu     → resWrite 钩子（走了 whistle.mockbubu:// 的请求，响应阶段介入）
+# 互斥：server 钩子已处理的请求，resWrite 直接 passThrough
+# * mockbubu://
+# * whistle.mockbubu://
+# * pipe://mockbubu
     `.trim()
 
     console.log('[mockbubu] ✅ 插件已启用，返回规则')

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

@@ -1,195 +1,13 @@
 /**
  * 文件名: capture-handler.js
- * 功能: 源数据捕获逻辑
+ * 功能: 源数据捕获逻辑（薄封装，实现已抽取到 shared）
  * 职责:
- * - 捕获真实 API 响应数据
- * - 处理响应体解压缩
- * - 保存源数据到存储 (file.json)
- * - 更新文件配置
- * - 并发控制
- */
-
-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}`)
-}
-
-/**
- * 保存源数据到内存缓冲区
+ * - captureResponse / saveSourceData 重新导出自 shared
  *
- * 职责：
- * - 不写入文件系统（文件仅在用户点击"保存"时创建）
- * - 将完整会话数据添加到内存缓冲区（供前端轮询拉取）
- * - 刷新页面后，memoryBuffer 自动清空，未保存的数据消失
- *
- * @param {Object} params - 参数对象
+ * 实现位置: lib/core/shared/capture.js
  */
-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)
-}
+const { captureResponse, saveSourceData } = require('../shared/capture')
 
 module.exports = {
   captureResponse,