feat: add MCP

* feat: add MCP services

* feat: add MCP web pages

* feat: optimize web page UI and add inspector iframe

* feat: enhance mcp services implements

* feat: add mcp inspector agent process

* chore: add @env alias and update node engines

* feat: update sql template

* fix: revert database config

* fix: remove unnessary styles

* fix: fix sql syntax

* feat: refactor mcpProxy to agent process

* feat: optimize markdown reviewer styles

* fix: add agent args

* fix: use cjs import for react-syntax-highlighter

* fix: stdio args split with white-space

* fix: remove useless endpoint

* feat: add one-click fill options for Node and UV commands in MCP server registry

* feat: enhance start script to manage MCP deployment directory and update build command

* fix: update message endpoint construction to use forwarded protocol and hostname

* fix: run lint:fix

* chore: update CI.yml

* chore: add NODE_OPTIONS for legacy OpenSSL support in CI workflow

* fix: handle server-side rendering in InspectorIframe component

* chore: update MCP health check schedule time

* feat: update inspector to v0.17.5

* chore: add .nvmrc file specifying Node.js version 18.20.3

* feat: enhance file upload validation and logging for extraction process

* chore: upgrade inspector and mcp sdk to compatible with 2025-11-25 mcp protocal version

---------

Co-authored-by: JackWang032 <[email protected]>

Author: JackWang032

.github/workflows/CI.yml

@@ -11,9 +11,11 @@ on:
 jobs:
     setup:
         runs-on: ubuntu-latest
+        env:
+          NODE_OPTIONS: --openssl-legacy-provider
         strategy:
             matrix:
-                node-version: [14.x, 16.x]
+                node-version: [18.x]
                 # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
         steps:
             - name: Checkout code

.nvmrc

@@ -0,0 +1 @@
+18.20.3

agent.js

@@ -1,13 +1,38 @@
+const http = require('http');
+const env = require('./env.json');
 const {
     createTimedTask,
     changeTimedTask,
     cancelTimedTask,
     timedTaskList,
     timedTaskResult,
 } = require('./app/utils/timedTask');
