sloth-d2c-mcp 1.0.4-beta75 → 1.0.4-beta77

package/dist/build/socket-client.js

@@ -0,0 +1,163 @@
+import * as net from 'net';
+import { Logger } from './utils/logger.js';
+/**
+ * Socket 客户端类
+ * 用于子进程连接到主进程的 Socket 服务器，接收认证结果
+ */
+export class SocketClient {
+    socket = null;
+    host;
+    port;
+    connected = false;
+    messageBuffer = '';
+    messageHandlers = new Map();
+    constructor(host = 'localhost', port) {
+        this.host = host;
+        this.port = port;
+    }
+    /**
+     * 连接到 Socket 服务器
+     */
+    connect() {
+        return new Promise((resolve, reject) => {
+            this.socket = new net.Socket();
+            this.socket.setEncoding('utf8');
+            // 连接成功
+            this.socket.on('connect', () => {
+                Logger.log(`Socket 客户端已连接到 ${this.host}:${this.port}`);
+                this.connected = true;
+                resolve();
+            });
+            // 接收数据
+            this.socket.on('data', (data) => {
+                this.handleData(data);
+            });
+            // 处理错误
+            this.socket.on('error', (error) => {
+                Logger.error('Socket 客户端错误:', error);
+                this.connected = false;
+                if (!this.socket?.connecting) {
+                    reject(error);
+                }
+            });
+            // 处理断开连接
+            this.socket.on('close', () => {
+                Logger.log('Socket 客户端已断开连接');
+                this.connected = false;
+            });
+            // 开始连接
+            this.socket.connect(this.port, this.host);
+        });
+    }
+    /**
+     * 处理接收到的数据（支持粘包处理）
+     */
+    handleData(data) {
+        // 将数据添加到缓冲区
+        this.messageBuffer += data;
+        // 按换行符分割消息
+        const messages = this.messageBuffer.split('\n');
+        // 保留最后一个不完整的消息
+        this.messageBuffer = messages.pop() || '';
+        // 处理每个完整的消息
+        for (const messageStr of messages) {
+            if (!messageStr.trim())
+                continue;
+            try {
+                const message = JSON.parse(messageStr);
+                this.handleMessage(message);
+            }
+            catch (error) {
+                Logger.error('解析 Socket 消息失败:', error, '原始数据:', messageStr);
+            }
+        }
+    }
+    /**
+     * 处理解析后的消息
+     */
+    handleMessage(message) {
+        Logger.log('收到 Socket 消息:', message.type);
+        // 如果是认证响应，调用对应的处理器
+        if (message.type === 'submit-response' && message.token) {
+            const handler = this.messageHandlers.get(message.token);
+            if (handler) {
+                handler(message.data);
+                this.messageHandlers.delete(message.token);
+            }
+        }
+        // 处理其他消息类型
+        switch (message.type) {
+            case 'welcome':
+                Logger.log('收到欢迎消息:', message.message);
+                break;
+            case 'pong':
+                Logger.log('收到 pong 响应');
+                break;
+            case 'error':
+                Logger.error('服务器错误:', message.message);
+                break;
+        }
+    }
+    /**
+     * 发送消息到服务器
+     */
+    send(message) {
+        if (!this.socket || !this.connected) {
+            throw new Error('Socket 客户端未连接');
+        }
+        try {
+            this.socket.write(JSON.stringify(message) + '\n');
+        }
+        catch (error) {
+            Logger.error('发送 Socket 消息失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 注册 token，等待认证响应
+     */
+    registerToken(token) {
+        return new Promise((resolve, reject) => {
+            // 设置超时（可选，根据需求调整）
+            const timeout = setTimeout(() => {
+                this.messageHandlers.delete(token);
+                reject(new Error('等待认证响应超时'));
+            }, 5 * 60 * 1000); // 5分钟超时
+            // 注册消息处理器
+            this.messageHandlers.set(token, (data) => {
+                clearTimeout(timeout);
+                resolve(JSON.stringify(data));
+            });
+            // 发送注册消息到服务器
+            this.send({
+                type: 'register-token',
+                token,
+                timestamp: Date.now(),
+            });
+            Logger.log(`已注册 token: ${token}，等待认证响应...`);
+        });
+    }
+    /**
+     * 发送 ping 消息
+     */
+    ping() {
+        this.send({ type: 'ping', timestamp: Date.now() });
+    }
+    /**
+     * 断开连接
+     */
+    disconnect() {
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = null;
+            this.connected = false;
+            this.messageHandlers.clear();
+        }
+    }
+    /**
+     * 检查是否已连接
+     */
+    isConnected() {
+        return this.connected;
+    }
+}

package/dist/build/socket-server.js

@@ -0,0 +1,233 @@
+import * as net from 'net';
+import { Logger } from './utils/logger.js';
+/**
+ * Socket 服务器类
+ * 使用原生 net 模块实现 TCP Socket 通信
+ */
+export class SocketServer {
+    server = null;
+    connections = new Set();
+    tokenSockets = new Map(); // token -> socket 映射
+    messageBuffers = new Map(); // socket -> 消息缓冲区
+    port = 0;
+    constructor() {
+        this.server = net.createServer(this.handleConnection.bind(this));
+        this.setupServerEvents();
+    }
+    /**
+     * 处理新的 Socket 连接
+     */
+    handleConnection(socket) {
+        const clientId = `${socket.remoteAddress}:${socket.remotePort}`;
+        Logger.log(`Socket 客户端已连接: ${clientId}`);
+        // 添加到活跃连接集合
+        this.connections.add(socket);
+        this.messageBuffers.set(socket, '');
+        // 设置编码
+        socket.setEncoding('utf8');
+        // 接收数据
+        socket.on('data', (data) => {
+            this.handleData(socket, clientId, data);
+        });
+        // 处理错误
+        socket.on('error', (error) => {
+            Logger.error(`Socket 客户端 ${clientId} 错误:`, error);
+        });
+        // 处理断开连接
+        socket.on('close', () => {
+            Logger.log(`Socket 客户端已断开: ${clientId}`);
+            this.connections.delete(socket);
+            this.messageBuffers.delete(socket);
+            // 清理该 socket 关联的所有 token
+            for (const [token, sock] of this.tokenSockets.entries()) {
+                if (sock === socket) {
+                    this.tokenSockets.delete(token);
+                    Logger.log(`清理 token: ${token}`);
+                }
+            }
+        });
+        // 发送欢迎消息
+        this.sendMessage(socket, {
+            type: 'welcome',
+            message: 'Socket 服务器已连接',
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * 处理接收到的数据（支持粘包处理）
+     */
+    handleData(socket, clientId, data) {
+        // 将数据添加到缓冲区
+        const buffer = this.messageBuffers.get(socket) || '';
+        this.messageBuffers.set(socket, buffer + data);
+        // 按换行符分割消息
+        const messages = this.messageBuffers.get(socket).split('\n');
+        // 保留最后一个不完整的消息
+        this.messageBuffers.set(socket, messages.pop() || '');
+        // 处理每个完整的消息
+        for (const messageStr of messages) {
+            if (!messageStr.trim())
+                continue;
+            try {
+                const message = JSON.parse(messageStr);
+                this.handleMessage(socket, clientId, message);
+            }
+            catch (error) {
+                Logger.error(`解析 Socket 消息失败: ${error}`, '原始数据:', messageStr);
+                this.sendMessage(socket, { type: 'error', message: '无效的 JSON 格式' });
+            }
+        }
+    }
+    /**
+     * 处理解析后的消息
+     */
+    handleMessage(socket, clientId, message) {
+        Logger.log(`收到来自 ${clientId} 的消息类型: ${message.type}`);
+        // 处理不同类型的消息
+        switch (message.type) {
+            case 'ping':
+                this.sendMessage(socket, { type: 'pong', timestamp: Date.now() });
+                break;
+            case 'echo':
+                this.sendMessage(socket, { type: 'echo', data: message.data });
+                break;
+            case 'register-token':
+                // 注册 token，建立 token -> socket 映射
+                if (message.token) {
+                    this.tokenSockets.set(message.token, socket);
+                    Logger.log(`已注册 token: ${message.token} -> ${clientId}`);
+                    this.sendMessage(socket, {
+                        type: 'token-registered',
+                        token: message.token,
+                        timestamp: Date.now()
+                    });
+                }
+                else {
+                    this.sendMessage(socket, { type: 'error', message: '缺少 token' });
+                }
+                break;
+            default:
+                this.sendMessage(socket, { type: 'error', message: '未知的消息类型' });
+        }
+    }
+    /**
+     * 发送消息到客户端
+     */
+    sendMessage(socket, message) {
+        try {
+            socket.write(JSON.stringify(message) + '\n');
+        }
+        catch (error) {
+            Logger.error('发送 Socket 消息失败:', error);
+        }
+    }
+    /**
+     * 广播消息到所有连接的客户端
+     */
+    broadcast(message) {
+        const data = JSON.stringify(message) + '\n';
+        for (const socket of this.connections) {
+            try {
+                socket.write(data);
+            }
+            catch (error) {
+                Logger.error('广播消息失败:', error);
+            }
+        }
+    }
+    /**
+     * 设置服务器事件监听
+     */
+    setupServerEvents() {
+        if (!this.server)
+            return;
+        this.server.on('error', (error) => {
+            Logger.error('Socket 服务器错误:', error);
+        });
+        this.server.on('close', () => {
+            Logger.log('Socket 服务器已关闭');
+        });
+    }
+    /**
+     * 启动 Socket 服务器
+     */
+    start(port) {
+        return new Promise((resolve, reject) => {
+            if (!this.server) {
+                reject(new Error('Socket 服务器未初始化'));
+                return;
+            }
+            this.port = port;
+            this.server.listen(port, () => {
+                Logger.log(`Socket server listening on port ${port}`);
+                resolve();
+            });
+            this.server.once('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+    /**
+     * 发送认证响应到指定 token 的客户端
+     */
+    sendSubmitResponse(token, data) {
+        const socket = this.tokenSockets.get(token);
+        if (!socket) {
+            Logger.warn(`未找到 token 对应的 socket: ${token}`);
+            return false;
+        }
+        try {
+            this.sendMessage(socket, {
+                type: 'submit-response',
+                token,
+                data,
+                timestamp: Date.now(),
+            });
+            // 发送后清理 token 映射
+            this.tokenSockets.delete(token);
+            Logger.log(`已发送认证响应到 token: ${token}`);
+            return true;
+        }
+        catch (error) {
+            Logger.error(`发送认证响应失败: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * 停止 Socket 服务器
+     */
+    stop() {
+        return new Promise((resolve) => {
+            // 关闭所有活跃连接
+            for (const socket of this.connections) {
+                socket.destroy();
+            }
+            this.connections.clear();
+            this.tokenSockets.clear();
+            this.messageBuffers.clear();
+            // 关闭服务器
+            if (this.server) {
+                this.server.close(() => {
+                    Logger.log('Socket 服务器已停止');
+                    this.server = null;
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    /**
+     * 获取当前连接数
+     */
+    getConnectionCount() {
+        return this.connections.size;
+    }
+    /**
+     * 获取服务器端口
+     */
+    getPort() {
+        return this.port;
+    }
+}

package/dist/build/utils/extract.js

@@ -70,25 +70,26 @@ export function extractJson(text) {
 /**
  * 从 markdown 文本中提取代码块
  * 遵循 CommonMark 规范，使用三个反引号包围的代码块格式
+ * 支持从代码块 info string 中提取组件名，格式：```language:ComponentName
  * @param text 包含 markdown 代码块的文本
  * @returns 提取到的代码块数组
  */
 export function extractCodeBlocks(text) {
     const trimmedText = text.trim();
-    // 匹配 markdown 代码块的正则表达式
-    // 兼容以下情况：
-    // - 结尾处没有换行直接关闭 ```
-    // - Windows 换行 \r\n
-    // - 语言标记包含短横线（如 "c++" 之类极少数场景，放宽为 [\w-]）
-    // 格式: ```language\ncode\n?```
-    const codeBlockRegex = /```([\w-]+)?\s*\r?\n([\s\S]*?)\r?\n?\s*```/g;
+    // 匹配带有组件名的代码块
+    // 格式: ```language:ComponentName\ncode\n```
+    // 组件名是可选的，通过冒号分隔
+    // 示例: ```tsx:UserCard 或 ```vue:ProductList
+    const codeBlockRegex = /```([\w-]+)(?::([A-Z][a-zA-Z0-9]*))?\s*\r?\n([\s\S]*?)\r?\n?\s*```/g;
     const codeBlocks = [];
     let match;
     while ((match = codeBlockRegex.exec(trimmedText)) !== null) {
         const language = match[1];
-        const code = match[2].trim();
+        const declaredComponentName = match[2]; // 从 info string 中提取的组件名（可能为 undefined）
+        const code = match[3].trim();
         if (code) {
-            const componentName = extractComponentName(code, language);
+            // 优先使用声明的组件名，否则降级到正则提取
+            const componentName = declaredComponentName || extractComponentName(code, language);
             codeBlocks.push({
                 language,
                 code,
@@ -99,6 +100,7 @@ export function extractCodeBlocks(text) {
     return codeBlocks;
 }
 /**
+ * @deprecated: 为支持跨框架已废弃，改为从模型返回中提取
  * 从代码中提取组件名
  * 支持多种常见的组件定义模式
  * @param code 代码内容

package/dist/build/utils/file-manager.js

@@ -46,7 +46,8 @@ export class FileManager {
      * @param filename - 文件名
      * @returns 完整的文件路径
      */
-    getWorkspaceFilePath(fileKey, nodeId, filename) {
+    getWorkspaceFilePath(fileKey, nodeId, filename, opts = { skipParsePath: false }) {
+        const { skipParsePath = false } = opts;
         if (!this.workspaceRoot) {
             console.error('工作目录根路径未设置,使用默认目录:', this.baseDir);
             return this.getFilePath(fileKey, nodeId, filename);
@@ -55,6 +56,9 @@ export class FileManager {
         const cleanFileKey = fileKey.replace(/[^a-zA-Z0-9-_]/g, '_');
         const cleanNodeId = nodeId ? nodeId.replace(/[^a-zA-Z0-9-_:]/g, '_') : 'root';
         const cleanFilename = filename.replace(/[^a-zA-Z0-9-_.]/g, '_');
+        if (skipParsePath) {
+            return path.join(this.workspaceRoot, '.sloth', fileKey, nodeId || 'root', cleanFilename);
+        }
         return path.join(this.workspaceRoot, '.sloth', cleanFileKey, cleanNodeId, cleanFilename);
     }
     /**
@@ -76,9 +80,10 @@ export class FileManager {
      * @param content - 文件内容
      * @param useWorkspaceDir - 是否使用工作目录
      */
-    async saveFile(fileKey, nodeId, filename, content, useWorkspaceDir = false) {
+    async saveFile(fileKey, nodeId, filename, content, opts = { useWorkspaceDir: false, skipParsePath: false }) {
+        const { useWorkspaceDir = false, ...restOpts } = opts;
         try {
-            const filePath = useWorkspaceDir ? this.getWorkspaceFilePath(fileKey, nodeId, filename) : this.getFilePath(fileKey, nodeId, filename);
+            const filePath = useWorkspaceDir ? this.getWorkspaceFilePath(fileKey, nodeId, filename, restOpts) : this.getFilePath(fileKey, nodeId, filename);
             // 确保目录存在
             await fs.mkdir(path.dirname(filePath), { recursive: true });
             // 保存文件内容
@@ -98,9 +103,10 @@ export class FileManager {
      * @param useWorkspaceDir - 是否使用工作目录
      * @returns Promise<string> - 文件内容，如果文件不存在则返回空字符串
      */
-    async loadFile(fileKey, nodeId, filename, useWorkspaceDir = false) {
+    async loadFile(fileKey, nodeId, filename, opts = { useWorkspaceDir: false, skipParsePath: false }) {
+        const { useWorkspaceDir = false, ...restOpts } = opts;
         try {
-            const filePath = useWorkspaceDir ? this.getWorkspaceFilePath(fileKey, nodeId, filename) : this.getFilePath(fileKey, nodeId, filename);
+            const filePath = useWorkspaceDir ? this.getWorkspaceFilePath(fileKey, nodeId, filename, restOpts) : this.getFilePath(fileKey, nodeId, filename);
             Logger.log(`加载文件: ${filePath}, workspaceRoot: ${this.workspaceRoot}`);
             const content = await fs.readFile(filePath, 'utf-8');
             return content;
@@ -238,7 +244,7 @@ export class FileManager {
      * @param groupsData - 分组数据
      */
     async saveGroupsData(fileKey, nodeId, groupsData) {
-        await this.saveFile(fileKey, nodeId, 'groupsData.json', JSON.stringify(groupsData, null, 2), true);
+        await this.saveFile(fileKey, nodeId, 'groupsData.json', JSON.stringify(groupsData, null, 2), { useWorkspaceDir: true, skipParsePath: false });
     }
     /**
      * 加载 groupsData 从特定的 nodeId 文件
@@ -248,7 +254,7 @@ export class FileManager {
      */
     async loadGroupsData(fileKey, nodeId) {
         try {
-            const content = await this.loadFile(fileKey, nodeId, 'groupsData.json', true);
+            const content = await this.loadFile(fileKey, nodeId, 'groupsData.json', { useWorkspaceDir: true, skipParsePath: false });
             return content ? JSON.parse(content) : [];
         }
         catch (error) {
@@ -263,7 +269,9 @@ export class FileManager {
      * @param promptSetting - 提示词设置
      */
     async savePromptSetting(fileKey, nodeId, promptSetting) {
-        await this.saveFile(fileKey, nodeId, 'promptSetting.json', JSON.stringify(promptSetting, null, 2), true);
+        fileKey = '.';
+        nodeId = '.';
+        await this.saveFile(fileKey, nodeId, 'promptSetting.json', JSON.stringify(promptSetting, null, 2), { useWorkspaceDir: true, skipParsePath: true });
     }
     /**
      * 加载 promptSetting 从特定的 nodeId 文件
@@ -272,8 +280,10 @@ export class FileManager {
      * @returns Promise<any> - 提示词设置，如果文件不存在则返回 null
      */
     async loadPromptSetting(fileKey, nodeId) {
+        fileKey = '.';
+        nodeId = '.';
         try {
-            const content = await this.loadFile(fileKey, nodeId, 'promptSetting.json', true);
+            const content = await this.loadFile(fileKey, nodeId, 'promptSetting.json', { useWorkspaceDir: true, skipParsePath: true });
             return content ? JSON.parse(content) : null;
         }
         catch (error) {
@@ -288,7 +298,9 @@ export class FileManager {
      * @param configSetting - 配置设置
      */
     async saveConfigSetting(fileKey, nodeId, configSetting) {
-        await this.saveFile(fileKey, nodeId, 'configSetting.json', JSON.stringify(configSetting, null, 2), true);
+        fileKey = '.';
+        nodeId = '.';
+        await this.saveFile(fileKey, nodeId, 'configSetting.json', JSON.stringify(configSetting, null, 2), { useWorkspaceDir: true, skipParsePath: true });
     }
     /**
      * 加载 configSetting 从特定的 nodeId 文件
@@ -297,8 +309,10 @@ export class FileManager {
      * @returns Promise<any> - 配置设置，如果文件不存在则返回 null
      */
     async loadConfigSetting(fileKey, nodeId) {
+        fileKey = '.';
+        nodeId = '.';
         try {
-            const content = await this.loadFile(fileKey, nodeId, 'configSetting.json', true);
+            const content = await this.loadFile(fileKey, nodeId, 'configSetting.json', { useWorkspaceDir: true, skipParsePath: true });
             return content ? JSON.parse(content) : null;
         }
         catch (error) {
@@ -598,5 +612,60 @@ export class FileManager {
             throw new Error(`无法写入文件: ${componentsPath}`);
         }
     }
+    /**
+     * 根据截图 hash 在整个 .sloth 目录下搜索截图文件
+     * @param hash - 截图文件的哈希值
+     * @returns Promise<string | null> - 截图文件的完整路径，如果未找到则返回 null
+     */
+    async findScreenshotByHash(hash) {
+        const workspaceRoot = this.getWorkspaceRoot();
+        if (!workspaceRoot) {
+            Logger.warn('工作目录根路径未设置，无法搜索截图');
+            return null;
+        }
+        const slothDir = path.join(workspaceRoot, '.sloth');
+        try {
+            await fs.access(slothDir);
+        }
+        catch {
+            Logger.warn('.sloth 目录不存在');
+            return null;
+        }
+        const targetFilename = `${hash}.png`;
+        // 递归搜索 .sloth 目录下所有 screenshots 文件夹
+        const searchDir = async (dir) => {
+            try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        // 如果是 screenshots 目录，检查是否有目标文件
+                        if (entry.name === 'screenshots') {
+                            const screenshotPath = path.join(fullPath, targetFilename);
+                            try {
+                                await fs.access(screenshotPath);
+                                return screenshotPath;
+                            }
+                            catch {
+                                // 文件不存在，继续搜索
+                            }
+                        }
+                        else {
+                            // 递归搜索子目录
+                            const result = await searchDir(fullPath);
+                            if (result)
+                                return result;
+                        }
+                    }
+                }
+                return null;
+            }
+            catch (error) {
+                Logger.error(`搜索目录失败 ${dir}:`, error);
+                return null;
+            }
+        };
+        return searchDir(slothDir);
+    }
 }
 export default FileManager;