sloth-d2c-mcp 1.0.4-beta65

package/dist/build/interceptor/client.js

@@ -0,0 +1,142 @@
+import express from 'express';
+import http from 'http';
+import { v4 as uuidv4 } from 'uuid';
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+// ES模块中获取__dirname的替代方案
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// 存储等待中的请求 { token: { resolve } }
+const pendingRequests = new Map();
+let server = null;
+let app = null;
+let serverPort = 3005;
+// 初始化Express应用和服务器
+function initializeServer() {
+    if (app && server) {
+        return Promise.resolve(); // 已经初始化过了
+    }
+    return new Promise((resolve, reject) => {
+        app = express();
+        app.use(express.urlencoded({ extended: true }));
+        app.use(express.json());
+        // 接收Tauri应用发送的数据
+        app.post('/callback/:token', (req, res) => {
+            const token = req.params.token;
+            const { result } = req.body;
+            console.log(`收到来自Tauri应用的数据 - Token: ${token}, Result: ${result}`);
+            const request = pendingRequests.get(token);
+            if (request && request.resolve) {
+                request.resolve(result);
+                res.json({ success: true, message: 'Data received successfully' });
+            }
+            else {
+                res.status(404).json({ success: false, message: 'Invalid or expired token' });
+            }
+        });
+        // 启动服务器，如果端口被占用则尝试下一个端口
+        server = http.createServer(app);
+        const tryListen = (port) => {
+            server.listen(port, () => {
+                serverPort = port;
+                console.log(`Tauri callback server running on http://localhost:${port}`);
+                resolve();
+            });
+            server.on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    console.log(`Port ${port} is busy, trying ${port + 1}...`);
+                    tryListen(port + 1);
+                }
+                else {
+                    reject(err);
+                }
+            });
+        };
+        tryListen(serverPort);
+    });
+}
+// 打开Tauri应用并获取用户输入
+export async function getUserInputFromTauri(prompt = "Please provide input") {
+    return new Promise(async (resolve, reject) => {
+        try {
+            // 确保服务器已初始化
+            await initializeServer();
+        }
+        catch (error) {
+            reject(new Error(`Failed to initialize server: ${error}`));
+            return;
+        }
+        const token = uuidv4();
+        // 声明heartbeat变量
+        let heartbeat;
+        // 设置超时 - 增加到10分钟
+        const timeout = setTimeout(() => {
+            if (pendingRequests.has(token)) {
+                pendingRequests.delete(token);
+                clearInterval(heartbeat);
+                console.log(`Token ${token} 超时，用户未在10分钟内提供输入`);
+                reject(new Error('Timeout: User did not provide input within 10 minutes'));
+            }
+        }, 600000); // 10分钟超时
+        console.log(`Token ${token} 已创建，等待用户输入...`);
+        // 添加心跳机制，每30秒输出一次状态
+        heartbeat = setInterval(() => {
+            if (pendingRequests.has(token)) {
+                console.log(`Token ${token} 仍在等待用户输入...`);
+            }
+        }, 30000);
+        // 存储解析函数
+        pendingRequests.set(token, {
+            resolve: (value) => {
+                console.log(`Token ${token} 收到用户输入，正在解析...`);
+                clearTimeout(timeout);
+                clearInterval(heartbeat);
+                pendingRequests.delete(token);
+                resolve(value);
+            },
+            timeout
+        });
+        // 启动Tauri应用
+        const tauriAppPath = path.resolve(__dirname, '../../client');
+        console.log(`正在启动Tauri应用: ${tauriAppPath}`);
+        console.log(`Token: ${token}`);
+        // 设置环境变量传递token和端口
+        const env = {
+            ...process.env,
+            MCP_TOKEN: token,
+            MCP_PORT: serverPort.toString()
+        };
+        // 使用pnpm tauri dev启动应用
+        const tauriProcess = spawn('pnpm', ['tauri', 'dev'], {
+            cwd: tauriAppPath,
+            stdio: 'ignore',
+            detached: false,
+            env: env
+        });
+        tauriProcess.stdout?.on('data', (data) => {
+            console.log(`Tauri stdout: ${data}`);
+        });
+        tauriProcess.stderr?.on('data', (data) => {
+            console.error(`Tauri stderr: ${data}`);
+        });
+        tauriProcess.on('error', (error) => {
+            clearTimeout(timeout);
+            clearInterval(heartbeat);
+            pendingRequests.delete(token);
+            reject(new Error(`Failed to start Tauri app: ${error.message}`));
+        });
+        tauriProcess.on('close', (code) => {
+            console.log(`Tauri process exited with code ${code}`);
+        });
+    });
+}
+// 清理函数
+export function cleanup() {
+    if (server) {
+        server.close();
+        server = null;
+        app = null;
+    }
+    pendingRequests.clear();
+}

package/dist/build/interceptor/vscode.js

