sloth-d2c-mcp 1.0.4-beta65

package/dist/build/index.js

@@ -0,0 +1,839 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { convertFigmaToD2CNode, generateAbsoluteHtml, getBoundingBox, getCode, chunkOptimizeCodePrompt, aggregationOptimizeCodePrompt, finalOptimizeCodePrompt, } 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 } from './server.js';
+import { FileManager } from './utils/file-manager.js';
+import { updateImageMapIfNeeded } from './utils/update.js';
+import { Logger } from './utils/logger.js';
+import { getAvailablePort, resetNodeListPosition, saveImageFile, replaceImageSrc } from './utils/utils.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';
+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');
+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'),
+}, async (args) => {
+    try {
+        Logger.log(`收到工具调用参数:`, JSON.stringify(args, null, 2));
+        const { fileKey, nodeId, depth, local } = args;
+        let config = await configManager.load();
+        let hasLaunchWebview = false;
+        // 检测 VSCode 扩展是否可用
+        const isVSCodePluginAvailable = await isVSCodeAvailable();
+        Logger.log(`VSCode 扩展检测结果: ${isVSCodePluginAvailable ? '可用' : '不可用'}`);
+        // 没有配置figmaApiKey，无法预览，直接唤起配置页面
+        if (!config.mcp?.figmaApiKey) {
+            hasLaunchWebview = true;
+            let configDataString;
+            if (isVSCodePluginAvailable) {
+                // 优先使用 VSCode 扩展
+                Logger.log('使用 VSCode 扩展获取用户输入');
+                configDataString = await getUserInputFromVSCode({ fileKey: fileKey, nodeId: nodeId });
+            }
+            else {
+                // 降级到网页浏览器
+                Logger.log('VSCode 扩展不可用，降级到网页浏览器');
+                configDataString = await getUserInput({ fileKey: fileKey, nodeId: nodeId });
+            }
+            if (!configDataString || configDataString.trim() === '') {
+                throw new Error('未提供有效的转码配置');
+            }
+            else {
+                const configData = JSON.parse(configDataString);
+                const { mcp, groupsData, ...rest } = configData;
+                config = {
+                    ...config,
+                    mcp,
+                    fileConfigs: {
+                        ...config.fileConfigs,
+                        [fileKey]: rest,
+                    },
+                };
+                mcpServer.setConfig(config.mcp);
+                configManager.save(config);
+                // 将 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.saveFile(fileKey, nodeId, 'absolute.html', absoluteHtml);
+        }
+        else {
+            d2cNodeList = flatted.parse(await fileManager.loadFile(fileKey, nodeId, 'nodeList.json'));
+            imageMap = flatted.parse(await fileManager.loadFile(fileKey, nodeId, 'imageMap.json'));
+            absoluteHtml = await fileManager.loadFile(fileKey, nodeId, 'absolute.html');
+            console.log('cache load data');
+        }
+        console.log('d2cNodeList', d2cNodeList);
+        console.log('imageMap', imageMap);
+        console.log('absoluteHtml', absoluteHtml);
+        // 如果配置了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 });
+            }
+            else {
+                configDataString = await getUserInput({ fileKey: fileKey, nodeId: nodeId });
+            }
+            if (!configDataString || configDataString.trim() === '') {
+                throw new Error('未提供有效的转码配置');
+            }
+            else {
+                const configData = JSON.parse(configDataString);
+                const { mcp, groupsData, ...rest } = configData;
+                // 保存旧配置用于比较
+                const oldFileConfig = config.fileConfigs?.[fileKey] || defaultConfigData;
+                config = {
+                    ...config,
+                    mcp,
+                    fileConfigs: {
+                        ...config.fileConfigs,
+                        [fileKey]: rest,
+                    },
+                };
+                mcpServer.setConfig(config.mcp);
+                configManager.save(config);
+                // 将 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);
+                    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);
+                }
+            }
+        }
+        // 从 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 chunkPrompt = savedPromptSetting?.chunkOptimizePrompt || chunkOptimizeCodePrompt;
+        const aggregationPrompt = savedPromptSetting?.aggregationOptimizePrompt || aggregationOptimizeCodePrompt;
+        const finalPrompt = savedPromptSetting?.finalOptimizePrompt || finalOptimizeCodePrompt;
+        let root = './';
+        try {
+            const rootRes = await mcpServer.server.listRoots();
+            Logger.log('获取根目录:', rootRes);
+            root = rootRes.roots[0]?.uri?.slice(7) || './';
+        }
+        catch (error) {
+            Logger.log('获取根目录时出错:', error);
+        }
+        const codeSnippets = [];
+        let isSupportSampling = true;
+        // 并发采样：针对每个分组生成 AI 相对布局树并转码
+        if (groupsData && groupsData?.length > 0) {
+            // 限制并发为 2，分批执行，多个采样并发可能存在超时问题
+            const concurrency = 1;
+            for (let i = 0; i < groupsData.length; i += concurrency) {
+                const batch = groupsData.slice(i, i + concurrency);
+                const samplingPromises = batch.map(async (group) => {
+                    const groupElements = group.elements;
+                    let nodeList = d2cNodeList.filter((node) => groupElements.includes(node.id));
+                    group.nodeList = nodeList;
+                    // 重置节点位置
+                    nodeList = resetNodeListPosition(nodeList);
+                    // 获取代码
+                    const code = await getCode({
+                        d2cNodeList: nodeList,
+                        config: convertConfig,
+                    });
+                    console.log('code', code);
+                    // 使用 imageMap 的 path 替换 code 中对应的 src
+                    let replacedCode = replaceImageSrc(code, imageMap);
+                    const componentName = `Group${group.groupIndex + 1}`;
+                    const codeWithCustomName = replacedCode.replace(/\bApp\b/g, componentName);
+                    try {
+                        const { content: { text }, } = await mcpServer.server.createMessage({
+                            messages: [
+                                {
+                                    role: 'user',
+                                    content: {
+                                        type: 'text',
+                                        text: chunkPrompt.replace(/{FRAMEWORK}/g, convertConfig.convertSetting?.framework || ''),
+                                    },
+                                },
+                                {
+                                    role: 'user',
+                                    content: {
+                                        type: 'text',
+                                        text: codeWithCustomName + (group.userPrompt ? '\n以下是用户针对该代码的优化提出的补充说明和要求，请在优化代码时特别关注这些指导并尽可能实现：\n' + group.userPrompt : ''),
+                                    },
+                                },
+                            ],
+                            maxTokens: 48000,
+                        }, { timeout: 5 * 60 * 1000 });
+                        Logger.log('采样成功', text);
+                        const { code: chunkCode, componentName } = extractCodeAndComponents(text)[0];
+                        Logger.log('采样解析成功', chunkCode, componentName);
+                        group.name = componentName;
+                        codeSnippets.push(chunkCode);
+                    }
+                    catch (e) {
+                        Logger.log('调用采样出错', e);
+                        codeSnippets.push(codeWithCustomName + (group.userPrompt ? '\n以下是用户针对该代码的优化提出的补充说明和要求，请在优化代码时特别关注这些指导并尽可能实现：\n' + group.userPrompt : ''));
+                    }
+                });
+                await Promise.all(samplingPromises);
+            }
+        }
+        // 分组外元素：注入分组占位并进行整合采样
+        const groupedElementIds = new Set();
+        groupsData?.forEach((group) => {
+            group.elements.forEach((id) => {
+                groupedElementIds.add(id);
+            });
+        });
+        // 分组外元素
+        const ungroupedNodeList = d2cNodeList.filter((node) => !groupedElementIds.has(node.id));
+        if (ungroupedNodeList.length > 0) {
+            // 注入分组占位
+            groupsData?.forEach((group, index) => {
+                const { x, y, width, height, absoluteRenderX, absoluteRenderY, absoluteRenderWidth, absoluteRenderHeight } = getBoundingBox(group.nodeList);
+                ungroupedNodeList.push({
+                    id: 'G_' + index,
+                    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 code = await getCode({
+                d2cNodeList: ungroupedNodeList,
+                config: convertConfig,
+            });
+            console.log('code', code);
+            // 使用 imageMap 的 path 替换 code 中对应的 src
+            const replacedCode = replaceImageSrc(code, imageMap);
+            // 整合采样
+            try {
+                // 使用提示词（已包含默认值）
+                const { content: { text }, } = await mcpServer.server.createMessage({
+                    messages: [
+                        {
+                            role: 'user',
+                            content: {
+                                type: 'text',
+                                text: aggregationPrompt.replace(/{FRAMEWORK}/g, convertConfig.convertSetting?.framework || ''),
+                            },
+                        },
+                        {
+                            role: 'user',
+                            content: {
+                                type: 'text',
+                                text: replacedCode,
+                            },
+                        },
+                    ],
+                    maxTokens: 48000,
+                }, {
+                    timeout: 5 * 60 * 1000,
+                });
+                Logger.log('采样成功 (分组外元素)', text);
+                const { code: pageCode } = extractCodeAndComponents(text)[0];
+                codeSnippets.unshift(pageCode);
+            }
+            catch (e) {
+                isSupportSampling = false;
+                Logger.log('调用分组外元素采样出错，降级到传统模式', e);
+                codeSnippets.unshift(replacedCode);
+            }
+        }
+        // 保存图片文件
+        saveImageFile({ imageMap, root });
+        Logger.log('处理完成，生成的代码片段数量:', codeSnippets.length);
+        // 使用提示词（已包含默认值）
+        return {
+            content: [
+                isSupportSampling
+                    ? {
+                        type: 'text',
+                        text: finalPrompt,
+                    }
+                    : {
+                        type: 'text',
+                        text: aggregationPrompt.replace(/{FRAMEWORK}/g, convertConfig.convertSetting?.framework || ''),
+                    },
+                ...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)}`,
+                },
+            ],
+        };
+    }
+});
+// 启动 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('  config    显示配置文件信息');
+        console.log('  page      显示 interceptor-web 页面地址');
+        console.log('  version   显示版本信息');
+        console.log('');
+        console.log('全局选项:');
+        console.log('  --help, -h       显示帮助信息');
+        console.log('  --version, -v    显示版本信息');
+        console.log('');
+        console.log('使用 "sloth <命令> --help" 获取特定命令的帮助信息');
+        console.log('');
+        console.log('示例:');
+        console.log('  sloth config              # 显示配置信息');
+        console.log('  sloth config --path       # 仅显示配置路径');
+        console.log('  sloth page                # 显示页面地址');
+        console.log('  sloth page --list         # 列出所有页面文件');
+        console.log('  sloth version             # 显示版本信息');
+        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.toString();
+            }
+        }
+        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);
+    }
+    // 检查是否是 page 命令
+    if (process.env.SLOTH_COMMAND === 'page') {
+        // 获取子命令参数
+        const pageArgsStr = process.env.SLOTH_PAGE_ARGS || '[]';
+        const pageArgs = JSON.parse(pageArgsStr);
+        const isJsonOutput = pageArgs.includes('--json');
+        // 处理帮助参数
+        if (pageArgs.includes('--help') || pageArgs.includes('-h')) {
+            console.log('使用方法: sloth page [选项]');
+            console.log('');
+            console.log('显示安装包目录下 interceptor-web 页面的地址');
+            console.log('');
+            console.log('选项:');
+            console.log('  --help, -h    显示帮助信息');
+            console.log('  --list        列出所有可用的页面文件');
+            console.log('  --json        以 JSON 格式输出');
+            process.exit(0);
+        }
+        try {
+            // 获取当前模块的目录
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = path.dirname(__filename);
+            // 构建 interceptor-web 目录路径
+            // 在开发环境中路径是: dist/build/index.js -> ../interceptor-web/dist
+            // 在全局安装后路径是: node_modules/sloth-d2c-mcp/dist/build/index.js -> ../../interceptor-web/dist
+            let interceptorWebPath = path.join(__dirname, '..', 'interceptor-web', 'dist');
+            Logger.log('interceptorWebPath', interceptorWebPath);
+            // 检查目录是否存在，如果不存在可能是全局安装的情况
+            let pathFound = false;
+            try {
+                await fs.access(interceptorWebPath);
+                pathFound = true;
+            }
+            catch {
+                // 尝试全局安装的路径
+                interceptorWebPath = path.join(__dirname, '..', '..', 'interceptor-web', 'dist');
+                try {
+                    await fs.access(interceptorWebPath);
+                    pathFound = true;
+                }
+                catch {
+                    // 路径都不存在
+                }
+            }
+            if (!pathFound) {
+                const errorInfo = {
+                    error: 'Interceptor-web 目录不存在',
+                    attemptedPaths: [path.join(__dirname, '..', 'interceptor-web', 'dist'), path.join(__dirname, '..', '..', 'interceptor-web', 'dist')],
+                    suggestions: ['包未正确构建', 'interceptor-web 目录结构发生变化', '安装方式不同导致路径差异'],
+                };
+                if (isJsonOutput) {
+                    console.log(JSON.stringify(errorInfo, null, 2));
+                }
+                else {
+                    console.log(`Interceptor-web 目录不存在:`);
+                    console.log(`  尝试路径1: ${errorInfo.attemptedPaths[0]}`);
+                    console.log(`  尝试路径2: ${errorInfo.attemptedPaths[1]}`);
+                    console.log('');
+                    console.log('可能的原因:');
+                    errorInfo.suggestions.forEach((suggestion, index) => {
+                        console.log(`  ${index + 1}. ${suggestion}`);
+                    });
+                }
+                process.exit(1);
+            }
+            // 如果是 --list 参数，列出所有文件
+            if (pageArgs.includes('--list')) {
+                try {
+                    const files = await fs.readdir(interceptorWebPath);
+                    const fileList = [];
+                    for (const file of files) {
+                        const filePath = path.join(interceptorWebPath, file);
+                        const stat = await fs.stat(filePath);
+                        if (stat.isFile()) {
+                            fileList.push({
+                                name: file,
+                                path: filePath,
+                            });
+                        }
+                    }
+                    if (isJsonOutput) {
+                        console.log(JSON.stringify({
+                            directory: interceptorWebPath,
+                            files: fileList,
+                        }, null, 2));
+                    }
+                    else {
+                        console.log(`Interceptor-web 目录路径: ${interceptorWebPath}`);
+                        console.log('可用的页面文件:');
+                        fileList.forEach((file) => {
+                            console.log(`  ${file.name} -> ${file.path}`);
+                        });
+                    }
+                }
+                catch (error) {
+                    const errorInfo = {
+                        error: '读取目录失败',
+                        message: error.toString(),
+                        directory: interceptorWebPath,
+                    };
+                    if (isJsonOutput) {
+                        console.log(JSON.stringify(errorInfo, null, 2));
+                    }
+                    else {
+                        console.log(`读取目录失败: ${error}`);
+                    }
+                    process.exit(1);
+                }
+            }
+            else {
+                // 默认显示主要页面
+                const indexPath = path.join(interceptorWebPath, 'index.html');
+                const detailPath = path.join(interceptorWebPath, 'detail.html');
+                const pages = {
+                    directory: interceptorWebPath,
+                    pages: {
+                        index: {
+                            path: indexPath,
+                            exists: false,
+                        },
+                        detail: {
+                            path: detailPath,
+                            exists: false,
+                        },
+                    },
+                };
+                // 检查 index.html
+                try {
+                    await fs.access(indexPath);
+                    pages.pages.index.exists = true;
+                }
+                catch {
+                    // 文件不存在
+                }
+                // 检查 detail.html
+                try {
+                    await fs.access(detailPath);
+                    pages.pages.detail.exists = true;
+                }
+                catch {
+                    // 文件不存在
+                }
+                if (isJsonOutput) {
+                    console.log(JSON.stringify(pages, null, 2));
+                }
+                else {
+                    console.log(`Interceptor-web 目录路径: ${interceptorWebPath}`);
+                    console.log('主要页面文件:');
+                    console.log(`  主页面: ${indexPath}${pages.pages.index.exists ? '' : ' (不存在)'}`);
+                    console.log(`  详情页: ${detailPath}${pages.pages.detail.exists ? '' : ' (不存在)'}`);
+                }
+            }
+        }
+        catch (error) {
+            const errorInfo = {
+                error: '获取页面信息失败',
+                message: error.toString(),
+            };
+            if (isJsonOutput) {
+                console.log(JSON.stringify(errorInfo, null, 2));
+            }
+            else {
+                console.log(`获取页面信息失败: ${error}`);
+            }
+            process.exit(1);
+        }
+        process.exit(0);
+    }
+    if (process.env.SLOTH_COMMAND === 'clear') {
+        fileManager.cleanup();
+        process.exit(0);
+    }
+    try {
+        // 先输出基本启动信息到控制台，确保即使 VSCode 日志失败也能看到启动过程
+        console.log(`[${new Date().toISOString()}] Starting Figma transcoding interceptor MCP server...`);
+        const port = await getAvailablePort();
+        // Create config manager instance to pass to server
+        const configManager = new ConfigManager('d2c-mcp');
+        const isStdioMode = process.env.NODE_ENV === 'cli' || process.argv.includes('--stdio');
+        if (isStdioMode) {
+            Logger.log(`Stdio模式启动`);
+            await loadConfig(mcpServer, configManager);
+            const transport = new StdioServerTransport();
+            await mcpServer.connect(transport);
+            // 启动 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}!`);
+    }
+    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();
+    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();
+    Logger.cleanup(); // 清理日志连接
+    await stopHttpServer();
+    process.exit(0);
+});
+main();
+// 获取命令行参数
+const args = process.argv.slice(2);
+// 处理 --log 参数：开启文件日志（同时保留控制台输出）
+const logArgIndex = args.findIndex((a) => a === '--log' || a.startsWith('--log='));
+if (logArgIndex !== -1) {
+    let logFilePath = 'runtime.log';
+    const raw = args[logArgIndex];
+    // 移除 --log 参数，避免传递给后续程序
+    args.splice(logArgIndex, 1);
+    process.argv = [process.argv[0], process.argv[1], ...args];
+    try {
+        const { createWriteStream, mkdirSync, existsSync } = await import('node:fs');
+        const path = await import('node:path');
+        const util = await import('node:util');
+        if (raw.startsWith('--log=')) {
+            const provided = raw.slice('--log='.length).trim();
+            if (provided) {
+                logFilePath = path.isAbsolute(provided) ? provided : path.resolve(process.cwd(), provided);
+            }
+        }
+        else {
+            logFilePath = path.resolve(process.cwd(), logFilePath);
+        }
+        const logDir = path.dirname(logFilePath);
+        if (!existsSync(logDir)) {
+            mkdirSync(logDir, { recursive: true });
+        }
+        const logStream = createWriteStream(logFilePath, { flags: 'a' });
+        const originalConsole = {
+            log: console.log,
+            info: console.info,
+            warn: console.warn,
+            error: console.error,
+        };
+        const writeLine = (...args) => {
+            try {
+                const line = util.format(...args) + '\n';
+                logStream.write(line);
+            }
+            catch { }
+        };
+        console.log = (...a) => {
+            originalConsole.log(...a);
+            writeLine(...a);
+        };
+        console.info = (...a) => {
+            originalConsole.info(...a);
+            writeLine(...a);
+        };
+        console.warn = (...a) => {
+            originalConsole.warn(...a);
+            writeLine(...a);
+        };
+        console.error = (...a) => {
+            originalConsole.error(...a);
+            writeLine(...a);
+        };
+        process.env.SLOTH_LOG_FILE = logFilePath;
+        originalConsole.log(`[sloth] 日志已开启，写入: ${logFilePath}`);
+        const close = () => {
+            try {
+                logStream.end();
+            }
+            catch { }
+        };
+        process.on('exit', close);
+        process.on('SIGINT', close);
+        process.on('SIGTERM', close);
+        process.on('uncaughtException', close);
+        process.on('unhandledRejection', close);
+    }
+    catch (e) {
+        // 记录但不中断启动
+        console.warn('[sloth] 启用文件日志失败:', e);
+    }
+}
+// 检查是否是 config 命令
+if (args[0] === 'config') {
+    // 设置环境变量标识这是 config 命令
+    process.env.SLOTH_COMMAND = 'config';
+    // 传递子命令参数
+    process.env.SLOTH_CONFIG_ARGS = JSON.stringify(args.slice(1));
+}
+else if (args[0] === 'page') {
+    // 设置环境变量标识这是 page 命令
+    process.env.SLOTH_COMMAND = 'page';
+    // 传递子命令参数
+    process.env.SLOTH_PAGE_ARGS = JSON.stringify(args.slice(1));
+}
+else if (args[0] === 'version' || args[0] === '--version' || args[0] === '-v') {
+    // 设置环境变量标识这是 version 命令
+    process.env.SLOTH_COMMAND = 'version';
+}
+else if (args[0] === '--help' || args[0] === '-h' || args.length === 0) {
+    // 显示主帮助信息
+    process.env.SLOTH_COMMAND = 'help';
+}
+else if (args[0] === 'clear') {
+    // 设置环境变量标识这是 clear 命令
+    process.env.SLOTH_COMMAND = 'clear';
+}
+else {
+    // 设置环境变量为CLI模式
+    process.env.NODE_ENV = 'cli';
+    // 确保--stdio参数被传递
+    if (!process.argv.includes('--stdio')) {
+        process.argv.push('--stdio');
+    }
+}