sloth-d2c-mcp 1.0.4-beta100

package/dist/build/index.js

@@ -0,0 +1,852 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { convertFigmaToD2CNode, generateAbsoluteHtml, getBoundingBox, getCode, chunkOptimizeCodePrompt, aggregationOptimizeCodePrompt, finalOptimizeCodePrompt, noSamplingAggregationPrompt, } from 'sloth-d2c-node/convert';
+import axios from 'axios';
+import { z } from 'zod';
+import { ConfigManager, defaultConfigData, } from './config-manager/index.js';
+import { cleanup as cleanupTauri } from './interceptor/client.js';
+import { cleanup as cleanupVSCode, getUserInputFromVSCode, isVSCodeAvailable } from './interceptor/vscode.js';
+import { cleanup as cleanupWeb, getUserInput } from './interceptor/web.js';
+import { loadConfig, startHttpServer, stopHttpServer, generateComponentId } from './server.js';
+import { FileManager } from './utils/file-manager.js';
+import { updateImageMapIfNeeded } from './utils/update.js';
+import { Logger } from './utils/logger.js';
+import { getAvailablePort, saveImageFile, replaceImageSrc, formatListRoots } from './utils/utils.js';
+import { processSampling, buildNestingStructure } from './core/sampling.js';
+import { buildComponentMappingPrompt, buildFullUpdatePromptForAI, buildPlaceholderPrompt } from './core/prompt-builder.js';
+import { pluginManager } from './plugin/manager.js';
+import { detectClientApiSupport, clearCapabilitiesCache } from './utils/client-capabilities.js';
+// @ts-ignore
+import * as flatted from 'flatted';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { extractCodeAndComponents } from './utils/extract.js';
+import { trackToolCall } from './utils/tj.js';
+const spawnServerProcess = async () => {
+    const { spawn } = await import('node:child_process');
+    // 直接调用 sloth CLI 命令
+    const child = spawn('sloth', ['server', 'start'], {
+        detached: true,
+        stdio: 'ignore',
+        shell: true, // 需要 shell 来解析命令
+        env: { ...process.env }
+    });
+    child.unref();
+    console.log(`[sloth] MCP触发：已在后台启动，PID: ${child.pid}`);
+};
+/**
+ * 启动http & socket监听
+ * @param init 是否是初始化，初始化时需要连接stdio transport
+ */
+export async function startListening(init = false) {
+    const isStdioMode = process.env.NODE_ENV === 'cli' || process.argv.includes('--stdio');
+    const configManager = new ConfigManager('d2c-mcp');
+    const port = await getAvailablePort();
+    if (isStdioMode) {
+        Logger.log(`Stdio模式启动`);
+        await loadConfig(mcpServer, configManager);
+        if (init) {
+            const transport = new StdioServerTransport();
+            await mcpServer.connect(transport);
+            // 单独启动httpServer进程，用于网页访问
+            spawnServerProcess();
+        }
+        else {
+            // 启动 HTTP 服务器 - 仅启用web服务
+            await startHttpServer(port, mcpServer, configManager, false);
+        }
+    }
+    else {
+        // 启动 HTTP 服务器 - 这是核心功能，不依赖 VSCode 日志
+        await startHttpServer(port, mcpServer, configManager, true);
+    }
+    // 服务器启动成功后再尝试使用 Logger（包含 VSCode 日志）
+    Logger.log(`Server started successfully on port ${port}!`);
+}
+export class D2CMcpServer extends McpServer {
+    figmaApiKey = '';
+    baseURL = '';
+    constructor(serverInfo, options) {
+        super(serverInfo, options);
+    }
+    setConfig(config) {
+        this.figmaApiKey = config?.figmaApiKey || '';
+        this.baseURL = config?.baseURL || '';
+        console.log('setConfig', this.figmaApiKey, this.baseURL);
+        axios.defaults.baseURL = this.baseURL;
+    }
+}
+// 创建 MCP 服务器实例
+const mcpServer = new D2CMcpServer({
+    name: 'transcoding-interceptor-server',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        resources: {},
+        tools: {},
+    },
+});
+const configManager = new ConfigManager('d2c-mcp');
+export const fileManager = new FileManager('d2c-mcp');
+// 注册 Figma 转码拦截工具
+mcpServer.tool('d2c_figma', 'Convert Figma Design File to Code', {
+    fileKey: z.string().describe('The key of the Figma file to fetch, often found in a provided URL like figma.com/(file|design)/<fileKey>/...'),
+    nodeId: z.string().optional().describe('The ID of the node to fetch, often found as URL parameter node-id=<nodeId>, always use if provided'),
+    depth: z.number().optional().describe('How many levels deep to traverse the node tree, only use if explicitly requested by the user'),
+    local: z.boolean().optional().describe('Whether to use local data cache, default is false'),
+    update: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Set to true only when user explicitly wants to modify/update previously generated code. Default is false (create new code).'),
+}, async (args) => {
+    try {
+        trackToolCall('d2c_figma');
+        Logger.log(`收到工具调用参数:`, JSON.stringify(args, null, 2));
+        const { fileKey, nodeId, depth, local, update = false } = args;
+        let config = await configManager.load();
+        let hasLaunchWebview = false;
+        // 检测客户端 API 支持程度
+        const clientApiSupport = await detectClientApiSupport(mcpServer);
+        // 检测 VSCode 扩展是否可用
+        const isVSCodePluginAvailable = await isVSCodeAvailable();
+        Logger.log(`VSCode 扩展检测结果: ${isVSCodePluginAvailable ? '可用' : '不可用'}`);
+        let root = './';
+        try {
+            const rootRes = await mcpServer.server.listRoots();
+            Logger.log('获取根目录:', rootRes);
+            root = formatListRoots(rootRes);
+            Logger.log('标准化根目录:', root);
+            // 设置 fileManager 的工作目录根路径
+            fileManager.setWorkspaceRoot(root);
+            // 设置插件管理器的工作区根目录并初始化
+            pluginManager.setWorkspaceRoot(root);
+            await pluginManager.initialize();
+        }
+        catch (error) {
+            Logger.log('获取根目录时出错:', error);
+        }
+        // await startListening()
+        let userConfirmedChanges;
+        let userHtmlDiff; // 存储 HTML diff 文本
+        // 没有配置figmaApiKey，非数据推送模式，无法预览，直接唤起配置页面
+        if (!config.mcp?.figmaApiKey && !local) {
+            hasLaunchWebview = true;
+            let configDataString;
+            if (isVSCodePluginAvailable) {
+                // 优先使用 VSCode 扩展
+                Logger.log('使用 VSCode 扩展获取用户输入');
+                configDataString = await getUserInputFromVSCode({
+                    fileKey: fileKey,
+                    nodeId: nodeId,
+                    mode: update ? 'update' : 'create',
+                    clientApiSupport,
+                });
+            }
+            else {
+                // 降级到网页浏览器
+                Logger.log('VSCode 扩展不可用，降级到网页浏览器');
+                configDataString = await getUserInput({
+                    fileKey: fileKey,
+                    nodeId: nodeId,
+                    mode: update ? 'update' : 'create',
+                    clientApiSupport,
+                });
+            }
+            console.log('getting configDataString', configDataString);
+            if (!configDataString || configDataString.trim() === '') {
+                throw new Error('未提供有效的转码配置');
+            }
+            else {
+                const configData = JSON.parse(configDataString);
+                const { mcp, groupsData, confirmedChanges, htmlDiff, ...rest } = configData;
+                config = {
+                    ...config,
+                    mcp,
+                    fileConfigs: {
+                        ...config.fileConfigs,
+                        [fileKey]: rest,
+                    },
+                };
+                userConfirmedChanges = confirmedChanges;
+                userHtmlDiff = htmlDiff; // 保存 HTML diff
+                mcpServer.setConfig(config.mcp);
+                configManager.save(config);
+                if (rest) {
+                    const { promptSetting, ...restConfig } = rest;
+                    await fileManager.saveConfigSetting(fileKey, nodeId, restConfig);
+                    Logger.log(`已保存 configSetting 到 fileKey: ${fileKey}, nodeId: ${nodeId}`);
+                }
+                // 将 groupsData 保存到 fileManager 按 nodeId 存储
+                if (groupsData && groupsData.length > 0) {
+                    await fileManager.saveGroupsData(fileKey, nodeId, groupsData);
+                    Logger.log(`已保存 groupsData 到 nodeId: ${nodeId}`);
+                }
+            }
+        }
+        // 调用 get_ai_group_layout
+        Logger.log(`Fetching AI group layout for ${nodeId ? `node ${nodeId} from file` : `full file`} ${fileKey}`);
+        let d2cNodeList, imageMap, absoluteHtml;
+        if (!local) {
+            const { d2cNodeList: nodes, imageMap: imgMap } = await convertFigmaToD2CNode({
+                fileKey,
+                nodeId,
+                depth,
+                config: config.fileConfigs?.[fileKey] || defaultConfigData,
+                figmaToken: mcpServer.figmaApiKey,
+            });
+            d2cNodeList = nodes;
+            imageMap = imgMap;
+            absoluteHtml = await generateAbsoluteHtml(d2cNodeList);
+            // 保存nodeList
+            await fileManager.saveFile(fileKey, nodeId, 'nodeList.json', flatted.stringify(d2cNodeList));
+            await fileManager.saveFile(fileKey, nodeId, 'imageMap.json', flatted.stringify(imageMap));
+            // 保存figma绝对定位代码
+            await fileManager.saveAbsoluteHtml(fileKey, nodeId, absoluteHtml);
+            await fileManager.saveAbsoluteHtml(fileKey, nodeId, absoluteHtml, true);
+        }
+        else {
+            try {
+                d2cNodeList = flatted.parse(await fileManager.loadFile(fileKey, nodeId, 'nodeList.json'));
+                imageMap = flatted.parse(await fileManager.loadFile(fileKey, nodeId, 'imageMap.json'));
+                absoluteHtml = await fileManager.loadAbsoluteHtml(fileKey, nodeId);
+            }
+            catch (err) {
+                throw new Error('加载本地数据失败, 请检查文件路径：' + fileManager.getFilePathPublic(fileKey, nodeId, 'nodeList.json'));
+            }
+            await fileManager.saveAbsoluteHtml(fileKey, nodeId, absoluteHtml, true);
+            console.log('cache load data');
+        }
+        console.log('d2cNodeList', d2cNodeList);
+        console.log('imageMap', imageMap);
+        console.log('absoluteHtml', absoluteHtml);
+        pluginManager.executeHook('onFetchImage', { imageMap });
+        console.log('pluginManager executeHook onFetchImage', imageMap);
+        // 如果配置了figmaApiKey，则可以预览，传入absoluteHtml
+        if (!hasLaunchWebview) {
+            // await fileManager.saveFile(fileKey, nodeId, 'absolute.html', absoluteHtml)
+            Logger.log(`收到网页工具调用参数:`, JSON.stringify(args, null, 2));
+            let configDataString;
+            if (isVSCodePluginAvailable) {
+                configDataString = await getUserInputFromVSCode({
+                    fileKey: fileKey,
+                    nodeId: nodeId,
+                    mode: update ? 'update' : 'create',
+                    clientApiSupport,
+                });
+            }
+            else {
+                configDataString = await getUserInput({
+                    fileKey: fileKey,
+                    nodeId: nodeId,
+                    mode: update ? 'update' : 'create',
+                    clientApiSupport,
+                });
+            }
+            console.log('收到网页提交数据', configDataString);
+            if (!configDataString || configDataString.trim() === '') {
+                throw new Error('未提供有效的转码配置');
+            }
+            else {
+                const configData = JSON.parse(configDataString);
+                const { mcp, groupsData, confirmedChanges, htmlDiff, ...rest } = configData;
+                pluginManager.executeHook('afterSubmitConfigData', {
+                    configData,
+                });
+                userConfirmedChanges = confirmedChanges;
+                userHtmlDiff = htmlDiff; // 保存 HTML diff
+                // 保存旧配置用于比较
+                const oldFileConfig = config.fileConfigs?.[fileKey] || defaultConfigData;
+                config = {
+                    ...config,
+                    mcp,
+                    fileConfigs: {
+                        ...config.fileConfigs,
+                        [fileKey]: rest,
+                    },
+                };
+                mcpServer.setConfig(config.mcp);
+                configManager.save(config);
+                if (rest) {
+                    const { promptSetting, ...restConfig } = rest;
+                    await fileManager.saveConfigSetting(fileKey, nodeId, restConfig);
+                    Logger.log(`已保存 configSetting 到 fileKey: ${fileKey}, nodeId: ${nodeId}`);
+                }
+                // 将 groupsData 保存到 fileManager 按 nodeId 存储
+                if (groupsData && groupsData.length > 0) {
+                    await fileManager.saveGroupsData(fileKey, nodeId, groupsData);
+                    Logger.log(`已保存 groupsData 到 nodeId: ${nodeId}`);
+                }
+                // 检查是否需要更新imageMap
+                try {
+                    const imageNodeList = d2cNodeList?.filter((node) => ['IMG', 'ICON'].includes(node.type)) || [];
+                    const { imageMap: updatedImageMap, updated } = await updateImageMapIfNeeded(imageMap, imageNodeList, oldFileConfig, rest, local);
+                    if (updated) {
+                        // 更新imageMap并重新保存
+                        Object.assign(imageMap, updatedImageMap);
+                        await fileManager.saveFile(fileKey, nodeId, 'imageMap.json', flatted.stringify(imageMap));
+                        Logger.log('已更新并保存新的imageMap');
+                    }
+                }
+                catch (error) {
+                    Logger.log('更新imageMap时出错:', error);
+                }
+            }
+        }
+        // Update 模式：直接返回提示词，不需要复杂的采样逻辑
+        if (update) {
+            // 保存图片文件
+            saveImageFile({ imageMap, root });
+            Logger.log(`Update 模式: 收到已构建的提示词，直接返回`);
+            Logger.log(`Update 模式: 变更点数量 - ${userConfirmedChanges?.length || 0} 个`);
+            Logger.log(`Update 模式: HTML Diff 长度 - ${userHtmlDiff?.length || 0} 字符`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: buildFullUpdatePromptForAI(userConfirmedChanges, { htmlDiff: userHtmlDiff }),
+                    },
+                ],
+            };
+        }
+        // 从 fileManager 按 nodeId 加载 groupsData 和 promptSetting
+        const groupsData = await fileManager.loadGroupsData(fileKey, nodeId);
+        const savedPromptSetting = await fileManager.loadPromptSetting(fileKey, nodeId);
+        const convertConfig = config.fileConfigs?.[fileKey] || defaultConfigData;
+        // 获取提示词，优先使用用户保存的提示词，否则使用默认提示词
+        const frameworkPrompt = savedPromptSetting?.frameworkGuidePrompt || '';
+        const chunkPrompt = savedPromptSetting?.chunkOptimizePrompt || chunkOptimizeCodePrompt;
+        const aggregationPrompt = savedPromptSetting?.aggregationOptimizePrompt || aggregationOptimizeCodePrompt;
+        const finalPrompt = savedPromptSetting?.finalOptimizePrompt || finalOptimizeCodePrompt;
+        const noSamplingPrompt = savedPromptSetting?.noSamplingAggregationPrompt || noSamplingAggregationPrompt;
+        let codeSnippets = [];
+        let isSupportSampling = clientApiSupport.sampling;
+        Logger.log(`客户端 API 支持检测: sampling=${isSupportSampling}, roots=${clientApiSupport.roots}`);
+        // 收集已映射的组件信息，用于在最终写入时添加提示词
+        const componentMappings = [];
+        // 收集所有组的组件上下文信息，用于在最终提示词中显示
+        const componentContexts = [];
+        // 构建采样配置
+        const samplingConfig = {
+            d2cNodeList,
+            imageMap,
+            convertConfig,
+            chunkPrompt,
+            frameworkPrompt,
+            mcpServer,
+            componentMappings,
+            codeSnippets,
+            componentContexts,
+            isSupportSampling,
+            isLocalMode: local,
+        };
+        // 深度遍历采样：针对每个分组生成 AI 相对布局树并转码
+        if (groupsData && groupsData?.length > 0) {
+            await processSampling(groupsData, samplingConfig);
+            // 采样完成后，更新组件名并保存到文件
+            try {
+                const groupsDataToSave = groupsData.map((group) => {
+                    // 将提取的组件名更新到 componentName（仅标记的分组）
+                    if (group.marked && group.name) {
+                        group.componentName = group.name;
+                        Logger.log(`组 ${group.groupIndex} 已标记，更新组件名: ${group.componentName}`);
+                    }
+                    // 去掉 nodeList 后返回
+                    const { nodeList, ...groupWithoutNodeList } = group;
+                    return groupWithoutNodeList;
+                });
+                await fileManager.saveGroupsData(fileKey, nodeId, groupsDataToSave);
+                Logger.log(`已保存更新后的 groupsData，包含 ${groupsData.filter((g) => g.marked).length} 个标记的组件`);
+            }
+            catch (error) {
+                Logger.error(`保存 groupsData 失败:`, error);
+            }
+        }
+        // 分组外元素：注入分组占位并进行整合采样
+        // 构建嵌套结构，只收集根组（第一层）的元素
+        const nestingInfo = buildNestingStructure(groupsData || []);
+        const groupedElementIds = new Set();
+        // 只收集根组的元素ID
+        nestingInfo.rootGroups.forEach((rootIndex) => {
+            const rootGroup = nestingInfo.groupMap.get(rootIndex);
+            if (rootGroup) {
+                rootGroup.elements.forEach((id) => {
+                    groupedElementIds.add(id);
+                });
+            }
+        });
+        Logger.log(`收集到 ${groupedElementIds.size} 个根组元素ID，根组数量: ${nestingInfo.rootGroups.length}`);
+        // 分组外元素
+        const ungroupedNodeList = d2cNodeList.filter((node) => !groupedElementIds.has(node.id));
+        if (ungroupedNodeList.length > 0) {
+            // 只注入根组占位符
+            nestingInfo.rootGroups.forEach((rootIndex) => {
+                const group = nestingInfo.groupMap.get(rootIndex);
+                if (!group)
+                    return;
+                const { x, y, width, height, absoluteRenderX, absoluteRenderY, absoluteRenderWidth, absoluteRenderHeight } = getBoundingBox(group.nodeList);
+                ungroupedNodeList.push({
+                    id: 'G_' + rootIndex,
+                    name: group.name || `Group${group.groupIndex + 1}`,
+                    x,
+                    y,
+                    width,
+                    height,
+                    debuggerInfo: {
+                        originNode: {
+                            absoluteBoundingBox: {
+                                x: absoluteRenderX,
+                                y: absoluteRenderY,
+                                width: absoluteRenderWidth,
+                                height: absoluteRenderHeight,
+                            },
+                            absoluteRenderBounds: {
+                                x: absoluteRenderX,
+                                y: absoluteRenderY,
+                                width: absoluteRenderWidth,
+                                height: absoluteRenderHeight,
+                            },
+                        },
+                    },
+                    parentId: ungroupedNodeList.find((node) => group.nodeList?.find((groupNode) => groupNode.parentId === node.id))?.id,
+                    type: 'COMPONENT',
+                });
+            });
+            console.log('ungroupedNodeList', ungroupedNodeList);
+            // 检测占位符元素（分组占位符）
+            const placeholders = ungroupedNodeList
+                .filter((node) => node.type === 'COMPONENT' && node.id?.startsWith('G_'))
+                .map((node) => ({
+                name: node.name || 'Unknown',
+            }));
+            const placeholderPrompt = buildPlaceholderPrompt(placeholders, isSupportSampling);
+            Logger.log(`整合采样检测到 ${placeholders.length} 个分组占位符`);
+            // 获取代码
+            const code = await getCode({
+                d2cNodeList: ungroupedNodeList,
+                config: convertConfig,
+                options: { isLocalMode: local },
+            });
+            // 使用 imageMap 的 path 替换 code 中对应的 src
+            const replacedCode = replaceImageSrc(code, imageMap);
+            // 整合采样
+            try {
+                if (!isSupportSampling)
+                    throw new Error('不支持采样');
+                // 使用提示词（已包含默认值）
+                const { content: { text }, } = await mcpServer.server.createMessage({
+                    messages: [
+                        {
+                            role: 'user',
+                            content: {
+                                type: 'text',
+                                text: frameworkPrompt + aggregationPrompt.replace(/{FRAMEWORK}/g, convertConfig.convertSetting?.framework || '') + placeholderPrompt,
+                            },
+                        },
+                        {
+                            role: 'user',
+                            content: {
+                                type: 'text',
+                                text: replacedCode,
+                            },
+                        },
+                    ],
+                    maxTokens: 48000,
+                }, {
+                    timeout: 5 * 60 * 1000,
+                });
+                Logger.log('采样成功 (分组外元素)', text, '采样请求代码', replacedCode, '采样提示词', frameworkPrompt + aggregationPrompt.replace(/{FRAMEWORK}/g, convertConfig.convertSetting?.framework || '') + placeholderPrompt);
+                const { code: pageCode } = extractCodeAndComponents(text)[0];
+                codeSnippets.unshift(pageCode);
+            }
+            catch (e) {
+                Logger.log('调用分组外元素采样出错，降级到传统模式', e);
+                codeSnippets.unshift(replacedCode);
+            }
+        }
+        const onSamplingComplete = await pluginManager.executeHook('onSamplingComplete', {
+            codeSnippets,
+            imageMap,
+        });
+        codeSnippets = onSamplingComplete?.codeSnippets || codeSnippets;
+        imageMap = onSamplingComplete?.imageMap || imageMap;
+        console.log('executeHook onSamplingComplete', imageMap);
+        console.log('executeHook onSamplingComplete', codeSnippets);
+        // 保存图片文件
+        saveImageFile({ imageMap, root });
+        Logger.log('处理完成，生成的代码片段数量:', codeSnippets.length);
+        Logger.log('已映射的组件数量:', componentMappings.length);
+        Logger.log('组件上下文数量:', componentContexts.length);
+        // 收集标记的组件（用于提示 LLM 调用 mark_components）
+        const markedComponents = [];
+        if (groupsData && groupsData.length > 0) {
+            groupsData.forEach((group) => {
+                if (group.marked && group.screenshot && group.name) {
+                    markedComponents.push({
+                        name: group.name,
+                        signature: group.screenshot,
+                    });
+                }
+            });
+            Logger.log(`收集到 ${markedComponents.length} 个标记的组件`);
+        }
+        // 加载完整的组件数据库（用于查找继承链）
+        const componentsDatabase = await fileManager.loadComponentsDatabase();
+        Logger.log(`加载组件数据库，共 ${componentsDatabase.length} 个组件`);
+        // 构建组件映射提示词（包含组件映射、组件上下文、标记组件和完整组件数据库）
+        const componentMappingPrompt = buildComponentMappingPrompt(componentMappings, componentContexts, markedComponents, componentsDatabase);
+        const { prompt: pluginFinalPrompt = '' } = await pluginManager.executeHook('beforeFinalPrompt', { configData: config.fileConfigs?.[fileKey] || '' });
+        console.log('pluginFinalPrompt', pluginFinalPrompt);
+        // 使用提示词（已包含默认值）
+        return {
+            content: [
+                isSupportSampling
+                    ? {
+                        type: 'text',
+                        text: finalPrompt + componentMappingPrompt + pluginFinalPrompt,
+                    }
+                    : {
+                        type: 'text',
+                        text: noSamplingPrompt + componentMappingPrompt + pluginFinalPrompt,
+                    },
+                ...codeSnippets.map((code) => {
+                    return {
+                        type: 'text',
+                        text: code,
+                    };
+                }),
+            ].filter(Boolean),
+        };
+    }
+    catch (error) {
+        Logger.log('网页工具处理过程中发生错误:', error);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `处理 Figma 转码时发生错误: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+        };
+    }
+});
+// 标记并保存组件到 components.json
+mcpServer.tool('mark_components', 'Mark and save components to project components.json for future reuse and matching', {
+    components: z
+        .array(z.object({
+        name: z.string().describe('Component name in PascalCase'),
+        path: z.string().describe('Component file path relative to project root'),
+        signature: z.string().optional().describe('Component Screenshot (SHA256 hash) for matching'),
+        type: z.enum(['button', 'input', 'card', 'text', 'image', 'container', 'list', 'custom']).optional(),
+        description: z.string().optional(),
+        import: z.string().optional().describe('Import statement for the component'),
+        props: z
+            .array(z.object({
+            name: z.string(),
+            type: z.string().optional(),
+            required: z.boolean().optional(),
+            description: z.string().optional(),
+        }))
+            .optional(),
+        super: z.string().optional().describe('Parent class or base component name'),
+        functions: z
+            .array(z.object({
+            name: z.string().describe('Method or function name'),
+            params: z
+                .array(z.object({
+                name: z.string(),
+                type: z.string(),
+            }))
+                .optional()
+                .describe('Method parameters'),
+            returnType: z.string().optional().describe('Return type of the method'),
+            description: z.string().optional(),
+        }))
+            .optional()
+            .describe('Public methods or functions exposed by the component'),
+    }))
+        .describe('Array of components to mark and save'),
+}, async (args) => {
+    try {
+        const { components } = args;
+        // 1. 设置 workspaceRoot
+        let root = './';
+        try {
+            const rootRes = await mcpServer.server.listRoots();
+            Logger.log('获取根目录:', rootRes);
+            root = formatListRoots(rootRes);
+            Logger.log('标准化根目录:', root);
+            // 设置 fileManager 的工作目录根路径
+            fileManager.setWorkspaceRoot(root);
+        }
+        catch (error) {
+            Logger.log('获取根目录时出错:', error);
+        }
+        // 2. 加载现有组件
+        const existingComponents = await fileManager.loadComponentsDatabase();
+        // 3. 构建 path 索引（用于去重，path 一致则认为是同一组件）
+        const pathIndex = new Map();
+        existingComponents.forEach((comp, index) => {
+            if (comp.path) {
+                pathIndex.set(comp.path, index);
+            }
+        });
+        // 4. 处理新组件（合并逻辑）
+        const now = new Date().toISOString();
+        let addedCount = 0;
+        let updatedCount = 0;
+        for (const comp of components) {
+            // 使用 path 判断组件是否已存在（组件冲突检测）
+            const existingIndex = pathIndex.get(comp.path);
+            const storedComponent = {
+                id: generateComponentId(),
+                name: comp.name,
+                type: comp.type || 'custom',
+                path: comp.path,
+                import: comp.import || `import { ${comp.name} } from '${comp.path}'`,
+                props: (comp.props || []).map((p) => ({
+                    name: p.name,
+                    type: p.type || 'any',
+                    required: p.required || false,
+                    description: p.description,
+                })),
+                functions: (comp.functions || []).map((f) => ({
+                    name: f.name,
+                    params: (f.params || []).map((p) => ({ name: p.name, type: p.type })),
+                    returnType: f.returnType,
+                    description: f.description,
+                })),
+                super: comp.super,
+                description: comp.description,
+            };
+            if (comp.signature) {
+                storedComponent.signature = comp.signature;
+            }
+            if (existingIndex !== undefined) {
+                // 更新已存在的组件（保留原始导入时间）
+                const originalImportedAt = existingComponents[existingIndex].importedAt;
+                existingComponents[existingIndex] = {
+                    ...storedComponent,
+                    importedAt: originalImportedAt,
+                };
+                updatedCount++;
+            }
+            else {
+                // 添加新组件
+                existingComponents.push(storedComponent);
+                pathIndex.set(comp.path, existingComponents.length - 1);
+                addedCount++;
+            }
+        }
+        // 5. 保存到文件
+        await fileManager.saveComponentsDatabase(existingComponents);
+        // 6. 返回结果
+        Logger.log(`mark_components: 新增 ${addedCount} 个，更新 ${updatedCount} 个，共 ${existingComponents.length} 个组件`);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `✅ 组件标记完成：新增 ${addedCount} 个，更新 ${updatedCount} 个，共 ${existingComponents.length} 个组件`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        Logger.error('mark_components 处理失败:', error);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `❌ 标记组件失败: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+        };
+    }
+});
+// 启动 HTTP 服务器
+async function main() {
+    // 检查是否是版本命令
+    if (process.env.SLOTH_COMMAND === 'version' || process.argv.includes('--version') || process.argv.includes('-v')) {
+        try {
+            // 读取 package.json 获取版本信息
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = path.dirname(__filename);
+            // 在构建后的目录中，需要向上两级才能找到 package.json
+            // dist/build/index.js -> ../../package.json
+            const packageJsonPath = path.join(__dirname, '..', '..', 'package.json');
+            const packageJsonContent = await fs.readFile(packageJsonPath, 'utf8');
+            const packageJson = JSON.parse(packageJsonContent);
+            console.log(`${packageJson.name} v${packageJson.version}`);
+            process.exit(0);
+        }
+        catch (error) {
+            console.error('无法读取版本信息:', error);
+            process.exit(1);
+        }
+    }
+    // 检查是否是帮助命令
+    if (process.env.SLOTH_COMMAND === 'help') {
+        console.log('Sloth D2C MCP Server - Figma 设计转代码工具');
+        console.log('');
+        console.log('使用方法: sloth <命令> [选项]');
+        console.log('');
+        console.log('可用命令:');
+        console.log('  cache          显示缓存目录路径');
+        console.log('  config         显示配置文件路径');
+        console.log('  server start   后台启动服务');
+        console.log('  server stop    停止服务');
+        console.log('  update         更新 sloth');
+        console.log('  version        显示版本信息');
+        console.log('');
+        console.log('全局选项:');
+        console.log('  --help, -h       显示帮助信息');
+        console.log('  --version, -v    显示版本信息');
+        console.log('');
+        console.log('示例:');
+        console.log('  sloth cache         # 显示缓存目录路径');
+        console.log('  sloth config        # 显示配置文件路径');
+        console.log('  sloth server start  # 后台启动服务');
+        console.log('  sloth server stop   # 停止服务');
+        console.log('  sloth update        # 更新 sloth');
+        console.log('  sloth version       # 显示版本信息');
+        process.exit(0);
+    }
+    // 检查是否是 config 命令
+    if (process.env.SLOTH_COMMAND === 'config') {
+        const configManager = new ConfigManager('d2c-mcp');
+        const configPath = configManager.getConfigPath();
+        // 获取子命令参数
+        const configArgsStr = process.env.SLOTH_CONFIG_ARGS || '[]';
+        const configArgs = JSON.parse(configArgsStr);
+        const isJsonOutput = configArgs.includes('--json');
+        // 处理帮助参数
+        if (configArgs.includes('--help') || configArgs.includes('-h')) {
+            console.log('使用方法: sloth config [选项]');
+            console.log('');
+            console.log('显示配置文件信息');
+            console.log('');
+            console.log('选项:');
+            console.log('  --help, -h    显示帮助信息');
+            console.log('  --path        仅显示配置文件路径');
+            console.log('  --json        以 JSON 格式输出');
+            process.exit(0);
+        }
+        // 处理只显示路径的参数
+        if (configArgs.includes('--path')) {
+            if (isJsonOutput) {
+                console.log(JSON.stringify({ path: configPath }));
+            }
+            else {
+                console.log(configPath);
+            }
+            process.exit(0);
+        }
+        // 检查配置文件是否存在
+        const exists = await configManager.exists();
+        let config = null;
+        let error = null;
+        if (exists) {
+            try {
+                config = await configManager.load();
+            }
+            catch (err) {
+                error = err instanceof Error ? err.message : String(err);
+            }
+        }
+        if (isJsonOutput) {
+            const result = {
+                path: configPath,
+                exists: exists,
+                config: config,
+                error: error,
+            };
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`配置文件路径: ${configPath}`);
+            if (exists) {
+                console.log(`配置文件存在`);
+                if (config) {
+                    console.log(`当前配置内容:`);
+                    console.log(JSON.stringify(config, null, 2));
+                }
+                else if (error) {
+                    console.log(`读取配置文件失败: ${error}`);
+                }
+            }
+            else {
+                console.log(`配置文件不存在`);
+            }
+        }
+        process.exit(0);
+    }
+    // 检查是否是 cache 命令
+    if (process.env.SLOTH_COMMAND === 'cache') {
+        console.log(fileManager.getBaseDir());
+        process.exit(0);
+    }
+    if (process.env.SLOTH_COMMAND === 'server') {
+        await startListening();
+        return;
+    }
+    try {
+        // 先输出基本启动信息到控制台，确保即使 VSCode 日志失败也能看到启动过程
+        console.log(`[${new Date().toISOString()}] Starting Figma transcoding interceptor MCP server...`);
+        // 注意：插件管理器的初始化已移到 d2c_figma 工具中
+        // 因为需要先获取工作区根目录才能加载工作区插件
+        // Create config manager instance to pass to server
+        await startListening(true);
+    }
+    catch (error) {
+        // 确保错误信息能够输出，即使 VSCode 日志服务不可用
+        const timestamp = new Date().toISOString();
+        console.error(`[${timestamp}] Failed to start server:`, error);
+        // 尝试使用 Logger 输出错误，但不依赖它
+        try {
+            Logger.error('Failed to start server:', error);
+        }
+        catch (logError) {
+            console.error(`[${timestamp}] Logger also failed:`, logError);
+        }
+        process.exit(1);
+    }
+}
+// 处理进程退出时的清理
+process.on('SIGINT', async () => {
+    Logger.log('MCP: 收到SIGINT信号');
+    const timestamp = new Date().toISOString();
+    console.log(`[${timestamp}] 正在关闭服务器...`);
+    try {
+        Logger.log('正在关闭服务器...');
+    }
+    catch (error) {
+        // 忽略日志错误，确保清理过程继续
+    }
+    cleanupTauri();
+    cleanupWeb();
+    cleanupVSCode();
+    clearCapabilitiesCache(); // 清理能力检测缓存
+    Logger.cleanup(); // 清理日志连接
+    await stopHttpServer();
+    process.exit(0);
+});
+process.on('SIGTERM', async () => {
+    Logger.log('MCP: 收到SIGTERM信号');
+    const timestamp = new Date().toISOString();
+    console.log(`[${timestamp}] 正在关闭服务器...`);
+    try {
+        Logger.log('正在关闭服务器...');
+    }
+    catch (error) {
+        // 忽略日志错误，确保清理过程继续
+    }
+    cleanupTauri();
+    cleanupWeb();
+    cleanupVSCode();
+    clearCapabilitiesCache(); // 清理能力检测缓存
+    Logger.cleanup(); // 清理日志连接
+    await stopHttpServer();
+    process.exit(0);
+});
+main();