whistle.mockbubu 1.0.0 → 2.0.0-beta.1

package/.gitignore

@@ -61,3 +61,7 @@ typings/
 .next
 /.history
 /dist
+
+# macOS system files
+.DS_Store
+**/.DS_Store

package/README.md

@@ -1,76 +1,225 @@
 # whistle.mockbubu
 
-whistle.mockbubu 是[whistle](https://github.com/avwo/whistle)的一个扩展脚本插件，包括以下功能
+whistle.mockbubu is an extension script plugin for [whistle](https://github.com/avwo/whistle) that provides the following features:
 
-- 实时生成捕获接口的 mock 文件
-- 管理 mock 文件
+- Real-time generation of mock files from captured API responses
+- Mock file management
 
-# 安装
+# Installation
 
+```bash
 $ w2 install whistle.mockbubu
+```
 
-# 用法
+# Usage
 
-### 配置 [whistle 规则](https://avwo.github.io/whistle/rules/)
+### Configure [whistle rules](https://avwo.github.io/whistle/rules/)
 
-> mode 有三种选项 pathname | href | pattern，默认是 pathname
+> Default mode uses pathname
 
 ```text
 pattern mockbubu://[mode]
 ```
 
-### 生成 mock 文件
+### Generate Mock Files
 
 ---
 
-#### pathname 模式：使用接口的 origin + pathname 作为文件名
+#### Pathname Mode: Uses the interface's origin + pathname as the filename
 
 ```text
-pattern mockbubu://  或者 pattern mockbubu://pathname
+pattern mockbubu://   or pattern mockbubu://pathname
 ```
 
+> After configuring the rules and enabling the plugin, mockbubu will capture matching request data in real-time
+
+[![step1.png](https://i.postimg.cc/MpvFTQkF/step1.png)](https://postimg.cc/21Nw93SQ)
+
 ---
 
-#### href 模式：使用接口的 路径 作为文件名
+### Start Mocking
 
-```text
-pattern mockbubu://href
+**Step 1:** Enable the mock switch for the file. When mockbubu intercepts the corresponding request, it will directly return the matched request data. After enabling the mock switch, you can manage file content in the Response panel.
 
-```
+**Step 2:** Manage file content in the Response panel
+
+**Edit Files**
+
+- Supports file editing
+- Supports keyboard shortcuts for saving: Mac: Command + S / Windows: Ctrl + S
+
+**Multiple Versions**
+
+- Supports creating different versions of file content. Click to switch between different versions for instant effect and return that version's data
+- The "source" version is the default generated version containing the original API response data and supports modification
+
+**Switch Mock Files**
+
+- Mock return content uses the currently selected version
+
+[![step2.png](https://i.postimg.cc/K8wsg8xv/step2.png)](https://postimg.cc/Js3Qfms9)
 
 ---
 
-#### pattern 模式：使用 pattern 作为文件名
+# Performance & Memory Monitoring
 
-```text
-pattern mockbubu://pattern
+For developers and advanced users, we provide performance monitoring tools:
+
+## Memory Usage Monitoring
+
+Monitor real-time memory usage of the mockbubu plugin:
+
+```bash
+$ node scripts/monitor-memory.js
 ```
 
+This will display:
+- Heap memory usage (New Space & Old Space)
+- Process memory (RSS, external, array buffers)
+- GC statistics
+- Warnings when memory usage exceeds 80%
+
+## Stress Testing
+
+Test plugin performance with large datasets:
+
+```bash
+$ ./scripts/stress-test-memory.sh [file_count] [group_name]
+
+# Example: Create 10,000 test files
+$ ./scripts/stress-test-memory.sh 10000 stress-test-group
+```
+
+The test will:
+1. Create specified number of mock files
+2. Measure API list query performance (cold start, hot cache, concurrent)
+3. Test batch deletion performance
+4. Generate a detailed performance report
+
+## Memory Limit Analysis
+
+See [docs/MEMORY-LIMIT-ANALYSIS.md](/docs/MEMORY-LIMIT-ANALYSIS.md) for:
+- Whistle's `--max-semi-space-size=64` parameter explanation
+- Memory architecture analysis (New Space vs Old Space)
+- Impact assessment for different file counts (10K, 100K, 1M files)
+- Optimization recommendations
+- Action plan for scaling
+
+**Key Findings**:
+- Current implementation is safe for up to 10,000 files without any optimization
+- For 100,000+ files, consider implementing pagination or index sharding
+- The plugin's file-system based V3 architecture provides excellent memory efficiency
+
 ---
 
-### 开始 mock
+# whistle.mockbubu
 
-第一步：开启文件的 mock 开关，系统生成一条规则：
+whistle.mockbubu 是[whistle](https://github.com/avwo/whistle)的一个扩展脚本插件，包括以下功能
+
+- 实时生成捕获接口的 mock 文件
+- 管理 mock 文件
+
+# 安装
+
+$ w2 install whistle.mockbubu
 
+# 用法
+
+### 配置 [whistle 规则](https://avwo.github.io/whistle/rules/)
+
+> mode默认使用 pathname
+
+```text
+pattern mockbubu://[mode]
 ```
-文件名 resBody:{文件内容}
+
+### 生成 mock 文件
+
+---
+
+#### pathname 模式：使用接口的 origin + pathname 作为文件名
+
+```text
+pattern mockbubu://  或者 pattern mockbubu://pathname
 ```
+> 配置规则并开启插件后，mockbubu将实时获取匹配到的请求数据
 
-第二步：在 Response 面板管理文件内容
+[![step1.png](https://i.postimg.cc/MpvFTQkF/step1.png)](https://postimg.cc/21Nw93SQ)
+
+---
+
+### 开始 mock
+
+第一步：开启文件的 mock 开关，拦截到对应请求mockbubu将直接返回对应匹配请求的数据，开启mock开关后可在Response面板管理文件内容
 
-手动添加文件
 
-- 如果需要提前生成 mock 文件，可手动添加（通常不需要手动添加，通过实时捕获接口即可生成 mock 文件）
+第二步：在 Response 面板管理文件内容
 
 编辑文件
 
 - 支持文件编辑
+- 支持快捷键保存 Mac: Command + s / Windows: Ctrl + s
 
 多版本
 
-- 支持新增不同版本的文件内容
+- 支持新增不同版本的文件内容,点击切换不同版本即刻生效返回该版本数据
 - 其中 source 版本是默认生成的，是原始接口响应数据，支持修改
 
 切换 mock 文件
 
 - mock 返回内容使用当前选中的版本
+
+[![step2.png](https://i.postimg.cc/K8wsg8xv/step2.png)](https://postimg.cc/Js3Qfms9)
+
+---
+
+# 性能与内存监控
+
+为开发者和高级用户提供性能监控工具：
+
+## 内存使用监控
+
+实时监控 mockbubu 插件的内存使用情况：
+
+```bash
+$ node scripts/monitor-memory.js
+```
+
+将显示以下信息：
+- 堆内存使用情况（New Space 和 Old Space）
+- 进程内存（RSS、外部内存、数组缓冲区）
+- GC 统计
+- 内存使用超过 80% 时的警告
+
+## 压力测试
+
+使用大数据集测试插件性能：
+
+```bash
+$ ./scripts/stress-test-memory.sh [文件数量] [组名]
+
+# 示例：创建 10,000 个测试文件
+$ ./scripts/stress-test-memory.sh 10000 stress-test-group
+```
+
+测试将执行：
+1. 创建指定数量的 mock 文件
+2. 测量 API 列表查询性能（冷启动、热缓存、并发）
+3. 测试批量删除性能
+4. 生成详细的性能报告
+
+## 内存限制分析
+
+查看 [docs/MEMORY-LIMIT-ANALYSIS.md](/docs/MEMORY-LIMIT-ANALYSIS.md) 了解：
+- Whistle 的 `--max-semi-space-size=64` 参数说明
+- 内存架构分析（New Space vs Old Space）
+- 不同文件数量（1万、10万、100万）的影响评估
+- 优化建议
+- 扩展性行动计划
+
+**关键结论**：
+- 当前实现在 10,000 文件以下完全安全，无需任何优化
+- 对于 100,000+ 文件，建议实施分页或索引分片
+- 插件的基于文件系统的 V3 架构提供了出色的内存效率
+
+---

package/lib/archive-utils.js

@@ -0,0 +1,332 @@
+/**
+ * 压缩包工具函数
+ * 使用 Node.js 内置 API，无需额外依赖
+ */
+const fs = require('fs').promises
+const path = require('path')
+const zlib = require('zlib')
+const { createReadStream, createWriteStream } = require('fs')
+const { pipeline } = require('stream/promises')
+const os = require('os')
+
+/**
+ * 递归复制目录
+ */
+async function copyDirectory(src, dest) {
+  await fs.mkdir(dest, { recursive: true })
+  const entries = await fs.readdir(src, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name)
+    const destPath = path.join(dest, entry.name)
+
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath)
+    } else {
+      await fs.copyFile(srcPath, destPath)
+    }
+  }
+}
+
+/**
+ * 递归读取目录，返回所有文件路径
+ */
+async function getAllFiles(dir, baseDir = dir) {
+  const files = []
+  const entries = await fs.readdir(dir, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name)
+    if (entry.isDirectory()) {
+      files.push(...await getAllFiles(fullPath, baseDir))
+    } else {
+      files.push({
+        path: fullPath,
+        name: path.relative(baseDir, fullPath),
+      })
+    }
+  }
+
+  return files
+}
+
+/**
+ * 创建 tar.gz 压缩包
+ * 使用 Node.js 内置 zlib + tar 格式手动实现
+ */
+async function createTarGz(sourceDir, outputFile) {
+  // 获取所有文件
+  const files = await getAllFiles(sourceDir)
+
+  // 创建 tar 文件
+  const tarPath = outputFile.replace(/\.gz$/, '')
+  await createTar(sourceDir, tarPath, files)
+
+  // gzip 压缩
+  await new Promise((resolve, reject) => {
+    const input = createReadStream(tarPath)
+    const output = createWriteStream(outputFile)
+    const gzip = zlib.createGzip()
+
+    pipeline(input, gzip, output)
+      .then(() => {
+        // 删除临时 tar 文件
+        fs.unlink(tarPath).catch(() => {})
+        resolve()
+      })
+      .catch(reject)
+  })
+}
+
+/**
+ * 创建 tar 文件（简化实现，支持基本的 tar 格式）
+ */
+async function createTar(sourceDir, outputFile, files) {
+  const output = createWriteStream(outputFile)
+
+  for (const file of files) {
+    const stat = await fs.stat(file.path)
+    const content = await fs.readFile(file.path)
+
+    // 写入 tar header (512 bytes)
+    const header = createTarHeader(file.name, stat.size)
+    output.write(header)
+
+    // 写入文件内容
+    output.write(content)
+
+    // 对齐到 512 字节边界
+    const padding = 512 - (content.length % 512)
+    if (padding < 512) {
+      output.write(Buffer.alloc(padding, 0))
+    }
+  }
+
+  // 写入结束标记（两个 512 字节的零块）
+  output.write(Buffer.alloc(1024, 0))
+  output.end()
+
+  return new Promise((resolve, reject) => {
+    output.on('finish', resolve)
+    output.on('error', reject)
+  })
+}
+
+/**
+ * 创建 tar header (POSIX ustar 格式)
+ */
+function createTarHeader(filename, size) {
+  const header = Buffer.alloc(512, 0)
+
+  // 文件名 (100 bytes)
+  header.write(filename, 0, 100, 'utf8')
+
+  // 文件模式 (8 bytes) - 0644
+  header.write('0000644 ', 100, 8, 'utf8')
+
+  // UID (8 bytes)
+  header.write('0000000 ', 108, 8, 'utf8')
+
+  // GID (8 bytes)
+  header.write('0000000 ', 116, 8, 'utf8')
+
+  // 文件大小 (12 bytes, 8进制)
+  const sizeOctal = size.toString(8).padStart(11, '0') + ' '
+  header.write(sizeOctal, 124, 12, 'utf8')
+
+  // 修改时间 (12 bytes, 8进制)
+  const mtime = Math.floor(Date.now() / 1000).toString(8).padStart(11, '0') + ' '
+  header.write(mtime, 136, 12, 'utf8')
+
+  // Checksum (8 bytes) - 先填充空格
+  header.write('        ', 148, 8, 'utf8')
+
+  // 文件类型 (1 byte) - '0' = 普通文件
+  header.write('0', 156, 1, 'utf8')
+
+  // ustar 标识 (6 bytes)
+  header.write('ustar', 257, 6, 'utf8')
+
+  // ustar 版本 (2 bytes)
+  header.write('00', 263, 2, 'utf8')
+
+  // 计算 checksum
+  let checksum = 0
+  for (let i = 0; i < 512; i++) {
+    checksum += header[i]
+  }
+  const checksumOctal = checksum.toString(8).padStart(6, '0') + '\0 '
+  header.write(checksumOctal, 148, 8, 'utf8')
+
+  return header
+}
+
+/**
+ * 解压 tar.gz 文件
+ */
+async function extractTarGz(archiveFile, destDir) {
+  // 先 gunzip 解压
+  const tarPath = path.join(os.tmpdir(), `extract-${Date.now()}.tar`)
+
+  await new Promise((resolve, reject) => {
+    const input = createReadStream(archiveFile)
+    const output = createWriteStream(tarPath)
+    const gunzip = zlib.createGunzip()
+
+    pipeline(input, gunzip, output)
+      .then(resolve)
+      .catch(reject)
+  })
+
+  // 解压 tar
+  await extractTar(tarPath, destDir)
+
+  // 删除临时 tar 文件
+  await fs.unlink(tarPath).catch(() => {})
+}
+
+/**
+ * 解压 tar 文件
+ */
+async function extractTar(tarFile, destDir) {
+  const buffer = await fs.readFile(tarFile)
+  let offset = 0
+
+  while (offset < buffer.length) {
+    // 检查是否到达结束标记
+    if (buffer[offset] === 0) {
+      break
+    }
+
+    // 读取 header
+    const header = buffer.subarray(offset, offset + 512)
+
+    // 读取文件名
+    const filename = header.subarray(0, 100).toString('utf8').replace(/\0.*$/, '')
+    if (!filename) break
+
+    // 读取文件大小
+    const sizeStr = header.subarray(124, 136).toString('utf8').trim()
+    const size = parseInt(sizeStr, 8)
+
+    // 跳过 header
+    offset += 512
+
+    // 读取文件内容
+    const content = buffer.subarray(offset, offset + size)
+
+    // 写入文件
+    const filepath = path.join(destDir, filename)
+    await fs.mkdir(path.dirname(filepath), { recursive: true })
+    await fs.writeFile(filepath, content)
+
+    // 移动到下一个文件（对齐到 512 字节）
+    const padding = 512 - (size % 512)
+    offset += size + (padding < 512 ? padding : 0)
+  }
+}
+
+/**
+ * 文件名安全处理（移除特殊字符）
+ */
+function sanitizeFilename(filename) {
+  // eslint-disable-next-line no-control-regex
+  return filename.replace(/[<>:"/\\|?*\x00-\x1F]/g, '_')
+}
+
+/**
+ * 检查路径是否在指定目录内（防止路径遍历攻击）
+ */
+function isPathSafe(filepath, baseDir) {
+  const normalized = path.normalize(filepath)
+  const relative = path.relative(baseDir, normalized)
+  return !relative.startsWith('..') && !path.isAbsolute(relative)
+}
+
+/**
+ * 解析 multipart/form-data 文件上传（原生实现）
+ */
+async function parseMultipartFile(ctx) {
+  return new Promise((resolve, reject) => {
+    const contentType = ctx.request.headers['content-type']
+    if (!contentType || !contentType.includes('multipart/form-data')) {
+      reject(new Error('不是 multipart/form-data 格式'))
+      return
+    }
+
+    // 提取 boundary
+    const boundaryMatch = contentType.match(/boundary=(.+)/)
+    if (!boundaryMatch) {
+      reject(new Error('缺少 boundary'))
+      return
+    }
+    const boundary = '--' + boundaryMatch[1]
+
+    const chunks = []
+    ctx.req.on('data', chunk => chunks.push(chunk))
+    ctx.req.on('end', () => {
+      try {
+        const buffer = Buffer.concat(chunks)
+        const file = parseMultipartBuffer(buffer, boundary)
+        resolve(file)
+      } catch (err) {
+        reject(err)
+      }
+    })
+    ctx.req.on('error', reject)
+  })
+}
+
+/**
+ * 解析 multipart buffer
+ */
+function parseMultipartBuffer(buffer, boundary) {
+  const parts = []
+  let start = 0
+
+  while (start < buffer.length) {
+    // 查找 boundary
+    const boundaryIndex = buffer.indexOf(boundary, start)
+    if (boundaryIndex === -1) break
+
+    // 查找下一个 boundary
+    const nextBoundaryIndex = buffer.indexOf(boundary, boundaryIndex + boundary.length)
+    if (nextBoundaryIndex === -1) break
+
+    // 提取部分内容
+    const partBuffer = buffer.subarray(boundaryIndex + boundary.length, nextBoundaryIndex)
+
+    // 查找 headers 和 body 的分隔符（\r\n\r\n）
+    const headerEndIndex = partBuffer.indexOf('\r\n\r\n')
+    if (headerEndIndex !== -1) {
+      const headers = partBuffer.subarray(0, headerEndIndex).toString('utf8')
+      const body = partBuffer.subarray(headerEndIndex + 4, partBuffer.length - 2) // 去掉结尾的 \r\n
+
+      // 解析 Content-Disposition
+      const filenameMatch = headers.match(/filename="(.+?)"/)
+      const nameMatch = headers.match(/name="(.+?)"/)
+
+      if (filenameMatch) {
+        parts.push({
+          fieldname: nameMatch ? nameMatch[1] : 'file',
+          filename: filenameMatch[1],
+          buffer: body,
+        })
+      }
+    }
+
+    start = nextBoundaryIndex
+  }
+
+  return parts[0] // 返回第一个文件
+}
+
+module.exports = {
+  copyDirectory,
+  getAllFiles,
+  createTarGz,
+  extractTarGz,
+  sanitizeFilename,
+  isPathSafe,
+  parseMultipartFile,
+}

package/lib/const.js

@@ -26,3 +26,22 @@ exports.LockedFilterMap = {
   'locked': { key: 'locked', value: true, method: 'equal' },
   'unlocked': { key: 'locked', value: false, method: 'equal' },
 }
+
+// HTTP Method 筛选映射
+exports.MethodFilterMap = {
+  'GET': { key: 'method', value: 'GET', method: 'equal' },
+  'POST': { key: 'method', value: 'POST', method: 'equal' },
+  'PUT': { key: 'method', value: 'PUT', method: 'equal' },
+  'DELETE': { key: 'method', value: 'DELETE', method: 'equal' },
+  'PATCH': { key: 'method', value: 'PATCH', method: 'equal' },
+  'HEAD': { key: 'method', value: 'HEAD', method: 'equal' },
+  'OPTIONS': { key: 'method', value: 'OPTIONS', method: 'equal' },
+}
+
+// 状态码筛选映射（使用自定义 method: 'statusRange'）
+exports.StatusFilterMap = {
+  '2xx': { key: 'status', value: [200, 299], method: 'range' },
+  '3xx': { key: 'status', value: [300, 399], method: 'range' },
+  '4xx': { key: 'status', value: [400, 499], method: 'range' },
+  '5xx': { key: 'status', value: [500, 599], method: 'range' },
+}