whistle.mockbubu 2.0.0 → 2.1.0

package/lib/uiServer/router/global/system-info-router.js

@@ -0,0 +1,386 @@
+/**
+ * 文件名: system-info-router.js
+ * 功能: 系统信息路由（存储统计、规则信息、内存监控）
+ * 依赖: util.js, fs, path, child_process
+ *
+ * 职责:
+ * - 存储统计（文件数量、磁盘占用）
+ * - 生效规则列表查询
+ * - 内存使用监控（堆内存、GC统计）
+ *
+ * 路由:
+ * - GET /cgi-bin/mockbubu/storage-stats - 存储统计
+ * - GET /cgi-bin/mockbubu/active-rules - 生效规则列表
+ * - GET /cgi-bin/mockbubu/memory-stats - 内存统计
+ */
+
+const {
+  createErrorResponse,
+  createSuccessResponse,
+} = require('../../utils/util')
+const fs = require('fs').promises
+const path = require('path')
+const ruleCollector = require('../../../config/rule-collector')
+
+module.exports = (router) => {
+  /**
+   * 存储统计信息
+   *
+   * 功能:
+   * - 统计所有组的文件数量
+   * - 统计 mock 状态、锁定状态
+   * - 统计版本数量
+   * - 计算磁盘占用（groups, backup, recycle_bin, tmp）
+   *
+   * 响应:
+   * ```javascript
+   * {
+   *   code: 0,
+   *   data: {
+   *     // 文件统计
+   *     totalFiles: 100,
+   *     mockEnabled: 30,
+   *     mockDisabled: 70,
+   *     locked: 5,
+   *     totalVersions: 50,
+   *
+   *     // 磁盘使用（字节）
+   *     diskUsage: {
+   *       total: 10485760,
+   *       groups: 8388608,
+   *       backup: 1048576,
+   *       recycleBin: 1048576,
+   *       tmp: 0
+   *     },
+   *
+   *     // 组详情
+   *     groups: [
+   *       {
+   *         id: 'default',
+   *         name: '默认组',
+   *         mockEnabled: 30,
+   *         locked: 5
+   *       }
+   *     ],
+   *
+   *     // 元信息
+   *     timestamp: 1762891525570,
+   *     baseDir: '/path/to/.whistle/...'
+   *   },
+   *   msg: 'success'
+   * }
+   * ```
+   */
+  router.get('/cgi-bin/mockbubu/storage-stats', async (ctx) => {
+    const timestamp = new Date().toLocaleString('zh-CN', { hour12: false })
+    console.log(`[mockbubu ${timestamp}] 开始统计存储信息`)
+
+    try {
+      const { storageAdapter } = ctx
+      const v3Storage = storageAdapter.getV3Storage()
+
+      // 1. 获取所有组
+      const groups = await v3Storage.listGroups()
+      console.log(`[mockbubu ${timestamp}] 组数量: ${groups.length}`)
+
+      // 2. 统计文件数据
+      let totalFiles = 0
+      let mockEnabled = 0
+      let mockDisabled = 0
+      let locked = 0
+      let totalVersions = 0
+
+      const groupsData = []
+
+      for (const group of groups) {
+        const fileIndexData = await v3Storage.getIndex(group.id)
+        totalFiles += fileIndexData.files.length
+
+        let groupMockEnabled = 0
+        let groupLocked = 0
+
+        // 统计每个文件的状态和版本数
+        for (const fileEntry of fileIndexData.files) {
+          // 从索引中读取配置信息（V3 架构已包含）
+          if (fileEntry.config) {
+            if (fileEntry.config.mock) {
+              mockEnabled++
+              groupMockEnabled++
+            } else {
+              mockDisabled++
+            }
+
+            if (fileEntry.config.locked) {
+              locked++
+              groupLocked++
+            }
+          } else {
+            mockDisabled++
+          }
+
+          // 统计版本数（从索引中的 versionCount）
+          totalVersions += fileEntry.versionCount || 0
+        }
+
+        groupsData.push({
+          id: group.id,
+          name: group.name,
+          description: group.description,
+          mockEnabled: groupMockEnabled,
+          locked: groupLocked,
+        })
+      }
+
+      // 3. 计算目录大小（包括 groups, .backup, .recycle_bin, .tmp）
+      const { exec } = require('child_process')
+      const { promisify } = require('util')
+      const execAsync = promisify(exec)
+
+      const getDirectorySize = async (dirPath) => {
+        try {
+          await fs.access(dirPath)
+          const { stdout, stderr } = await execAsync(`du -sk "${dirPath}"`)
+          if (stderr) {
+            console.error(`[mockbubu ${timestamp}] du stderr: ${stderr}`)
+          }
+          const sizeKB = parseInt(stdout.trim().split(/\s+/)[0])
+          const sizeBytes = sizeKB * 1024
+          console.log(`[mockbubu ${timestamp}] 目录大小: ${path.basename(dirPath)} => ${sizeKB} KB (${(sizeBytes / 1024 / 1024).toFixed(2)} MB)`)
+          return sizeBytes // 转换为字节
+        } catch (error) {
+          console.error(`[mockbubu ${timestamp}] 获取目录大小失败: ${dirPath}`, error.message)
+          return 0
+        }
+      }
+
+      const baseDir = v3Storage.baseDir
+      console.log(`[mockbubu ${timestamp}] baseDir: ${baseDir}`)
+
+      const [groupsSize, backupSize, recycleBinSize, tmpSize] = await Promise.all([
+        getDirectorySize(path.join(baseDir, 'groups')),
+        getDirectorySize(path.join(baseDir, '.backup')),
+        getDirectorySize(path.join(baseDir, '.recycle_bin')),
+        getDirectorySize(path.join(baseDir, '.tmp')),
+      ])
+
+      const totalDiskUsage = groupsSize + backupSize + recycleBinSize + tmpSize
+
+      console.log(`[mockbubu ${timestamp}] 统计完成:`, {
+        totalFiles,
+        mockEnabled,
+        locked,
+        totalVersions,
+        totalDiskUsage: (totalDiskUsage / 1024 / 1024).toFixed(2) + ' MB',
+      })
+
+      // 4. 返回统计数据
+      ctx.body = createSuccessResponse({
+        // 文件统计
+        totalFiles,
+        mockEnabled,
+        mockDisabled,
+        locked,
+        totalVersions,
+
+        // 磁盘使用统计
+        diskUsage: {
+          total: totalDiskUsage,
+          groups: groupsSize,
+          backup: backupSize,
+          recycleBin: recycleBinSize,
+          tmp: tmpSize,
+        },
+
+        // 组详情
+        groups: groupsData,
+
+        // 元信息
+        timestamp: Date.now(),
+        baseDir,
+      })
+    } catch (error) {
+      const timestampError = new Date().toLocaleString('zh-CN', { hour12: false })
+      console.error(`[mockbubu ${timestampError}] 存储统计失败:`, error)
+      ctx.body = createErrorResponse(`存储统计失败: ${error.message}`)
+    }
+  })
+
+  /**
+   * 获取生效的 Whistle 规则列表
+   *
+   * 功能:
+   * - 获取当前会话中生效的 mockbubu 规则
+   * - 规则由 server.js 在捕获请求时记录
+   * - 用于帮助用户调试 Whistle 规则配置
+   *
+   * 响应:
+   * ```javascript
+   * {
+   *   code: 0,
+   *   data: {
+   *     rules: [
+   *       '*.example.com mockbubu://pathname',
+   *       'https://api.test.com mockbubu://href'
+   *     ],
+   *     count: 2,
+   *     message: '检测到 2 条生效的规则'
+   *   },
+   *   msg: 'success'
+   * }
+   * ```
+   *
+   * 注意:
+   * - 规则列表会在一定时间后自动过期（10秒）
+   * - 如果没有规则，提示用户检查 Whistle 配置
+   */
+  router.get('/cgi-bin/mockbubu/active-rules', async (ctx) => {
+    try {
+      const rules = ruleCollector.getRules()
+      const count = ruleCollector.getCount()
+
+      ctx.body = createSuccessResponse({
+        rules,
+        count,
+        message: count > 0
+          ? `检测到 ${count} 条生效的规则`
+          : '尚未检测到生效的规则，请确保 Whistle 规则已配置并有请求触发',
+      })
+    } catch (error) {
+      console.error('[mockbubu] 获取规则列表失败:', error)
+      ctx.body = createErrorResponse(`获取规则列表失败: ${error.message}`)
+    }
+  })
+
+  /**
+   * 内存使用统计
+   *
+   * 功能:
+   * - 监控 Node.js 进程内存使用
+   * - 统计堆内存（Heap）使用情况
+   * - 统计新生代（New Space）和老生代（Old Space）
+   * - 提供 GC 相关统计信息
+   *
+   * 响应:
+   * ```javascript
+   * {
+   *   code: 0,
+   *   data: {
+   *     // 总体堆内存（单位：MB）
+   *     heap: {
+   *       used: '50.00',
+   *       total: '100.00',
+   *       limit: '1024.00',
+   *       usagePercent: '4.88'
+   *     },
+   *
+   *     // New Space（新生代，存放新对象）
+   *     newSpace: {
+   *       size: '10.00',
+   *       used: '5.00',
+   *       usagePercent: '50.00',
+   *       available: '5.00',
+   *       physical: '10.00'
+   *     },
+   *
+   *     // Old Space（老生代，存放长期对象）
+   *     oldSpace: {
+   *       size: '90.00',
+   *       used: '45.00',
+   *       usagePercent: '50.00',
+   *       available: '45.00',
+   *       physical: '90.00'
+   *     },
+   *
+   *     // 进程总内存
+   *     process: {
+   *       rss: '120.00',        // 常驻内存
+   *       heapUsed: '50.00',    // 已用堆内存
+   *       heapTotal: '100.00',  // 总堆内存
+   *       external: '2.00',     // C++ 对象内存
+   *       arrayBuffers: '1.00'  // ArrayBuffer 内存
+   *     },
+   *
+   *     // GC 统计
+   *     gc: {
+   *       mallocedMemory: '55.00',
+   *       peakMalloced: '60.00',
+   *       nativeContexts: 5,
+   *       detachedContexts: 0
+   *     },
+   *
+   *     timestamp: '2025-12-02T10:00:00.000Z',
+   *     pid: 12345
+   *   },
+   *   msg: '内存统计数据获取成功'
+   * }
+   * ```
+   */
+  router.get('/cgi-bin/mockbubu/memory-stats', async (ctx) => {
+    try {
+      const v8 = require('v8')
+      const memoryUsage = process.memoryUsage()
+      const heapStats = v8.getHeapStatistics()
+      const heapSpaces = v8.getHeapSpaceStatistics()
+
+      // 格式化字节为 MB
+      const formatMB = (bytes) => (bytes / 1024 / 1024).toFixed(2)
+
+      // New Space 和 Old Space
+      const newSpace = heapSpaces.find(space => space.space_name === 'new_space')
+      const oldSpace = heapSpaces.find(space => space.space_name === 'old_space')
+
+      // 计算使用率
+      const heapUsagePercent = ((heapStats.used_heap_size / heapStats.heap_size_limit) * 100).toFixed(2)
+
+      ctx.body = createSuccessResponse({
+        // 总体堆内存
+        heap: {
+          used: formatMB(heapStats.used_heap_size),
+          total: formatMB(heapStats.total_heap_size),
+          limit: formatMB(heapStats.heap_size_limit),
+          usagePercent: heapUsagePercent,
+        },
+        // New Space (Young Generation)
+        newSpace: newSpace
+          ? {
+            size: formatMB(newSpace.space_size),
+            used: formatMB(newSpace.space_used_size),
+            usagePercent: ((newSpace.space_used_size / newSpace.space_size) * 100).toFixed(2),
+            available: formatMB(newSpace.space_available_size),
+            physical: formatMB(newSpace.physical_space_size),
+          }
+          : null,
+        // Old Space (Old Generation)
+        oldSpace: oldSpace
+          ? {
+            size: formatMB(oldSpace.space_size),
+            used: formatMB(oldSpace.space_used_size),
+            usagePercent: ((oldSpace.space_used_size / oldSpace.space_size) * 100).toFixed(2),
+            available: formatMB(oldSpace.space_available_size),
+            physical: formatMB(oldSpace.physical_space_size),
+          }
+          : null,
+        // 进程总内存
+        process: {
+          rss: formatMB(memoryUsage.rss),
+          heapUsed: formatMB(memoryUsage.heapUsed),
+          heapTotal: formatMB(memoryUsage.heapTotal),
+          external: formatMB(memoryUsage.external),
+          arrayBuffers: formatMB(memoryUsage.arrayBuffers),
+        },
+        // GC 统计
+        gc: {
+          mallocedMemory: formatMB(heapStats.malloced_memory),
+          peakMalloced: formatMB(heapStats.peak_malloced_memory),
+          nativeContexts: heapStats.number_of_native_contexts,
+          detachedContexts: heapStats.number_of_detached_contexts,
+        },
+        // 时间戳
+        timestamp: new Date().toISOString(),
+        pid: process.pid,
+      }, '内存统计数据获取成功')
+    } catch (error) {
+      ctx.body = createErrorResponse(error.message)
+    }
+  })
+}

