flex-mcp 1.0.0

package/dist/api/configs.js

@@ -0,0 +1,693 @@
+/**
+ * MCP 配置管理 API
+ */
+import { Hono } from 'hono';
+import { authMiddleware, requireAdmin, getCurrentUserId, getCurrentUserRole } from './middleware.js';
+import { db } from '../db/index.js';
+import { mcpConfigs, mcpComponentTools } from '../db/schema.js';
+import { eq, and } from 'drizzle-orm';
+import { generateId } from '../utils/id.js';
+import { mcpService } from '../mcp/service.js';
+import { syncComponentTools, loadComponentToolsList } from '../mcp/tool-sync.js';
+import { report } from '../utils/telemetry.js';
+export const configRouter = new Hono();
+/**
+ * 将数据库行转换为 MCPConfig 对象
+ */
+function rowToConfig(row) {
+    return {
+        id: row.id,
+        userId: row.userId,
+        name: row.name,
+        components: JSON.parse(row.components),
+        customTools: JSON.parse(row.customTools),
+        variables: JSON.parse(row.variables),
+        initScript: row.initScript || undefined,
+        enableExploreTable: row.enableExploreTable !== undefined ? Boolean(row.enableExploreTable) : true, // 默认为 true
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+// 所有路由需要认证
+configRouter.use('*', authMiddleware);
+// 获取当前用户的唯一配置（如果不存在则创建）
+configRouter.get('/me', async (c) => {
+    try {
+        const currentUserId = getCurrentUserId(c);
+        const currentRole = getCurrentUserRole(c);
+        // 查找当前用户的配置
+        let result = await db
+            .select()
+            .from(mcpConfigs)
+            .where(eq(mcpConfigs.userId, currentUserId))
+            .limit(1);
+        if (result.length === 0) {
+            // 如果不存在，创建默认配置
+            const configId = generateId();
+            const now = new Date();
+            await db.insert(mcpConfigs).values({
+                id: configId,
+                userId: currentUserId,
+                name: 'Default Config',
+                components: '[]',
+                customTools: '[]',
+                variables: '[]',
+                initScript: null,
+                enableExploreTable: true,
+                createdAt: now,
+                updatedAt: now,
+            });
+            result = await db
+                .select()
+                .from(mcpConfigs)
+                .where(eq(mcpConfigs.id, configId))
+                .limit(1);
+            // 上报配置创建统计
+            report('config_created', {
+                is_default: true,
+            }, currentUserId);
+        }
+        const configRow = result[0];
+        const config = rowToConfig(configRow);
+        // 超级管理员查看时，隐藏variables
+        if (currentRole === 'admin') {
+            const sanitizedConfig = {
+                ...config,
+                variables: [],
+            };
+            return c.json({ success: true, data: sanitizedConfig });
+        }
+        return c.json({ success: true, data: config });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 管理员获取指定用户的配置（不包含敏感信息：variables）
+configRouter.get('/user/:userId', requireAdmin(), async (c) => {
+    try {
+        const targetUserId = c.req.param('userId');
+        let result = await db
+            .select()
+            .from(mcpConfigs)
+            .where(eq(mcpConfigs.userId, targetUserId))
+            .limit(1);
+        if (result.length === 0) {
+            // 如果管理员查看时不存在，也创建一个空的
+            const configId = generateId();
+            const now = new Date();
+            await db.insert(mcpConfigs).values({
+                id: configId,
+                userId: targetUserId,
+                name: 'Default Config',
+                components: '[]',
+                customTools: '[]',
+                variables: '[]',
+                initScript: null,
+                enableExploreTable: true,
+                createdAt: now,
+                updatedAt: now,
+            });
+            result = await db
+                .select()
+                .from(mcpConfigs)
+                .where(eq(mcpConfigs.id, configId))
+                .limit(1);
+        }
+        const configRow = result[0];
+        const config = rowToConfig(configRow);
+        // 管理员查看时，隐藏敏感信息（variables）
+        const sanitizedConfig = {
+            ...config,
+            variables: [], // 对管理员隐藏变量
+        };
+        return c.json({ success: true, data: sanitizedConfig });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 更新当前用户的配置
+configRouter.put('/me', async (c) => {
+    try {
+        const currentUserId = getCurrentUserId(c);
+        const currentRole = getCurrentUserRole(c);
+        const body = await c.req.json();
+        // 超级管理员不允许修改variables
+        if (currentRole === 'admin' && body.variables !== undefined) {
+            return c.json({ success: false, error: '超级管理员不允许修改变量管理' }, 403);
+        }
+        // 查找配置
+        const result = await db
+            .select()
+            .from(mcpConfigs)
+            .where(eq(mcpConfigs.userId, currentUserId))
+            .limit(1);
+        if (result.length === 0) {
+            return c.json({ success: false, error: 'Config not found' }, 404);
+        }
+        const configId = result[0].id;
+        // 更新配置（如果是admin，排除variables字段）
+        const updateData = {
+            name: body.name,
+            components: body.components ? JSON.stringify(body.components) : undefined,
+            customTools: body.customTools ? JSON.stringify(body.customTools) : undefined,
+            initScript: body.initScript || null,
+            updatedAt: new Date(),
+        };
+        // 只有非admin用户才能更新variables
+        if (currentRole !== 'admin') {
+            updateData.variables = body.variables ? JSON.stringify(body.variables) : undefined;
+        }
+        // 更新 enableExploreTable 字段（如果提供）
+        if (body.enableExploreTable !== undefined) {
+            updateData.enableExploreTable = body.enableExploreTable ? 1 : 0;
+        }
+        await db
+            .update(mcpConfigs)
+            .set(updateData)
+            .where(eq(mcpConfigs.id, configId));
+        // 上报配置更新统计
+        report('config_updated', {
+            has_components: !!body.components,
+            has_custom_tools: !!body.customTools,
+            has_init_script: !!body.initScript,
+            components_count: body.components?.length || 0,
+            custom_tools_count: body.customTools?.length || 0,
+            enable_explore_table: body.enableExploreTable,
+        }, currentUserId);
+        // 清理用户的聚合器缓存，强制重新加载配置
+        // 注意：清理失败不应该影响配置保存
+        try {
+            await mcpService.clearAggregator(currentUserId);
+        }
+        catch (error) {
+            console.error(`[Config] Failed to clear aggregator for user ${currentUserId}:`, error.message || error);
+            // 继续执行，不抛出错误
+        }
+        // 返回更新后的配置
+        const updatedResult = await db
+            .select()
+            .from(mcpConfigs)
+            .where(eq(mcpConfigs.id, configId))
+            .limit(1);
+        const configRow = updatedResult[0];
+        const config = rowToConfig(configRow);
+        // 如果是admin，返回时隐藏variables
+        if (currentRole === 'admin') {
+            const sanitizedConfig = {
+                ...config,
+                variables: [],
+            };
+            return c.json({ success: true, data: sanitizedConfig });
+        }
+        return c.json({ success: true, data: config });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 管理员更新指定用户的配置（不允许修改 variables）
+configRouter.put('/user/:userId', requireAdmin(), async (c) => {
+    try {
+        const targetUserId = c.req.param('userId');
+        const body = await c.req.json();
+        const result = await db
+            .select()
+            .from(mcpConfigs)
+            .where(eq(mcpConfigs.userId, targetUserId))
+            .limit(1);
+        if (result.length === 0) {
+            return c.json({ success: false, error: 'Config not found' }, 404);
+        }
+        const configId = result[0].id;
+        // 管理员不允许修改用户的 variables，移除该字段
+        const { ...updateData } = body;
+        await db
+            .update(mcpConfigs)
+            .set({
+            name: updateData.name,
+            components: updateData.components ? JSON.stringify(updateData.components) : undefined,
+            customTools: updateData.customTools ? JSON.stringify(updateData.customTools) : undefined,
+            // variables 字段被忽略，管理员无法修改
+            initScript: updateData.initScript || null,
+            enableExploreTable: updateData.enableExploreTable !== undefined ? updateData.enableExploreTable : undefined,
+            updatedAt: new Date(),
+        })
+            .where(eq(mcpConfigs.id, configId));
+        // 清理用户的聚合器缓存，强制重新加载配置
+        // 注意：清理失败不应该影响配置保存
+        try {
+            await mcpService.clearAggregator(targetUserId);
+        }
+        catch (error) {
+            console.error(`[Config] Failed to clear aggregator for user ${targetUserId}:`, error.message || error);
+            // 继续执行，不抛出错误
+        }
+        // 返回更新后的配置（不包含 variables）
+        const updatedResult = await db
+            .select()
+            .from(mcpConfigs)
+            .where(eq(mcpConfigs.id, configId))
+            .limit(1);
+        const configRow = updatedResult[0];
+        const config = rowToConfig(configRow);
+        // 管理员查看时，隐藏敏感信息（variables）
+        const sanitizedConfig = {
+            ...config,
+            variables: [],
+        };
+        return c.json({ success: true, data: sanitizedConfig });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 测试执行初始化脚本
+configRouter.post('/test-init-script', async (c) => {
+    try {
+        const currentUserId = getCurrentUserId(c);
+        const body = await c.req.json();
+        if (!body.script) {
+            return c.json({ success: false, error: 'Script is required' }, 400);
+        }
+        // 获取用户配置
+        const result = await db
+            .select()
+            .from(mcpConfigs)
+            .where(eq(mcpConfigs.userId, currentUserId))
+            .limit(1);
+        if (result.length === 0) {
+            return c.json({ success: false, error: 'Config not found' }, 404);
+        }
+        const config = rowToConfig(result[0]);
+        // 获取 MCP 客户端配置（如果存在）
+        const mcpClientConfig = mcpService.getMCPClientConfig(currentUserId);
+        // 创建临时脚本执行器
+        const { ScriptExecutor } = await import('../script/executor.js');
+        const executor = new ScriptExecutor(config, mcpClientConfig);
+        // 捕获输出
+        const output = [];
+        const originalLog = console.log;
+        const originalError = console.error;
+        const originalWarn = console.warn;
+        const originalDebug = console.debug;
+        // 重定向日志输出
+        console.log = (...args) => {
+            output.push(`[INFO] ${args.map(a => typeof a === 'object' ? JSON.stringify(a, null, 2) : String(a)).join(' ')}`);
+            originalLog(...args);
+        };
+        console.error = (...args) => {
+            output.push(`[ERROR] ${args.map(a => typeof a === 'object' ? JSON.stringify(a, null, 2) : String(a)).join(' ')}`);
+            originalError(...args);
+        };
+        console.warn = (...args) => {
+            output.push(`[WARN] ${args.map(a => typeof a === 'object' ? JSON.stringify(a, null, 2) : String(a)).join(' ')}`);
+            originalWarn(...args);
+        };
+        console.debug = (...args) => {
+            output.push(`[DEBUG] ${args.map(a => typeof a === 'object' ? JSON.stringify(a, null, 2) : String(a)).join(' ')}`);
+            originalDebug(...args);
+        };
+        try {
+            // 执行脚本
+            await executor.executeInitScript(body.script);
+            return c.json({
+                success: true,
+                data: {
+                    output: output.length > 0 ? output.join('\n') : '执行成功，无输出',
+                },
+            });
+        }
+        catch (error) {
+            return c.json({
+                success: false,
+                error: error.message,
+                data: {
+                    output: output.length > 0 ? output.join('\n') : '',
+                },
+            });
+        }
+        finally {
+            // 恢复原始日志函数
+            console.log = originalLog;
+            console.error = originalError;
+            console.warn = originalWarn;
+            console.debug = originalDebug;
+        }
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 测试执行自定义工具脚本
+configRouter.post('/test-custom-tool', async (c) => {
+    try {
+        const currentUserId = getCurrentUserId(c);
+        const body = await c.req.json();
+        if (!body.script) {
+            return c.json({ success: false, error: 'Script is required' }, 400);
+        }
+        // 获取用户配置
+        const result = await db
+            .select()
+            .from(mcpConfigs)
+            .where(eq(mcpConfigs.userId, currentUserId))
+            .limit(1);
+        if (result.length === 0) {
+            return c.json({ success: false, error: 'Config not found' }, 404);
+        }
+        const config = rowToConfig(result[0]);
+        // 获取 MCP 客户端配置（如果存在）
+        const mcpClientConfig = mcpService.getMCPClientConfig(currentUserId);
+        // 创建临时脚本执行器
+        const { ScriptExecutor } = await import('../script/executor.js');
+        const executor = new ScriptExecutor(config, mcpClientConfig);
+        // 创建临时自定义工具对象
+        const tempTool = {
+            id: 'test-tool',
+            name: body.toolName || 'test-tool',
+            description: 'Test tool',
+            serverScript: body.script,
+            parameters: [],
+        };
+        // 捕获输出
+        const output = [];
+        const originalLog = console.log;
+        const originalError = console.error;
+        const originalWarn = console.warn;
+        const originalDebug = console.debug;
+        // 重定向日志输出
+        console.log = (...args) => {
+            output.push(`[INFO] ${args.map(a => typeof a === 'object' ? JSON.stringify(a, null, 2) : String(a)).join(' ')}`);
+            originalLog(...args);
+        };
+        console.error = (...args) => {
+            output.push(`[ERROR] ${args.map(a => typeof a === 'object' ? JSON.stringify(a, null, 2) : String(a)).join(' ')}`);
+            originalError(...args);
+        };
+        console.warn = (...args) => {
+            output.push(`[WARN] ${args.map(a => typeof a === 'object' ? JSON.stringify(a, null, 2) : String(a)).join(' ')}`);
+            originalWarn(...args);
+        };
+        console.debug = (...args) => {
+            output.push(`[DEBUG] ${args.map(a => typeof a === 'object' ? JSON.stringify(a, null, 2) : String(a)).join(' ')}`);
+            originalDebug(...args);
+        };
+        try {
+            // 执行工具脚本
+            const result = await executor.executeTool(tempTool, body.args || {});
+            return c.json({
+                success: true,
+                data: {
+                    result,
+                    output: output.length > 0 ? output.join('\n') : '执行成功，无输出',
+                },
+            });
+        }
+        catch (error) {
+            return c.json({
+                success: false,
+                error: error.message,
+                data: {
+                    output: output.length > 0 ? output.join('\n') : '',
+                },
+            });
+        }
+        finally {
+            // 恢复原始日志函数
+            console.log = originalLog;
+            console.error = originalError;
+            console.warn = originalWarn;
+            console.debug = originalDebug;
+        }
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 同步 MCP 组件工具配置到数据库
+configRouter.post('/sync-tools', async (c) => {
+    try {
+        const currentUserId = getCurrentUserId(c);
+        const body = await c.req.json();
+        const componentId = body.componentId; // 可选，如果提供则只同步该组件
+        // 获取用户配置
+        const result = await db
+            .select()
+            .from(mcpConfigs)
+            .where(eq(mcpConfigs.userId, currentUserId))
+            .limit(1);
+        if (result.length === 0) {
+            return c.json({ success: false, error: 'MCP configuration not found' }, 404);
+        }
+        const config = rowToConfig(result[0]);
+        // 如果指定了 componentId，验证组件存在
+        if (componentId) {
+            const component = config.components.find(c => c.id === componentId);
+            if (!component) {
+                return c.json({ success: false, error: `Component ${componentId} not found` }, 404);
+            }
+            // 注意：即使组件被禁用，也允许同步工具（用于工具管理）
+        }
+        // 同步工具（允许禁用组件同步工具，用于工具管理）
+        const syncResult = await syncComponentTools(config, componentId, true);
+        // 上报工具同步统计
+        report('tools_synced', {
+            component_id: componentId || 'all',
+            success_count: syncResult.success,
+            failed_count: syncResult.failed,
+            has_errors: syncResult.errors.length > 0,
+        }, currentUserId);
+        // 清理聚合器缓存，强制重新加载
+        await mcpService.clearAggregator(currentUserId);
+        return c.json({
+            success: true,
+            data: {
+                success: syncResult.success,
+                failed: syncResult.failed,
+                errors: syncResult.errors,
+            },
+        });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 仅加载组件的工具列表（不保存到数据库，即使组件禁用也可以加载）
+configRouter.post('/component-tools/load', async (c) => {
+    try {
+        const currentUserId = getCurrentUserId(c);
+        const body = await c.req.json();
+        const componentId = body.componentId;
+        if (!componentId) {
+            return c.json({ success: false, error: 'componentId is required' }, 400);
+        }
+        // 获取用户配置
+        const result = await db
+            .select()
+            .from(mcpConfigs)
+            .where(eq(mcpConfigs.userId, currentUserId))
+            .limit(1);
+        if (result.length === 0) {
+            return c.json({ success: false, error: 'MCP configuration not found' }, 404);
+        }
+        const config = rowToConfig(result[0]);
+        // 加载工具列表（即使组件禁用也可以加载）
+        const loadResult = await loadComponentToolsList(config, componentId);
+        return c.json({
+            success: true,
+            data: {
+                tools: loadResult.tools,
+                errors: loadResult.errors,
+            },
+        });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 获取指定组件的工具列表（从数据库读取）
+configRouter.get('/component-tools/:componentId', async (c) => {
+    try {
+        const currentUserId = getCurrentUserId(c);
+        const componentId = c.req.param('componentId');
+        // 获取用户配置
+        const result = await db
+            .select()
+            .from(mcpConfigs)
+            .where(eq(mcpConfigs.userId, currentUserId))
+            .limit(1);
+        if (result.length === 0) {
+            return c.json({ success: false, error: 'MCP configuration not found' }, 404);
+        }
+        const config = rowToConfig(result[0]);
+        // 验证组件存在
+        const component = config.components.find(c => c.id === componentId);
+        if (!component) {
+            return c.json({ success: false, error: `Component ${componentId} not found` }, 404);
+        }
+        // 从数据库获取该组件的工具列表（原始数据）
+        const dbTools = await db
+            .select()
+            .from(mcpComponentTools)
+            .where(and(eq(mcpComponentTools.configId, config.id), eq(mcpComponentTools.componentId, componentId)));
+        // 获取组件的 toolPatches 配置（配置数据，用于覆盖原始数据）
+        const toolPatches = component.config?.toolPatches || {};
+        // 转换为前端需要的格式
+        // 注意：这里应用 toolPatches 来覆盖原始数据，但原始数据仍然保存在数据库中
+        const tools = dbTools.map(dbTool => {
+            // 从原始数据开始
+            let inputSchema = dbTool.inputSchema;
+            let description = dbTool.description;
+            // 应用工具补丁（如果存在，使用原始工具名称作为键）
+            // toolPatches 存储在组件配置中，不在工具记录中
+            const toolPatch = toolPatches[dbTool.originalToolName];
+            if (toolPatch && typeof toolPatch === 'object') {
+                // 应用 description 补丁（如果存在）
+                if (toolPatch.description !== undefined && toolPatch.description !== null && toolPatch.description !== '') {
+                    description = toolPatch.description;
+                }
+                // 应用 inputSchema 补丁（如果存在）
+                if (toolPatch.inputSchema) {
+                    inputSchema = {
+                        ...inputSchema,
+                        ...toolPatch.inputSchema,
+                    };
+                }
+                // 应用 fieldDescriptions 补丁（如果存在）
+                if (toolPatch.fieldDescriptions && typeof toolPatch.fieldDescriptions === 'object') {
+                    // 更新 inputSchema 中对应字段的 description
+                    if (inputSchema.properties) {
+                        for (const [fieldName, fieldDescription] of Object.entries(toolPatch.fieldDescriptions)) {
+                            if (inputSchema.properties[fieldName]) {
+                                inputSchema.properties[fieldName] = {
+                                    ...inputSchema.properties[fieldName],
+                                    description: fieldDescription,
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+            return {
+                name: dbTool.toolName,
+                description: description,
+                inputSchema: inputSchema,
+                disabled: dbTool.disabled, // 使用数据库中存储的 disabled 状态
+                originalToolName: dbTool.originalToolName,
+            };
+        });
+        return c.json({
+            success: true,
+            data: { tools },
+        });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 获取所有组件的所有工具列表（包括禁用的），用于 Context 类型生成
+// 返回的是原始数据 + 编辑数据的叠加结果
+configRouter.get('/all-tools', async (c) => {
+    try {
+        const currentUserId = getCurrentUserId(c);
+        // 获取用户配置
+        const result = await db
+            .select()
+            .from(mcpConfigs)
+            .where(eq(mcpConfigs.userId, currentUserId))
+            .limit(1);
+        if (result.length === 0) {
+            return c.json({ success: false, error: 'MCP configuration not found' }, 404);
+        }
+        const config = rowToConfig(result[0]);
+        // 从数据库获取所有组件的所有工具列表（包括禁用的）
+        const dbTools = await db
+            .select()
+            .from(mcpComponentTools)
+            .where(eq(mcpComponentTools.configId, config.id));
+        // 创建一个组件ID到组件配置的映射
+        const componentMap = new Map();
+        for (const comp of config.components) {
+            componentMap.set(comp.id, comp);
+        }
+        // 转换为前端需要的格式，应用 toolPatches
+        const allTools = [];
+        for (const dbTool of dbTools) {
+            const component = componentMap.get(dbTool.componentId);
+            if (!component) {
+                continue; // 跳过找不到组件的工具
+            }
+            // 获取组件的 toolPatches 配置（配置数据，用于覆盖原始数据）
+            const toolPatches = component.config?.toolPatches || {};
+            // 从原始数据开始
+            let inputSchema = dbTool.inputSchema;
+            let description = dbTool.description;
+            // 应用工具补丁（如果存在，使用原始工具名称作为键）
+            const toolPatch = toolPatches[dbTool.originalToolName];
+            if (toolPatch && typeof toolPatch === 'object') {
+                // 应用 description 补丁（如果存在）
+                if (toolPatch.description !== undefined && toolPatch.description !== null && toolPatch.description !== '') {
+                    description = toolPatch.description;
+                }
+                // 应用 inputSchema 补丁（如果存在）
+                if (toolPatch.inputSchema) {
+                    inputSchema = {
+                        ...inputSchema,
+                        ...toolPatch.inputSchema,
+                    };
+                }
+                // 应用 fieldDescriptions 补丁（如果存在）
+                if (toolPatch.fieldDescriptions && typeof toolPatch.fieldDescriptions === 'object') {
+                    // 更新 inputSchema 中对应字段的 description
+                    if (inputSchema.properties) {
+                        for (const [fieldName, fieldDescription] of Object.entries(toolPatch.fieldDescriptions)) {
+                            if (inputSchema.properties[fieldName]) {
+                                inputSchema.properties[fieldName] = {
+                                    ...inputSchema.properties[fieldName],
+                                    description: fieldDescription,
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+            allTools.push({
+                name: dbTool.toolName,
+                description: description,
+                inputSchema: inputSchema,
+                originalToolName: dbTool.originalToolName,
+            });
+        }
+        // 添加自定义工具
+        // 自定义工具没有 originalToolName，使用 name 作为工具名称
+        for (const customTool of config.customTools) {
+            allTools.push({
+                name: customTool.name,
+                description: customTool.description,
+                inputSchema: {
+                    type: 'object',
+                    properties: customTool.parameters.reduce((acc, param) => {
+                        acc[param.name] = {
+                            type: param.type,
+                            description: param.description || '',
+                        };
+                        return acc;
+                    }, {}),
+                    required: customTool.parameters.filter((p) => p.required).map((p) => p.name),
+                },
+                // 自定义工具没有 originalToolName，所以不设置这个字段
+                // Context 类型生成时会使用 name 作为工具名称
+            });
+        }
+        return c.json({
+            success: true,
+            data: { tools: allTools },
+        });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+//# sourceMappingURL=configs.js.map