sloth-d2c-mcp 1.0.4-beta75 → 1.0.4-beta77

package/dist/build/server.js

@@ -10,15 +10,20 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { v4 as uuidv4 } from 'uuid';
+import { nanoid } from 'nanoid';
 import open from 'open';
 import { fileManager } from './index.js';
 import * as flatted from 'flatted';
-import { ComponentMappingSystem } from './component-mapping/index.js';
 import multer from 'multer';
 import { ImageMatcher } from './utils/image-matcher.js';
 import { initOpenCV } from './utils/opencv-loader.js';
 import { extractJson } from './utils/extract.js';
 import { componentAnalysisPrompt, componentAnalysisPromptVue } from 'sloth-d2c-node/convert';
+import { SocketServer } from './socket-server.js';
+/**
+ * 生成组件 ID（4位随机字符串）
+ */
+export const generateComponentId = () => `comp_${nanoid(4)}`;
 // 配置 multer 用于文件上传
 const storage = multer.memoryStorage();
 const upload = multer({
@@ -29,6 +34,8 @@ const upload = multer({
 import { chunkOptimizeCodePrompt, aggregationOptimizeCodePrompt, finalOptimizeCodePrompt, chunkOptimizeCodePromptVue, aggregationOptimizeCodePromptVue, finalOptimizeCodePromptVue, } from 'sloth-d2c-node/convert';
 // 保存 HTTP 服务器实例
 let httpServer = null;
+// 保存 Socket 服务器实例
+let socketServer = null;
 // 管理所有活跃的传输对象，按 sessionId 分类
 const transports = {
     streamable: {}, // 流式 HTTP 传输
@@ -38,11 +45,14 @@ const transports = {
 const pendingRequests = new Map(); // 等待中的认证请求
 let configStorage = {}; // 配置缓存
 let configManager = null; // 配置管理器实例
-let mappingSystem = null; // 组件映射系统实例
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // 获取端口号
 let PORT = 0;
+// 导出获取端口号的函数
+export function getPort() {
+    return PORT;
+}
 export async function loadConfig(mcpServer, configManagerInstance) {
     if (configManagerInstance) {
         configManager = configManagerInstance;
@@ -112,14 +122,13 @@ export async function loadConfig(mcpServer, configManagerInstance) {
             }
             else {
                 const vueConfig = await configManager.loadFrameworkConfig('vue');
-                if (!vueConfig || Object.keys(vueConfig).length < 3) {
-                    await configManager.saveFrameworkConfig('vue', {
-                        chunkOptimizePrompt: chunkOptimizeCodePromptVue,
-                        aggregationOptimizePrompt: aggregationOptimizeCodePromptVue,
-                        finalOptimizePrompt: finalOptimizeCodePromptVue,
-                        ...(vueConfig || {}),
-                    });
-                }
+                await configManager.saveFrameworkConfig('vue', {
+                    chunkOptimizePrompt: chunkOptimizeCodePromptVue,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePromptVue,
+                    finalOptimizePrompt: finalOptimizeCodePromptVue,
+                    componentAnalysisPrompt: componentAnalysisPromptVue,
+                    ...(vueConfig || {}),
+                });
             }
         }
         catch (error) {
@@ -326,11 +335,29 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                 // const fileManager = new FileManager('d2c-mcp')
                 const groupsData = await fileManager.loadGroupsData(fileKey, nodeId);
                 const savedPromptSetting = await fileManager.loadPromptSetting(fileKey, nodeId);
+                let curFramework = fileConfig?.convertSetting?.framework;
+                // 获取框架列表
+                const frameworks = await configManager.getFrameworks();
+                if (!curFramework || !frameworks.find((fw) => fw.value === curFramework)) {
+                    curFramework = globalConfig.defaultFramework || 'react';
+                }
+                const curFrameworkDefaultConfig = (await configManager.loadFrameworkConfig(curFramework)) ||
+                    (curFramework !== 'vue'
+                        ? {
+                            chunkOptimizePrompt: chunkOptimizeCodePrompt,
+                            aggregationOptimizePrompt: aggregationOptimizeCodePrompt,
+                            finalOptimizePrompt: finalOptimizeCodePrompt,
+                        }
+                        : {
+                            chunkOptimizePrompt: chunkOptimizeCodePromptVue,
+                            aggregationOptimizePrompt: aggregationOptimizeCodePromptVue,
+                            finalOptimizePrompt: finalOptimizeCodePromptVue,
+                        });
                 // 如果指定了框架，加载框架配置的提示词
                 let promptSetting = {
-                    chunkOptimizePrompt: savedPromptSetting?.chunkOptimizePrompt || chunkOptimizeCodePrompt,
-                    aggregationOptimizePrompt: savedPromptSetting?.aggregationOptimizePrompt || aggregationOptimizeCodePrompt,
-                    finalOptimizePrompt: savedPromptSetting?.finalOptimizePrompt || finalOptimizeCodePrompt,
+                    chunkOptimizePrompt: savedPromptSetting?.chunkOptimizePrompt || curFrameworkDefaultConfig.chunkOptimizePrompt,
+                    aggregationOptimizePrompt: savedPromptSetting?.aggregationOptimizePrompt || curFrameworkDefaultConfig.aggregationOptimizePrompt,
+                    finalOptimizePrompt: savedPromptSetting?.finalOptimizePrompt || curFrameworkDefaultConfig.finalOptimizePrompt,
                 };
                 if (framework) {
                     // 加载框架配置
@@ -344,8 +371,6 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                         };
                     }
                 }
-                // 获取框架列表
-                const frameworks = await configManager.getFrameworks();
                 res.json({
                     success: true,
                     data: {
@@ -428,7 +453,15 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
             let promptSetting = {};
             const fw = frameworks.find((f) => f.value === framework) ? framework : defaultFramework;
             const frameworkConfig = await configManager.loadFrameworkConfig(fw);
-            promptSetting[fw] = frameworkConfig;
+            promptSetting[fw] = {
+                ...frameworkConfig,
+                enableFrameworkGuide: frameworkConfig.enableFrameworkGuide || false,
+                frameworkPrompt: frameworkConfig.frameworkPrompt || '',
+                chunkOptimizePrompt: frameworkConfig.chunkOptimizePrompt || chunkOptimizeCodePrompt,
+                aggregationOptimizePrompt: frameworkConfig.aggregationOptimizePrompt || aggregationOptimizeCodePrompt,
+                finalOptimizePrompt: frameworkConfig.finalOptimizePrompt || finalOptimizeCodePrompt,
+                componentAnalysisPrompt: frameworkConfig.componentAnalysisPrompt || componentAnalysisPrompt,
+            };
             res.json({
                 success: true,
                 data: {
@@ -494,14 +527,16 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                 chunkOptimizePrompt: chunkOptimizeCodePrompt,
                 aggregationOptimizePrompt: aggregationOptimizeCodePrompt,
                 finalOptimizePrompt: finalOptimizeCodePrompt,
+                componentAnalysisPrompt: componentAnalysisPrompt,
             };
             const frameworkConfig = await configManager.loadFrameworkConfig(framework);
             if (frameworkConfig && Object.keys(frameworkConfig).length > 0) {
                 // 框架配置优先级更高
                 promptSetting = {
-                    chunkOptimizePrompt: frameworkConfig.chunkOptimizePrompt,
-                    aggregationOptimizePrompt: frameworkConfig.aggregationOptimizePrompt,
-                    finalOptimizePrompt: frameworkConfig.finalOptimizePrompt,
+                    chunkOptimizePrompt: frameworkConfig.chunkOptimizePrompt || promptSetting.chunkOptimizePrompt,
+                    aggregationOptimizePrompt: frameworkConfig.aggregationOptimizePrompt || promptSetting.aggregationOptimizePrompt,
+                    finalOptimizePrompt: frameworkConfig.finalOptimizePrompt || promptSetting.finalOptimizePrompt,
+                    componentAnalysisPrompt: frameworkConfig.componentAnalysisPrompt || promptSetting.componentAnalysisPrompt,
                 };
             }
             res.json({
@@ -607,14 +642,19 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                 await configManager.save(globalConfig);
                 Logger.log('已更新全局 MCP 配置');
             }
+            // 首先尝试主进程的 pendingRequests（主进程场景），查询对应token的Promise，判断是否是主进程提交的
             const request = pendingRequests.get(token);
+            Logger.log('submit pendingRequests', [...pendingRequests.keys()]);
             if (request && request.resolve) {
                 request.resolve(JSON.stringify(value));
                 res.send('提交成功！您可以关闭此窗口。');
+                return;
             }
-            else {
-                res.status(404).send('无效或已过期的 token');
-            }
+            // 如果主进程查不到pendingRequests，则判断是子进程提交的，通过 Socket 发送提交数据给子进程
+            socketServer?.sendSubmitResponse(token, value);
+            Logger.log(`已通过 Socket 发送认证响应: token=${token}`);
+            res.send('提交成功！您可以关闭此窗口。');
+            return;
         }
         catch (error) {
             Logger.error('保存配置失败:', error);
@@ -793,6 +833,10 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
             });
         }
     });
+    // 多文件分析限制
+    const MAX_FILES = 10; // 最多 10 个文件
+    const MAX_TOTAL_CHARS = 40000; // 总内容最多 40000 字符
+    const MAX_FILE_CHARS = 5000; // 单文件最多 5000 字符
     /**
      * 分析项目中的组件
      */
@@ -806,10 +850,17 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                 });
                 return;
             }
-            Logger.log(`分析 ${filePaths.length} 个项目文件`);
+            // 限制文件数量
+            if (filePaths.length > MAX_FILES) {
+                res.status(400).json({
+                    success: false,
+                    message: `文件数量超过限制，最多支持 ${MAX_FILES} 个文件`,
+                });
+                return;
+            }
+            Logger.log(`批量分析 ${filePaths.length} 个项目文件`);
             const projectPath = getProjectRoot();
-            const results = [];
-            // 尝试加载保存的提示词设置（如果提供了 fileKey 和 nodeId）
+            // 尝试加载保存的提示词设置
             let savedPromptSetting = null;
             if (fileKey && nodeId) {
                 try {
@@ -822,148 +873,163 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
             }
             const frameworkGuidePrompt = savedPromptSetting?.frameworkGuidePrompt;
             const _componentAnalysisPrompt = savedPromptSetting?.componentAnalysisPrompt || componentAnalysisPrompt;
-            // 读取并分析每个文件
+            // 读取所有文件内容
+            const fileContents = [];
+            let totalChars = 0;
             for (const filePath of filePaths) {
                 try {
                     const fullPath = path.join(projectPath, filePath);
                     // 安全检查：确保文件在项目目录内
                     if (!fullPath.startsWith(projectPath)) {
-                        results.push({
-                            success: false,
-                            filename: filePath,
+                        fileContents.push({
+                            path: filePath,
+                            content: '',
                             error: '无权访问该文件',
                         });
                         continue;
                     }
                     // 读取文件内容
-                    const content = await fs.promises.readFile(fullPath, 'utf-8');
-                    const filename = path.basename(filePath);
-                    // 使用 MCP Sampling 进行实际分析
-                    if (mcpServer) {
-                        try {
-                            // 构建提示词，替换占位符
-                            const prompt = _componentAnalysisPrompt.replace(/{filename}/g, filename).replace(/{fileContent}/g, content);
-                            // 调用 MCP Sampling API
-                            const { content: { text }, } = await mcpServer.server.createMessage({
-                                messages: [
-                                    frameworkGuidePrompt && {
-                                        role: 'user',
-                                        content: {
-                                            type: 'text',
-                                            text: frameworkGuidePrompt,
-                                        },
-                                    },
-                                    {
-                                        role: 'user',
-                                        content: {
-                                            type: 'text',
-                                            text: prompt,
-                                        },
-                                    },
-                                ].filter(Boolean),
-                                maxTokens: 8000,
-                            }, { timeout: 2 * 60 * 1000 });
-                            // 解析 AI 返回的 JSON
-                            const extractResult = extractJson(text);
-                            if (extractResult.state === 'successful-parse' && extractResult.value) {
-                                const analysisResult = extractResult.value;
-                                // 构建组件信息
-                                const component = {
-                                    id: `comp-${Date.now()}-${Math.random()}`,
-                                    name: analysisResult.componentName || path.basename(filePath, path.extname(filePath)),
-                                    type: 'custom',
-                                    path: filePath,
-                                    import: analysisResult.import,
-                                    props: analysisResult.props || [],
-                                    description: analysisResult.description || '组件描述',
-                                };
-                                results.push({
-                                    success: true,
-                                    component,
-                                    filename: filePath,
-                                });
-                                Logger.log(`成功分析组件: ${filePath}, 组件名: ${component.name}`);
-                            }
-                            else {
-                                // JSON 解析失败，使用默认值
-                                Logger.warn(`解析组件分析结果失败: ${extractResult.error}, 文件: ${filePath}`);
-                                results.push({
-                                    success: true,
-                                    component: {
-                                        id: `comp-${Date.now()}-${Math.random()}`,
-                                        name: path.basename(filePath, path.extname(filePath)),
-                                        type: 'custom',
-                                        path: filePath,
-                                        import: `import { ${path.basename(filePath, path.extname(filePath))} } from './${filePath}'`,
-                                        props: [],
-                                        description: '组件描述',
-                                    },
-                                    filename: filePath,
-                                });
-                            }
-                        }
-                        catch (samplingError) {
-                            Logger.error(`调用采样 API 失败: ${filePath}`, samplingError);
-                            // 采样失败时使用默认值
-                            results.push({
-                                success: true,
-                                component: {
-                                    id: `comp-${Date.now()}-${Math.random()}`,
-                                    name: path.basename(filePath, path.extname(filePath)),
-                                    type: 'custom',
-                                    path: filePath,
-                                    import: `import { ${path.basename(filePath, path.extname(filePath))} } from './${filePath}'`,
-                                    props: [],
-                                    description: '组件描述',
-                                },
-                                filename: filePath,
-                            });
-                        }
+                    let content = await fs.promises.readFile(fullPath, 'utf-8');
+                    // 单文件截断
+                    if (content.length > MAX_FILE_CHARS) {
+                        content = content.slice(0, MAX_FILE_CHARS) + '\n// ... 内容已截断 ...';
+                        Logger.warn(`文件 ${filePath} 内容过长，已截断至 ${MAX_FILE_CHARS} 字符`);
                     }
-                    else {
-                        // MCP 服务器未初始化，使用默认值
-                        Logger.warn('MCP 服务器未初始化，使用默认组件信息');
-                        results.push({
-                            success: true,
-                            component: {
-                                id: `comp-${Date.now()}-${Math.random()}`,
-                                name: path.basename(filePath, path.extname(filePath)),
-                                type: 'custom',
-                                path: filePath,
-                                import: `import { ${path.basename(filePath, path.extname(filePath))} } from './${filePath}'`,
-                                props: [],
-                                description: '组件描述',
-                            },
-                            filename: filePath,
+                    // 检查总字符数
+                    if (totalChars + content.length > MAX_TOTAL_CHARS) {
+                        Logger.warn(`总内容超过 ${MAX_TOTAL_CHARS} 字符限制，跳过文件: ${filePath}`);
+                        fileContents.push({
+                            path: filePath,
+                            content: '',
+                            error: '总内容超过限制，已跳过',
                         });
+                        continue;
                     }
+                    totalChars += content.length;
+                    fileContents.push({
+                        path: filePath,
+                        content,
+                    });
                 }
                 catch (error) {
                     Logger.error(`读取文件失败: ${filePath}`, error);
-                    results.push({
-                        success: false,
-                        filename: filePath,
+                    fileContents.push({
+                        path: filePath,
+                        content: '',
                         error: error instanceof Error ? error.message : String(error),
                     });
                 }
             }
-            const succeeded = results.filter((r) => r.success).length;
-            const failed = results.filter((r) => !r.success).length;
-            res.json({
-                success: true,
-                data: {
-                    total: filePaths.length,
-                    succeeded,
-                    failed,
-                    components: results.filter((r) => r.success).map((r) => r.component),
-                    errors: results
-                        .filter((r) => !r.success)
-                        .map((r) => ({
-                        filename: r.filename,
-                        error: r.error,
-                    })),
-                },
-            });
+            // 过滤出成功读取的文件
+            const validFiles = fileContents.filter((f) => f.content && !f.error);
+            const errorFiles = fileContents.filter((f) => f.error);
+            if (validFiles.length === 0) {
+                res.json({
+                    success: true,
+                    data: {
+                        total: filePaths.length,
+                        succeeded: 0,
+                        failed: errorFiles.length,
+                        components: [],
+                        errors: errorFiles.map((f) => ({ filename: f.path, error: f.error })),
+                    },
+                });
+                return;
+            }
+            // 构建多文件内容部分
+            const filesSection = validFiles
+                .map((f) => {
+                const ext = path.extname(f.path).slice(1) || 'txt';
+                return `### 文件：${f.path}\n\`\`\`${ext}\n${f.content}\n\`\`\``;
+            })
+                .join('\n\n');
+            // 构建最终 Prompt
+            const prompt = _componentAnalysisPrompt.replace('{filesSection}', filesSection);
+            Logger.log(`构建 Prompt 完成，总字符数: ${prompt.length}`);
+            // 调用 MCP Sampling API
+            if (!mcpServer) {
+                Logger.warn('MCP 服务器未初始化，返回空结果');
+                res.json({
+                    success: true,
+                    data: {
+                        total: filePaths.length,
+                        succeeded: 0,
+                        failed: filePaths.length,
+                        components: [],
+                        errors: filePaths.map((p) => ({ filename: p, error: 'MCP 服务器未初始化' })),
+                    },
+                });
+                return;
+            }
+            try {
+                const { content: { text }, } = await mcpServer.server.createMessage({
+                    messages: [
+                        frameworkGuidePrompt && {
+                            role: 'user',
+                            content: {
+                                type: 'text',
+                                text: frameworkGuidePrompt,
+                            },
+                        },
+                        {
+                            role: 'user',
+                            content: {
+                                type: 'text',
+                                text: prompt,
+                            },
+                        },
+                    ].filter(Boolean),
+                    maxTokens: 8000,
+                }, { timeout: 2 * 60 * 1000 });
+                // 解析 AI 返回的 JSON
+                const extractResult = extractJson(text);
+                if (extractResult.state === 'successful-parse' && extractResult.value) {
+                    const analysisResult = extractResult.value;
+                    const components = (analysisResult.components || []).map((comp) => ({
+                        id: generateComponentId(),
+                        name: comp.componentName || 'Unknown',
+                        type: 'custom',
+                        path: comp.path || '',
+                        import: comp.import || '',
+                        props: comp.props || [],
+                        description: comp.description || '',
+                        super: comp.super || undefined,
+                        functions: comp.functions || undefined,
+                    }));
+                    Logger.log(`成功分析 ${components.length} 个组件`);
+                    res.json({
+                        success: true,
+                        data: {
+                            total: filePaths.length,
+                            succeeded: validFiles.length,
+                            failed: errorFiles.length,
+                            components,
+                            errors: errorFiles.map((f) => ({ filename: f.path, error: f.error })),
+                        },
+                    });
+                }
+                else {
+                    Logger.warn(`解析组件分析结果失败: ${extractResult.error}`);
+                    res.json({
+                        success: true,
+                        data: {
+                            total: filePaths.length,
+                            succeeded: 0,
+                            failed: filePaths.length,
+                            components: [],
+                            errors: [{ filename: 'all', error: `AI 返回结果解析失败: ${extractResult.error}` }],
+                        },
+                    });
+                }
+            }
+            catch (samplingError) {
+                Logger.error('调用采样 API 失败:', samplingError);
+                res.status(500).json({
+                    success: false,
+                    message: '调用 Sampling 分析失败，请调用 #mark_components tool进行组件分析',
+                    error: samplingError instanceof Error ? samplingError.message : String(samplingError),
+                });
+            }
         }
         catch (error) {
             Logger.error('分析项目组件失败:', error);
@@ -976,6 +1042,7 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
     });
     /**
      * 保存项目中的组件到components.json
+     * 根据组件 id 自动判断是新增还是更新
      */
     app.post('/saveComponents', async (req, res) => {
         try {
@@ -990,19 +1057,35 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
             Logger.log(`准备保存 ${components.length} 个组件`);
             // 读取现有组件
             const existingComponents = await fileManager.loadComponentsDatabase();
-            // 直接追加（暂不处理冲突）
-            const allComponents = [...components, ...existingComponents];
+            const existingMap = new Map(existingComponents.map((c) => [c.id, c]));
+            let addedCount = 0;
+            let updatedCount = 0;
+            // 根据 id 判断新增或更新
+            for (const comp of components) {
+                if (existingMap.has(comp.id)) {
+                    // 更新现有组件
+                    existingMap.set(comp.id, { ...existingMap.get(comp.id), ...comp });
+                    updatedCount++;
+                }
+                else {
+                    // 新增组件
+                    existingMap.set(comp.id, comp);
+                    addedCount++;
+                }
+            }
+            const allComponents = Array.from(existingMap.values());
             // 保存到文件（带备份）
             await fileManager.saveComponentsDatabase(allComponents);
-            Logger.log(`✅ 成功保存，当前共 ${allComponents.length} 个组件`);
+            Logger.log(`✅ 成功保存：新增 ${addedCount} 个，更新 ${updatedCount} 个，共 ${allComponents.length} 个组件`);
             res.json({
                 success: true,
                 data: {
-                    added: components.length,
+                    added: addedCount,
+                    updated: updatedCount,
                     total: allComponents.length,
                     components: allComponents,
                 },
-                message: '组件导入成功',
+                message: '组件保存成功',
             });
         }
         catch (error) {
@@ -1014,32 +1097,13 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
             });
         }
     });
-    /**
-     * 获取或创建映射系统实例
-     */
-    async function getMappingSystem() {
-        if (!mappingSystem) {
-            const projectPath = getProjectRoot();
-            mappingSystem = new ComponentMappingSystem(projectPath);
-            await mappingSystem.initialize();
-            Logger.log('组件映射系统已初始化，项目路径:', projectPath);
-        }
-        return mappingSystem;
-    }
-    // 扫描项目组件接口（同时返回项目组件和外部依赖组件）
+    // 扫描项目组件接口
     app.get('/scanComponents', async (req, res) => {
         try {
-            const { platform, includePaths, excludePaths } = req.query;
-            if (!platform) {
-                res.status(400).json({
-                    success: false,
-                    message: '缺少必要参数: platform',
-                });
-                return;
-            }
+            const { includePaths, excludePaths } = req.query;
             const projectPath = getProjectRoot();
-            Logger.log('扫描项目组件:', { platform, includePaths, excludePaths });
-            // 读取外部依赖组件（从 .sloth/components.json）
+            Logger.log('扫描项目组件:', { includePaths, excludePaths });
+            // 读取项目组件（从 .sloth/components.json）
             let projectComponents = [];
             const slothPath = path.join(projectPath, '.sloth', 'components.json');
             const fs = await import('fs/promises');
@@ -1063,7 +1127,7 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                             type: p.type || 'any',
                             required: p.required || false,
                         })),
-                        description: c.description || c.metadata?.description,
+                        description: c.description,
                         import: c.import,
                     }));
                     Logger.log(`从 .sloth/components.json 加载了 ${projectComponents.length} 个项目组件`);
@@ -1082,7 +1146,6 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                 success: true,
                 data: {
                     total: projectComponents.length,
-                    platform,
                     projectComponents, // 项目组件
                 },
             });
@@ -1096,43 +1159,28 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
             });
         }
     });