package/lib/uiServer/router/{group-router.js → groups/group-router.js}

@@ -1,21 +1,21 @@
 const {
   createErrorResponse,
   createSuccessResponse,
-} = require('../util')
+} = require('../../utils/util')
 const {
   validate,
-} = require('../validator')
+} = require('../../utils/validator')
 
 /**
  * 组管理路由
  */
 module.exports = (router) => {
   // 获取组列表
-  router.post('/cgi-bin/mockbubu/groups/list', (ctx) => {
+  router.post('/cgi-bin/mockbubu/groups/list', async (ctx) => {
     try {
       const { groupManager } = ctx
-      const groups = groupManager.getGroups()
-      const currentGroupId = groupManager.getCurrentGroupId()
+      const groups = await groupManager.getGroups()
+      const currentGroupId = await groupManager.getCurrentGroupId()
 
       ctx.body = createSuccessResponse({
         groups,
@@ -27,14 +27,14 @@ module.exports = (router) => {
   })
 
   // 获取当前组
-  router.post('/cgi-bin/mockbubu/groups/current', (ctx) => {
+  router.post('/cgi-bin/mockbubu/groups/current', async (ctx) => {
     try {
       const { groupManager } = ctx
-      const currentGroup = groupManager.getCurrentGroup()
+      const currentGroup = await groupManager.getCurrentGroup()
 
       ctx.body = createSuccessResponse({
         currentGroup,
-        currentGroupId: groupManager.getCurrentGroupId(),
+        currentGroupId: await groupManager.getCurrentGroupId(),
       })
     } catch (error) {
       ctx.body = createErrorResponse(error.message)
@@ -65,12 +65,12 @@ module.exports = (router) => {
       }
       return null
     },
-  }), (ctx) => {
+  }), async (ctx) => {
     try {
       const { groupManager } = ctx
       const { name, description, copyFromGroupId } = ctx.request.body
 
-      const newGroup = groupManager.createGroup({
+      const newGroup = await groupManager.createGroup({
         name: name.trim(),
         description: description ? description.trim() : '',
         copyFromGroupId: copyFromGroupId || null,
@@ -107,12 +107,12 @@ module.exports = (router) => {
       }
       return null
     },
-  }), (ctx) => {
+  }), async (ctx) => {
     try {
       const { groupManager } = ctx
       const { groupId, name, description } = ctx.request.body
 
-      const updatedGroup = groupManager.updateGroup(groupId, {
+      const updatedGroup = await groupManager.updateGroup(groupId, {
         name: name ? name.trim() : undefined,
         description: description !== undefined ? description.trim() : undefined,
       })
@@ -131,12 +131,13 @@ module.exports = (router) => {
       }
       return null
     },
-  }), (ctx) => {
+  }), async (ctx) => {
     try {
-      const { groupManager } = ctx
+      const { groupManager, memoryBuffer } = ctx
       const { groupId } = ctx.request.body
 
-      groupManager.deleteGroup(groupId)
+      // 删除组时清理内存缓冲区
+      await groupManager.deleteGroup(groupId, { memoryBuffer })
 
       ctx.body = createSuccessResponse(null, '删除成功')
     } catch (error) {
@@ -152,12 +153,12 @@ module.exports = (router) => {
       }
       return null
     },
-  }), (ctx) => {
+  }), async (ctx) => {
     try {
       const { groupManager } = ctx
       const { groupId } = ctx.request.body
 
-      const currentGroup = groupManager.setCurrentGroup(groupId)
+      const currentGroup = await groupManager.setCurrentGroup(groupId)
 
       ctx.body = createSuccessResponse({
         currentGroup,
@@ -191,20 +192,20 @@ module.exports = (router) => {
       }
       return null
     },
-  }), (ctx) => {
+  }), async (ctx) => {
     try {
       const { groupManager } = ctx
       const { sourceGroupId, name, description } = ctx.request.body
 
       // 检查源组是否存在
-      const groups = groupManager.getGroups()
+      const groups = await groupManager.getGroups()
       const sourceGroup = groups.find(g => g.id === sourceGroupId)
       if (!sourceGroup) {
         throw new Error(`源组不存在: ${sourceGroupId}`)
       }
 
       // 创建新组并复制配置
-      const newGroup = groupManager.createGroup({
+      const newGroup = await groupManager.createGroup({
         name: name.trim(),
         description: description ? description.trim() : '',
         copyFromGroupId: sourceGroupId,