sloth-d2c-mcp 1.0.4-beta74 → 1.0.4-beta76

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);
@@ -869,7 +909,7 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                                 const analysisResult = extractResult.value;
                                 // 构建组件信息
                                 const component = {
-                                    id: `comp-${Date.now()}-${Math.random()}`,
+                                    id: generateComponentId(),
                                     name: analysisResult.componentName || path.basename(filePath, path.extname(filePath)),
                                     type: 'custom',
                                     path: filePath,
@@ -890,7 +930,7 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                                 results.push({
                                     success: true,
                                     component: {
-                                        id: `comp-${Date.now()}-${Math.random()}`,
+                                        id: generateComponentId(),
                                         name: path.basename(filePath, path.extname(filePath)),
                                         type: 'custom',
                                         path: filePath,
@@ -908,7 +948,7 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                             results.push({
                                 success: true,
                                 component: {
-                                    id: `comp-${Date.now()}-${Math.random()}`,
+                                    id: generateComponentId(),
                                     name: path.basename(filePath, path.extname(filePath)),
                                     type: 'custom',
                                     path: filePath,
@@ -926,7 +966,7 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                         results.push({
                             success: true,
                             component: {
-                                id: `comp-${Date.now()}-${Math.random()}`,
+                                id: generateComponentId(),
                                 name: path.basename(filePath, path.extname(filePath)),
                                 type: 'custom',
                                 path: filePath,
@@ -976,6 +1016,7 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
     });
     /**
      * 保存项目中的组件到components.json
+     * 根据组件 id 自动判断是新增还是更新
      */
     app.post('/saveComponents', async (req, res) => {
         try {
@@ -990,19 +1031,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,31 +1071,12 @@ 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 });
+            Logger.log('扫描项目组件:', { includePaths, excludePaths });
             // 读取外部依赖组件（从 .sloth/components.json）
             let projectComponents = [];
             const slothPath = path.join(projectPath, '.sloth', 'components.json');
@@ -1063,7 +1101,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 +1120,6 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                 success: true,
                 data: {
                     total: projectComponents.length,
-                    platform,
                     projectComponents, // 项目组件
                 },
             });
@@ -1096,43 +1133,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 +1162,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 +1200,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 +1213,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 +1274,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 +1291,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 +1307,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 +1331,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 +1399,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 +1411,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();
             });
         });