sloth-d2c-mcp 1.0.4-beta100

package/dist/build/socket-client.js

@@ -0,0 +1,166 @@
+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，等待认证响应
+     * @param token 认证 token
+     * @param extra 额外数据（可选），如 { workspaceRoot: string, ... }
+     */
+    registerToken(token, extra) {
+        return new Promise((resolve, reject) => {
+            // 设置超时（可选，根据需求调整）
+            const timeout = setTimeout(() => {
+                this.messageHandlers.delete(token);
+                reject(new Error('等待认证响应超时'));
+            }, 30 * 60 * 1000); // 30分钟超时
+            // 注册消息处理器
+            this.messageHandlers.set(token, (data) => {
+                clearTimeout(timeout);
+                resolve(JSON.stringify(data));
+            });
+            // 发送注册消息到服务器
+            this.send({
+                type: 'register-token',
+                token,
+                extra,
+                timestamp: Date.now(),
+            });
+            Logger.log(`已注册 token: ${token}，extra: ${JSON.stringify(extra)}，等待认证响应...`);
+        });
+    }
+    /**
+     * 发送 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,260 @@
+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 映射
+    tokenExtras = new Map(); // token -> extra 数据映射
+    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);
+                    this.tokenExtras.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);
+                    // 保存 extra 数据（如果提供）
+                    if (message.extra && typeof message.extra === 'object') {
+                        this.tokenExtras.set(message.token, message.extra);
+                        Logger.log(`已保存 extra 数据: ${message.token} -> ${JSON.stringify(message.extra)}`);
+                    }
+                    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.tokenExtras.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;
+    }
+    /**
+     * 根据 token 获取对应的 extra 数据
+     */
+    getTokenExtra(token) {
+        return this.tokenExtras.get(token);
+    }
+    /**
+     * 根据 token 获取 extra 中的特定字段
+     */
+    getTokenExtraField(token, field) {
+        const extra = this.tokenExtras.get(token);
+        return extra?.[field];
+    }
+    /**
+     * 获取所有已注册的 token extra 映射
+     */
+    getAllTokenExtras() {
+        return new Map(this.tokenExtras);
+    }
+}

package/dist/build/utils/client-capabilities.js

@@ -0,0 +1,143 @@
+import { Logger } from './logger.js';
+// 缓存检测结果，避免重复检测
+let cachedCapabilities = null;
+/**
+ * 检测 MCP Client 的 API 支持程度
+ * @param mcpServer MCP 服务器实例
+ * @param forceRecheck 是否强制重新检测（忽略缓存）
+ * @returns ClientApiSupport 对象
+ */
+export async function detectClientApiSupport(mcpServer, forceRecheck = false) {
+    // 使用缓存
+    if (cachedCapabilities && !forceRecheck) {
+        return cachedCapabilities;
+    }
+    const support = {
+        sampling: false,
+        roots: false,
+    };
+    try {
+        // 方法1: 通过 capabilities 协商机制检测
+        // MCP SDK 在连接时会进行能力协商
+        const serverInstance = mcpServer.server;
+        // 尝试获取客户端能力
+        if (typeof serverInstance.getClientCapabilities === 'function') {
+            const clientCapabilities = serverInstance.getClientCapabilities();
+            Logger.log('客户端能力:', JSON.stringify(clientCapabilities, null, 2));
+            if (clientCapabilities) {
+                // 检查 sampling 能力
+                support.sampling = clientCapabilities.sampling !== undefined;
+                // 检查 roots 能力
+                support.roots = clientCapabilities.roots !== undefined;
+            }
+        }
+        // 方法2: 如果 capabilities 检测不到，通过 try-catch 探测
+        // 检测 roots 支持
+        if (!support.roots) {
+            support.roots = await probeRootsSupport(mcpServer);
+        }
+        // 检测 sampling 支持（仅当 capabilities 未声明时才探测）
+        if (!support.sampling) {
+            support.sampling = await probeSamplingSupport(mcpServer);
+        }
+    }
+    catch (error) {
+        Logger.log('检测客户端能力时出错:', error);
+    }
+    // 缓存结果
+    cachedCapabilities = support;
+    Logger.log('MCP Client API 支持检测结果:', support);
+    return support;
+}
+/**
+ * 探测 listRoots API 支持
+ */
+async function probeRootsSupport(mcpServer) {
+    try {
+        const result = await mcpServer.server.listRoots();
+        // 如果调用成功，说明支持
+        return result !== undefined;
+    }
+    catch (error) {
+        // 检查错误类型
+        const errorMessage = error?.message || String(error);
+        const errorCode = error?.code;
+        // Method not found 或明确不支持的错误
+        if (errorCode === -32601 ||
+            errorMessage.includes('not supported') ||
+            errorMessage.includes('not implemented') ||
+            errorMessage.includes('Method not found')) {
+            return false;
+        }
+        // 其他错误（如超时、网络问题）可能是暂时性的，保守认为支持
+        Logger.log('探测 listRoots 时出现非致命错误:', errorMessage);
+        return false;
+    }
+}
+/**
+ * 探测 createMessage (sampling) API 支持
+ * 注意：这个探测可能会产生实际的 API 调用，应谨慎使用
+ */
+async function probeSamplingSupport(mcpServer) {
+    try {
+        // 使用最小化的测试请求
+        // 注意：某些客户端可能会实际执行这个请求，所以使用非常小的 maxTokens
+        await mcpServer.server.createMessage({
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: 'ping', // 最小化测试消息
+                    },
+                },
+            ],
+            maxTokens: 1, // 最小化 token 消耗
+        }, {
+            timeout: 10000, // 10秒超时
+        });
+        // 如果调用成功，说明支持
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error?.message || String(error);
+        const errorCode = error?.code;
+        // Method not found 或明确不支持的错误
+        if (errorCode === -32601 ||
+            errorMessage.includes('not supported') ||
+            errorMessage.includes('not implemented') ||
+            errorMessage.includes('Method not found') ||
+            errorMessage.includes('Sampling not supported')) {
+            Logger.log('客户端不支持 sampling API');
+            return false;
+        }
+        // 超时或其他错误，可能是支持但调用失败
+        // 保守处理：认为不支持，让业务逻辑走降级路径
+        Logger.log('探测 sampling 时出现错误:', errorMessage);
+        return false;
+    }
+}
+/**
+ * 清除缓存的能力检测结果
+ * 在重新连接时应调用此方法
+ */
+export function clearCapabilitiesCache() {
+    cachedCapabilities = null;
+    Logger.log('已清除客户端能力缓存');
+}
+/**
+ * 检查是否支持 sampling
+ * 便捷方法，直接返回 boolean
+ */
+export async function isSamplingSupported(mcpServer) {
+    const support = await detectClientApiSupport(mcpServer);
+    return support.sampling;
+}
+/**
+ * 检查是否支持 roots
+ * 便捷方法，直接返回 boolean
+ */
+export async function isRootsSupported(mcpServer) {
+    const support = await detectClientApiSupport(mcpServer);
+    return support.roots;
+}