sloth-d2c-mcp 1.0.4-beta65

package/dist/build/server.js

@@ -0,0 +1,539 @@
+import { randomUUID } from 'node:crypto';
+import express from 'express';
+// 流式 HTTP 传输实现
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+// 判断是否为初始化请求
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+// 日志工具类，带时间戳输出日志
+import { Logger } from './utils/logger.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { v4 as uuidv4 } from 'uuid';
+import open from 'open';
+import FileManager from './utils/file-manager.js';
+import * as flatted from 'flatted';
+// 导入默认提示词
+import { chunkOptimizeCodePrompt, aggregationOptimizeCodePrompt, finalOptimizeCodePrompt } from 'sloth-d2c-node/convert';
+// 保存 HTTP 服务器实例
+let httpServer = null;
+// 管理所有活跃的传输对象，按 sessionId 分类
+const transports = {
+    streamable: {}, // 流式 HTTP 传输
+    sse: {}, // SSE 传输
+};
+// 认证功能存储
+const pendingRequests = new Map(); // 等待中的认证请求
+let configStorage = {}; // 配置缓存
+let configManager = null; // 配置管理器实例
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// 获取端口号
+let PORT = 0;
+export async function loadConfig(mcpServer, configManagerInstance) {
+    if (configManagerInstance) {
+        configManager = configManagerInstance;
+        // 打印配置文件路径
+        try {
+            const configPath = configManager.getConfigPath();
+            Logger.log(`配置文件路径: ${configPath}`);
+            // 检查配置文件是否存在
+            const configExists = await configManager.exists();
+            Logger.log(`配置文件存在: ${configExists ? '是' : '否'}`);
+            if (configExists) {
+                // 如果配置文件存在，加载并显示配置信息
+                try {
+                    const config = await configManager.load();
+                    mcpServer.setConfig(config.mcp);
+                    Logger.log(`当前配置内容: ${JSON.stringify(config, null, 2)}`);
+                }
+                catch (error) {
+                    Logger.warn(`读取配置文件失败: ${error}`);
+                }
+            }
+        }
+        catch (error) {
+            Logger.error(`获取配置信息时出错: ${error}`);
+        }
+    }
+}
+// 启动 HTTP 服务器，监听指定端口，注册各类路由
+export async function startHttpServer(port = PORT, mcpServer, configManagerInstance, isWeb) {
+    const app = express();
+    PORT = port;
+    // 存储配置管理器实例（如果提供）
+    loadConfig(mcpServer, configManagerInstance);
+    // if (configManagerInstance) {
+    //   configManager = configManagerInstance;
+    //   // 打印配置文件路径
+    //   try {
+    //     const configPath = configManager.getConfigPath();
+    //     Logger.log(`配置文件路径: ${configPath}`);
+    //     // 检查配置文件是否存在
+    //     const configExists = await configManager.exists();
+    //     Logger.log(`配置文件存在: ${configExists ? '是' : '否'}`);
+    //     if (configExists) {
+    //       // 如果配置文件存在，加载并显示配置信息
+    //       try {
+    //         const config = await configManager.load();
+    //         mcpServer.setConfig(config.mcp);
+    //         Logger.log(`当前配置内容: ${JSON.stringify(config, null, 2)}`);
+    //       } catch (error) {
+    //         Logger.warn(`读取配置文件失败: ${error}`);
+    //       }
+    //     }
+    //   } catch (error) {
+    //     Logger.error(`获取配置信息时出错: ${error}`);
+    //   }
+    // }
+    // 仅对 /mcp /submit 路径解析 JSON 请求体，避免影响 SSE
+    app.use('/mcp', express.json());
+    app.use('/submit', express.json());
+    app.use('/saveNodes', express.json({
+        limit: '100mb'
+    }));
+    // 为认证端点添加中间件 - 需要同时支持 JSON 和表单数据
+    app.use(express.urlencoded({ extended: true }));
+    // 设置跨域
+    app.use((req, res, next) => {
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Methods', 'GET, POST');
+        res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, Content-Length, X-Requested-With');
+        next();
+    });
+    // app.use(express.json());
+    // 处理流式 HTTP 的 POST 请求，支持会话复用和初始化
+    app.post('/mcp', async (req, res) => {
+        Logger.log('Received StreamableHTTP request');
+        const sessionId = req.headers['mcp-session-id']; // 获取会话ID
+        let transport;
+        if (sessionId && transports.streamable[sessionId]) {
+            // 已有会话，复用传输对象
+            Logger.log('Reusing existing StreamableHTTP transport for sessionId', sessionId);
+            transport = transports.streamable[sessionId];
+        }
+        else if (!sessionId && isInitializeRequest(req.body)) {
+            // 新会话初始化请求
+            Logger.log('New initialization request for StreamableHTTP sessionId', sessionId);
+            transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(), // 生成唯一 sessionId
+                onsessioninitialized: (sessionId) => {
+                    // 会话初始化后，存储传输对象
+                    transports.streamable[sessionId] = transport;
+                },
+            });
+            // 会话关闭时清理资源
+            transport.onclose = () => {
+                if (transport.sessionId) {
+                    delete transports.streamable[transport.sessionId];
+                }
+            };
+            // 连接 MCP 服务器，建立上下文
+            if (isWeb === true) {
+                await mcpServer.connect(transport);
+            }
+        }
+        else {
+            // 非法请求，缺少有效 sessionId
+            Logger.log('Invalid request:', req.body);
+            res.status(400).json({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32000,
+                    message: 'Bad Request: No valid session ID provided',
+                },
+                id: null,
+            });
+            return;
+        }
+        // 进度通知相关逻辑
+        let progressInterval = null;
+        const progressToken = req.body.params?._meta?.progressToken; // 获取进度令牌
+        let progress = 0;
+        Logger.log(`progressToken:${progressToken}`);
+        if (progressToken) {
+            Logger.log(`Setting up progress notifications for token ${progressToken} on session ${sessionId} 1112222222`);
+            // 定时发送进度通知
+            progressInterval = setInterval(async () => {
+                // Logger.log("Sending progress notification", progress);
+                await mcpServer.server.notification({
+                    method: 'notifications/progress',
+                    params: {
+                        progress,
+                        progressToken,
+                    },
+                });
+                progress++;
+            }, 1000);
+        }
+        Logger.log('Handling StreamableHTTP request');
+        // 处理请求，响应客户端
+        await transport.handleRequest(req, res, req.body);
+        // 清理进度通知定时器
+        // if (progressInterval) {
+        //   clearInterval(progressInterval);
+        // }
+        Logger.log('StreamableHTTP request handled');
+    });
+    // 处理 GET/DELETE 请求，用于会话终止或获取会话状态
+    const handleSessionRequest = async (req, res) => {
+        const sessionId = req.headers['mcp-session-id'];
+        if (!sessionId || !transports.streamable[sessionId]) {
+            res.status(400).send('Invalid or missing session ID');
+            return;
+        }
+        Logger.log(`Received session termination request for session ${sessionId}`);
+        try {
+            const transport = transports.streamable[sessionId];
+            await transport.handleRequest(req, res);
+        }
+        catch (error) {
+            console.error('Error handling session termination:', error);
+            if (!res.headersSent) {
+                res.status(500).send('Error processing session termination');
+            }
+        }
+    };
+    // GET 请求：获取会话状态
+    app.get('/mcp', handleSessionRequest);
+    // DELETE 请求：终止会话
+    app.delete('/mcp', handleSessionRequest);
+    // SSE 连接建立，分配 sessionId 并注册到 transports.sse
+    // app.get("/sse", async (req: any, res: any) => {
+    //   Logger.log("Establishing new SSE connection");
+    //   const transport = new SSEServerTransport("/messages", res);
+    //   Logger.log(`New SSE connection established for sessionId ${transport.sessionId}`);
+    //   Logger.log("/sse request headers:", req.headers);
+    //   Logger.log("/sse request body:", req.body);
+    //   transports.sse[transport.sessionId] = transport;
+    //   // 连接关闭时清理资源
+    //   res.on("close", () => {
+    //     delete transports.sse[transport.sessionId];
+    //   });
+    //   // 连接 MCP 服务器，建立 SSE 通道
+    //   await mcpServer.connect(transport);
+    // });
+    // SSE 消息推送接口，根据 sessionId 找到对应传输对象
+    app.post('/messages', async (req, res) => {
+        const sessionId = req.query.sessionId;
+        const transport = transports.sse[sessionId];
+        Logger.log('/messages request headers:', req.headers);
+        Logger.log('/messages request body:', req.body);
+        if (transport) {
+            Logger.log(`Received SSE message for sessionId ${sessionId}`);
+            await transport.handlePostMessage(req, res);
+        }
+        else {
+            res.status(400).send(`No transport found for sessionId ${sessionId}`);
+            return;
+        }
+    });
+    // 认证相关端点
+    // 获取配置接口，支持 fileKey 和 nodeId 参数
+    app.get('/getConfig', async (req, res) => {
+        try {
+            const fileKey = req.query.fileKey;
+            const nodeId = req.query.nodeId;
+            if (fileKey) {
+                // 如果提供了 fileKey，返回该 fileKey 的特定配置
+                const globalConfig = await configManager.load();
+                const fileConfig = globalConfig.fileConfigs?.[fileKey] || {};
+                // 从 fileManager 按 nodeId 加载 groupsData 和 promptSetting
+                const fileManager = new FileManager('d2c-mcp');
+                const groupsData = await fileManager.loadGroupsData(fileKey, nodeId);
+                const savedPromptSetting = await fileManager.loadPromptSetting(fileKey, nodeId);
+                // 合并用户自定义提示词和默认提示词
+                const promptSetting = {
+                    chunkOptimizePrompt: savedPromptSetting?.chunkOptimizePrompt || chunkOptimizeCodePrompt,
+                    aggregationOptimizePrompt: savedPromptSetting?.aggregationOptimizePrompt || aggregationOptimizeCodePrompt,
+                    finalOptimizePrompt: savedPromptSetting?.finalOptimizePrompt || finalOptimizeCodePrompt,
+                };
+                res.json({
+                    success: true,
+                    data: {
+                        mcp: globalConfig.mcp || {},
+                        convertSetting: fileConfig.convertSetting,
+                        imageSetting: fileConfig.imageSetting,
+                        promptSetting: promptSetting,
+                        fileKey: fileKey,
+                        groupsData: groupsData,
+                    },
+                });
+            }
+            else {
+                // 如果没有提供 fileKey，返回默认配置
+                if (await configManager.exists()) {
+                    configStorage = await configManager.load();
+                }
+                // 返回默认提示词
+                const promptSetting = {
+                    chunkOptimizePrompt: chunkOptimizeCodePrompt,
+                    aggregationOptimizePrompt: aggregationOptimizeCodePrompt,
+                    finalOptimizePrompt: finalOptimizeCodePrompt,
+                };
+                res.json({
+                    success: true,
+                    data: {
+                        mcp: configStorage.mcp || {},
+                        convertSetting: configStorage.convertSetting || {},
+                        imageSetting: configStorage.imageSetting || {},
+                        promptSetting: promptSetting,
+                    },
+                });
+            }
+        }
+        catch (error) {
+            Logger.error('获取配置失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '获取配置失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    app.get('/getHtml', async (req, res) => {
+        // 加载现有配置
+        const fileManager = new FileManager('d2c-mcp');
+        const html = await fileManager.loadFile(req.query.fileKey, req.query.nodeId, 'absolute.html');
+        res.json({
+            success: true,
+            data: html,
+        });
+    });
+    // 认证页面
+    app.get('/auth-page', (req, res) => {
+        try {
+            // 尝试找到相对于当前位置的模板路径
+            const isStdioMode = process.env.NODE_ENV === 'cli' || process.argv.includes('--stdio');
+            const isDevMode = process.argv.includes('--dev');
+            const templatePath = path.join(__dirname, isStdioMode && !isDevMode ? '../interceptor-web/dist/index.html' : '../../interceptor-web/dist/index.html');
+            Logger.log('templatePath', templatePath);
+            if (fs.existsSync(templatePath)) {
+                const htmlContent = fs.readFileSync(templatePath, 'utf8');
+                res.send(htmlContent);
+            }
+            else {
+                // 备用方案：简单的 HTML 表单
+                const fallbackHtml = `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>身份验证</title>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+</head>
+<body>
+    <div style="max-width: 500px; margin: 50px auto; padding: 20px; font-family: Arial, sans-serif;">
+        <h2>需要身份验证</h2>
+        <form id="authForm" method="POST" action="/submit">
+            <input type="hidden" name="token" value="${req.query.token || ''}" />
+            <div style="margin-bottom: 15px;">
+                <label for="value" style="display: block; margin-bottom: 5px;">请输入您的信息:</label>
+                <input type="text" id="value" name="value" required style="width: 100%; padding: 8px; border: 1px solid #ddd; border-radius: 4px;" />
+            </div>
+            <button type="submit" style="background: #007cba; color: white; padding: 10px 20px; border: none; border-radius: 4px; cursor: pointer;">提交</button>
+        </form>
+    </div>
+</body>
+</html>`;
+                res.send(fallbackHtml);
+            }
+        }
+        catch (error) {
+            res.status(500).send('加载认证页面时出错');
+        }
+    });
+    // 提交认证信息，支持 fileKey 和 nodeId 参数
+    app.post('/submit', async (req, res) => {
+        try {
+            // 安全地解构请求体，处理可能为空的情况
+            const { token, value, fileKey, nodeId } = req.body || {};
+            if (!token || !value) {
+                res.status(400).send('请求体中缺少 token 或 value');
+                return;
+            }
+            // 保存配置到对应的 fileKey 或默认配置
+            if (fileKey) {
+                // 保存到特定 fileKey 的配置
+                const globalConfig = await configManager.load();
+                if (!globalConfig.fileConfigs) {
+                    globalConfig.fileConfigs = {};
+                }
+                if (!globalConfig.fileConfigs[fileKey]) {
+                    globalConfig.fileConfigs[fileKey] = {};
+                }
+                if (value.convertSetting) {
+                    globalConfig.fileConfigs[fileKey].convertSetting = value.convertSetting;
+                }
+                if (value.imageSetting) {
+                    globalConfig.fileConfigs[fileKey].imageSetting = value.imageSetting;
+                }
+                await configManager.save(globalConfig);
+                Logger.log(`已保存 fileKey "${fileKey}" 的配置:`, value);
+            }
+            // 使用 fileManager 按 nodeId 保存 groupsData 和 promptSetting
+            const fileManager = new FileManager('d2c-mcp');
+            if (fileKey && value.groupsData && Array.isArray(value.groupsData)) {
+                await fileManager.saveGroupsData(fileKey, nodeId, value.groupsData);
+                Logger.log(`已保存 groupsData 到 fileKey "${fileKey}", nodeId "${nodeId}":`, value.groupsData.length, '个分组');
+            }
+            if (fileKey && value.promptSetting) {
+                await fileManager.savePromptSetting(fileKey, nodeId, value.promptSetting);
+                Logger.log(`已保存 promptSetting 到 fileKey "${fileKey}", nodeId "${nodeId}"`);
+            }
+            // 如果有 MCP 配置，更新全局配置
+            if (value.mcp) {
+                const globalConfig = await configManager.load();
+                globalConfig.mcp = { ...globalConfig.mcp, ...value.mcp };
+                await configManager.save(globalConfig);
+                Logger.log('已更新全局 MCP 配置');
+            }
+            const request = pendingRequests.get(token);
+            if (request && request.resolve) {
+                request.resolve(JSON.stringify(value));
+                res.send('提交成功！您可以关闭此窗口。');
+            }
+            else {
+                res.status(404).send('无效或已过期的 token');
+            }
+        }
+        catch (error) {
+            Logger.error('保存配置失败:', error);
+            res.status(500).send('保存配置失败: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    });
+    // 保存节点数据端点
+    app.post('/saveNodes', async (req, res) => {
+        try {
+            console.log('req.body', req);
+            const { nodeList, fileKey, nodeId, imageMap, absoluteHtml } = req.body;
+            if (!nodeList || !fileKey || !nodeId) {
+                res.status(400).json({
+                    success: false,
+                    message: '缺少必要参数: nodeList, fileKey, nodeId',
+                });
+                return;
+            }
+            const fileManager = new FileManager('d2c-mcp');
+            // 保存节点列表
+            await fileManager.saveFile(fileKey, nodeId, 'nodeList.json', (nodeList));
+            // 保存图片映射
+            if (imageMap) {
+                await fileManager.saveFile(fileKey, nodeId, 'imageMap.json', flatted.stringify(imageMap));
+            }
+            // 保存绝对布局HTML
+            if (absoluteHtml) {
+                await fileManager.saveFile(fileKey, nodeId, 'absolute.html', absoluteHtml);
+            }
+            Logger.log(`成功保存节点数据: fileKey=${fileKey}, nodeId=${nodeId}`);
+            res.json({
+                success: true,
+                message: '节点数据保存成功',
+            });
+        }
+        catch (error) {
+            Logger.error('保存节点数据失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '保存节点数据失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    // 日志重连端点
+    app.post('/reconnect-logging', (req, res) => {
+        Logger.log('收到来自 VSCode 扩展的日志重连请求');
+        // 重新初始化日志连接
+        Logger.reconnectVSCodeLogging();
+        res.status(200).json({
+            success: true,
+            message: '日志重连已启动',
+        });
+    });
+    // 启动 HTTP 服务器，监听端口
+    httpServer = app.listen(port, () => {
+        Logger.log(`HTTP server listening on port ${port}`);
+        Logger.log(`SSE endpoint available at http://localhost:${port}/sse`);
+        Logger.log(`Message endpoint available at http://localhost:${port}/messages`);
+        Logger.log(`StreamableHTTP endpoint available at http://localhost:${port}/mcp`);
+        Logger.log(`Auth endpoints available at http://localhost:${port}/auth-page`);
+        Logger.log(`MCP Config at http://localhost:${port}/getConfig`);
+        Logger.log(`Save Nodes endpoint available at http://localhost:${port}/saveNodes`);
+        Logger.log(`Logging reconnect endpoint available at http://localhost:${port}/reconnect-logging`);
+    });
+    // 监听 SIGINT 信号，优雅关闭服务器和所有会话
+    process.on('SIGINT', async () => {
+        Logger.log('SERVER: 收到SIGINT信号');
+        Logger.log('正在关闭服务器...');
+        // 清理等待中的认证请求
+        pendingRequests.clear();
+        // 关闭所有活跃的 SSE 和 streamable 传输，释放资源
+        await closeTransports(transports.sse);
+        await closeTransports(transports.streamable);
+        Logger.log('服务器关闭完成');
+        process.exit(0);
+    });
+}
+// 批量关闭所有传输对象，确保资源清理
+async function closeTransports(transports) {
+    for (const sessionId in transports) {
+        try {
+            await transports[sessionId].close(); // 调用传输对象的关闭方法
+            delete transports[sessionId]; // 删除会话
+        }
+        catch (error) {
+            console.error(`Error closing transport for session ${sessionId}:`, error);
+        }
+    }
+}
+// 认证功能 - 获取用户输入函数
+export async function getUserInput(payload) {
+    return new Promise(async (resolve, reject) => {
+        if (!httpServer) {
+            reject(new Error('HTTP 服务器未运行。请先启动服务器。'));
+            return;
+        }
+        const token = uuidv4();
+        const authUrl = `http://localhost:${PORT}/auth-page?token=${token}&fileKey=${payload.fileKey}&nodeId=${payload.nodeId}`;
+        // 存储解析函数 - 无超时限制
+        pendingRequests.set(token, {
+            resolve: (value) => {
+                pendingRequests.delete(token);
+                resolve(value);
+            },
+            timeout: null, // 不再使用超时
+        });
+        // 打开浏览器
+        try {
+            await open(authUrl);
+        }
+        catch (err) {
+            pendingRequests.delete(token);
+            reject(new Error(`打开浏览器失败: ${err.message}`));
+        }
+    });
+}
+// 停止 HTTP 服务器，并关闭所有 SSE 传输
+export async function stopHttpServer() {
+    if (!httpServer) {
+        throw new Error('HTTP 服务器未运行');
+    }
+    return new Promise((resolve, reject) => {
+        // 清理等待中的认证请求
+        pendingRequests.clear();
+        httpServer.close((err) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            httpServer = null;
+            // 关闭所有 SSE 传输
+            const closing = Object.values(transports.sse).map((transport) => {
+                return transport.close();
+            });
+            Promise.all(closing).then(() => {
+                resolve();
+            });
+        });
+    });
+}