@@ -0,0 +1,143 @@
+import * as net from 'net';
+/**
+ * 与VSCode扩展通信的工具类
+ */
+export class VSCodeCommunicator {
+    host = '127.0.0.1';
+    port = 13141;
+    // 新增: 生成会话ID
+    generateSessionId() {
+        return `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+    }
+    /**
+     * 长连接模式 - 直接等待用户输入，无超时限制
+     * @param sessionId 会话ID
+     * @param payload 传递给webview的数据
+     * @returns Promise<string> 返回用户输入的数据
+     */
+    waitForUserInputLongConnection(sessionId, payload) {
+        return new Promise((resolve, reject) => {
+            const client = net.connect({ port: this.port, host: this.host }, () => {
+                console.log(`[MCP] 建立长连接等待用户输入，会话ID: ${sessionId}`);
+                // 发送长连接等待命令，包含 payload 数据
+                const requestPayload = JSON.stringify({
+                    cmd: 'waitForInput',
+                    sessionId,
+                    payload: payload
+                });
+                client.write(requestPayload);
+            });
+            let isResolved = false;
+            client.on('data', (data) => {
+                const response = data.toString();
+                console.log('[MCP] 收到响应:', response);
+                if (response === 'WAITING_FOR_INPUT') {
+                    console.log('[MCP] 服务器确认等待状态，webview已打开，等待用户输入...');
+                }
+                else if (response === 'SERVER_STOPPING') {
+                    if (!isResolved) {
+                        isResolved = true;
+                        client.end();
+                        reject(new Error('服务器正在关闭'));
+                    }
+                }
+                else {
+                    // 收到用户数据
+                    if (!isResolved) {
+                        isResolved = true;
+                        console.log('[MCP] 成功获取用户输入:', response);
+                        resolve(response);
+                    }
+                }
+            });
+            client.on('error', (err) => {
+                if (!isResolved) {
+                    isResolved = true;
+                    reject(new Error(`VSCode扩展连接失败: ${err.message}`));
+                }
+            });
+            client.on('close', () => {
+                if (!isResolved) {
+                    isResolved = true;
+                    reject(new Error('连接意外关闭'));
+                }
+            });
+        });
+    }
+    /**
+     * 从VSCode获取用户输入 - 主要方法
+     * 使用长连接模式，无超时限制
+     * @param payload 传输参数
+     * @returns Promise<string> 返回用户输入的数据
+     */
+    async getUserInputFromVSCode(payload) {
+        try {
+            console.log('[MCP] 正在打开VSCode webview表单...');
+            // 生成会话ID
+            const sessionId = this.generateSessionId();
+            console.log(`[MCP] 生成会话ID: ${sessionId}`);
+            console.log('[MCP] 请在VSCode webview中输入内容并提交...');
+            console.log('[MCP] 使用长连接模式，无超时限制，请耐心等待用户输入');
+            // 使用长连接模式等待用户输入
+            return await this.waitForUserInputLongConnection(sessionId, payload);
+        }
+        catch (error) {
+            throw new Error(`获取用户输入失败: ${error}`);
+        }
+    }
+    /**
+     * 检查VSCode扩展是否可用
+     * @returns Promise<boolean> 返回扩展是否可用
+     */
+    async isVSCodeExtensionAvailable() {
+        try {
+            // 简单的连接测试
+            const client = net.connect({ port: this.port, host: this.host });
+            return new Promise((resolve) => {
+                client.on('connect', () => {
+                    client.end();
+                    resolve(true);
+                });
+                client.on('error', () => {
+                    resolve(false);
+                });
+                setTimeout(() => {
+                    client.destroy();
+                    resolve(false);
+                }, 1000);
+            });
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}
+// 创建单例实例
+const vscodeComm = new VSCodeCommunicator();
+/**
+ * 从VSCode获取用户输入的便捷函数
+ * @param payload 传输参数
+ * @returns Promise<string> 返回用户输入的数据
+ */
+export async function getUserInputFromVSCode(payload) {
+    return vscodeComm.getUserInputFromVSCode(payload);
+}
+/**
+ * 检查VSCode扩展是否可用的便捷函数
+ * @returns Promise<boolean> 返回扩展是否可用
+ */
+export async function isVSCodeAvailable() {
+    return vscodeComm.isVSCodeExtensionAvailable();
+}
+/**
+ * 清理资源的函数
+ */
+export function cleanup() {
+    console.log('[MCP] VSCode通信模块清理完成');
+    // 这里可以添加任何需要清理的资源
+    // 比如关闭连接池、清理缓存等
+}
+/**
+ * 导出通信器实例，供高级用法使用
+ */
+export { vscodeComm };

package/dist/build/interceptor/web.js

@@ -0,0 +1,28 @@
+import { getUserInput as getServerUserInput } from '../server.js';
+import ConfigManager from '../config-manager/index.js';
+const configManager = new ConfigManager("d2c-mcp");
+// 获取用户输入的主函数 - 现在使用共享的MCP服务器
+export async function getUserInput(payload) {
+    try {
+        return await getServerUserInput(payload);
+    }
+    catch (error) {
+        throw new Error(`Failed to get user input: ${error.message}`);
+    }
+}
+// 获取配置的辅助函数
+export async function getConfig() {
+    if (await configManager.exists()) {
+        return await configManager.load();
+    }
+    return {};
+}
+// 保存配置的辅助函数
+export async function saveConfig(config) {
+    await configManager.save(config);
+}
+// 清理函数 - 现在只需要清理本地资源
+export function cleanup() {
+    // 本地清理逻辑，如果有的话
+    console.log('Web interceptor cleanup completed');
+}