-    // 建议组件映射接口（基于历史组件截图匹配）
+    // 建议组件映射接口（基于 components.json 中组件的截图匹配）
     app.post('/suggestMappings', upload.single('currentScreenshot'), async (req, res) => {
         try {
-            const { fileKey, nodeId, threshold = '0.8' } = req.body;
+            const { threshold = '0.8' } = req.body;
             const currentScreenshotFile = req.file;
-            if (!currentScreenshotFile || !fileKey) {
+            if (!currentScreenshotFile) {
                 res.status(400).json({
                     success: false,
-                    message: '缺少必要参数: currentScreenshot, fileKey',
+                    message: '缺少必要参数: currentScreenshot',
                 });
                 return;
             }
-            Logger.log(`开始生成建议组件映射: fileKey=${fileKey}, nodeId=${nodeId}, threshold=${threshold}`);
-            // 检查当前 fileKey + nodeId 是否已经有 groupsData
-            const currentGroupsData = await fileManager.loadGroupsData(fileKey, nodeId);
-            if (currentGroupsData && currentGroupsData.length > 0) {
-                Logger.log(`当前设计稿已有 ${currentGroupsData.length} 个分组，跳过自动建议`);
-                res.json({
-                    success: true,
-                    data: {
-                        suggestions: [],
-                        reason: 'current_has_groups',
-                        message: '当前设计稿已有分组数据，不执行自动建议',
-                    },
-                });
-                return;
-            }
-            Logger.log('当前设计稿无分组数据，继续执行自动建议');
+            Logger.log(`开始生成建议组件映射: threshold=${threshold}`);
             // 保存当前设计稿截图到临时文件
             const tempDir = path.join(fileManager.getBaseDir(), 'temp');
             await fs.promises.mkdir(tempDir, { recursive: true });
             const currentScreenshotPath = path.join(tempDir, `suggest_${Date.now()}.png`);
             await fs.promises.writeFile(currentScreenshotPath, currentScreenshotFile.buffer);
-            // 加载整个项目所有 fileKey 的所有 groupsData（跨文件匹配）
-            const allProjectGroupsData = await fileManager.loadAllProjectGroupsData();
-            if (!allProjectGroupsData || allProjectGroupsData.length === 0) {
-                Logger.log('未找到历史分组数据，无法生成建议');
+            // 从 components.json 加载所有组件
+            const components = await fileManager.loadComponentsDatabase();
+            if (!components || components.length === 0) {
+                Logger.log('未找到已保存的组件，无法生成建议');
                 await fs.promises.unlink(currentScreenshotPath).catch(() => { });
                 res.json({
                     success: true,
@@ -1140,34 +1188,37 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                 });
                 return;
             }
-            Logger.log(`从整个项目加载了 ${allProjectGroupsData.length} 个节点的历史数据`);
+            Logger.log(`从 components.json 加载了 ${components.length} 个组件`);
+            // 构建匹配任务：查找每个组件的截图文件
             const matchTasks = [];
-            for (const { fileKey: storedFileKey, nodeId: storedNodeId, groups } of allProjectGroupsData) {
-                const normalizedNodeId = storedNodeId === 'root' ? undefined : storedNodeId;
-                for (const group of groups) {
-                    // 只处理标记的分组
-                    if (!group.marked || !group.screenshot)
-                        continue;
-                    const screenshotPath = fileManager.getScreenshotPath(storedFileKey, normalizedNodeId, group.screenshot.hash);
-                    const exists = await fileManager.screenshotExists(storedFileKey, normalizedNodeId, group.screenshot.hash);
-                    if (!exists)
-                        continue;
-                    matchTasks.push({
-                        path: screenshotPath,
-                        groupData: {
-                            fileKey: storedFileKey,
-                            nodeId: normalizedNodeId ?? 'root',
-                            componentMapping: group.componentMapping,
-                            userPrompt: group.userPrompt,
-                            originalRect: group.rect,
-                            componentName: group.componentName, // 传递组件名称
-                            screenshot: group.screenshot, // 传递截图信息（包含 hash）
-                        },
-                    });
+            for (const component of components) {
+                // 只处理有 signature（截图 hash）的组件
+                if (!component.signature) {
+                    Logger.log(`组件 ${component.name} 没有 signature，跳过`);
+                    continue;
                 }
+                // 根据 signature 搜索截图文件
+                const screenshotPath = await fileManager.findScreenshotByHash(component.signature);
+                if (!screenshotPath) {
+                    Logger.log(`组件 ${component.name} 的截图未找到 (hash: ${component.signature})，跳过`);
+                    continue;
+                }
+                matchTasks.push({
+                    path: screenshotPath,
+                    componentData: {
+                        id: component.id,
+                        name: component.name,
+                        type: component.type,
+                        path: component.path,
+                        import: component.import,
+                        props: component.props,
+                        description: component.description,
+                        signature: component.signature,
+                    },
+                });
             }
             if (matchTasks.length === 0) {
-                Logger.log('没有可用的历史截图，返回空建议');
+                Logger.log('没有可用的组件截图，返回空建议');
                 await fs.promises.unlink(currentScreenshotPath).catch(() => { });
                 res.json({
                     success: true,
@@ -1175,12 +1226,12 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                 });
                 return;
             }
-            Logger.log(`开始匹配，共 ${matchTasks.length} 个历史组件截图`);
+            Logger.log(`开始匹配，共 ${matchTasks.length} 个组件截图`);
             const matcher = new ImageMatcher();
-            const matches = await matcher.batchMatch(currentScreenshotPath, matchTasks, parseFloat(threshold));
+            const matches = await matcher.batchMatch(currentScreenshotPath, matchTasks.map((t) => ({ path: t.path, groupData: t.componentData })), parseFloat(threshold));
             Logger.log(`匹配完成，找到 ${matches.length} 个相似组件`);
             matches.forEach((match, index) => {
-                Logger.log(`  匹配 ${index + 1}: 来源 fileKey=${match.groupData?.fileKey}, nodeId=${match.groupData?.nodeId}, 组件=${match.groupData?.componentName || 'N/A'}, 相似度=${Math.round(match.confidence * 100)}%`);
+                Logger.log(`  匹配 ${index + 1}: 组件=${match.groupData?.name || 'N/A'}, 相似度=${Math.round(match.confidence * 100)}%, 位置=(${match.position.left}, ${match.position.top}, ${match.position.width}x${match.position.height})`);
             });
             await fs.promises.unlink(currentScreenshotPath).catch(() => { });
             res.json({
@@ -1188,14 +1239,22 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                 data: {
                     suggestions: matches.map((match) => ({
                         confidence: Math.round(match.confidence * 100) / 100,
-                        position: match.position,
-                        componentMapping: match.groupData?.componentMapping,
-                        userPrompt: match.groupData?.userPrompt,
-                        originalRect: match.groupData?.originalRect,
-                        fileKey: match.groupData?.fileKey,
-                        nodeId: match.groupData?.nodeId,
-                        componentName: match.groupData?.componentName,
-                        screenshotHash: match.groupData?.screenshot?.hash, // 返回截图 hash，用于匹配组件 signature
+                        position: {
+                            left: match.position.left,
+                            top: match.position.top,
+                            width: match.position.width,
+                            height: match.position.height,
+                        },
+                        component: {
+                            id: match.groupData?.id,
+                            name: match.groupData?.name,
+                            type: match.groupData?.type,
+                            path: match.groupData?.path,
+                            import: match.groupData?.import,
+                            props: match.groupData?.props,
+                            description: match.groupData?.description,
+                            signature: match.groupData?.signature,
+                        },
                     })),
                 },
             });
@@ -1241,7 +1300,12 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
         }
     });
     // 启动 HTTP 服务器，监听端口
-    httpServer = app.listen(port, () => {
+    httpServer = app.listen(port, async (err) => {
+        if (err) {
+            Logger.error('HTTP 服务器启动失败:', err);
+            httpServer = null;
+            return;
+        }
         Logger.log(`HTTP server listening on port ${port}`);
         Logger.log(`SSE endpoint available at http://localhost:${port}/sse`);
         Logger.log(`Message endpoint available at http://localhost:${port}/messages`);
@@ -1253,6 +1317,15 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
         Logger.log(`Framework Config at http://localhost:${port}/getFrameworkConfig`);
         Logger.log(`Save Nodes endpoint available at http://localhost:${port}/saveNodes`);
         Logger.log(`Logging reconnect endpoint available at http://localhost:${port}/reconnect-logging`);
+        // 启动 Socket 服务器，监听端口 + 1
+        try {
+            socketServer = new SocketServer();
+            await socketServer.start(port + 1);
+        }
+        catch (error) {
+            Logger.error('Socket 服务器启动失败:', error);
+            Logger.error('进入子进程模式');
+        }
     });
     // 监听 SIGINT 信号，优雅关闭服务器和所有会话
     process.on('SIGINT', async () => {
@@ -1260,6 +1333,8 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
         Logger.log('正在关闭服务器...');
         // 清理等待中的认证请求
         pendingRequests.clear();
+        // 关闭 Socket 服务器
+        await stopSocketServer();
         // 关闭所有活跃的 SSE 和 streamable 传输，释放资源
         await closeTransports(transports.sse);
         await closeTransports(transports.streamable);
@@ -1282,30 +1357,66 @@ async function closeTransports(transports) {
 // 认证功能 - 获取用户输入函数
 export async function getUserInput(payload) {
     return new Promise(async (resolve, reject) => {
-        if (!httpServer) {
-            reject(new Error('HTTP 服务器未运行。请先启动服务器。'));
-            return;
-        }
         const token = uuidv4();
-        const authUrl = `http://localhost:${PORT}/auth-page?token=${token}&fileKey=${payload.fileKey}&nodeId=${payload.nodeId}`;
-        // 存储解析函数 - 无超时限制
-        pendingRequests.set(token, {
-            resolve: (value) => {
-                pendingRequests.delete(token);
-                resolve(value);
-            },
-            timeout: null, // 不再使用超时
-        });
-        // 打开浏览器
+        const port = getPort();
+        const authUrl = `http://localhost:${port}/auth-page?token=${token}&fileKey=${payload.fileKey}&nodeId=${payload.nodeId}`;
+        Logger.log('authUrl', authUrl);
+        // 判断是主进程还是子进程
+        const isMainProcess = httpServer !== null;
+        if (isMainProcess) {
+            // 主进程：存在 pendingRequests中, 在/submit里resolve
+            Logger.log('主进程：使用 pendingRequests 等待认证响应');
+            pendingRequests.set(token, {
+                resolve: (value) => {
+                    pendingRequests.delete(token);
+                    resolve(value);
+                },
+                timeout: null,
+            });
+            Logger.log('getUserInput pendingRequests', [...pendingRequests.keys()]);
+        }
+        else {
+            // 子进程：使用 Socket 客户端，监听SocketServer的submit-response消息
+            Logger.log('子进程：使用 Socket 客户端等待认证响应');
+            try {
+                const { SocketClient } = await import('./socket-client.js');
+                const socketClient = new SocketClient('localhost', port + 1);
+                // 连接到 Socket 服务器
+                await socketClient.connect();
+                Logger.log('Socket 客户端已连接');
+                // 注册 token 并等待响应
+                const responsePromise = socketClient.registerToken(token);
+                // 打开浏览器
+                await open(authUrl);
+                // 等待认证响应
+                const response = await responsePromise;
+                // 断开连接
+                socketClient.disconnect();
+                return resolve(response);
+            }
+            catch (err) {
+                reject(new Error(`Socket 客户端错误: ${err.message}`));
+                return;
+            }
+        }
+        // 打开浏览器（主进程）
         try {
             await open(authUrl);
         }
         catch (err) {
-            pendingRequests.delete(token);
+            if (isMainProcess) {
+                pendingRequests.delete(token);
+            }
             reject(new Error(`打开浏览器失败: ${err.message}`));
         }
     });
 }
+// 停止 Socket 服务器
+export async function stopSocketServer() {
+    if (socketServer) {
+        await socketServer.stop();
+    }
+}
 // 停止 HTTP 服务器，并关闭所有 SSE 传输
 export async function stopHttpServer() {
     if (!httpServer) {
@@ -1314,6 +1425,8 @@ export async function stopHttpServer() {
     return new Promise((resolve, reject) => {
         // 清理等待中的认证请求
         pendingRequests.clear();
+        // 关闭 Socket 服务器
+        const closeSocket = stopSocketServer();
         httpServer.close((err) => {
             if (err) {
                 reject(err);
@@ -1324,7 +1437,7 @@ export async function stopHttpServer() {
             const closing = Object.values(transports.sse).map((transport) => {
                 return transport.close();
             });
-            Promise.all(closing).then(() => {
+            Promise.all([...closing, closeSocket]).then(() => {
                 resolve();
             });
         });