+const { startMcpInspector } = require('./app/agent/mcpInspector');
+const { MCPHttpHandler } = require('./app/agent/mcpHttpHandler');
+const { MCPProxy } = require('./app/mcp/mcpProxy');
+const { buildMCPConfig } = require('./app/utils');
 
 // 接收 app 发送来的消息并作出反应
 module.exports = (agent) => {
+    // 初始化MCP端点HTTP处理器
+    const mcpHttpHandler = new MCPHttpHandler(agent);
+    const mcpProxy = new MCPProxy(agent.logger);
+    let httpServer = null;
+
+    // 等待Worker进程启动完成后再启动MCP服务
+    agent.messenger.once('egg-ready', async () => {
+        try {
+            agent.logger.info('Worker进程已就绪，开始启动MCP端点HTTP服务...');
+
+            httpServer = await createHttpServer(agent, mcpHttpHandler);
+
+            // 启动所有已注册的MCP代理服务
+            await startMCPServices(agent);
+        } catch (error) {
+            agent.logger.error('MCP端点HTTP服务启动失败:', error);
+        }
+    });
+
     // 创建文章订阅任务
     agent.messenger.on('createTimedTask', ({ id, sendCron }) => {
         createTimedTask(id, sendCron, agent);
@@ -32,4 +57,169 @@ module.exports = (agent) => {
     agent.messenger.on('timedTaskResult', ({ result }) => {
         timedTaskResult(result, agent);
     });
+
+    // 处理MCP服务器启动请求
+    agent.messenger.on('mcpStart', async ({ serverId, config }) => {
+        try {
+            await mcpProxy.startProxy(serverId, config);
+            agent.logger.info(`MCP服务器启动成功 [${serverId}]`);
+
+            // 发送成功消息回 worker
+            agent.messenger.sendRandom('mcpStartResult', {
+                serverId,
+                success: true,
+            });
+        } catch (error) {
+            agent.logger.error(`MCP服务器启动失败 [${serverId}]:`, error);
+
+            // 发送失败消息回 worker
+            agent.messenger.sendRandom('mcpStartResult', {
+                serverId,
+                success: false,
+                error: error.message,
+            });
+        }
+    });
+
+    // 处理MCP服务器停止请求
+    agent.messenger.on('mcpStop', async ({ serverId }) => {
+        try {
+            await mcpProxy.stopProxy(serverId);
+            agent.logger.info(`MCP服务器停止成功 [${serverId}]`);
+
+            // 发送成功消息回 worker
+            agent.messenger.sendToApp('mcpStopResult', {
+                serverId,
+                success: true,
+            });
+        } catch (error) {
+            agent.logger.error(`MCP服务器停止失败 [${serverId}]:`, error);
+
+            // 发送失败消息回 worker
+            agent.messenger.sendRandom('mcpStopResult', {
+                serverId,
+                success: false,
+                error: error.message,
+            });
+        }
+    });
+
+    // 处理MCP服务器重启请求
+    agent.messenger.on('mcpRestart', async ({ serverId }) => {
+        try {
+            await mcpProxy.restartProxy(serverId);
+            agent.logger.info(`MCP服务器重启成功 [${serverId}]`);
+
+            // 发送成功消息回 worker
+            agent.messenger.sendRandom('mcpRestartResult', {
+                serverId,
+                success: true,
+            });
+        } catch (error) {
+            agent.logger.error(`MCP服务器重启失败 [${serverId}]:`, error);
+
+            // 发送失败消息回 worker
+            agent.messenger.sendRandom('mcpRestartResult', {
+                serverId,
+                success: false,
+                error: error.message,
+            });
+        }
+    });
+
+    // 启动MCP Inspector
+    startMcpInspector(agent);
+
+    // 进程退出前清理
+    agent.beforeClose(async () => {
+        agent.logger.info('Agent进程关闭，清理MCP服务...');
+
+        try {
+            // 关闭HTTP服务器
+            if (httpServer) {
+                await new Promise((resolve) => {
+                    httpServer.close(() => {
+                        resolve();
+                    });
+                });
+            }
+
+            // 清理MCP代理
+            await mcpProxy.cleanup();
+            agent.logger.info('MCP服务清理完成');
+        } catch (error) {
+            agent.logger.error('MCP服务清理失败:', error);
+        }
+    });
 };
+
+// 创建HTTP服务（用于处理MCP端点请求）
+async function createHttpServer(agent, mcpHttpHandler) {
+    const port = env.mcpEndpointPort || 7005;
+
+    const server = http.createServer(async (req, res) => {
+        await mcpHttpHandler.handleRequest(req, res);
+    });
+
+    server.listen(port, () => {
+        agent.logger.info(`MCP端点HTTP服务已启动，监听端口: ${port}`);
+    });
+
+    server.on('error', (error) => {
+        agent.logger.error('MCP端点HTTP服务错误:', error);
+    });
+
+    return server;
+}
+
+// 启动所有MCP服务，缓存配置信息
+async function startMCPServices(agent) {
+    agent.logger.info('开始启动MCP服务...');
+
+    const ctx = agent.createAnonymousContext();
+
+    // 获取所有未删除的MCP服务器
+    const enabledServers = await ctx.model.McpServer.findAll({
+        where: {
+            is_delete: 0,
+        },
+    });
+
+    if (enabledServers.length === 0) {
+        agent.logger.info('无需要启动的MCP服务器');
+        return;
+    }
+
+    agent.logger.info(`启动${enabledServers.length}个MCP服务器...`);
+
+    let successCount = 0;
+    let failCount = 0;
+
+    // 启动每个服务器
+    for (const server of enabledServers) {
+        try {
+            // 构建MCP配置对象
+            const config = buildMCPConfig(server);
+            await MCPProxy.getInstance().startProxy(server.server_id, config);
+
+            successCount++;
+        } catch (error) {
+            agent.logger.error(`MCP服务器启动失败 [${server.server_id}]:`, error);
+
+            // 更新状态为错误
+            await server.update({
+                status: 'error',
+                ping_error: error.message,
+                last_ping_at: new Date(),
+            });
+
+            failCount++;
+        }
+    }
+
+    setTimeout(() => {
+        agent.messenger.sendRandom('mcpCheckAllServersHealth');
+    }, 2000);
+
+    agent.logger.info(`MCP服务启动完成: 成功${successCount}个, 失败${failCount}个`);
+}

app.js

@@ -21,5 +21,49 @@ module.exports = class AppBootHook {
                 await ctx.service.articleSubscription.sendArticleSubscription(id);
             });
         });
+
+        // 监听 MCP 服务器启动结果
+        app.messenger.on('mcpStartResult', (data) => {
+            const { serverId, success, error } = data;
+            const ctx = app.createAnonymousContext();
+            ctx.runInBackground(async () => {
+                await ctx.service.mcp.handleMCPStartResult(serverId, success, error);
+            });
+        });
+
+        // 监听 MCP 服务器停止结果
+        app.messenger.on('mcpStopResult', (data) => {
+            const { serverId, success, error } = data;
+            const ctx = app.createAnonymousContext();
+            ctx.runInBackground(async () => {
+                await ctx.service.mcp.handleMCPStopResult(serverId, success, error);
+            });
+        });
+
+        // 监听 MCP 服务器重启结果
+        app.messenger.on('mcpRestartResult', (data) => {
+            const { serverId, success, error } = data;
+            const ctx = app.createAnonymousContext();
+            ctx.runInBackground(async () => {
+                await ctx.service.mcp.handleMCPRestartResult(serverId, success, error);
+            });
+        });
+
+        // 监听 MCP 服务器健康检查请求
+        app.messenger.on('mcpCheckAllServersHealth', () => {
+            const ctx = app.createAnonymousContext();
+            ctx.runInBackground(async () => {
+                await ctx.service.mcp.checkAllServersHealth();
+            });
+        });
+
+        // 监听 MCP 请求埋点
+        app.messenger.on('mcpTraceRequest', (data) => {
+            const ctx = app.createAnonymousContext();
+            ctx.runInBackground(async () => {
+                const { serverId } = data;
+                await ctx.service.mcp.incrementUseCount(serverId);
+            });
+        });
     }
 };