sloth-d2c-mcp 1.0.4-beta100

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的数据（包含 clientApiSupport）
+     * @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 数据（clientApiSupport 已在 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 传输参数（包含 clientApiSupport）
+     * @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 传输参数（包含 clientApiSupport）
+ * @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');
+}

package/dist/build/plugin/index.js

@@ -0,0 +1,4 @@
+// 导出插件管理器
+export { pluginManager } from './manager.js';
+// 导出插件加载器函数
+export { installPlugin, uninstallPlugin, listPlugins, listWorkspacePlugins, loadAllPlugins, loadWorkspacePlugins, loadPlugin } from './loader.js';

package/dist/build/plugin/loader.js

@@ -0,0 +1,349 @@
+import { execSync } from 'child_process';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import envPaths from 'env-paths';
+import { PLUGIN_HOOKS } from './types.js';
+import { createRequire } from 'module';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// 检测是否存在 pnpm
+function hasPnpm() {
+    try {
+        execSync('pnpm --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// 获取包管理器命令
+function getPackageManager() {
+    return 'npm';
+}
+// 使用 env-paths 获取配置目录（与 config-manager 保持一致）
+const paths = envPaths('d2c-mcp');
+// 获取全局 sloth-d2c-mcp 包的目录
+function getGlobalPackageDir() {
+    // 在构建后的目录中: dist/build/plugin/loader.js
+    // 需要向上三级才能找到包根目录
+    // return path.resolve(__dirname, '..', '..', '..')
+    try {
+        const pm = getPackageManager();
+        return execSync(`${pm} root -g`, { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+// 获取全局插件配置文件路径（与 config.json 在同一目录）
+function getGlobalPluginsConfigPath() {
+    return path.join(paths.config, 'plugins.json');
+}
+// 获取工作区插件目录路径
+function getWorkspacePluginDir(workspaceRoot) {
+    return path.join(workspaceRoot, '.sloth', 'plugin');
+}
+// 获取工作区插件配置文件路径
+function getWorkspacePluginsConfigPath(workspaceRoot) {
+    return path.join(getWorkspacePluginDir(workspaceRoot), 'plugins.json');
+}
+// 加载全局插件配置
+async function loadGlobalPluginsConfig() {
+    const configPath = getGlobalPluginsConfigPath();
+    try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { plugins: [] };
+    }
+}
+// 保存全局插件配置
+async function saveGlobalPluginsConfig(config) {
+    const configPath = getGlobalPluginsConfigPath();
+    // 确保目录存在
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}
+// 加载工作区插件配置
+async function loadWorkspacePluginsConfig(workspaceRoot) {
+    const configPath = getWorkspacePluginsConfigPath(workspaceRoot);
+    try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { plugins: [] };
+    }
+}
+export async function loadPluginFromGlobalDirAsync(packageName) {
+    const globalDir = getGlobalPackageDir();
+    const require = createRequire(path.join(globalDir));
+    const resolvedPath = require.resolve(packageName);
+    return await import(resolvedPath);
+}
+/**
+ * 解析插件配置项，统一返回 { name, config } 格式
+ */
+function parsePluginConfigItem(item) {
+    if (typeof item === 'string') {
+        return { name: item };
+    }
+    return { name: item.name, config: item.config };
+}
+// 检查本地插件是否存在
+async function checkLocalPlugin(workspaceRoot, pluginName) {
+    const pluginDir = getWorkspacePluginDir(workspaceRoot);
+    const localPluginPath = path.join(pluginDir, pluginName, 'index.cjs');
+    try {
+        await fs.access(localPluginPath);
+        return localPluginPath;
+    }
+    catch {
+        return null;
+    }
+}
+// 检查 npm 包是否已安装
+async function isNpmPackageInstalled(packageName) {
+    try {
+        await loadPluginFromGlobalDirAsync(packageName);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// 尝试安装 npm 包
+async function tryInstallNpmPackage(packageName) {
+    const globalDir = getGlobalPackageDir();
+    const pm = getPackageManager();
+    try {
+        console.log(`[sloth] 尝试安装插件包: ${packageName}`);
+        execSync(`${pm} install ${packageName}`, {
+            cwd: globalDir,
+            stdio: 'pipe',
+        });
+        return true;
+    }
+    catch (error) {
+        console.error(`[sloth] 安装插件包 ${packageName} 失败:`, error);
+        return false;
+    }
+}
+/**
+ * 安装插件 npm 包到全局（sloth add 命令）
+ * 注意：这只是安装到全局，不会直接生效
+ * 需要在工作区的 .sloth/plugin/plugins.json 中声明才会生效
+ * @param packageName 插件包名
+ */
+export async function installPlugin(packageName) {
+    const globalDir = getGlobalPackageDir();
+    console.log(`[sloth] 正在安装插件: ${packageName}`);
+    // console.log(`[sloth] 安装目录: ${globalDir}`)
+    try {
+        const pm = getPackageManager();
+        // 在全局包目录下执行安装
+        execSync(`${pm} install -g ${packageName}`, {
+            cwd: globalDir,
+            stdio: 'inherit',
+        });
+        // 更新全局插件配置（记录已安装的插件）
+        const config = await loadGlobalPluginsConfig();
+        const existingNames = config.plugins.map(item => parsePluginConfigItem(item).name);
+        if (!existingNames.includes(packageName)) {
+            config.plugins.push(packageName);
+            await saveGlobalPluginsConfig(config);
+        }
+        console.log(`[sloth] 插件 ${packageName} 安装成功`);
+        console.log(`[sloth] 注意：需要在工作区的 .sloth/plugin/plugins.json 中声明才会生效`);
+        return {
+            success: true,
+            message: `插件 ${packageName} 安装成功。请在工作区的 .sloth/plugin/plugins.json 中添加该插件以启用。`
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`[sloth] 插件安装失败: ${errorMessage}`);
+        return { success: false, message: `插件安装失败: ${errorMessage}` };
+    }
+}
+/**
+ * 卸载插件 npm 包
+ * @param packageName 插件包名
+ */
+export async function uninstallPlugin(packageName) {
+    const globalDir = getGlobalPackageDir();
+    console.log(`[sloth] 正在卸载插件: ${packageName}`);
+    try {
+        const pm = getPackageManager();
+        // 在全局包目录下执行卸载
+        execSync(`${pm} uninstall ${packageName}`, {
+            cwd: globalDir,
+            stdio: 'inherit',
+        });
+        // 更新全局插件配置
+        const config = await loadGlobalPluginsConfig();
+        config.plugins = config.plugins.filter((p) => parsePluginConfigItem(p).name !== packageName);
+        await saveGlobalPluginsConfig(config);
+        console.log(`[sloth] 插件 ${packageName} 卸载成功`);
+        return { success: true, message: `插件 ${packageName} 卸载成功` };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`[sloth] 插件卸载失败: ${errorMessage}`);
+        return { success: false, message: `插件卸载失败: ${errorMessage}` };
+    }
+}
+/**
+ * 列出全局已安装的插件
+ */
+export async function listPlugins() {
+    const config = await loadGlobalPluginsConfig();
+    return config.plugins.map(item => parsePluginConfigItem(item).name);
+}
+/**
+ * 列出工作区声明的插件
+ * @param workspaceRoot 工作区根目录
+ */
+export async function listWorkspacePlugins(workspaceRoot) {
+    const config = await loadWorkspacePluginsConfig(workspaceRoot);
+    return config.plugins.map(item => parsePluginConfigItem(item));
+}
+/**
+ * 校验并加载工作区声明的所有插件
+ * 1. 先尝试查找 .sloth/plugin/ 文件夹下的本地插件
+ * 2. 再尝试通过 pnpm/npm 安装声明的 npm 包
+ * 3. 都失败则抛出错误
+ * @param workspaceRoot 工作区根目录
+ */
+export async function loadWorkspacePlugins(workspaceRoot) {
+    const config = await loadWorkspacePluginsConfig(workspaceRoot);
+    const plugins = [];
+    const failedPlugins = [];
+    console.log(`[sloth] 开始加载工作区插件，工作区: ${workspaceRoot}`);
+    const pluginNames = config.plugins.map(item => parsePluginConfigItem(item).name);
+    console.log(`[sloth] 声明的插件: ${pluginNames.join(', ') || '无'}`);
+    for (const pluginItem of config.plugins) {
+        const { name: pluginName, config: pluginConfig } = parsePluginConfigItem(pluginItem);
+        let loaded = false;
+        console.log('pluginConfig', pluginConfig);
+        // 1. 先尝试查找本地插件
+        const localPluginPath = await checkLocalPlugin(workspaceRoot, pluginName);
+        if (localPluginPath) {
+            try {
+                console.log(`[sloth] 尝试加载本地插件: ${localPluginPath}`);
+                const pluginModule = await import(localPluginPath);
+                const plugin = {
+                    name: pluginName,
+                    // 只取出PluginHooks
+                    ...PLUGIN_HOOKS.reduce((acc, hookName) => {
+                        acc[hookName] = (pluginModule.default || pluginModule)[hookName];
+                        return acc;
+                    }, {}),
+                    // ...(pluginModule.default || pluginModule),
+                    _config: pluginConfig,
+                };
+                plugins.push(plugin);
+                console.log(`[sloth] 本地插件 ${pluginName} 加载成功`);
+                loaded = true;
+            }
+            catch (error) {
+                console.error(`[sloth] 本地插件 ${pluginName} 加载失败:`, error);
+            }
+        }
+        // 2. 如果本地插件不存在或加载失败，尝试加载 npm 包
+        if (!loaded) {
+            // 检查是否已安装
+            const isInstalled = await isNpmPackageInstalled(pluginName);
+            if (!isInstalled) {
+                // 尝试安装
+                console.log(`[sloth] 插件 ${pluginName} 未安装，尝试安装...`);
+                // const installSuccess = await tryInstallNpmPackage(pluginName)
+                // if (!installSuccess) {
+                //   failedPlugins.push(pluginName)
+                //   continue
+                // }
+            }
+            // 加载 npm 包
+            try {
+                const pluginModule = await loadPluginFromGlobalDirAsync(pluginName);
+                console.log('pluginModule', pluginModule);
+                const plugin = {
+                    name: pluginName,
+                    ...PLUGIN_HOOKS.reduce((acc, hookName) => {
+                        acc[hookName] = (pluginModule.default || pluginModule)[hookName];
+                        return acc;
+                    }, {}),
+                    _config: pluginConfig,
+                };
+                plugins.push(plugin);
+                console.log(`[sloth] npm 插件 ${pluginName} 加载成功`);
+                loaded = true;
+            }
+            catch (error) {
+                console.error(`[sloth] npm 插件 ${pluginName} 加载失败:`, error);
+                failedPlugins.push(pluginName);
+            }
+        }
+    }
+    // 如果有插件加载失败，打印错误
+    if (failedPlugins.length > 0) {
+        console.error(`以下插件加载失败: ${failedPlugins.join(', ')}。` +
+            `请确保插件存在于 .sloth/plugin/<pluginName>/index.js 或为有效的 npm 包。`);
+    }
+    return plugins;
+}
+/**
+ * 动态加载所有已安装的全局插件（旧方法，保留兼容）
+ * @deprecated 请使用 loadWorkspacePlugins 代替
+ */
+export async function loadAllPlugins() {
+    const config = await loadGlobalPluginsConfig();
+    const plugins = [];
+    for (const pluginItem of config.plugins) {
+        const { name: packageName, config: pluginConfig } = parsePluginConfigItem(pluginItem);
+        try {
+            // 动态导入插件模块
+            const pluginModule = await import(packageName);
+            console.log('pluginModule', pluginModule);
+            console.log('pluginConfig', pluginConfig);
+            const plugin = {
+                name: packageName,
+                ...PLUGIN_HOOKS.reduce((acc, hookName) => {
+                    acc[hookName] = (pluginModule.default || pluginModule)[hookName];
+                    return acc;
+                }, {}),
+                _config: pluginConfig,
+            };
+            plugins.push(plugin);
+            console.log(`[sloth] 插件 ${packageName} 加载成功`);
+        }
+        catch (error) {
+            console.error(`[sloth] 插件 ${packageName} 加载失败:`, error);
+        }
+    }
+    return plugins;
+}
+/**
+ * 动态加载单个插件
+ * @param packageName 插件包名
+ */
+export async function loadPlugin(packageName) {
+    try {
+        const pluginModule = await import(packageName);
+        const plugin = {
+            name: packageName,
+            ...PLUGIN_HOOKS.reduce((acc, hookName) => {
+                acc[hookName] = (pluginModule.default || pluginModule)[hookName];
+                return acc;
+            }, {}),
+        };
+        console.log(`[sloth] 插件 ${packageName} 加载成功`);
+        return plugin;
+    }
+    catch (error) {
+        console.error(`[sloth] 插件 ${packageName} 加载失败:`, error);
+        return null;
+    }
+}