sloth-d2c-mcp 1.0.4-beta70 → 1.0.4-beta71

package/dist/build/utils/file-manager.js

@@ -9,10 +9,22 @@ import { Logger } from '../utils/logger.js';
 export class FileManager {
     paths; // 应用路径配置
     baseDir; // 基础存储目录
+    workspaceRoot = null; // MCP 工作目录根路径
     constructor(appName) {
         this.paths = envPaths(appName);
         this.baseDir = path.join(this.paths.data, 'files');
     }
+    /**
+     * 设置工作目录根路径（用于 MCP 工作项目）
+     * @param rootPath - 工作目录根路径
+     */
+    setWorkspaceRoot(rootPath) {
+        this.workspaceRoot = rootPath;
+        Logger.log(`已设置工作目录根路径: ${rootPath}`);
+    }
+    getWorkspaceRoot() {
+        return this.workspaceRoot;
+    }
     /**
      * 生成文件路径
      * @param fileKey - Figma文件的key
@@ -27,16 +39,46 @@ export class FileManager {
         const cleanFilename = filename.replace(/[^a-zA-Z0-9-_.]/g, '_');
         return path.join(this.baseDir, cleanFileKey, cleanNodeId, cleanFilename);
     }
+    /**
+     * 生成工作目录中的文件路径（保存到 .sloth 文件夹）
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param filename - 文件名
+     * @returns 完整的文件路径
+     */
+    getWorkspaceFilePath(fileKey, nodeId, filename) {
+        if (!this.workspaceRoot) {
+            console.error('工作目录根路径未设置,使用默认目录:', this.baseDir);
+            return this.getFilePath(fileKey, nodeId, filename);
+        }
+        // 清理文件名中的特殊字符
+        const cleanFileKey = fileKey.replace(/[^a-zA-Z0-9-_]/g, '_');
+        const cleanNodeId = nodeId ? nodeId.replace(/[^a-zA-Z0-9-_:]/g, '_') : 'root';
+        const cleanFilename = filename.replace(/[^a-zA-Z0-9-_.]/g, '_');
+        return path.join(this.workspaceRoot, '.sloth', cleanFileKey, cleanNodeId, cleanFilename);
+    }
+    /**
+     * 获取工作目录下特定 fileKey 的目录路径
+     * @param fileKey - Figma 文件的 key
+     * @returns string | null
+     */
+    getWorkspaceFileKeyDirPath(fileKey) {
+        if (!this.workspaceRoot)
+            return null;
+        const cleanFileKey = fileKey.replace(/[^a-zA-Z0-9-_]/g, '_');
+        return path.join(this.workspaceRoot, '.sloth', cleanFileKey);
+    }
     /**
      * 保存文件内容
      * @param fileKey - Figma文件的key
      * @param nodeId - 节点ID（可选）
      * @param filename - 文件名
      * @param content - 文件内容
+     * @param useWorkspaceDir - 是否使用工作目录
      */
-    async saveFile(fileKey, nodeId, filename, content) {
+    async saveFile(fileKey, nodeId, filename, content, useWorkspaceDir = false) {
         try {
-            const filePath = this.getFilePath(fileKey, nodeId, filename);
+            const filePath = useWorkspaceDir ? this.getWorkspaceFilePath(fileKey, nodeId, filename) : this.getFilePath(fileKey, nodeId, filename);
             // 确保目录存在
             await fs.mkdir(path.dirname(filePath), { recursive: true });
             // 保存文件内容
@@ -53,11 +95,13 @@ export class FileManager {
      * @param fileKey - Figma文件的key
      * @param nodeId - 节点ID（可选）
      * @param filename - 文件名
+     * @param useWorkspaceDir - 是否使用工作目录
      * @returns Promise<string> - 文件内容，如果文件不存在则返回空字符串
      */
-    async loadFile(fileKey, nodeId, filename) {
+    async loadFile(fileKey, nodeId, filename, useWorkspaceDir = false) {
         try {
-            const filePath = this.getFilePath(fileKey, nodeId, filename);
+            const filePath = useWorkspaceDir ? this.getWorkspaceFilePath(fileKey, nodeId, filename) : this.getFilePath(fileKey, nodeId, filename);
+            Logger.log(`加载文件: ${filePath}, workspaceRoot: ${this.workspaceRoot}`);
             const content = await fs.readFile(filePath, 'utf-8');
             return content;
         }
@@ -188,13 +232,13 @@ export class FileManager {
         return path.join(this.baseDir, cleanFileKey, cleanNodeId);
     }
     /**
-     * 保存 groupsData 到特定的 nodeId 文件
+     * 保存 groupsData 到特定的 nodeId 文件（保存到工作目录的 .sloth 文件夹）
      * @param fileKey - Figma文件的key
      * @param nodeId - 节点ID（可选）
      * @param groupsData - 分组数据
      */
     async saveGroupsData(fileKey, nodeId, groupsData) {
-        await this.saveFile(fileKey, nodeId, 'groupsData.json', JSON.stringify(groupsData, null, 2));
+        await this.saveFile(fileKey, nodeId, 'groupsData.json', JSON.stringify(groupsData, null, 2), true);
     }
     /**
      * 加载 groupsData 从特定的 nodeId 文件
@@ -204,7 +248,7 @@ export class FileManager {
      */
     async loadGroupsData(fileKey, nodeId) {
         try {
-            const content = await this.loadFile(fileKey, nodeId, 'groupsData.json');
+            const content = await this.loadFile(fileKey, nodeId, 'groupsData.json', true);
             return content ? JSON.parse(content) : [];
         }
         catch (error) {
@@ -213,13 +257,13 @@ export class FileManager {
         }
     }
     /**
-     * 保存 promptSetting 到特定的 nodeId 文件
+     * 保存 promptSetting 到特定的 nodeId 文件（保存到工作目录的 .sloth 文件夹）
      * @param fileKey - Figma文件的key
      * @param nodeId - 节点ID（可选）
      * @param promptSetting - 提示词设置
      */
     async savePromptSetting(fileKey, nodeId, promptSetting) {
-        await this.saveFile(fileKey, nodeId, 'promptSetting.json', JSON.stringify(promptSetting, null, 2));
+        await this.saveFile(fileKey, nodeId, 'promptSetting.json', JSON.stringify(promptSetting, null, 2), true);
     }
     /**
      * 加载 promptSetting 从特定的 nodeId 文件
@@ -229,7 +273,7 @@ export class FileManager {
      */
     async loadPromptSetting(fileKey, nodeId) {
         try {
-            const content = await this.loadFile(fileKey, nodeId, 'promptSetting.json');
+            const content = await this.loadFile(fileKey, nodeId, 'promptSetting.json', true);
             return content ? JSON.parse(content) : null;
         }
         catch (error) {
@@ -237,5 +281,252 @@ export class FileManager {
             return null;
         }
     }
+    /**
+     * 保存 configSetting 到特定的 nodeId 文件（保存到工作目录的 .sloth 文件夹）
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param configSetting - 配置设置
+     */
+    async saveConfigSetting(fileKey, nodeId, configSetting) {
+        await this.saveFile(fileKey, nodeId, 'configSetting.json', JSON.stringify(configSetting, null, 2), true);
+    }
+    /**
+     * 加载 configSetting 从特定的 nodeId 文件
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @returns Promise<any> - 配置设置，如果文件不存在则返回 null
+     */
+    async loadConfigSetting(fileKey, nodeId) {
+        try {
+            const content = await this.loadFile(fileKey, nodeId, 'configSetting.json', true);
+            return content ? JSON.parse(content) : null;
+        }
+        catch (error) {
+            Logger.log(`加载 configSetting 失败，返回 null: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * 列出指定 fileKey 下的所有 nodeId（目录名）
+     * @param fileKey - Figma 文件的 key
+     */
+    async listNodeIds(fileKey) {
+        const workspaceDir = this.getWorkspaceFileKeyDirPath(fileKey);
+        const targetDir = workspaceDir || this.getFileKeyDir(fileKey);
+        try {
+            const dirents = await fs.readdir(targetDir, { withFileTypes: true });
+            return dirents.filter((d) => d.isDirectory()).map((d) => d.name);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * 列出所有 fileKey
+     * @returns Promise<string[]> - 所有 fileKey 的列表
+     */
+    async listAllFileKeys() {
+        try {
+            if (!this.workspaceRoot) {
+                Logger.log('workspaceRoot 未设置，无法列出所有 fileKey');
+                return [];
+            }
+            const slothDir = path.join(this.workspaceRoot, '.sloth');
+            const entries = await fs.readdir(slothDir, { withFileTypes: true });
+            const fileKeys = entries
+                .filter(entry => entry.isDirectory())
+                .map(entry => entry.name);
+            Logger.log(`找到 ${fileKeys.length} 个 fileKey:`, fileKeys);
+            return fileKeys;
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * 加载指定 fileKey 下所有 nodeId 的 groupsData
+     * @param fileKey - Figma 文件的 key
+     */
+    async loadAllGroupsData(fileKey) {
+        const nodeIds = await this.listNodeIds(fileKey);
+        const results = [];
+        Logger.log(`加载指定 fileKey 下所有 nodeId 的 groupsData: ${fileKey}, nodeIds: ${nodeIds}`);
+        if (nodeIds.length === 0) {
+            const groups = await this.loadGroupsData(fileKey, undefined);
+            if (groups.length > 0) {
+                results.push({ nodeId: 'root', groups });
+            }
+            return results;
+        }
+        for (const nodeId of nodeIds) {
+            const normalizedNodeId = nodeId === 'root' ? undefined : nodeId;
+            Logger.log(`加载指定 fileKey 下 nodeId 的 groupsData: ${fileKey}, nodeId: ${nodeId}`);
+            const groups = await this.loadGroupsData(fileKey, normalizedNodeId);
+            if (groups && groups.length > 0) {
+                results.push({ nodeId, groups });
+            }
+        }
+        return results;
+    }
+    /**
+     * 加载整个项目所有 fileKey 的所有 groupsData（用于跨文件组件匹配）
+     * @returns Promise<Array<{ fileKey: string; nodeId: string; groups: any[] }>>
+     */
+    async loadAllProjectGroupsData() {
+        const fileKeys = await this.listAllFileKeys();
+        const results = [];
+        Logger.log(`开始加载整个项目的 groupsData，共 ${fileKeys.length} 个 fileKey`);
+        for (const fileKey of fileKeys) {
+            const groupsDataByNode = await this.loadAllGroupsData(fileKey);
+            for (const { nodeId, groups } of groupsDataByNode) {
+                if (groups && groups.length > 0) {
+                    results.push({ fileKey, nodeId, groups });
+                }
+            }
+        }
+        Logger.log(`项目 groupsData 加载完成，共 ${results.length} 个节点有分组数据`);
+        return results;
+    }
+    /**
+     * 获取 screenshots 目录路径
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @returns string - screenshots 目录的完整路径
+     */
+    getScreenshotsDir(fileKey, nodeId) {
+        const nodeDir = this.getWorkspaceFilePath(fileKey, nodeId, '');
+        return path.join(nodeDir, 'screenshots');
+    }
+    /**
+     * 保存截图文件
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param hash - 截图文件的哈希值（作为文件名）
+     * @param buffer - 截图文件的二进制数据
+     */
+    async saveScreenshot(fileKey, nodeId, hash, buffer) {
+        try {
+            const screenshotsDir = this.getScreenshotsDir(fileKey, nodeId);
+            // 确保目录存在
+            await fs.mkdir(screenshotsDir, { recursive: true });
+            const filePath = path.join(screenshotsDir, `${hash}.png`);
+            await fs.writeFile(filePath, buffer);
+            Logger.log(`截图已保存: ${filePath}`);
+        }
+        catch (error) {
+            Logger.error(`保存截图失败: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * 加载截图文件
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param hash - 截图文件的哈希值
+     * @returns Promise<Buffer> - 截图文件的二进制数据
+     */
+    async loadScreenshot(fileKey, nodeId, hash) {
+        try {
+            const screenshotsDir = this.getScreenshotsDir(fileKey, nodeId);
+            const filePath = path.join(screenshotsDir, `${hash}.png`);
+            const buffer = await fs.readFile(filePath);
+            return buffer;
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                Logger.log(`截图文件不存在: ${hash}.png`);
+                return null;
+            }
+            Logger.error(`加载截图失败: ${err.toString()}`);
+            throw err;
+        }
+    }
+    /**
+     * 检查截图文件是否存在
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param hash - 截图文件的哈希值
+     * @returns Promise<boolean> - 如果文件存在则返回 true
+     */
+    async screenshotExists(fileKey, nodeId, hash) {
+        try {
+            const screenshotsDir = this.getScreenshotsDir(fileKey, nodeId);
+            const filePath = path.join(screenshotsDir, `${hash}.png`);
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 获取截图文件的完整路径
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param hash - 截图文件的哈希值
+     * @returns string - 截图文件的完整路径
+     */
+    getScreenshotPath(fileKey, nodeId, hash) {
+        const screenshotsDir = this.getScreenshotsDir(fileKey, nodeId);
+        return path.join(screenshotsDir, `${hash}.png`);
+    }
+    /**
+     * 删除截图文件
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param hash - 截图文件的哈希值
+     */
+    async deleteScreenshot(fileKey, nodeId, hash) {
+        try {
+            const screenshotsDir = this.getScreenshotsDir(fileKey, nodeId);
+            const filePath = path.join(screenshotsDir, `${hash}.png`);
+            await fs.unlink(filePath);
+            Logger.log(`截图已删除: ${filePath}`);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                Logger.error(`删除截图失败: ${err.toString()}`);
+                throw err;
+            }
+        }
+    }
+    /**
+     * 清理旧的截图文件（根据时间戳）
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param maxAgeDays - 最大保留天数
+     */
+    async cleanupOldScreenshots(fileKey, nodeId, maxAgeDays = 30) {
+        try {
+            const screenshotsDir = this.getScreenshotsDir(fileKey, nodeId);
+            // 检查目录是否存在
+            try {
+                await fs.access(screenshotsDir);
+            }
+            catch {
+                // 目录不存在，直接返回
+                return;
+            }
+            const files = await fs.readdir(screenshotsDir);
+            const now = Date.now();
+            const maxAge = maxAgeDays * 24 * 60 * 60 * 1000;
+            let deletedCount = 0;
+            for (const file of files) {
+                const filePath = path.join(screenshotsDir, file);
+                const stats = await fs.stat(filePath);
+                const age = now - stats.mtimeMs;
+                if (age > maxAge) {
+                    await fs.unlink(filePath);
+                    deletedCount++;
+                }
+            }
+            if (deletedCount > 0) {
+                Logger.log(`清理了 ${deletedCount} 个旧截图文件（超过 ${maxAgeDays} 天）`);
+            }
+        }
+        catch (error) {
+            Logger.error(`清理旧截图失败: ${error}`);
+        }
+    }
 }
 export default FileManager;

package/dist/build/utils/image-matcher.js

@@ -0,0 +1,154 @@
+import Jimp from 'jimp';
+import { getCV } from './opencv-loader.js';
+import { Logger } from './logger.js';
+export class ImageMatcher {
+    /**
+     * 使用 OpenCV 模板匹配在大图中查找小图
+     * @param haystackPath 大图路径（当前设计稿）
+     * @param needlePath 小图路径（历史截图）
+     * @param threshold 匹配阈值 (0-1)
+     */
+    async findMatch(haystackPath, needlePath, threshold = 0.8) {
+        try {
+            const startTime = Date.now();
+            Logger.log(`开始 OpenCV 模板匹配: ${needlePath}`);
+            // 获取 OpenCV 实例
+            const cv = getCV();
+            // 使用 Jimp 读取图片
+            const haystackImg = await Jimp.read(haystackPath);
+            const needleImg = await Jimp.read(needlePath);
+            Logger.log(`大图尺寸: ${haystackImg.bitmap.width}x${haystackImg.bitmap.height}`);
+            Logger.log(`小图尺寸: ${needleImg.bitmap.width}x${needleImg.bitmap.height}`);
+            // 转换为 OpenCV Mat
+            const haystack = this.jimpToMat(haystackImg, cv);
+            const needle = this.jimpToMat(needleImg, cv);
+            // 创建结果矩阵
+            const result = new cv.Mat();
+            const mask = new cv.Mat();
+            // 执行模板匹配
+            // TM_CCOEFF_NORMED: 归一化相关系数匹配，返回值 -1 到 1
+            cv.matchTemplate(haystack, needle, result, cv.TM_CCOEFF_NORMED, mask);
+            // 找到最佳匹配位置
+            const minMax = cv.minMaxLoc(result);
+            const maxVal = minMax.maxVal; // 最大相似度（-1 到 1）
+            const maxLoc = minMax.maxLoc; // 最佳匹配位置
+            const elapsedTime = Date.now() - startTime;
+            Logger.log(`OpenCV 匹配完成，耗时: ${elapsedTime}ms，最大相似度: ${maxVal.toFixed(4)}`);
+            // 清理内存
+            haystack.delete();
+            needle.delete();
+            result.delete();
+            mask.delete();
+            // 判断是否满足阈值
+            if (maxVal >= threshold) {
+                return {
+                    matched: true,
+                    confidence: maxVal,
+                    position: {
+                        left: maxLoc.x,
+                        top: maxLoc.y,
+                        width: needleImg.bitmap.width,
+                        height: needleImg.bitmap.height,
+                    },
+                };
+            }
+            Logger.log(`匹配失败，相似度 ${maxVal.toFixed(4)} 低于阈值 ${threshold}`);
+            return null;
+        }
+        catch (error) {
+            Logger.error('OpenCV 图像匹配失败:', error);
+            return null;
+        }
+    }
+    /**
+     * 将 Jimp 图像转换为 OpenCV Mat
+     */
+    jimpToMat(jimpImg, cv) {
+        const { width, height, data } = jimpImg.bitmap;
+        // 创建 Mat (RGBA 格式)
+        const mat = new cv.Mat(height, width, cv.CV_8UC4);
+        // 复制像素数据
+        mat.data.set(data);
+        // 转换为 RGB（模板匹配只需要 RGB，去掉 Alpha 通道）
+        const rgbMat = new cv.Mat();
+        cv.cvtColor(mat, rgbMat, cv.COLOR_RGBA2RGB);
+        mat.delete();
+        return rgbMat;
+    }
+    /**
+     * 使用多尺度模板匹配（处理截图可能有缩放的情况）
+     * @param haystackPath 大图路径
+     * @param needlePath 小图路径
+     * @param threshold 匹配阈值
+     * @param scales 尝试的缩放比例列表
+     */
+    async findMatchMultiScale(haystackPath, needlePath, threshold = 0.8, scales = [1.0, 0.95, 1.05, 0.9, 1.1]) {
+        Logger.log(`开始多尺度匹配，尝试 ${scales.length} 个缩放比例`);
+        let bestMatch = null;
+        for (const scale of scales) {
+            try {
+                // 读取并缩放模板图片
+                const needleImg = await Jimp.read(needlePath);
+                if (scale !== 1.0) {
+                    needleImg.scale(scale);
+                    Logger.log(`尝试缩放比例: ${scale}`);
+                }
+                // 保存临时缩放图片
+                const fs = await import('fs/promises');
+                const path = await import('path');
+                const tempPath = needlePath.replace('.png', `_scale${scale}.png`);
+                await needleImg.writeAsync(tempPath);
+                // 执行匹配
+                const result = await this.findMatch(haystackPath, tempPath, threshold);
+                // 清理临时文件
+                await fs.unlink(tempPath).catch(() => { });
+                if (result && (!bestMatch || result.confidence > bestMatch.confidence)) {
+                    // 调整位置和尺寸（补偿缩放）
+                    result.position.width = Math.round(result.position.width / scale);
+                    result.position.height = Math.round(result.position.height / scale);
+                    bestMatch = result;
+                    Logger.log(`找到更好的匹配，缩放比例: ${scale}，置信度: ${result.confidence.toFixed(4)}`);
+                }
+                // 如果找到完美匹配，提前退出
+                if (result && result.confidence >= 0.95) {
+                    Logger.log('找到完美匹配，提前退出多尺度搜索');
+                    break;
+                }
+            }
+            catch (error) {
+                Logger.error(`缩放比例 ${scale} 匹配失败:`, error);
+                continue;
+            }
+        }
+        if (bestMatch) {
+            Logger.log(`多尺度匹配完成，最佳置信度: ${bestMatch.confidence.toFixed(4)}`);
+        }
+        else {
+            Logger.log('多尺度匹配未找到符合要求的结果');
+        }
+        return bestMatch;
+    }
+    /**
+     * 批量匹配多个历史截图
+     */
+    async batchMatch(haystackPath, needlePaths, threshold = 0.8) {
+        Logger.log(`开始批量匹配 ${needlePaths.length} 个历史截图`);
+        const matches = [];
+        for (const { path, groupData } of needlePaths) {
+            try {
+                const result = await this.findMatch(haystackPath, path, threshold);
+                if (result && result.matched) {
+                    result.groupData = groupData;
+                    matches.push(result);
+                    Logger.log(`匹配成功: ${groupData.componentMapping?.name || 'Unknown'}`);
+                }
+            }
+            catch (error) {
+                Logger.error(`批量匹配失败 (${path}):`, error);
+                continue;
+            }
+        }
+        Logger.log(`批量匹配完成，找到 ${matches.length} 个匹配`);
+        return matches;
+    }
+}

package/dist/build/utils/opencv-loader.js

@@ -0,0 +1,70 @@
+import { Logger } from './logger.js';
+let cv = null;
+let isOpencvReady = false;
+/**
+ * 初始化 OpenCV.js
+ */
+export async function initOpenCV() {
+    if (isOpencvReady && cv) {
+        Logger.log('OpenCV.js 已经初始化');
+        return;
+    }
+    try {
+        Logger.log('开始初始化 OpenCV.js...');
+        // 动态导入 OpenCV.js
+        const opencvModule = await import('@techstark/opencv-js');
+        cv = opencvModule.default || opencvModule;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('OpenCV.js 初始化超时（30秒）'));
+            }, 30000);
+            if (cv.getBuildInformation) {
+                // OpenCV 已经加载完成
+                clearTimeout(timeout);
+                isOpencvReady = true;
+                Logger.log('OpenCV.js 已就绪');
+                Logger.log('OpenCV 版本信息:', cv.getBuildInformation());
+                resolve();
+            }
+            else {
+                // 等待 OpenCV 运行时初始化
+                cv.onRuntimeInitialized = () => {
+                    clearTimeout(timeout);
+                    isOpencvReady = true;
+                    Logger.log('OpenCV.js 运行时初始化完成');
+                    if (cv.getBuildInformation) {
+                        Logger.log('OpenCV 版本信息:', cv.getBuildInformation());
+                    }
+                    resolve();
+                };
+            }
+        });
+    }
+    catch (error) {
+        Logger.error('OpenCV.js 初始化失败:', error);
+        throw error;
+    }
+}
+/**
+ * 检查 OpenCV 是否就绪
+ */
+export function isReady() {
+    return isOpencvReady;
+}
+/**
+ * 获取 OpenCV 实例
+ */
+export function getCV() {
+    if (!cv || !isOpencvReady) {
+        throw new Error('OpenCV.js 尚未初始化，请先调用 initOpenCV()');
+    }
+    return cv;
+}
+/**
+ * 清理 OpenCV 资源（如果需要）
+ */
+export function cleanup() {
+    isOpencvReady = false;
+    cv = null;
+    Logger.log('OpenCV.js 资源已清理');
+}

package/dist/interceptor-web/dist/build-report.json

@@ -1,18 +1,18 @@
 {
-  "buildTime": "2025-11-05T12:32:59.574Z",
+  "buildTime": "2025-12-01T03:49:02.385Z",
   "mode": "build",
   "pages": {
     "main": {
       "file": "index.html",
-      "size": 1089842,
-      "sizeFormatted": "1.04 MB"
+      "size": 1414275,
+      "sizeFormatted": "1.35 MB"
     },
     "detail": {
       "file": "detail.html",
-      "size": 240699,
-      "sizeFormatted": "235.06 KB"
+      "size": 281682,
+      "sizeFormatted": "275.08 KB"
     }
   },
-  "totalSize": 1330541,
-  "totalSizeFormatted": "1.27 MB"
+  "totalSize": 1695957,
+  "totalSizeFormatted": "1.62 MB"
 }