sloth-d2c-mcp 1.0.4-beta65

package/dist/build/utils/utils.js

@@ -0,0 +1,165 @@
+import { createServer } from 'net';
+import { execSync } from 'child_process';
+import axios from 'axios';
+import fs from 'fs';
+import path from 'path';
+/**
+ * 获取可用的端口号，从指定端口开始寻找
+ * @param startPort 起始端口号，默认3100
+ * @param maxAttempts 最大尝试次数，默认100
+ * @returns Promise<number> 返回可用的端口号
+ */
+export async function getAvailablePort(startPort = 3100, maxAttempts = 10) {
+    for (let port = startPort; port < startPort + maxAttempts; port++) {
+        if (await isPortAvailable(port)) {
+            return port;
+        }
+    }
+    return 3100;
+    // throw new Error(`No available port found in range ${startPort}-${startPort + maxAttempts - 1}`)
+}
+/**
+ * 检查指定端口是否可用
+ * @param port 要检查的端口号
+ * @returns Promise<boolean> 端口是否可用
+ */
+function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.listen(port, () => {
+            server.close(() => {
+                resolve(true);
+            });
+        });
+        server.on('error', () => {
+            resolve(false);
+        });
+    });
+}
+// 判断是否全局可用的命令
+export function isInstalled(command) {
+    try {
+        // macOS / Linux 用 which，Windows 用 where
+        const checkCmd = process.platform === 'win32' ? `where ${command}` : `which ${command}`;
+        execSync(checkCmd, { stdio: 'ignore' });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+export function getBase64(url) {
+    return axios
+        .get(url, {
+        responseType: 'arraybuffer',
+    })
+        .then((response) => Buffer.from(response.data, 'binary').toString('base64'));
+}
+/**
+ * Download Figma image and save it locally
+ * @param fileName - The filename to save as
+ * @param localPath - The local path to save to
+ * @param imageUrl - Image URL (images[nodeId])
+ * @returns A Promise that resolves to the full file path where the image was saved
+ * @throws Error if download fails
+ */
+export async function downloadFigmaImage(fileName, localPath, imageUrl, base64) {
+    try {
+        console.log('downloadFigmaImage', 'fileName', fileName, 'localPath', localPath, 'imageUrl', imageUrl);
+        // 处理 fileName，提取文件名和可能的子目录路径
+        const fileNameParts = fileName.split('/');
+        const actualFileName = fileNameParts.pop() || fileName; // 获取最后的文件名部分
+        const subDirPath = fileNameParts.length > 0 ? fileNameParts.join('/') : ''; // 获取子目录路径
+        // 构建完整的本地路径，包含子目录
+        let fullLocalPath = localPath;
+        if (subDirPath) {
+            fullLocalPath = path.join(localPath, subDirPath);
+        }
+        // 确保目录存在
+        if (!fs.existsSync(fullLocalPath)) {
+            fs.mkdirSync(fullLocalPath, { recursive: true });
+        }
+        // 构建完整的文件路径
+        const fullPath = path.resolve(path.join(fullLocalPath, actualFileName));
+        console.log('downloadFigmaImage fullPath', fullPath);
+        if (base64) {
+            // 将base64字符串的前缀去掉，支持 data:image/png;base64, data:image/svg+xml;base64, 等格式
+            const base64Str = base64.replace(/^data:image\/[\w+]+;base64,/, '');
+            // 将base64写入为文件
+            const buffer = Buffer.from(base64Str, 'base64');
+            fs.writeFileSync(fullPath, buffer);
+        }
+        else {
+            // Use fetch to download the image
+            const response = await fetch(imageUrl, {
+                method: 'GET',
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const buffer = await response.arrayBuffer();
+            fs.writeFileSync(fullPath, Buffer.from(buffer));
+        }
+        return fullPath;
+    }
+    catch (error) {
+        console.error('error', error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Error downloading image: ${errorMessage}; url: ${imageUrl}`);
+    }
+}
+/**
+ * 获取系统支持的文件名
+ * @param name
+ * @returns
+ */
+export const getSystemSupportFileName = (name) => {
+    return name.replace(/[\\\\/:*?\\"<>|#%]/g, '').replace(/\s+/g, '');
+};
+/**
+ * 保存图片文件并替换代码中的图片路径
+ * @param imageMap 图片映射对象
+ * @param code 原始代码
+ * @param root 根目录路径
+ * @returns 替换后的代码
+ */
+export const saveImageFile = (params) => {
+    const { imageMap, root } = params;
+    // 下载图片文件
+    for (const [, source] of Object.entries(imageMap)) {
+        try {
+            downloadFigmaImage(source.path, path.join(root), source.src, source.base64);
+        }
+        catch (error) {
+            console.error('Failed to download image:', error);
+        }
+    }
+};
+export const replaceImageSrc = (code, imageMap) => {
+    let replacedCode = code;
+    for (const [, source] of Object.entries(imageMap)) {
+        if (!source?.src || !source?.path)
+            continue;
+        const escapedSrc = source.src?.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        console.log('escapedSrc', escapedSrc);
+        if (escapedSrc) {
+            replacedCode = replacedCode.replace(new RegExp(escapedSrc, 'g'), source.path);
+        }
+    }
+    return replacedCode;
+};
+/**
+ * 重置节点列表的坐标
+ * @param nodeList 节点列表
+ * @returns
+ */
+export const resetNodeListPosition = (nodeList) => {
+    console.log('resetNodeListPosition', nodeList);
+    const minX = Math.min(...nodeList.map((node) => node.x));
+    const minY = Math.min(...nodeList.map((node) => node.y));
+    return nodeList.map(({ ...node }) => {
+        node.x -= minX;
+        node.y -= minY;
+        return node;
+    });
+};

package/dist/build/utils/vscode-logger.js

@@ -0,0 +1,133 @@
+import * as net from 'net';
+/**
+ * VSCode 日志传输器
+ * 将日志通过 TCP 连接发送到 VSCode 扩展的输出面板
+ */
+export class VSCodeLogger {
+    static instance;
+    socket = null;
+    isConnected = false;
+    reconnectTimer = null;
+    logBuffer = [];
+    maxBufferSize = 100;
+    constructor() {
+        this.connect();
+    }
+    static getInstance() {
+        if (!VSCodeLogger.instance) {
+            VSCodeLogger.instance = new VSCodeLogger();
+        }
+        return VSCodeLogger.instance;
+    }
+    connect() {
+        try {
+            this.socket = new net.Socket();
+            this.socket.connect(13142, '127.0.0.1', () => {
+                this.isConnected = true;
+                console.log('[VSCodeLogger] 已连接到 VSCode 扩展日志服务');
+                // 发送缓冲的日志
+                this.flushBuffer();
+                // 清除重连定时器
+                if (this.reconnectTimer) {
+                    clearTimeout(this.reconnectTimer);
+                    this.reconnectTimer = null;
+                }
+            });
+            this.socket.on('error', (error) => {
+                this.isConnected = false;
+                console.log('[VSCodeLogger] 连接错误:', error.message);
+                this.scheduleReconnect();
+            });
+            this.socket.on('close', () => {
+                this.isConnected = false;
+                console.log('[VSCodeLogger] 连接已关闭');
+                this.scheduleReconnect();
+            });
+        }
+        catch (error) {
+            console.log('[VSCodeLogger] 连接失败:', error);
+            this.scheduleReconnect();
+        }
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer) {
+            return; // 已经在重连中
+        }
+        this.reconnectTimer = setTimeout(() => {
+            console.log('[VSCodeLogger] 尝试重新连接...');
+            this.connect();
+        }, 5000); // 5秒后重连
+    }
+    flushBuffer() {
+        if (this.logBuffer.length > 0 && this.isConnected && this.socket) {
+            const logs = this.logBuffer.join('');
+            this.socket.write(logs);
+            this.logBuffer = [];
+        }
+    }
+    sendLog(level, ...args) {
+        const timestamp = new Date().toISOString();
+        const levelPrefix = level.toUpperCase().padEnd(5);
+        const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)).join(' ');
+        const logLine = `[${timestamp}] [${levelPrefix}] ${message}\n`;
+        if (this.isConnected && this.socket) {
+            try {
+                this.socket.write(logLine);
+            }
+            catch (error) {
+                // 如果发送失败，添加到缓冲区
+                this.addToBuffer(logLine);
+            }
+        }
+        else {
+            // 连接未建立，添加到缓冲区
+            this.addToBuffer(logLine);
+        }
+    }
+    addToBuffer(logLine) {
+        this.logBuffer.push(logLine);
+        // 限制缓冲区大小
+        if (this.logBuffer.length > this.maxBufferSize) {
+            this.logBuffer.shift(); // 移除最旧的日志
+        }
+    }
+    log(...args) {
+        this.sendLog('log', ...args);
+    }
+    error(...args) {
+        this.sendLog('error', ...args);
+    }
+    warn(...args) {
+        this.sendLog('warn', ...args);
+    }
+    info(...args) {
+        this.sendLog('info', ...args);
+    }
+    reconnect() {
+        console.log('[VSCodeLogger] 手动重连请求');
+        // 清除现有连接和定时器
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = null;
+        }
+        this.isConnected = false;
+        // 立即重新连接
+        this.connect();
+    }
+    destroy() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = null;
+        }
+        this.isConnected = false;
+        this.logBuffer = [];
+    }
+}

package/dist/build/utils/webpack-substitutions.js

@@ -0,0 +1,196 @@
+// @ts-nocheck
+const parseResource = (str) => {
+    return {
+        resource: str,
+        path: str,
+        query: '',
+        fragment: '',
+    };
+};
+const REGEXP = /\[\\*([\w:]+)\\*\]/gi;
+/**
+ * @param {string | number} id id
+ * @returns {string | number} result
+ */
+const prepareId = (id) => {
+    if (typeof id !== 'string')
+        return id;
+    if (/^"\s\+*.*\+\s*"$/.test(id)) {
+        const match = /^"\s\+*\s*(.*)\s*\+\s*"$/.exec(id);
+        return `" + (${ /** @type {string[]} */match[1]} + "").replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_") + "`;
+    }
+    return id.replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, '_');
+};
+/**
+ * @callback ReplacerFunction
+ * @param {string} match
+ * @param {string | undefined} arg
+ * @param {string} input
+ */
+/**
+ * @param {ReplacerFunction} replacer replacer
+ * @param {((arg0: number) => string) | undefined} handler handler
+ * @param {AssetInfo | undefined} assetInfo asset info
+ * @param {string} hashName hash name
+ * @returns {ReplacerFunction} hash replacer function
+ */
+const hashLength = (replacer, handler, assetInfo, hashName) => {
+    /** @type {ReplacerFunction} */
+    const fn = (match, arg, input) => {
+        let result;
+        const length = arg && Number.parseInt(arg, 10);
+        if (length && handler) {
+            result = handler(length);
+        }
+        else {
+            const hash = replacer(match, arg, input);
+            result = length ? hash.slice(0, length) : hash;
+        }
+        if (assetInfo) {
+            assetInfo.immutable = true;
+            if (Array.isArray(assetInfo[hashName])) {
+                assetInfo[hashName] = [...assetInfo[hashName], result];
+            }
+            else if (assetInfo[hashName]) {
+                assetInfo[hashName] = [assetInfo[hashName], result];
+            }
+            else {
+                assetInfo[hashName] = result;
+            }
+        }
+        return result;
+    };
+    return fn;
+};
+/** @typedef {(match: string, arg?: string, input?: string) => string} Replacer */
+/**
+ * @param {string | number | null | undefined | (() => string | number | null | undefined)} value value
+ * @param {boolean=} allowEmpty allow empty
+ * @returns {Replacer} replacer
+ */
+const replacer = (value, allowEmpty) => {
+    /** @type {Replacer} */
+    const fn = (match, arg, input) => {
+        if (typeof value === 'function') {
+            value = value();
+        }
+        if (value === null || value === undefined) {
+            if (!allowEmpty) {
+                throw new Error(`Path variable ${match} not implemented in this context: ${input}`);
+            }
+            return '';
+        }
+        return `${value}`;
+    };
+    return fn;
+};
+/** @typedef {string | function(PathData, AssetInfo=): string} TemplatePath */
+/**
+ * @param {TemplatePath} path the raw path
+ * @param {PathData} data context data
+ * @param {AssetInfo | undefined} assetInfo extra info about the asset (will be written to)
+ * @returns {string} the interpolated path
+ */
+export const replacePathVariables = (path, data, assetInfo) => {
+    /** @type {Map<string, Function>} */
+    const replacements = new Map();
+    // Filename context
+    //
+    // Placeholders
+    //
+    // for /some/path/file.js?query#fragment:
+    // [file] - /some/path/file.js
+    // [query] - ?query
+    // [fragment] - #fragment
+    // [base] - file.js
+    // [path] - /some/path/
+    // [name] - file
+    // [ext] - .js
+    if (typeof data.filename === 'string') {
+        // check that filename is data uri
+        const match = data.filename.match(/^data:([^;,]+)/);
+        if (match) {
+            const emptyReplacer = replacer('', true);
+            // "XXXX" used for `updateHash`, so we don't need it here
+            const contentHash = data.contentHash && !/X+/.test(data.contentHash) ? data.contentHash : false;
+            const baseReplacer = contentHash ? replacer(contentHash) : emptyReplacer;
+            replacements.set('file', emptyReplacer);
+            replacements.set('query', emptyReplacer);
+            replacements.set('path', emptyReplacer);
+            replacements.set('base', baseReplacer);
+            replacements.set('name', baseReplacer);
+        }
+        else {
+            const { path: file, query, fragment } = parseResource(data.filename);
+            const ext = file.includes('.') ? file.substring(file.lastIndexOf('.') + 1) : '';
+            const base = file.split('/').pop() || '';
+            const name = base.slice(0, base.length - ext.length);
+            const path = file.slice(0, file.length - base.length);
+            replacements.set('file', replacer(file));
+            replacements.set('query', replacer(query, true));
+            replacements.set('path', replacer(path, true));
+            replacements.set('base', replacer(base));
+            replacements.set('name', replacer(name));
+            replacements.set('ext', replacer(ext, true));
+        }
+    }
+    // Compilation context
+    //
+    // Placeholders
+    //
+    // [fullhash] - data.hash (3a4b5c6e7f)
+    //
+    // Legacy Placeholders
+    //
+    // [hash] - data.hash (3a4b5c6e7f)
+    if (data.hash) {
+        const hashReplacer = hashLength(replacer(data.hash), data.hashWithLength, assetInfo, 'fullhash');
+        replacements.set('fullhash', hashReplacer);
+    }
+    // Chunk Context
+    //
+    // Placeholders
+    //
+    // [id] - chunk.id (0.js)
+    // [name] - chunk.name (app.js)
+    // [chunkhash] - chunk.hash (7823t4t4.js)
+    // [contenthash] - chunk.contentHash[type] (3256u3zg.js)
+    if (data.chunk) {
+        const chunk = data.chunk;
+        const contentHashType = data.contentHashType;
+        const idReplacer = replacer(chunk.id);
+        const nameReplacer = replacer(chunk.name || chunk.id);
+        const contenthashReplacer = hashLength(replacer(data.contentHash || (contentHashType && chunk.contentHash && chunk.contentHash[contentHashType])), data.contentHashWithLength ||
+            ('contentHashWithLength' in chunk && chunk.contentHashWithLength ? chunk.contentHashWithLength[ /** @type {string} */contentHashType] : undefined), assetInfo, 'contenthash');
+        replacements.set('id', idReplacer);
+        replacements.set('name', nameReplacer);
+        replacements.set('contenthash', contenthashReplacer);
+    }
+    // Other things
+    if (data.url) {
+        replacements.set('url', replacer(data.url));
+    }
+    if (typeof data.runtime === 'string') {
+        replacements.set('runtime', replacer(() => prepareId(/** @type {string} */ data.runtime)));
+    }
+    else {
+        replacements.set('runtime', replacer('_'));
+    }
+    path = path.replace(REGEXP, (match, content) => {
+        if (content.length + 2 === match.length) {
+            const contentMatch = /^(\w+)(?::(\w+))?$/.exec(content);
+            if (!contentMatch)
+                return match;
+            const [, kind, arg] = contentMatch;
+            const replacer = replacements.get(kind);
+            if (replacer !== undefined) {
+                return replacer(match, arg, path);
+            }
+        }
+        else if (match.startsWith('[\\') && match.endsWith('\\]')) {
+            return `[${match.slice(2, -2)}]`;
+        }
+        return match;
+    });
+    return path;
+};

package/dist/interceptor-web/dist/build-report.json

@@ -0,0 +1,18 @@
+{
+  "buildTime": "2025-10-21T12:55:46.930Z",
+  "mode": "build",
+  "pages": {
+    "main": {
+      "file": "index.html",
+      "size": 1089770,
+      "sizeFormatted": "1.04 MB"
+    },
+    "detail": {
+      "file": "detail.html",
+      "size": 240085,
+      "sizeFormatted": "234.46 KB"
+    }
+  },
+  "totalSize": 1329855,
+  "totalSizeFormatted": "1.27 MB"
+}