sloth-d2c-mcp 1.0.4-beta100

package/dist/build/server.js

@@ -0,0 +1,2116 @@
+import { randomUUID } from 'node:crypto';
+import express from 'express';
+// 流式 HTTP 传输实现
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+// 判断是否为初始化请求
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+// 日志工具类，带时间戳输出日志
+import { Logger } from './utils/logger.js';
+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 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, chunkOptimizeCodePromptKuikly, aggregationOptimizeCodePromptKuikly, finalOptimizeCodePromptKuikly, chunkOptimizeCodePrompt, aggregationOptimizeCodePrompt, finalOptimizeCodePrompt, chunkOptimizeCodePromptVue, aggregationOptimizeCodePromptVue, finalOptimizeCodePromptVue, frameworkPromptKuikly, noSamplingAggregationPrompt, noSamplingAggregationPromptVue, noSamplingAggregationPromptKuikly, chunkOptimizeCodePromptIosOc, aggregationOptimizeCodePromptIosOc, finalOptimizeCodePromptIosOc, noSamplingAggregationPromptIosOc, chunkOptimizeCodePromptIosSwift, aggregationOptimizeCodePromptIosSwift, finalOptimizeCodePromptIosSwift, noSamplingAggregationPromptIosSwift, chunkOptimizeCodePromptTaro, aggregationOptimizeCodePromptTaro, finalOptimizeCodePromptTaro, noSamplingAggregationPromptTaro, chunkOptimizeCodePromptUniapp, aggregationOptimizeCodePromptUniapp, finalOptimizeCodePromptUniapp, noSamplingAggregationPromptUniapp, } from 'sloth-d2c-node/convert';
+import { SocketServer } from './socket-server.js';
+import { getParam } from './utils/utils.js';
+import { loadPluginFromGlobalDirAsync } from './plugin/loader.js';
+import { pluginManager } from './plugin/manager.js';
+/**
+ * 生成组件 ID（4位随机字符串）
+ */
+export const generateComponentId = () => `comp_${nanoid(4)}`;
+// 配置 multer 用于文件上传
+const storage = multer.memoryStorage();
+const upload = multer({
+    storage,
+    limits: { fileSize: 10 * 1024 * 1024 }, // 10MB
+});
+// 保存 HTTP 服务器实例
+export let httpServer = null;
+// 保存 Socket 服务器实例
+export let socketServer = null;
+// 管理所有活跃的传输对象，按 sessionId 分类
+const transports = {
+    streamable: {}, // 流式 HTTP 传输
+    sse: {}, // SSE 传输
+};
+// 认证功能存储
+const pendingRequests = new Map(); // 等待中的认证请求
+let configStorage = {}; // 配置缓存
+let configManager = null; // 配置管理器实例
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// 获取端口号
+let PORT = 3100;
+// 导出获取端口号的函数
+export function getPort() {
+    return PORT;
+}
+export async function loadConfig(mcpServer, configManagerInstance) {
+    if (configManagerInstance) {
+        configManager = configManagerInstance;
+        // 打印配置文件路径
+        try {
+            const configPath = configManager.getConfigPath();
+            Logger.log(`配置文件路径: ${configPath}`);
+            // 检查配置文件是否存在
+            const configExists = await configManager.exists();
+            Logger.log(`配置文件存在: ${configExists ? '是' : '否'}`);
+            let config = {};
+            if (configExists) {
+                // 如果配置文件存在，加载并显示配置信息
+                try {
+                    config = await configManager.load();
+                    mcpServer.setConfig(config.mcp);
+                    Logger.log(`当前配置内容: ${JSON.stringify(config, null, 2)}`);
+                }
+                catch (error) {
+                    Logger.warn(`读取配置文件失败: ${error}`);
+                }
+            }
+            // 默认框架列表
+            const defaultFrameworks = [
+                { value: 'react', label: 'React' },
+                { value: 'vue', label: 'Vue' },
+                { value: 'ios-oc', label: 'iOS OC' },
+                { value: 'ios-swift', label: 'iOS Swift' },
+                { value: 'kuikly', label: 'Kuikly' },
+                { value: 'taro', label: 'Taro' },
+                { value: 'uniapp', label: 'Uniapp' },
+            ];
+            // 初始化默认框架配置
+            if (!config.frameworks || config.frameworks.length === 0) {
+                Logger.log('初始化默认框架配置...');
+                config.frameworks = [...defaultFrameworks];
+                await configManager.save(config);
+            }
+            else {
+                // 检查是否缺少默认框架，补充缺失的
+                const existingValues = config.frameworks.map((fw) => fw.value);
+                const missingFrameworks = defaultFrameworks.filter((fw) => !existingValues.includes(fw.value));
+                if (missingFrameworks.length > 0) {
+                    config.frameworks = [...config.frameworks, ...missingFrameworks];
+                    await configManager.save(config);
+                }
+            }
+            // 检查 react.json 是否存在，如果不存在则创建
+            const reactConfigExists = await configManager.frameworkConfigExists('react');
+            if (!reactConfigExists) {
+                await configManager.saveFrameworkConfig('react', {
+                    chunkOptimizePrompt: chunkOptimizeCodePrompt,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePrompt,
+                    finalOptimizePrompt: finalOptimizeCodePrompt,
+                    componentAnalysisPrompt: componentAnalysisPrompt,
+                    noSamplingAggregationPrompt: noSamplingAggregationPrompt,
+                });
+                const reactConfigPath = configManager.getFrameworkConfigPath('react');
+                Logger.log(`已创建默认 react 配置文件: ${reactConfigPath}`);
+            }
+            // 检查 vue.json 是否存在，如果不存在则创建
+            const vueConfigExists = await configManager.frameworkConfigExists('vue');
+            if (!vueConfigExists) {
+                await configManager.saveFrameworkConfig('vue', {
+                    chunkOptimizePrompt: chunkOptimizeCodePromptVue,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePromptVue,
+                    finalOptimizePrompt: finalOptimizeCodePromptVue,
+                    componentAnalysisPrompt: componentAnalysisPromptVue,
+                    noSamplingAggregationPromptVue: noSamplingAggregationPromptVue,
+                });
+                const vueConfigPath = configManager.getFrameworkConfigPath('vue');
+                Logger.log(`已创建默认 vue 配置文件: ${vueConfigPath}`);
+            }
+            else {
+                const vueConfig = await configManager.loadFrameworkConfig('vue');
+                await configManager.saveFrameworkConfig('vue', {
+                    chunkOptimizePrompt: chunkOptimizeCodePromptVue,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePromptVue,
+                    finalOptimizePrompt: finalOptimizeCodePromptVue,
+                    componentAnalysisPrompt: componentAnalysisPromptVue,
+                    noSamplingAggregationPrompt: noSamplingAggregationPromptVue,
+                    ...(vueConfig || {}),
+                });
+            }
+            // 检查 ios-oc.json 是否存在，如果不存在则创建
+            const iosOcConfigExists = await configManager.frameworkConfigExists('ios-oc');
+            if (!iosOcConfigExists) {
+                await configManager.saveFrameworkConfig('ios-oc', {
+                    chunkOptimizePrompt: chunkOptimizeCodePromptIosOc,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePromptIosOc,
+                    finalOptimizePrompt: finalOptimizeCodePromptIosOc,
+                    componentAnalysisPrompt: '',
+                    noSamplingAggregationPrompt: noSamplingAggregationPromptIosOc,
+                });
+                const iosOcConfigPath = configManager.getFrameworkConfigPath('ios-oc');
+                Logger.log(`已创建默认 ios-oc 配置文件: ${iosOcConfigPath}`);
+            }
+            else {
+                const iosOcConfig = await configManager.loadFrameworkConfig('ios-oc');
+                await configManager.saveFrameworkConfig('ios-oc', {
+                    chunkOptimizePrompt: chunkOptimizeCodePromptIosOc,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePromptIosOc,
+                    finalOptimizePrompt: finalOptimizeCodePromptIosOc,
+                    componentAnalysisPrompt: '',
+                    noSamplingAggregationPrompt: noSamplingAggregationPromptIosOc,
+                    ...(iosOcConfig || {}),
+                });
+            }
+            // 检查 ios-swift.json 是否存在，如果不存在则创建
+            const iosswiftConfigExists = await configManager.frameworkConfigExists('ios-swift');
+            if (!iosswiftConfigExists) {
+                await configManager.saveFrameworkConfig('ios-swift', {
+                    chunkOptimizePrompt: chunkOptimizeCodePromptIosSwift,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePromptIosSwift,
+                    finalOptimizePrompt: finalOptimizeCodePromptIosSwift,
+                    componentAnalysisPrompt: '',
+                    noSamplingAggregationPrompt: noSamplingAggregationPromptIosSwift,
+                });
+                const iosswiftConfigPath = configManager.getFrameworkConfigPath('ios-swift');
+                Logger.log(`已创建默认 ios-swift 配置文件: ${iosswiftConfigPath}`);
+            }
+            else {
+                const iosSwiftConfig = await configManager.loadFrameworkConfig('ios-swift');
+                await configManager.saveFrameworkConfig('ios-swift', {
+                    chunkOptimizePrompt: chunkOptimizeCodePromptIosSwift,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePromptIosSwift,
+                    finalOptimizePrompt: finalOptimizeCodePromptIosSwift,
+                    componentAnalysisPrompt: '',
+                    noSamplingAggregationPrompt: noSamplingAggregationPromptIosSwift,
+                    ...(iosSwiftConfig || {}),
+                });
+            }
+            // 检查 kuikly.json 是否存在，如果不存在则创建
+            const kuiklyConfigExists = await configManager.frameworkConfigExists('kuikly');
+            if (!kuiklyConfigExists) {
+                await configManager.saveFrameworkConfig('kuikly', {
+                    enableFrameworkGuide: true,
+                    frameworkGuidePrompt: frameworkPromptKuikly,
+                    chunkOptimizePrompt: chunkOptimizeCodePromptKuikly,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePromptKuikly,
+                    finalOptimizePrompt: finalOptimizeCodePromptKuikly,
+                    componentAnalysisPrompt: '',
+                    noSamplingAggregationPrompt: noSamplingAggregationPromptKuikly,
+                });
+                const kuiklyConfigPath = configManager.getFrameworkConfigPath('kuikly');
+                Logger.log(`已创建默认 kuikly 配置文件: ${kuiklyConfigPath}`);
+            }
+            else {
+                const kuiklyConfig = await configManager.loadFrameworkConfig('kuikly');
+                await configManager.saveFrameworkConfig('kuikly', {
+                    enableFrameworkGuide: true,
+                    frameworkGuidePrompt: frameworkPromptKuikly,
+                    chunkOptimizePrompt: chunkOptimizeCodePromptKuikly,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePromptKuikly,
+                    finalOptimizePrompt: finalOptimizeCodePromptKuikly,
+                    componentAnalysisPrompt: '',
+                    noSamplingAggregationPrompt: noSamplingAggregationPromptKuikly,
+                    ...(kuiklyConfig || {}),
+                });
+            }
+            // 检查 taro.json 是否存在，如果不存在则创建
+            const taroConfigExists = await configManager.frameworkConfigExists('taro');
+            if (!taroConfigExists) {
+                await configManager.saveFrameworkConfig('taro', {
+                    chunkOptimizePrompt: chunkOptimizeCodePromptTaro,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePromptTaro,
+                    finalOptimizePrompt: finalOptimizeCodePromptTaro,
+                    componentAnalysisPrompt: '',
+                    noSamplingAggregationPrompt: noSamplingAggregationPromptTaro,
+                });
+                const taroConfigPath = configManager.getFrameworkConfigPath('taro');
+                Logger.log(`已创建默认 taro 配置文件: ${taroConfigPath}`);
+            }
+            else {
+                const taroConfig = await configManager.loadFrameworkConfig('taro');
+                await configManager.saveFrameworkConfig('taro', {
+                    chunkOptimizePrompt: chunkOptimizeCodePromptTaro,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePromptTaro,
+                    finalOptimizePrompt: finalOptimizeCodePromptTaro,
+                    componentAnalysisPrompt: '',
+                    noSamplingAggregationPrompt: noSamplingAggregationPromptTaro,
+                    ...(taroConfig || {}),
+                });
+            }
+            // 检查 uniapp.json 是否存在，如果不存在则创建
+            const uniappConfigExists = await configManager.frameworkConfigExists('uniapp');
+            if (!uniappConfigExists) {
+                await configManager.saveFrameworkConfig('uniapp', {
+                    chunkOptimizePrompt: chunkOptimizeCodePromptUniapp,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePromptUniapp,
+                    finalOptimizePrompt: finalOptimizeCodePromptUniapp,
+                    componentAnalysisPrompt: '',
+                    noSamplingAggregationPrompt: noSamplingAggregationPromptUniapp,
+                });
+                const uniappConfigPath = configManager.getFrameworkConfigPath('uniapp');
+                Logger.log(`已创建默认 uniapp 配置文件: ${uniappConfigPath}`);
+            }
+            else {
+                const uniappConfig = await configManager.loadFrameworkConfig('uniapp');
+                await configManager.saveFrameworkConfig('uniapp', {
+                    chunkOptimizePrompt: chunkOptimizeCodePromptUniapp,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePromptUniapp,
+                    finalOptimizePrompt: finalOptimizeCodePromptUniapp,
+                    componentAnalysisPrompt: '',
+                    noSamplingAggregationPrompt: noSamplingAggregationPromptUniapp,
+                    ...(uniappConfig || {}),
+                });
+            }
+        }
+        catch (error) {
+            Logger.error(`获取配置信息时出错: ${error}`);
+        }
+    }
+}
+// 启动 HTTP 服务器，监听指定端口，注册各类路由
+export async function startHttpServer(port = PORT, mcpServer, configManagerInstance, isWeb) {
+    const app = express();
+    PORT = port;
+    // 初始化 OpenCV
+    try {
+        await initOpenCV();
+        Logger.log('✅ OpenCV.js 初始化成功');
+    }
+    catch (error) {
+        Logger.error('❌ OpenCV.js 初始化失败:', error);
+        Logger.warn('图像匹配功能将不可用，但不影响其他功能');
+    }
+    // 存储配置管理器实例（如果提供）
+    loadConfig(mcpServer, configManagerInstance);
+    // if (configManagerInstance) {
+    //   configManager = configManagerInstance;
+    //   // 打印配置文件路径
+    //   try {
+    //     const configPath = configManager.getConfigPath();
+    //     Logger.log(`配置文件路径: ${configPath}`);
+    //     // 检查配置文件是否存在
+    //     const configExists = await configManager.exists();
+    //     Logger.log(`配置文件存在: ${configExists ? '是' : '否'}`);
+    //     if (configExists) {
+    //       // 如果配置文件存在，加载并显示配置信息
+    //       try {
+    //         const config = await configManager.load();
+    //         mcpServer.setConfig(config.mcp);
+    //         Logger.log(`当前配置内容: ${JSON.stringify(config, null, 2)}`);
+    //       } catch (error) {
+    //         Logger.warn(`读取配置文件失败: ${error}`);
+    //       }
+    //     }
+    //   } catch (error) {
+    //     Logger.error(`获取配置信息时出错: ${error}`);
+    //   }
+    // }
+    // 仅对 /mcp /submit 路径解析 JSON 请求体，避免影响 SSE
+    app.use('/mcp', express.json());
+    app.use('/submit', express.json());
+    app.use('/saveNodes', express.json({
+        limit: '100mb',
+    }));
+    // 为认证端点添加中间件 - 需要同时支持 JSON 和表单数据
+    app.use(express.urlencoded({ extended: true }));
+    app.use('/saveGlobalConfig', express.json());
+    app.use('/analyzeComponents', express.json());
+    app.use('/saveComponents', express.json());
+    // 设置跨域
+    app.use((req, res, next) => {
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Methods', 'GET, POST');
+        res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, Content-Length, X-Requested-With');
+        next();
+    });
+    // app.use(express.json());
+    app.use((req, _res, next) => {
+        // 通过referer取url上面的uuid
+        const uuid = getParam(req.headers.referer || '', 'token') || '';
+        req.uuid = uuid;
+        req.fileManager = fileManager.withUUID(uuid);
+        req.workspaceRoot = req.fileManager.getWorkspaceRoot();
+        next();
+    });
+    // 处理流式 HTTP 的 POST 请求，支持会话复用和初始化
+    app.post('/mcp', async (req, res) => {
+        Logger.log('Received StreamableHTTP request');
+        const sessionId = req.headers['mcp-session-id']; // 获取会话ID
+        let transport;
+        if (sessionId && transports.streamable[sessionId]) {
+            // 已有会话，复用传输对象
+            Logger.log('Reusing existing StreamableHTTP transport for sessionId', sessionId);
+            transport = transports.streamable[sessionId];
+        }
+        else if (!sessionId && isInitializeRequest(req.body)) {
+            // 新会话初始化请求
+            Logger.log('New initialization request for StreamableHTTP sessionId', sessionId);
+            transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(), // 生成唯一 sessionId
+                onsessioninitialized: (sessionId) => {
+                    // 会话初始化后，存储传输对象
+                    transports.streamable[sessionId] = transport;
+                },
+            });
+            // 会话关闭时清理资源
+            transport.onclose = () => {
+                if (transport.sessionId) {
+                    delete transports.streamable[transport.sessionId];
+                }
+            };
+            // 连接 MCP 服务器，建立上下文
+            if (isWeb === true) {
+                await mcpServer.connect(transport);
+            }
+        }
+        else {
+            // 非法请求，缺少有效 sessionId
+            Logger.log('Invalid request:', req.body);
+            res.status(400).json({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32000,
+                    message: 'Bad Request: No valid session ID provided',
+                },
+                id: null,
+            });
+            return;
+        }
+        // 进度通知相关逻辑
+        let progressInterval = null;
+        const progressToken = req.body.params?._meta?.progressToken; // 获取进度令牌
+        let progress = 0;
+        Logger.log(`progressToken:${progressToken}`);
+        if (progressToken) {
+            Logger.log(`Setting up progress notifications for token ${progressToken} on session ${sessionId} 1112222222`);
+            // 定时发送进度通知
+            progressInterval = setInterval(async () => {
+                // Logger.log("Sending progress notification", progress);
+                await mcpServer.server.notification({
+                    method: 'notifications/progress',
+                    params: {
+                        progress,
+                        progressToken,
+                    },
+                });
+                progress++;
+            }, 1000);
+        }
+        Logger.log('Handling StreamableHTTP request');
+        // 处理请求，响应客户端
+        await transport.handleRequest(req, res, req.body);
+        // 清理进度通知定时器
+        // if (progressInterval) {
+        //   clearInterval(progressInterval);
+        // }
+        Logger.log('StreamableHTTP request handled');
+    });
+    // 处理 GET/DELETE 请求，用于会话终止或获取会话状态
+    const handleSessionRequest = async (req, res) => {
+        const sessionId = req.headers['mcp-session-id'];
+        if (!sessionId || !transports.streamable[sessionId]) {
+            res.status(400).send('Invalid or missing session ID');
+            return;
+        }
+        Logger.log(`Received session termination request for session ${sessionId}`);
+        try {
+            const transport = transports.streamable[sessionId];
+            await transport.handleRequest(req, res);
+        }
+        catch (error) {
+            console.error('Error handling session termination:', error);
+            if (!res.headersSent) {
+                res.status(500).send('Error processing session termination');
+            }
+        }
+    };
+    // GET 请求：获取会话状态
+    app.get('/mcp', handleSessionRequest);
+    // DELETE 请求：终止会话
+    app.delete('/mcp', handleSessionRequest);
+    // SSE 连接建立，分配 sessionId 并注册到 transports.sse
+    // app.get("/sse", async (req: any, res: any) => {
+    //   Logger.log("Establishing new SSE connection");
+    //   const transport = new SSEServerTransport("/messages", res);
+    //   Logger.log(`New SSE connection established for sessionId ${transport.sessionId}`);
+    //   Logger.log("/sse request headers:", req.headers);
+    //   Logger.log("/sse request body:", req.body);
+    //   transports.sse[transport.sessionId] = transport;
+    //   // 连接关闭时清理资源
+    //   res.on("close", () => {
+    //     delete transports.sse[transport.sessionId];
+    //   });
+    //   // 连接 MCP 服务器，建立 SSE 通道
+    //   await mcpServer.connect(transport);
+    // });
+    // SSE 消息推送接口，根据 sessionId 找到对应传输对象
+    app.post('/messages', async (req, res) => {
+        const sessionId = req.query.sessionId;
+        const transport = transports.sse[sessionId];
+        Logger.log('/messages request headers:', req.headers);
+        Logger.log('/messages request body:', req.body);
+        if (transport) {
+            Logger.log(`Received SSE message for sessionId ${sessionId}`);
+            await transport.handlePostMessage(req, res);
+        }
+        else {
+            res.status(400).send(`No transport found for sessionId ${sessionId}`);
+            return;
+        }
+    });
+    // 认证相关端点
+    // 获取配置接口，支持 fileKey 和 nodeId 参数
+    app.get('/getConfig', async (req, res) => {
+        try {
+            const fileKey = req.query.fileKey;
+            const nodeId = req.query.nodeId;
+            const framework = req.query.framework;
+            // const plugins = await listWorkspacePlugins(req.workspaceRoot)
+            const plugins = await socketServer?.getTokenExtraField(req.uuid, 'plugins');
+            if (fileKey) {
+                // 如果提供了 fileKey，返回该 fileKey 的特定配置
+                const globalConfig = await configManager.load();
+                // const fileConfig = globalConfig.fileConfigs?.[fileKey] || {}
+                const fileConfig = (await req.fileManager.loadConfigSetting(fileKey, nodeId)) || {};
+                // 从 fileManager 按 nodeId 加载 groupsData 和 promptSetting
+                // const fileManager = new FileManager('d2c-mcp')
+                const groupsData = await req.fileManager.loadGroupsData(fileKey, nodeId);
+                const savedPromptSetting = await req.fileManager.loadPromptSetting(fileKey, nodeId);
+                let curFramework = fileConfig?.convertSetting?.framework;
+                // 获取框架列表
+                const frameworks = await configManager.getFrameworks();
+                // 如果指定了框架，加载框架配置的提示词
+                let promptSetting = {
+                    enableFrameworkGuide: savedPromptSetting?.frameworkGuidePrompt,
+                    frameworkGuidePrompt: savedPromptSetting?.frameworkGuidePrompt,
+                    chunkOptimizePrompt: savedPromptSetting?.chunkOptimizePrompt,
+                    aggregationOptimizePrompt: savedPromptSetting?.aggregationOptimizePrompt,
+                    finalOptimizePrompt: savedPromptSetting?.finalOptimizePrompt,
+                    componentAnalysisPrompt: savedPromptSetting?.componentAnalysisPrompt,
+                    noSamplingAggregationPrompt: savedPromptSetting?.noSamplingAggregationPrompt,
+                };
+                res.json({
+                    success: true,
+                    data: {
+                        mcp: globalConfig.mcp || {},
+                        convertSetting: fileConfig.convertSetting,
+                        imageSetting: fileConfig.imageSetting,
+                        promptSetting: promptSetting,
+                        frameworks: frameworks,
+                        defaultFramework: globalConfig.defaultFramework || 'react',
+                        fileKey: fileKey,
+                        groupsData: groupsData,
+                        pluginSetting: plugins,
+                    },
+                });
+            }
+            else {
+                // 如果没有提供 fileKey，返回默认配置
+                if (await configManager.exists()) {
+                    configStorage = await configManager.load();
+                }
+                // 如果指定了框架，加载框架配置的提示词
+                let promptSetting = {
+                    enableFrameworkGuide: false,
+                    frameworkGuidePrompt: '',
+                    chunkOptimizePrompt: chunkOptimizeCodePrompt,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePrompt,
+                    finalOptimizePrompt: finalOptimizeCodePrompt,
+                    componentAnalysisPrompt: componentAnalysisPrompt,
+                    noSamplingAggregationPrompt: noSamplingAggregationPrompt,
+                };
+                if (framework) {
+                    // 加载框架配置
+                    const frameworkConfig = await configManager.loadFrameworkConfig(framework);
+                    if (frameworkConfig && Object.keys(frameworkConfig).length > 0) {
+                        // 框架配置优先级更高
+                        promptSetting = {
+                            enableFrameworkGuide: frameworkConfig.frameworkGuidePrompt || promptSetting.enableFrameworkGuide ? true : false,
+                            frameworkGuidePrompt: frameworkConfig.frameworkGuidePrompt || promptSetting.frameworkGuidePrompt,
+                            chunkOptimizePrompt: frameworkConfig.chunkOptimizePrompt || promptSetting.chunkOptimizePrompt,
+                            aggregationOptimizePrompt: frameworkConfig.aggregationOptimizePrompt || promptSetting.aggregationOptimizePrompt,
+                            finalOptimizePrompt: frameworkConfig.finalOptimizePrompt || promptSetting.finalOptimizePrompt,
+                            componentAnalysisPrompt: frameworkConfig.componentAnalysisPrompt || promptSetting.componentAnalysisPrompt,
+                            noSamplingAggregationPrompt: frameworkConfig.noSamplingAggregationPrompt || promptSetting.noSamplingAggregationPrompt,
+                        };
+                    }
+                }
+                // 获取框架列表
+                const frameworks = await configManager.getFrameworks();
+                res.json({
+                    success: true,
+                    data: {
+                        mcp: configStorage.mcp || {},
+                        convertSetting: configStorage.convertSetting || {},
+                        imageSetting: configStorage.imageSetting || {},
+                        promptSetting: promptSetting,
+                        frameworks: frameworks,
+                        pluginSetting: plugins,
+                    },
+                });
+            }
+        }
+        catch (error) {
+            Logger.error('获取配置失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '获取配置失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    app.get('/getHtml', async (req, res) => {
+        // 加载现有配置
+        // const fileManager = new FileManager('d2c-mcp')
+        const html = await fileManager.loadAbsoluteHtml(req.query.fileKey, req.query.nodeId);
+        res.json({
+            success: true,
+            data: html,
+        });
+    });
+    // 获取全局配置接口
+    app.get('/getGlobalConfig', async (req, res) => {
+        try {
+            const framework = req.query.framework;
+            const globalConfig = await configManager.load();
+            let frameworks = (await configManager.getFrameworks()) || [
+                { value: 'react', label: 'React' },
+                { value: 'vue', label: 'Vue' },
+                { value: 'kuikly', label: 'Kuikly' },
+            ];
+            const defaultFramework = globalConfig?.defaultFramework || 'react';
+            let promptSetting = {};
+            const fw = frameworks.find((f) => f.value === framework) ? framework : defaultFramework;
+            const frameworkConfig = await configManager.loadFrameworkConfig(fw);
+            promptSetting[fw] = {
+                ...frameworkConfig,
+                enableFrameworkGuide: frameworkConfig.enableFrameworkGuide || false,
+                frameworkGuidePrompt: frameworkConfig.frameworkGuidePrompt || '',
+                chunkOptimizePrompt: frameworkConfig.chunkOptimizePrompt || '',
+                aggregationOptimizePrompt: frameworkConfig.aggregationOptimizePrompt || '',
+                finalOptimizePrompt: frameworkConfig.finalOptimizePrompt || '',
+                componentAnalysisPrompt: frameworkConfig.componentAnalysisPrompt || '',
+                noSamplingAggregationPrompt: frameworkConfig.noSamplingAggregationPrompt || '',
+            };
+            res.json({
+                success: true,
+                data: {
+                    frameworks,
+                    defaultFramework,
+                    promptSetting,
+                },
+                message: '获取成功',
+            });
+        }
+        catch (error) {
+            Logger.error('获取全局配置失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '获取全局配置失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    // 保存全局配置接口
+    app.post('/saveGlobalConfig', async (req, res) => {
+        try {
+            const { token, value } = req.body;
+            if (!token || !value) {
+                res.status(400).json({
+                    success: false,
+                    message: '请求体中缺少 token 或 value',
+                });
+                return;
+            }
+            const { frameworks, defaultFramework, promptSetting: promptSettingMap } = value;
+            const globalConfig = await configManager.load();
+            globalConfig.frameworks = frameworks;
+            globalConfig.defaultFramework = defaultFramework;
+            await Promise.all(Object.entries(promptSettingMap).map(([key, value]) => configManager.saveFrameworkConfig(key, value)));
+            await configManager.save(globalConfig);
+            res.json({
+                success: true,
+                message: '保存全局配置成功',
+            });
+        }
+        catch (error) {
+            Logger.error('保存全局配置失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '保存全局配置失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    // 获取框架配置接口
+    app.get('/getFrameworkConfig', async (req, res) => {
+        try {
+            const framework = req.query.framework;
+            if (!framework) {
+                res.status(400).json({
+                    success: false,
+                    message: '缺少必要参数: framework',
+                });
+                return;
+            }
+            let promptSetting = {
+                enableFrameworkGuide: false,
+                frameworkGuidePrompt: '',
+                chunkOptimizePrompt: chunkOptimizeCodePrompt,
+                aggregationOptimizePrompt: aggregationOptimizeCodePrompt,
+                finalOptimizePrompt: finalOptimizeCodePrompt,
+                componentAnalysisPrompt: componentAnalysisPrompt,
+                noSamplingAggregationPrompt: noSamplingAggregationPrompt,
+            };
+            const frameworkConfig = await configManager.loadFrameworkConfig(framework);
+            if (frameworkConfig && Object.keys(frameworkConfig).length > 0) {
+                // 框架配置优先级更高
+                promptSetting = {
+                    enableFrameworkGuide: frameworkConfig.enableFrameworkGuide || promptSetting.enableFrameworkGuide,
+                    frameworkGuidePrompt: frameworkConfig.frameworkGuidePrompt || promptSetting.frameworkGuidePrompt,
+                    chunkOptimizePrompt: frameworkConfig.chunkOptimizePrompt || promptSetting.chunkOptimizePrompt,
+                    aggregationOptimizePrompt: frameworkConfig.aggregationOptimizePrompt || promptSetting.aggregationOptimizePrompt,
+                    finalOptimizePrompt: frameworkConfig.finalOptimizePrompt || promptSetting.finalOptimizePrompt,
+                    componentAnalysisPrompt: frameworkConfig.componentAnalysisPrompt || promptSetting.componentAnalysisPrompt,
+                    noSamplingAggregationPrompt: frameworkConfig.noSamplingAggregationPrompt || promptSetting.noSamplingAggregationPrompt,
+                };
+            }
+            res.json({
+                success: true,
+                data: promptSetting,
+                message: '获取框架配置成功',
+            });
+        }
+        catch (error) {
+            Logger.error('获取框架配置失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '获取框架配置失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    // 获取框架默认提示词接口（不读取用户配置，直接返回代码中的原始默认值）
+    app.get('/getDefaultFrameworkConfig', async (req, res) => {
+        try {
+            const framework = req.query.framework;
+            if (!framework) {
+                res.status(400).json({
+                    success: false,
+                    message: '缺少必要参数: framework',
+                });
+                return;
+            }
+            // 根据框架返回对应的原始默认提示词
+            const isVue = framework.toLowerCase() === 'vue';
+            const isIosOc = framework.toLowerCase() === 'ios-oc';
+            const isIosSwift = framework.toLowerCase() === 'ios-swift';
+            const isKuikly = framework.toLowerCase() === 'kuikly';
+            const isTaro = framework.toLowerCase() === 'taro';
+            const isUniapp = framework.toLowerCase() === 'uniapp';
+            let promptSetting = {
+                enableFrameworkGuide: isKuikly ? true : false,
+                frameworkGuidePrompt: isKuikly ? frameworkPromptKuikly : '',
+                chunkOptimizePrompt: isKuikly
+                    ? chunkOptimizeCodePromptKuikly
+                    : isIosOc
+                        ? chunkOptimizeCodePromptIosOc
+                        : isIosSwift
+                            ? chunkOptimizeCodePromptIosSwift
+                            : isVue
+                                ? chunkOptimizeCodePromptVue
+                                : chunkOptimizeCodePrompt,
+                aggregationOptimizePrompt: isKuikly
+                    ? aggregationOptimizeCodePromptKuikly
+                    : isIosOc
+                        ? aggregationOptimizeCodePromptIosOc
+                        : isIosSwift
+                            ? aggregationOptimizeCodePromptIosSwift
+                            : isVue
+                                ? aggregationOptimizeCodePromptVue
+                                : aggregationOptimizeCodePrompt,
+                finalOptimizePrompt: isKuikly
+                    ? finalOptimizeCodePromptKuikly
+                    : isIosOc
+                        ? finalOptimizeCodePromptIosOc
+                        : isIosSwift
+                            ? finalOptimizeCodePromptIosSwift
+                            : isVue
+                                ? finalOptimizeCodePromptVue
+                                : finalOptimizeCodePrompt,
+                componentAnalysisPrompt: isKuikly ? '' : isIosOc ? '' : isIosSwift ? '' : isVue ? componentAnalysisPromptVue : componentAnalysisPrompt,
+                noSamplingAggregationPrompt: isKuikly
+                    ? noSamplingAggregationPromptKuikly
+                    : isIosOc
+                        ? noSamplingAggregationPromptIosOc
+                        : isIosSwift
+                            ? noSamplingAggregationPromptIosSwift
+                            : isVue
+                                ? noSamplingAggregationPromptVue
+                                : noSamplingAggregationPrompt,
+            };
+            if (isTaro) {
+                promptSetting.enableFrameworkGuide = false;
+                promptSetting.frameworkGuidePrompt = '';
+                promptSetting.chunkOptimizePrompt = chunkOptimizeCodePromptTaro;
+                promptSetting.aggregationOptimizePrompt = aggregationOptimizeCodePromptTaro;
+                promptSetting.finalOptimizePrompt = finalOptimizeCodePromptTaro;
+                promptSetting.noSamplingAggregationPrompt = noSamplingAggregationPromptTaro;
+                promptSetting.componentAnalysisPrompt = componentAnalysisPrompt;
+            }
+            if (isUniapp) {
+                promptSetting.enableFrameworkGuide = false;
+                promptSetting.frameworkGuidePrompt = '';
+                promptSetting.chunkOptimizePrompt = chunkOptimizeCodePromptUniapp;
+                promptSetting.aggregationOptimizePrompt = aggregationOptimizeCodePromptUniapp;
+                promptSetting.finalOptimizePrompt = finalOptimizeCodePromptUniapp;
+                promptSetting.noSamplingAggregationPrompt = noSamplingAggregationPromptUniapp;
+                promptSetting.componentAnalysisPrompt = componentAnalysisPromptVue;
+            }
+            res.json({
+                success: true,
+                data: promptSetting,
+                message: '获取默认框架配置成功1',
+            });
+        }
+        catch (error) {
+            Logger.error('获取默认框架配置失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '获取默认框架配置失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    // 获取项目中的 Markdown 文件列表（扫描 .sloth/doc 目录）
+    app.get('/getMarkdownFiles', async (req, res) => {
+        try {
+            const projectRoot = getProjectRoot(req.fileManager);
+            if (!projectRoot) {
+                res.json({
+                    success: true,
+                    data: [],
+                    message: '未找到项目根目录',
+                });
+                return;
+            }
+            const markdownFiles = [];
+            const promptDir = path.join(projectRoot, '.sloth', 'prompt');
+            // 检查 .sloth/prompt 目录是否存在
+            if (!fs.existsSync(promptDir)) {
+                res.json({
+                    success: true,
+                    data: [],
+                    message: '.sloth/prompt 目录不存在',
+                });
+                return;
+            }
+            // 递归查找 prompt 目录下的 .md 文件
+            const findMarkdownFiles = (dir) => {
+                try {
+                    const items = fs.readdirSync(dir, { withFileTypes: true });
+                    for (const item of items) {
+                        const fullPath = path.join(dir, item.name);
+                        const relativePath = path.relative(promptDir, fullPath);
+                        if (item.isDirectory()) {
+                            findMarkdownFiles(fullPath);
+                        }
+                        else if (item.isFile() && item.name.endsWith('.md')) {
+                            markdownFiles.push({
+                                path: path.join('.sloth', 'prompt', relativePath),
+                                name: item.name,
+                            });
+                        }
+                    }
+                }
+                catch (err) {
+                    Logger.warn(`无法访问目录: ${dir}`, err);
+                }
+            };
+            findMarkdownFiles(promptDir);
+            res.json({
+                success: true,
+                data: markdownFiles,
+                message: `找到 ${markdownFiles.length} 个文档`,
+            });
+        }
+        catch (error) {
+            Logger.error('获取文档列表失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '获取文档列表失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    // 认证页面
+    app.get('/auth-page', (req, res) => {
+        try {
+            // 尝试找到相对于当前位置的模板路径
+            const isStdioMode = process.env.NODE_ENV === 'cli' || process.argv.includes('--stdio');
+            const isDevMode = process.argv.includes('--dev');
+            const templatePath = path.join(__dirname, isStdioMode && !isDevMode ? '../interceptor-web/dist/index.html' : '../../interceptor-web/dist/index.html');
+            Logger.log('templatePath', templatePath);
+            if (fs.existsSync(templatePath)) {
+                const htmlContent = fs.readFileSync(templatePath, 'utf8');
+                res.send(htmlContent);
+            }
+            else {
+                // 备用方案：简单的 HTML 表单
+                const fallbackHtml = `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>身份验证</title>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+</head>
+<body>
+    <div style="max-width: 500px; margin: 50px auto; padding: 20px; font-family: Arial, sans-serif;">
+        <h2>需要身份验证</h2>
+        <form id="authForm" method="POST" action="/submit">
+            <input type="hidden" name="token" value="${req.query.token || ''}" />
+            <div style="margin-bottom: 15px;">
+                <label for="value" style="display: block; margin-bottom: 5px;">请输入您的信息:</label>
+                <input type="text" id="value" name="value" required style="width: 100%; padding: 8px; border: 1px solid #ddd; border-radius: 4px;" />
+            </div>
+            <button type="submit" style="background: #007cba; color: white; padding: 10px 20px; border: none; border-radius: 4px; cursor: pointer;">提交</button>
+        </form>
+    </div>
+</body>
+</html>`;
+                res.send(fallbackHtml);
+            }
+        }
+        catch (error) {
+            res.status(500).send('加载认证页面时出错');
+        }
+    });
+    // 提交认证信息，支持 fileKey 和 nodeId 参数
+    app.post('/submit', async (req, res) => {
+        try {
+            // 安全地解构请求体，处理可能为空的情况
+            const { token, value, fileKey, nodeId } = req.body || {};
+            Logger.log('submit req.body', token, value, fileKey, nodeId);
+            if (!token || !value) {
+                res.status(400).send('请求体中缺少 token 或 value');
+                return;
+            }
+            // 保存配置到对应的 fileKey 或默认配置
+            if (fileKey) {
+                // 保存到特定 fileKey 的配置
+                const globalConfig = await configManager.load();
+                if (!globalConfig.fileConfigs) {
+                    globalConfig.fileConfigs = {};
+                }
+                if (!globalConfig.fileConfigs[fileKey]) {
+                    globalConfig.fileConfigs[fileKey] = {};
+                }
+                if (value.convertSetting) {
+                    globalConfig.fileConfigs[fileKey].convertSetting = value.convertSetting;
+                }
+                if (value.imageSetting) {
+                    globalConfig.fileConfigs[fileKey].imageSetting = value.imageSetting;
+                }
+                await configManager.save(globalConfig);
+                Logger.log(`已保存 fileKey "${fileKey}" 的配置:`, value);
+            }
+            // 使用 fileManager 按 nodeId 保存 groupsData 和 promptSetting
+            // const fileManager = new FileManager('d2c-mcp')
+            if (fileKey && value.groupsData && Array.isArray(value.groupsData)) {
+                await req.fileManager.saveGroupsData(fileKey, nodeId, value.groupsData);
+                Logger.log(`已保存 groupsData 到 fileKey "${fileKey}", nodeId "${nodeId}":`, value.groupsData.length, '个分组');
+            }
+            if (fileKey && value.promptSetting) {
+                if (!value.promptSetting.enableFrameworkGuide) {
+                    value.promptSetting.frameworkGuidePrompt = '';
+                }
+                await req.fileManager.savePromptSetting(fileKey, nodeId, value.promptSetting);
+                Logger.log(`已保存 promptSetting 到 fileKey "${fileKey}", nodeId "${nodeId}"`);
+            }
+            // 如果有 MCP 配置，更新全局配置
+            if (value.mcp) {
+                const globalConfig = await configManager.load();
+                globalConfig.mcp = { ...globalConfig.mcp, ...value.mcp };
+                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;
+            }
+            // 如果主进程查不到pendingRequests，则判断是子进程提交的，通过 Socket 发送提交数据给子进程
+            socketServer?.sendSubmitResponse(token, value);
+            Logger.log(`已通过 Socket 发送认证响应: token=${token}`);
+            res.send('提交成功！您可以关闭此窗口。');
+            return;
+        }
+        catch (error) {
+            Logger.error('保存配置失败:', error);
+            res.status(500).send('保存配置失败: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    });
+    // 保存节点数据端点
+    app.post('/saveNodes', async (req, res) => {
+        try {
+            console.log('req.body', req);
+            const { nodeList, fileKey, nodeId, imageMap, absoluteHtml } = req.body;
+            if (!nodeList || !fileKey || !nodeId) {
+                res.status(400).json({
+                    success: false,
+                    message: '缺少必要参数: nodeList, fileKey, nodeId',
+                });
+                return;
+            }
+            // const fileManager = new FileManager('d2c-mcp')
+            // 保存节点列表
+            await fileManager.saveFile(fileKey, nodeId, 'nodeList.json', nodeList);
+            // 保存图片映射
+            if (imageMap) {
+                await fileManager.saveFile(fileKey, nodeId, 'imageMap.json', flatted.stringify(imageMap));
+            }
+            // 保存绝对布局HTML
+            if (absoluteHtml) {
+                await fileManager.saveAbsoluteHtml(fileKey, nodeId, absoluteHtml);
+            }
+            Logger.log(`成功保存节点数据: fileKey=${fileKey}, nodeId=${nodeId}`);
+            res.json({
+                success: true,
+                message: '节点数据保存成功',
+            });
+        }
+        catch (error) {
+            Logger.error('保存节点数据失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '保存节点数据失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    // 日志重连端点
+    app.post('/reconnect-logging', (req, res) => {
+        Logger.log('收到来自 VSCode 扩展的日志重连请求');
+        // 重新初始化日志连接
+        Logger.reconnectVSCodeLogging();
+        res.status(200).json({
+            success: true,
+            message: '日志重连已启动',
+        });
+    });
+    // 插件渲染器端点 - 返回JS代码字符串
+    app.get('/pluginRenderer', async (req, res) => {
+        console.log('pluginRenderer');
+        const pluginName = req.query.pluginName;
+        let pluginRenderer = null;
+        try {
+            // @ts-ignore
+            pluginRenderer = await loadPluginFromGlobalDirAsync(pluginName);
+        }
+        catch (error) {
+            console.error('加载插件渲染器失败:', error);
+            res.type('application/javascript; charset=utf-8').send(`alert(${pluginName}加载失败)`);
+            return;
+        }
+        const renderer = pluginRenderer.default.renderConfigForm;
+        res.type('application/javascript; charset=utf-8').send(renderer);
+    });
+    // ==================== 组件映射相关接口 ====================
+    /**
+     * 获取项目根目录
+     */
+    function getProjectRoot(fs) {
+        try {
+            const projectPath = fs.getWorkspaceRoot();
+            return projectPath || './';
+        }
+        catch (error) {
+            Logger.warn('获取根目录时出错，使用默认路径:', error);
+            return './';
+        }
+    }
+    /**
+     * 获取项目文件树
+     */
+    app.get('/getProjectFiles', async (req, res) => {
+        try {
+            const { directory = '' } = req.query;
+            const projectPath = getProjectRoot(req.fileManager);
+            const targetPath = path.join(projectPath, directory);
+            Logger.log(`获取项目文件树: ${targetPath}`);
+            // 排除的文件扩展名（静态资源和配置文件）
+            const excludeExtensions = [
+                // 图片
+                '.png',
+                '.jpg',
+                '.jpeg',
+                '.gif',
+                '.svg',
+                '.ico',
+                '.webp',
+                '.bmp',
+                // 视频/音频
+                '.mp4',
+                '.avi',
+                '.mov',
+                '.mp3',
+                '.wav',
+                // 字体
+                '.ttf',
+                '.woff',
+                '.woff2',
+                '.eot',
+                // 配置文件
+                '.json',
+                '.lock',
+                '.yaml',
+                '.yml',
+                '.toml',
+                // 文档
+                '.md',
+                '.txt',
+                '.pdf',
+                '.doc',
+                '.docx',
+                // 其他
+                '.zip',
+                '.tar',
+                '.gz',
+                '.rar',
+                '.map',
+                '.d.ts.map',
+            ];
+            // 递归读取文件树
+            const buildFileTree = async (dirPath, relativePath = '') => {
+                const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+                const files = [];
+                for (const entry of entries) {
+                    // 排除特殊目录
+                    const excludeDirs = ['node_modules', 'dist', 'build', '.git', '.next', 'coverage', '.sloth', 'public', 'static', 'assets'];
+                    if (excludeDirs.includes(entry.name) || entry.name.startsWith('.')) {
+                        continue;
+                    }
+                    const entryRelativePath = path.join(relativePath, entry.name);
+                    const entryFullPath = path.join(dirPath, entry.name);
+                    if (entry.isDirectory()) {
+                        const children = await buildFileTree(entryFullPath, entryRelativePath);
+                        if (children.length > 0) {
+                            files.push({
+                                title: entry.name,
+                                key: entryRelativePath,
+                                path: entryRelativePath,
+                                isLeaf: false,
+                                selectable: false,
+                                children,
+                            });
+                        }
+                    }
+                    else {
+                        // 排除静态资源文件
+                        const ext = path.extname(entry.name).toLowerCase();
+                        if (!excludeExtensions.includes(ext)) {
+                            files.push({
+                                title: entry.name,
+                                key: entryRelativePath,
+                                path: entryRelativePath,
+                                isLeaf: true,
+                                selectable: true,
+                            });
+                        }
+                    }
+                }
+                return files;
+            };
+            const fileTree = await buildFileTree(targetPath);
+            res.json({
+                success: true,
+                data: {
+                    projectPath,
+                    files: fileTree,
+                },
+            });
+        }
+        catch (error) {
+            Logger.error('获取项目文件树失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '获取项目文件树失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    // 多文件分析限制
+    const MAX_FILES = 10; // 最多 10 个文件
+    const MAX_TOTAL_CHARS = 40000; // 总内容最多 40000 字符
+    const MAX_FILE_CHARS = 5000; // 单文件最多 5000 字符
+    /**
+     * 分析项目中的组件
+     */
+    app.post('/analyzeComponents', async (req, res) => {
+        try {
+            const { filePaths, fileKey, nodeId } = req.body;
+            if (!filePaths || !Array.isArray(filePaths)) {
+                res.status(400).json({
+                    success: false,
+                    message: '缺少必要参数: filePaths',
+                });
+                return;
+            }
+            // 限制文件数量
+            if (filePaths.length > MAX_FILES) {
+                res.status(400).json({
+                    success: false,
+                    message: `文件数量超过限制，最多支持 ${MAX_FILES} 个文件`,
+                });
+                return;
+            }
+            Logger.log(`批量分析 ${filePaths.length} 个项目文件`);
+            const projectPath = getProjectRoot(req.fileManager);
+            // 尝试加载保存的提示词设置
+            let savedPromptSetting = null;
+            if (fileKey && nodeId) {
+                try {
+                    savedPromptSetting = await req.fileManager.loadPromptSetting(fileKey, nodeId);
+                    Logger.log(`已加载提示词设置: fileKey=${fileKey}, nodeId=${nodeId}`);
+                }
+                catch (error) {
+                    Logger.warn(`加载提示词设置失败: ${error}`);
+                }
+            }
+            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)) {
+                        fileContents.push({
+                            path: filePath,
+                            content: '',
+                            error: '无权访问该文件',
+                        });
+                        continue;
+                    }
+                    // 读取文件内容
+                    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} 字符`);
+                    }
+                    // 检查总字符数
+                    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);
+                    fileContents.push({
+                        path: filePath,
+                        content: '',
+                        error: error instanceof Error ? error.message : String(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: 48000,
+                }, { 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);
+            res.status(500).json({
+                success: false,
+                message: '分析项目组件失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    /**
+     * 保存项目中的组件到components.json
+     * 根据组件 id 自动判断是新增还是更新
+     */
+    app.post('/saveComponents', async (req, res) => {
+        try {
+            const { components } = req.body;
+            if (!components || !Array.isArray(components)) {
+                res.status(400).json({
+                    success: false,
+                    message: '无效的组件数据',
+                });
+                return;
+            }
+            Logger.log(`准备保存 ${components.length} 个组件`);
+            // 读取现有组件
+            const existingComponents = await req.fileManager.loadComponentsDatabase();
+            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 req.fileManager.saveComponentsDatabase(allComponents);
+            Logger.log(`✅ 成功保存：新增 ${addedCount} 个，更新 ${updatedCount} 个，共 ${allComponents.length} 个组件`);
+            res.json({
+                success: true,
+                data: {
+                    added: addedCount,
+                    updated: updatedCount,
+                    total: allComponents.length,
+                    components: allComponents,
+                },
+                message: '组件保存成功',
+            });
+        }
+        catch (error) {
+            Logger.error('保存组件失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '保存组件失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    // 扫描项目组件接口
+    app.get('/scanComponents', async (req, res) => {
+        try {
+            const { includePaths, excludePaths } = req.query;
+            const projectPath = getProjectRoot(req.fileManager);
+            // 读取项目组件（从 .sloth/components.json）
+            let projectComponents = [];
+            const slothPath = path.join(projectPath, '.sloth', 'components.json');
+            const fs = await import('fs/promises');
+            try {
+                await fs.access(slothPath);
+                // 文件存在，读取内容
+                const fileContent = await fs.readFile(slothPath, 'utf-8');
+                const componentsData = JSON.parse(fileContent);
+                // 验证数据结构
+                if (Array.isArray(componentsData)) {
+                    // 验证每个组件的基本字段
+                    projectComponents = componentsData
+                        .filter((comp) => comp && comp.id && comp.name && comp.path)
+                        .map((c) => ({
+                        id: c.id,
+                        name: c.name,
+                        type: c.type || 'custom',
+                        path: c.path,
+                        props: (c.props || []).map((p) => ({
+                            name: p.name,
+                            type: p.type || 'any',
+                            required: p.required || false,
+                        })),
+                        description: c.description,
+                        import: c.import,
+                    }));
+                    Logger.log(`从 .sloth/components.json 加载了 ${projectComponents.length} 个项目组件`);
+                }
+                else {
+                    Logger.warn('.sloth/components.json 格式错误：应为组件数组');
+                }
+            }
+            catch (error) {
+                // 文件不存在或读取失败，忽略错误，继续返回项目组件
+                if (error.code !== 'ENOENT') {
+                    Logger.warn('读取外部依赖组件失败:', error.message);
+                }
+            }
+            res.json({
+                success: true,
+                data: {
+                    total: projectComponents.length,
+                    projectComponents, // 项目组件
+                },
+            });
+        }
+        catch (error) {
+            Logger.error('扫描项目组件失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '扫描项目组件失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    // 建议组件映射接口（基于 components.json 中组件的截图匹配）
+    app.post('/suggestMappings', upload.single('currentScreenshot'), async (req, res) => {
+        try {
+            const { threshold = '0.8' } = req.body;
+            const currentScreenshotFile = req.file;
+            if (!currentScreenshotFile) {
+                res.status(400).json({
+                    success: false,
+                    message: '缺少必要参数: currentScreenshot',
+                });
+                return;
+            }
+            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);
+            // 从 components.json 加载所有组件
+            const components = await req.fileManager.loadComponentsDatabase();
+            if (!components || components.length === 0) {
+                Logger.log('未找到已保存的组件，无法生成建议');
+                await fs.promises.unlink(currentScreenshotPath).catch(() => { });
+                res.json({
+                    success: true,
+                    data: { suggestions: [] },
+                });
+                return;
+            }
+            Logger.log(`从 components.json 加载了 ${components.length} 个组件`);
+            // 构建匹配任务：查找每个组件的截图文件
+            const matchTasks = [];
+            for (const component of components) {
+                // 只处理有 signature（截图 hash）的组件
+                if (!component.signature) {
+                    Logger.log(`组件 ${component.name} 没有 signature，跳过`);
+                    continue;
+                }
+                // 根据 signature 搜索截图文件
+                const screenshotPath = await req.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('没有可用的组件截图，返回空建议');
+                await fs.promises.unlink(currentScreenshotPath).catch(() => { });
+                res.json({
+                    success: true,
+                    data: { suggestions: [] },
+                });
+                return;
+            }
+            Logger.log(`开始匹配，共 ${matchTasks.length} 个组件截图`);
+            const matcher = new ImageMatcher();
+            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}: 组件=${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({
+                success: true,
+                data: {
+                    suggestions: matches.map((match) => ({
+                        confidence: Math.round(match.confidence * 100) / 100,
+                        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,
+                        },
+                    })),
+                },
+            });
+        }
+        catch (error) {
+            Logger.error('建议组件映射失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '建议组件映射失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    // 上传截图接口
+    app.post('/uploadScreenshot', upload.single('file'), async (req, res) => {
+        try {
+            const { fileKey, nodeId, hash } = req.body;
+            const file = req.file;
+            if (!file || !fileKey || !nodeId || !hash) {
+                res.status(400).json({
+                    success: false,
+                    message: '缺少必要参数: file, fileKey, nodeId, hash',
+                });
+                return;
+            }
+            Logger.log(`接收到截图上传请求: fileKey=${fileKey}, nodeId=${nodeId}, hash=${hash}`);
+            // 保存截图到 .sloth/{fileKey}/{nodeId}/screenshots/{hash}.png
+            await req.fileManager.saveScreenshot(fileKey, nodeId, hash, file.buffer);
+            Logger.log(`截图上传成功: ${hash}.png`);
+            res.json({
+                success: true,
+                message: '截图上传成功',
+                hash,
+            });
+        }
+        catch (error) {
+            Logger.error('上传截图失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '上传截图失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    // 列出设计稿快照接口（用于 update 模式选择旧设计稿）
+    app.get('/listDesignSnapshots', async (req, res) => {
+        try {
+            Logger.log('获取设计稿快照列表');
+            const workspaceRoot = getProjectRoot(req.fileManager);
+            Logger.log('workspaceRoot:', workspaceRoot);
+            if (!workspaceRoot) {
+                res.json({
+                    success: true,
+                    snapshots: [],
+                });
+                return;
+            }
+            const slothDir = path.join(workspaceRoot, '.sloth');
+            const snapshots = [];
+            try {
+                const fileKeys = await fs.promises.readdir(slothDir);
+                for (const fileKey of fileKeys) {
+                    // 跳过特殊文件
+                    if (fileKey === '.' || fileKey === 'components.json' || fileKey.startsWith('.'))
+                        continue;
+                    const fileKeyDir = path.join(slothDir, fileKey);
+                    const stat = await fs.promises.stat(fileKeyDir);
+                    if (!stat.isDirectory())
+                        continue;
+                    const nodeIds = await fs.promises.readdir(fileKeyDir);
+                    for (const nodeId of nodeIds) {
+                        const nodeDir = path.join(fileKeyDir, nodeId);
+                        const nodeStat = await fs.promises.stat(nodeDir);
+                        if (!nodeStat.isDirectory())
+                            continue;
+                        // 查找截图并转换为 base64
+                        let screenshotBase64 = '';
+                        const screenshotsDir = path.join(nodeDir, 'screenshots');
+                        try {
+                            const indexScreenshotPath = path.join(screenshotsDir, 'index.png');
+                            await fs.promises.access(indexScreenshotPath);
+                            // 读取截图文件并转换为 base64
+                            const imageBuffer = await fs.promises.readFile(indexScreenshotPath);
+                            screenshotBase64 = `data:image/png;base64,${imageBuffer.toString('base64')}`;
+                        }
+                        catch {
+                            // 没有 index.png，尝试找其他截图
+                            try {
+                                const screenshots = await fs.promises.readdir(screenshotsDir);
+                                if (screenshots.length > 0) {
+                                    const firstScreenshot = screenshots[0];
+                                    const screenshotPath = path.join(screenshotsDir, firstScreenshot);
+                                    const imageBuffer = await fs.promises.readFile(screenshotPath);
+                                    screenshotBase64 = `data:image/png;base64,${imageBuffer.toString('base64')}`;
+                                }
+                            }
+                            catch {
+                                // 没有截图目录
+                            }
+                        }
+                        // 加载 groupsData 获取名称和分组数量
+                        let name = `${fileKey}/${nodeId}`;
+                        snapshots.push({
+                            fileKey,
+                            nodeId,
+                            screenshotBase64,
+                            timestamp: nodeStat.mtime.toISOString(),
+                            name,
+                        });
+                    }
+                }
+                // 按时间倒序排列
+                snapshots.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+                Logger.log(`找到 ${snapshots.length} 个设计稿快照`);
+                res.json({
+                    success: true,
+                    snapshots,
+                });
+            }
+            catch (error) {
+                Logger.error('扫描设计稿快照失败:', error);
+                res.json({
+                    success: true,
+                    snapshots: [],
+                });
+            }
+        }
+        catch (error) {
+            Logger.error('获取设计稿快照列表失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '获取设计稿快照列表失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    // 分析设计稿变更接口（用于 update 模式）
+    app.use('/analyzeChange', express.json());
+    app.post('/analyzeChange', async (req, res) => {
+        try {
+            const { oldFileKey, oldNodeId, newFileKey, newNodeId } = req.body;
+            if (!oldFileKey || !oldNodeId || !newFileKey || !newNodeId) {
+                res.status(400).json({
+                    success: false,
+                    message: '缺少必要参数: oldFileKey, oldNodeId, newFileKey, newNodeId',
+                });
+                return;
+            }
+            Logger.log(`分析设计稿变更: old=${oldFileKey}/${oldNodeId}, new=${newFileKey}/${newNodeId}`);
+            // 1. 加载新旧 HTML 和 imageMap
+            let oldHtml = await fileManager.loadAbsoluteHtml(oldFileKey, oldNodeId, true);
+            let newHtml = await fileManager.loadAbsoluteHtml(newFileKey, newNodeId, true);
+            Logger.log(`[analyzeChange] 加载 HTML 完成: oldHtml=${oldHtml?.length || 0}字符, newHtml=${newHtml?.length || 0}字符`);
+            // 加载 imageMap 用于替换图片路径（flatted 格式）
+            let oldImageMap = {};
+            let newImageMap = {};
+            try {
+                const oldImageMapStr = await fileManager.loadFile(oldFileKey, oldNodeId, 'imageMap.json');
+                if (oldImageMapStr) {
+                    oldImageMap = flatted.parse(oldImageMapStr);
+                    Logger.log(`[analyzeChange] 加载旧 imageMap 成功, 条目数: ${Object.keys(oldImageMap).length}`);
+                }
+                else {
+                    Logger.log(`[analyzeChange] 旧 imageMap 为空`);
+                }
+            }
+            catch (e) {
+                Logger.log(`[analyzeChange] 加载旧 imageMap 失败: ${e}`);
+            }
+            try {
+                const newImageMapStr = await fileManager.loadFile(newFileKey, newNodeId, 'imageMap.json');
+                if (newImageMapStr) {
+                    newImageMap = flatted.parse(newImageMapStr);
+                    Logger.log(`[analyzeChange] 加载新 imageMap 成功, 条目数: ${Object.keys(newImageMap).length}`);
+                }
+                else {
+                    Logger.log(`[analyzeChange] 新 imageMap 为空`);
+                }
+            }
+            catch (e) {
+                Logger.log(`[analyzeChange] 加载新 imageMap 失败: ${e}`);
+            }
+            // 构建 base64 到 path 的映射表
+            const buildBase64ToPathMap = (imageMap, label) => {
+                const map = new Map();
+                for (const [key, value] of Object.entries(imageMap)) {
+                    if (value?.base64 && value?.path) {
+                        map.set(value.base64, value.path);
+                        Logger.log(`[analyzeChange] ${label} 映射: key=${key}, path=${value.path}, base64长度=${value.base64?.length || 0}`);
+                    }
+                }
+                Logger.log(`[analyzeChange] ${label} 构建映射表完成, 有效映射数: ${map.size}`);
+                return map;
+            };
+            // 处理 HTML 用于 diff 比较
+            const processHtmlForDiff = (html, imageMap, label) => {
+                // 构建 base64 到 path 的映射
+                const base64ToPath = buildBase64ToPathMap(imageMap, label);
+                // 替换图片 base64 为 path
+                let processedHtml = html;
+                let replaceCount = 0;
+                for (const [base64, imgPath] of base64ToPath) {
+                    // 转义特殊字符用于正则匹配
+                    const escapedBase64 = base64.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                    const beforeLength = processedHtml.length;
+                    processedHtml = processedHtml.replace(new RegExp(escapedBase64, 'g'), imgPath);
+                    if (processedHtml.length !== beforeLength) {
+                        replaceCount++;
+                        Logger.log(`[analyzeChange] ${label} 替换成功: ${imgPath}, 长度变化: ${beforeLength} -> ${processedHtml.length}`);
+                    }
+                }
+                Logger.log(`[analyzeChange] ${label} 图片替换完成, 替换数: ${replaceCount}, HTML长度: ${html.length} -> ${processedHtml.length}`);
+                return (processedHtml
+                    // 去除 data-id、data-name、data-type 属性（不参与 diff）
+                    .replace(/\s*data-id="[^"]*"/g, '')
+                    .replace(/\s*data-name="[^"]*"/g, '')
+                    .replace(/\s*data-type="[^"]*"/g, '')
+                    // 去除 z-index 相关的 Tailwind 类名
+                    .replace(/\bz-\[\d+\]/g, '')
+                    // 清理 class 中可能产生的多余空格
+                    .replace(/class="([^"]*)"/g, (_, classes) => {
+                    const cleaned = classes.replace(/\s+/g, ' ').trim();
+                    return `class="${cleaned}"`;
+                }));
+            };
+            oldHtml = processHtmlForDiff(oldHtml, oldImageMap, 'old');
+            newHtml = processHtmlForDiff(newHtml, newImageMap, 'new');
+            Logger.log(`[analyzeChange] HTML 处理完成: oldHtml=${oldHtml?.length || 0}字符, newHtml=${newHtml?.length || 0}字符`);
+            if (!oldHtml) {
+                res.status(404).json({
+                    success: false,
+                    message: '旧设计稿 HTML 不存在',
+                });
+                return;
+            }
+            if (!newHtml) {
+                res.status(404).json({
+                    success: false,
+                    message: '新设计稿 HTML 不存在',
+                });
+                return;
+            }
+            // 2. 加载新旧 groupsData
+            const oldGroupsData = (await req.fileManager.loadGroupsData(oldFileKey, oldNodeId)) || [];
+            const newGroupsData = (await req.fileManager.loadGroupsData(newFileKey, newNodeId)) || [];
+            // 3. 执行 HTML 差异分析
+            // @ts-ignore
+            const { diffLines } = await import('diff');
+            const diffResult = diffLines(oldHtml, newHtml);
+            // 统计变更并生成 diff 文本
+            let addedLines = 0;
+            let removedLines = 0;
+            let unchangedLines = 0;
+            const diffParts = [];
+            for (const part of diffResult) {
+                const lines = part.value.split('\n').filter((l) => l.trim()).length;
+                if (part.added) {
+                    addedLines += lines;
+                    // 标记新增内容
+                    diffParts.push(`+++ ${part.value.trim()}`);
+                }
+                else if (part.removed) {
+                    removedLines += lines;
+                    // 标记删除内容
+                    diffParts.push(`--- ${part.value.trim()}`);
+                }
+                else {
+                    unchangedLines += lines;
+                    // 不输出未变更的内容，减少 token
+                }
+            }
+            // 生成精简的 diff 文本（只包含变更部分）
+            const diffText = diffParts.join('\n');
+            // 4. 生成变更摘要
+            const changeSummary = {
+                totalChanges: addedLines + removedLines,
+                addedLines,
+                removedLines,
+                unchangedLines,
+                changeRatio: (((addedLines + removedLines) / (addedLines + removedLines + unchangedLines)) * 100).toFixed(1),
+            };
+            // 5. 尝试使用 AI 总结变更（如果 MCP 服务器可用）
+            let aiSummary = [];
+            if (mcpServer && changeSummary.totalChanges > 0) {
+                try {
+                    // 限制 diff 文本长度，避免 token 过大
+                    const maxDiffLength = 48000;
+                    const truncatedDiff = diffText.length > maxDiffLength ? diffText.substring(0, maxDiffLength) + '\n... (diff 内容已截断)' : diffText;
+                    const prompt = `
+你是一个专业的前端开发专家。请分析以下设计稿 HTML 的 diff 变更，总结出具体的变更点。
+
+## Diff 变更内容
+\`\`\`diff
+${truncatedDiff}
+\`\`\`
+
+说明：
+- \`---\` 开头的行表示被删除的内容
+- \`+++\` 开头的行表示新增的内容
+- HTML 使用 Tailwind CSS 类名
+
+请按以下 JSON 格式输出变更点列表：
+\`\`\`json
+[
+  {
+    "id": "change_1",
+    "type": "layout|style|content|structure",
+    "title": "变更标题（简短）",
+    "description": "详细描述变更内容",
+    "suggestedAction": "建议的代码修改方向"
+  }
+]
+\`\`\`
+
+请确保：
+1. 每个变更点都是独立的、可操作的
+2. 描述要具体，包含位置、样式、尺寸等信息
+3. 建议的操作要明确
+`;
+                    Logger.log('=== AI 分析变更提示词 ===');
+                    Logger.log(prompt);
+                    Logger.log('=== 提示词结束 ===');
+                    const { content: { text }, } = await mcpServer.server.createMessage({
+                        messages: [
+                            {
+                                role: 'user',
+                                content: { type: 'text', text: prompt },
+                            },
+                        ],
+                        maxTokens: 48000,
+                    }, { timeout: 2 * 60 * 1000 });
+                    // 解析 AI 返回的 JSON
+                    const jsonMatch = text.match(/```json\s*([\s\S]*?)\s*```/);
+                    if (jsonMatch) {
+                        aiSummary = JSON.parse(jsonMatch[1]);
+                    }
+                }
+                catch (aiError) {
+                    Logger.warn('AI 分析变更失败，使用基础分析:', aiError);
+                }
+            }
+            // 6. 如果 AI 分析失败，生成基础摘要
+            if (aiSummary.length === 0 && changeSummary.totalChanges > 0) {
+                aiSummary = [
+                    {
+                        id: 'change_1',
+                        type: 'structure',
+                        title: '设计稿结构变更',
+                        description: `检测到 ${addedLines} 行新增内容和 ${removedLines} 行删除内容，变更比例约 ${changeSummary.changeRatio}%`,
+                        suggestedAction: '请检查新设计稿的布局和样式变化，更新相应的代码',
+                    },
+                ];
+            }
+            Logger.log(`变更分析完成: ${aiSummary.length} 个变更点`);
+            res.json({
+                success: true,
+                data: {
+                    changeSummary,
+                    aiSummary,
+                    oldGroupsData,
+                    newGroupsData,
+                    diffText, // 返回 HTML diff 文本，用于 AI 代码修改
+                },
+            });
+        }
+        catch (error) {
+            Logger.error('分析设计稿变更失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '分析设计稿变更失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    app.get('/getVersion', async (req, res) => {
+        try {
+            // 计算 package.json 的正确路径
+            // 从 dist/build/server.js 到根目录的 package.json
+            const packagePath = path.join(__dirname, '../../package.json');
+            const packageContent = await fs.promises.readFile(packagePath, 'utf-8');
+            const packageData = JSON.parse(packageContent);
+            res.json({
+                success: true,
+                data: {
+                    version: packageData.version,
+                    name: packageData.name,
+                },
+            });
+        }
+        catch (error) {
+            Logger.error('获取版本信息失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '获取版本信息失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    // 启动 HTTP 服务器，监听端口
+    httpServer = app.listen(port, async (err) => {
+        if (err) {
+            httpServer = null;
+            Logger.error('HTTP 服务器启动失败:', err, '退出进程');
+            process.exit(0);
+        }
+        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`);
+        Logger.log(`StreamableHTTP endpoint available at http://localhost:${port}/mcp`);
+        Logger.log(`Auth endpoints available at http://localhost:${port}/auth-page`);
+        Logger.log(`MCP Config at http://localhost:${port}/getConfig`);
+        Logger.log(`Global Config at http://localhost:${port}/getGlobalConfig`);
+        Logger.log(`Save Global Config endpoint at http://localhost:${port}/saveGlobalConfig`);
+        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);
+            process.exit(0);
+        }
+    });
+    // 监听 SIGINT 信号，优雅关闭服务器和所有会话
+    process.on('SIGINT', async () => {
+        Logger.log('SERVER: 收到SIGINT信号');
+        Logger.log('正在关闭服务器...');
+        // 清理等待中的认证请求
+        pendingRequests.clear();
+        // 关闭 Socket 服务器
+        await stopHttpServer();
+        // 关闭所有活跃的 SSE 和 streamable 传输，释放资源
+        await closeTransports(transports.sse);
+        await closeTransports(transports.streamable);
+        Logger.log('服务器关闭完成');
+        process.exit(0);
+    });
+}
+// 批量关闭所有传输对象，确保资源清理
+async function closeTransports(transports) {
+    for (const sessionId in transports) {
+        try {
+            await transports[sessionId].close(); // 调用传输对象的关闭方法
+            delete transports[sessionId]; // 删除会话
+        }
+        catch (error) {
+            console.error(`Error closing transport for session ${sessionId}:`, error);
+        }
+    }
+}
+// 认证功能 - 获取用户输入函数
+export async function getUserInput(payload) {
+    return new Promise(async (resolve, reject) => {
+        const token = uuidv4();
+        const port = getPort();
+        // 构建 URL，从 payload 中提取 clientApiSupport
+        const clientApiSupport = payload.clientApiSupport;
+        const supportSampling = clientApiSupport?.sampling ? '1' : '0';
+        const supportRoots = clientApiSupport?.roots ? '1' : '0';
+        const authUrl = `http://localhost:${port}/auth-page?token=${token}&fileKey=${payload.fileKey}&nodeId=${payload.nodeId}&mode=${payload.mode}&supportSampling=${supportSampling}&supportRoots=${supportRoots}`;
+        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 客户端已连接');
+                const workspaceRoot = fileManager.getWorkspaceRoot();
+                // 注册 token 并等待响应，同时传递 extra 数据给主进程
+                const socketParams = { workspaceRoot, plugins: pluginManager.getPlugins() };
+                Logger.log('socketParams', socketParams);
+                const responsePromise = socketClient.registerToken(token, socketParams);
+                // 打开浏览器
+                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) {
+            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() {
+    // 关闭 Socket 服务器
+    const closeSocket = stopSocketServer();
+    if (!httpServer) {
+        throw new Error('HTTP 服务器未运行');
+    }
+    return new Promise((resolve, reject) => {
+        // 清理等待中的认证请求
+        pendingRequests.clear();
+        httpServer.close((err) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            httpServer = null;
+            // 关闭所有 SSE 传输
+            const closing = Object.values(transports.sse).map((transport) => {
+                return transport.close();
+            });
+            Promise.all([...closing, closeSocket]).then(() => {
+                resolve();
+            });
+        });
+    });
+}