flex-mcp 1.0.0

package/dist/mcp/aggregator.js

@@ -0,0 +1,1266 @@
+/**
+ * MCP 聚合器
+ * 聚合多个 MCP 组件，管理工具和资源
+ */
+import { ScriptExecutor } from '../script/executor.js';
+import { loadComponent } from './component-loader.js';
+import { replaceVariablesInObject, createVariableMap } from '../utils/variables.js';
+import { processPromptTemplate } from '../utils/prompt-template.js';
+import { db } from '../db/index.js';
+import { prompts, mcpComponentTools, mcpConfigs, tableDefinitions } from '../db/schema.js';
+import { eq, and } from 'drizzle-orm';
+import { report } from '../utils/telemetry.js';
+export class MCPAggregator {
+    config;
+    scriptExecutor;
+    components = new Map();
+    failedComponents = new Map(); // 记录加载失败的组件
+    variableMap;
+    mcpClientConfig;
+    isInitialized = false; // 标记是否已初始化
+    userId; // 用户 ID，用于加载用户自定义的 prompts
+    configUpdatedAt; // 配置更新时间，用于检测配置是否已更新
+    constructor(config, mcpClientConfig, userId) {
+        this.config = config;
+        this.mcpClientConfig = mcpClientConfig || null;
+        this.userId = userId || config.userId;
+        this.scriptExecutor = new ScriptExecutor(config, mcpClientConfig, this);
+        this.variableMap = createVariableMap(config.variables);
+        this.configUpdatedAt = config.updatedAt || new Date();
+    }
+    /**
+     * 检查是否已初始化
+     */
+    get initialized() {
+        return this.isInitialized;
+    }
+    /**
+     * 初始化聚合器
+     * 注意：不再在初始化时加载组件，组件将在调用工具时按需加载（延迟加载）
+     */
+    async initialize() {
+        console.log(`[MCP] Initializing aggregator for user ${this.userId}, ${this.config.components.length} components configured`);
+        // 不再在初始化时加载组件，组件将在调用工具时按需加载
+        // 这样可以避免初始化时查询工具列表，工具列表现在从数据库读取
+        console.log(`[MCP] Components will be loaded on-demand when tools are called`);
+        // 标记为已初始化
+        this.isInitialized = true;
+        // 执行初始化脚本
+        // 注意：初始化脚本的错误不应该阻止 MCP 连接，只记录错误并继续
+        if (this.config.initScript) {
+            try {
+                await this.scriptExecutor.executeInitScript(this.config.initScript);
+                console.log(`[MCP] Init script executed successfully`);
+            }
+            catch (error) {
+                const errorMessage = error.message || String(error);
+                console.error(`[MCP] Init script execution failed (non-blocking):`, errorMessage);
+                // 不抛出错误，允许 MCP 连接继续
+                // 初始化脚本的错误不应该影响主程序运行
+            }
+        }
+    }
+    /**
+     * 按需加载组件（延迟加载）
+     */
+    async ensureComponentLoaded(componentName, allowDisabled = false) {
+        // 如果组件已加载，直接返回
+        if (this.components.has(componentName)) {
+            return this.components.get(componentName);
+        }
+        // 查找组件配置
+        const component = this.config.components.find(c => c.name === componentName);
+        if (!component) {
+            throw new Error(`Component ${componentName} not found in config`);
+        }
+        // 检查组件是否被禁用（如果 allowDisabled 为 false）
+        if (!allowDisabled && component.disabled) {
+            throw new Error(`Component ${componentName} is disabled`);
+        }
+        // 替换组件配置中的变量
+        const processedComponent = {
+            ...component,
+            disabled: component.disabled,
+            env: component.env ? replaceVariablesInObject(component.env, this.variableMap) : undefined,
+            config: component.config ? replaceVariablesInObject(component.config, this.variableMap) : undefined,
+        };
+        // 加载组件
+        console.log(`[MCP] Loading component on-demand: ${componentName} (type: ${component.type})`);
+        try {
+            const loaded = await loadComponent(processedComponent);
+            this.components.set(componentName, loaded);
+            this.failedComponents.delete(componentName);
+            // 上报组件加载统计
+            report('component_loaded', {
+                component_type: component.type,
+                component_name: componentName,
+                has_namespace: !!component.namespace,
+                tools_count: loaded.tools?.length || 0,
+            }, this.userId);
+            return loaded;
+        }
+        catch (error) {
+            const errorMessage = error.message || String(error);
+            console.error(`[MCP] Failed to load component ${componentName}:`, errorMessage);
+            this.failedComponents.set(componentName, errorMessage);
+            // 上报组件加载失败
+            report('component_load_failed', {
+                component_type: component.type,
+                component_name: componentName,
+                error_type: error.constructor?.name || 'Unknown',
+            }, this.userId);
+            throw error;
+        }
+    }
+    /**
+     * 生成 explore_table 工具的描述（基于数据库中的表定义）
+     */
+    async generateExploreTableDescription() {
+        try {
+            // 获取当前用户的所有表定义，只包含允许探索的表
+            const tables = await db
+                .select()
+                .from(tableDefinitions)
+                .where(and(eq(tableDefinitions.userId, this.userId), eq(tableDefinitions.allowExplore, true) // 只包含允许探索的表
+            ));
+            if (tables.length === 0) {
+                return '目前没有可探索的数据表，该工具暂时不可用。';
+            }
+            let description = '可通过该工具自由探索多个业务相关的数据表，找到需要的信息。使用方式类似 MongoDB 查询语法。\n\n';
+            description += '# 使用示例:\n';
+            description += '  - 查询: { table: "users", query: { age: { $gt: 18 } } }\n';
+            description += '  - 限制返回数量: { table: "users", query: { age: { $gt: 18 }, $limit: 10 } } (默认最多返回5条)\n';
+            description += '  - 批量插入: { table: "users", operation: "insert", data: [{ name: "Alice", age: 25 }, { name: "Bob", age: 30 }] }\n\n';
+            description += '# 可用表列表：\n';
+            for (const table of tables) {
+                const tableDef = {
+                    id: table.id,
+                    name: table.name,
+                    description: table.description || undefined,
+                    columns: JSON.parse(table.columns),
+                    allowExplore: table.allowExplore !== undefined ? Boolean(table.allowExplore) : true,
+                    createdAt: table.createdAt,
+                    updatedAt: table.updatedAt,
+                };
+                description += `表: ${tableDef.name}\n`;
+                if (tableDef.description) {
+                    description += `表说明: ${tableDef.description}\n`;
+                }
+                description += '列定义:\n';
+                for (const col of tableDef.columns) {
+                    description += `  - ${col.name}[${col.type}] ${col.description || ''}\n`;
+                }
+                description += '\n';
+            }
+            return description;
+        }
+        catch (error) {
+            console.error(`[MCP] Failed to generate explore_table description:`, error);
+            return '无法加载表定义，该工具暂时不可用。';
+        }
+    }
+    /**
+     * 生成 explore_table 工具的执行脚本
+     */
+    generateExploreTableScript() {
+        return `export default async function(args: { table: string; query?: any; operation?: string; data?: any }, context: any) {
+  const { table, query, operation = 'find', data } = args;
+  
+  if (!table || typeof table !== 'string') {
+    throw new Error('Table parameter is required and must be a string');
+  }
+
+  // MongoDB 风格的查询匹配函数
+  function matchQuery(row: Record<string, any>, conditions: Record<string, any>): boolean {
+    // 处理逻辑操作符
+    if (conditions.$and) {
+      return conditions.$and.every((cond: Record<string, any>) => matchQuery(row, cond));
+    }
+    
+    if (conditions.$or) {
+      return conditions.$or.some((cond: Record<string, any>) => matchQuery(row, cond));
+    }
+    
+    if (conditions.$not) {
+      return !matchQuery(row, conditions.$not);
+    }
+
+    // 处理字段条件
+    for (const [field, condition] of Object.entries(conditions)) {
+      if (field.startsWith('$')) continue; // 跳过操作符字段
+      
+      const fieldValue = row[field];
+      
+      // 简单值匹配
+      if (typeof condition !== 'object' || condition === null || Array.isArray(condition)) {
+        if (fieldValue !== condition) {
+          return false;
+        }
+        continue;
+      }
+
+      // 操作符匹配
+      for (const [op, opValue] of Object.entries(condition)) {
+        switch (op) {
+          case '$eq':
+            if (fieldValue !== opValue) return false;
+            break;
+          case '$ne':
+            if (fieldValue === opValue) return false;
+            break;
+          case '$gt':
+            if (!(fieldValue > opValue)) return false;
+            break;
+          case '$gte':
+            if (!(fieldValue >= opValue)) return false;
+            break;
+          case '$lt':
+            if (!(fieldValue < opValue)) return false;
+            break;
+          case '$lte':
+            if (!(fieldValue <= opValue)) return false;
+            break;
+          case '$in':
+            if (!Array.isArray(opValue) || !opValue.includes(fieldValue)) return false;
+            break;
+          case '$nin':
+            if (Array.isArray(opValue) && opValue.includes(fieldValue)) return false;
+            break;
+          case '$like':
+            if (typeof fieldValue !== 'string' || typeof opValue !== 'string') return false;
+            const pattern = opValue.replace(/%/g, '.*').replace(/_/g, '.');
+            const regex = new RegExp(\`^\${pattern}$\`, 'i');
+            if (!regex.test(fieldValue)) return false;
+            break;
+          case '$regex':
+            // 支持正则表达式匹配
+            // opValue 可以是字符串（正则表达式）或对象 { pattern: string, flags?: string }
+            // 支持对字符串和数字类型进行匹配（数字会转换为字符串）
+            const fieldValueStr = String(fieldValue);
+            let regexPattern: string;
+            let regexFlags: string = 'i'; // 默认不区分大小写
+            
+            if (typeof opValue === 'string') {
+              regexPattern = opValue;
+            } else if (typeof opValue === 'object' && opValue !== null) {
+              regexPattern = opValue.pattern || opValue.$regex || String(opValue);
+              regexFlags = opValue.flags || opValue.$options || 'i';
+            } else {
+              return false;
+            }
+            
+            try {
+              const regex = new RegExp(regexPattern, regexFlags);
+              if (!regex.test(fieldValueStr)) return false;
+            } catch (e) {
+              // 正则表达式无效，返回 false
+              return false;
+            }
+            break;
+          default:
+            throw new Error(\`Unsupported operator: \${op}\`);
+        }
+      }
+    }
+
+    return true;
+  }
+
+  // MongoDB 风格的查询函数
+  async function findWithMongoQuery(tableName: string, queryObj?: Record<string, any>) {
+    // 获取所有数据
+    let allRows = await context.tables.get(tableName);
+    
+    // 默认 limit 为 5
+    const DEFAULT_LIMIT = 5;
+    
+    if (!queryObj || Object.keys(queryObj).length === 0) {
+      // 即使没有查询条件，也应用默认限制
+      return allRows.slice(0, DEFAULT_LIMIT);
+    }
+
+    // 分离查询条件和选项
+    const { $sort, $limit, $skip, ...conditions } = queryObj;
+    
+    // 应用过滤条件
+    if (Object.keys(conditions).length > 0) {
+      allRows = await context.tables.query(tableName, (row) => matchQuery(row, conditions));
+    }
+
+    // 应用排序
+    if ($sort) {
+      const sortKeys = Object.keys($sort);
+      allRows.sort((a, b) => {
+        for (const key of sortKeys) {
+          const order = $sort[key];
+          const aVal = a[key];
+          const bVal = b[key];
+          
+          if (aVal === bVal) continue;
+          
+          const comparison = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+          return order === 1 ? comparison : -comparison;
+        }
+        return 0;
+      });
+    }
+
+    // 应用跳过
+    if ($skip) {
+      allRows = allRows.slice($skip);
+    }
+
+    // 应用限制：如果没有指定 $limit，使用默认值 5
+    const limit = $limit !== undefined ? $limit : DEFAULT_LIMIT;
+    allRows = allRows.slice(0, limit);
+
+    return allRows;
+  }
+
+  try {
+    let result;
+    
+    switch (operation) {
+      case 'find':
+        // 查询数据：使用 MongoDB 风格的查询对象
+        result = await findWithMongoQuery(table, query || {});
+        break;
+        
+      case 'get':
+        // 获取所有数据（应用默认限制）
+        result = await context.tables.get(table);
+        result = result.slice(0, 5); // 默认最多返回5条
+        break;
+        
+      case 'insert':
+        // 插入数据：data 应该是对象或对象数组
+        if (!data) {
+          throw new Error('Data parameter is required for insert operation');
+        }
+        const rowsToInsert = Array.isArray(data) ? data : [data];
+        result = [];
+        for (const row of rowsToInsert) {
+          const inserted = await context.tables.create(table, row);
+          result.push(inserted);
+        }
+        break;
+        
+      case 'update':
+        // 更新数据：query 指定条件，data 指定更新内容
+        if (!query || !data) {
+          throw new Error('Query and data parameters are required for update operation');
+        }
+        const rowsToUpdate = await findWithMongoQuery(table, query);
+        result = { matched: rowsToUpdate.length, updated: 0 };
+        for (const row of rowsToUpdate) {
+          await context.tables.update(table, row.id, data);
+          result.updated++;
+        }
+        break;
+        
+      case 'delete':
+        // 删除数据：query 指定条件
+        if (!query) {
+          throw new Error('Query parameter is required for delete operation');
+        }
+        const rowsToDelete = await findWithMongoQuery(table, query);
+        result = { matched: rowsToDelete.length, deleted: 0 };
+        for (const row of rowsToDelete) {
+          await context.tables.delete(table, row.id);
+          result.deleted++;
+        }
+        break;
+        
+      default:
+        throw new Error(\`Unsupported operation: \${operation}\`);
+    }
+    
+    return {
+      success: true,
+      data: result,
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message || String(error),
+    };
+  }
+}`;
+    }
+    /**
+     * 获取所有工具（从数据库读取，不实时查询 MCP 组件）
+     * 每次调用时都从数据库重新加载最新配置，确保返回最新的工具列表
+     */
+    async getAllTools() {
+        const tools = [];
+        // 从数据库重新加载最新配置，确保获取最新的自定义工具
+        let latestConfig;
+        try {
+            const configResult = await db
+                .select()
+                .from(mcpConfigs)
+                .where(eq(mcpConfigs.id, this.config.id))
+                .limit(1);
+            if (configResult.length === 0) {
+                console.warn(`[MCP] getAllTools: Config ${this.config.id} not found, using cached config`);
+                latestConfig = this.config;
+            }
+            else {
+                const row = configResult[0];
+                const customToolsFromDB = JSON.parse(row.customTools);
+                latestConfig = {
+                    id: row.id,
+                    userId: row.userId,
+                    name: row.name,
+                    components: JSON.parse(row.components),
+                    customTools: customToolsFromDB,
+                    variables: JSON.parse(row.variables),
+                    initScript: row.initScript || undefined,
+                    enableExploreTable: row.enableExploreTable !== undefined ? Boolean(row.enableExploreTable) : true, // 默认为 true
+                    createdAt: row.createdAt,
+                    updatedAt: row.updatedAt,
+                };
+                // 打印调试信息：比较数据库中的配置和缓存的配置
+                const exploreTableToolFromDB = customToolsFromDB.find((t) => t.name === 'explore_table');
+                const exploreTableToolFromCache = this.config.customTools.find((t) => t.name === 'explore_table');
+                if (exploreTableToolFromDB) {
+                    console.log(`[MCP] getAllTools: explore_table description from DB (first 100 chars):`, exploreTableToolFromDB.description?.substring(0, 100));
+                }
+                if (exploreTableToolFromCache) {
+                    console.log(`[MCP] getAllTools: explore_table description from cache (first 100 chars):`, exploreTableToolFromCache.description?.substring(0, 100));
+                }
+                // 始终使用从数据库加载的最新配置，无论是否更新
+                // 这样可以确保每次调用 getAllTools 都返回最新的工具描述
+                if (latestConfig.updatedAt.getTime() !== this.configUpdatedAt.getTime()) {
+                    console.log(`[MCP] getAllTools: Config timestamp changed (DB: ${latestConfig.updatedAt.toISOString()}, Cache: ${this.configUpdatedAt.toISOString()}), refreshing cached config`);
+                    this.config = latestConfig;
+                    // 更新 configUpdatedAt 以反映新的配置时间
+                    this.configUpdatedAt = latestConfig.updatedAt;
+                }
+                else {
+                    // 即使时间戳相同，也使用数据库配置以确保一致性
+                    console.log(`[MCP] getAllTools: Using DB config (timestamp same: ${latestConfig.updatedAt.toISOString()})`);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`[MCP] getAllTools: Failed to reload config from database:`, error);
+            latestConfig = this.config; // 使用缓存的配置作为后备
+        }
+        console.log(`[MCP] getAllTools: Loading tools from database for config ${latestConfig.id}, customTools count: ${latestConfig.customTools.length}`);
+        try {
+            // 从数据库读取 MCP 组件工具（只读取未禁用的工具）
+            const dbTools = await db
+                .select()
+                .from(mcpComponentTools)
+                .where(and(eq(mcpComponentTools.configId, latestConfig.id), eq(mcpComponentTools.disabled, false)));
+            console.log(`[MCP] getAllTools: Found ${dbTools.length} MCP component tools in database (before filtering disabled components)`);
+            // 创建一个组件ID到组件配置的映射，用于快速查找组件是否被禁用
+            const componentMap = new Map();
+            for (const comp of latestConfig.components) {
+                componentMap.set(comp.id, comp);
+            }
+            // 转换为 MCPTool 格式，同时过滤掉被禁用组件的工具和被禁用的工具
+            let filteredCount = 0;
+            for (const dbTool of dbTools) {
+                // 检查组件是否被禁用
+                const component = componentMap.get(dbTool.componentId);
+                if (component?.disabled) {
+                    filteredCount++;
+                    console.log(`[MCP] getAllTools: Skipping tool ${dbTool.toolName} from disabled component ${component.name}`);
+                    continue;
+                }
+                // 检查工具是否在组件的 disabledTools 列表中
+                // disabledTools 中存储的是原始工具名称（不带命名空间），需要检查 originalToolName
+                const disabledTools = Array.isArray(component?.config?.disabledTools)
+                    ? component.config.disabledTools
+                    : [];
+                if (disabledTools.length > 0 && disabledTools.includes(dbTool.originalToolName)) {
+                    filteredCount++;
+                    console.log(`[MCP] getAllTools: Skipping disabled tool ${dbTool.toolName} (original: ${dbTool.originalToolName}, disabledTools: [${disabledTools.join(', ')}])`);
+                    continue;
+                }
+                // 确保工具名称包含命名空间前缀
+                // 如果数据库中的 toolName 没有命名空间前缀（向后兼容），则动态添加
+                let finalToolName = dbTool.toolName;
+                if (component) {
+                    // 确定命名空间：如果设置了命名空间则使用，否则使用组件名称
+                    const namespace = component.namespace && component.namespace.trim() !== ''
+                        ? component.namespace.trim()
+                        : component.name;
+                    // 检查 toolName 是否已经包含命名空间前缀
+                    // 如果 toolName 不包含命名空间前缀，则添加
+                    // 使用下横线连接命名空间和工具名称（Cursor 兼容性）
+                    if (!finalToolName.startsWith(`${namespace}_`)) {
+                        // 如果 toolName 已经是原始工具名称（不带命名空间），则添加命名空间前缀
+                        if (finalToolName === dbTool.originalToolName) {
+                            finalToolName = `${namespace}_${dbTool.originalToolName}`;
+                            console.log(`[MCP] getAllTools: Adding namespace prefix to tool: ${dbTool.originalToolName} -> ${finalToolName}`);
+                        }
+                        else {
+                            // 如果 toolName 包含其他命名空间，保持原样（可能是旧数据）
+                            console.log(`[MCP] getAllTools: Tool ${finalToolName} already has a namespace prefix, keeping as is`);
+                        }
+                    }
+                }
+                // 应用工具补丁（如果存在）
+                // toolPatches 的结构是：{ "originalToolName": { description: "...", inputSchema: {...}, fieldDescriptions: {...} } }
+                // 优先使用组件配置中的 toolPatches（最新），如果没有则使用数据库中的 toolPatches
+                let inputSchema = dbTool.inputSchema || { type: 'object', properties: {} };
+                let description = dbTool.description;
+                // 优先从组件配置中获取 toolPatches
+                let toolPatches = null;
+                if (component?.config?.toolPatches && typeof component.config.toolPatches === 'object') {
+                    toolPatches = component.config.toolPatches;
+                }
+                else if (dbTool.toolPatches && typeof dbTool.toolPatches === 'object' && dbTool.toolPatches !== null) {
+                    toolPatches = dbTool.toolPatches;
+                }
+                if (toolPatches) {
+                    // 使用 originalToolName 查找对应的补丁
+                    const toolPatch = toolPatches[dbTool.originalToolName];
+                    if (toolPatch) {
+                        // 应用 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,
+                                        };
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                tools.push({
+                    name: finalToolName, // 确保包含命名空间前缀
+                    description: description,
+                    inputSchema: inputSchema,
+                });
+            }
+            if (filteredCount > 0) {
+                console.log(`[MCP] getAllTools: Filtered out ${filteredCount} tools (disabled components or disabled tools)`);
+            }
+            console.log(`[MCP] getAllTools: Returning ${tools.length} MCP component tools (after filtering disabled components and tools)`);
+        }
+        catch (error) {
+            console.error(`[MCP] Failed to load tools from database:`, error);
+            // 如果数据库查询失败，返回空数组而不是抛出错误
+        }
+        // 添加自定义工具（使用最新加载的配置，但排除 explore_table，因为它是内置特殊工具）
+        const mcpToolsCount = tools.length;
+        const customToolsFiltered = latestConfig.customTools.filter(t => t.name !== 'explore_table');
+        console.log(`[MCP] getAllTools: Adding ${customToolsFiltered.length} custom tools (excluding explore_table)`);
+        if (customToolsFiltered.length > 0) {
+            console.log(`[MCP] getAllTools: Custom tools:`, customToolsFiltered.map(t => t.name).join(', '));
+        }
+        for (const customTool of customToolsFiltered) {
+            const toolSchema = {
+                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),
+                },
+            };
+            console.log(`[MCP] getAllTools: Adding custom tool: ${toolSchema.name}`);
+            tools.push(toolSchema);
+        }
+        // 添加内置的 explore_table 工具（基于数据库中的表定义动态生成）
+        // 只有当配置中 enableExploreTable 为 true 时才添加（默认为 true）
+        // 使用 latestConfig 而不是 this.config，确保使用最新加载的配置
+        if (latestConfig.enableExploreTable !== false) {
+            try {
+                const exploreTableDescription = await this.generateExploreTableDescription();
+                const exploreTableTool = {
+                    name: 'explore_table',
+                    description: exploreTableDescription,
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            table: {
+                                type: 'string',
+                                description: '表名',
+                            },
+                            operation: {
+                                type: 'string',
+                                description: '操作类型: find(查询), get(获取所有), insert(插入), update(更新), delete(删除)',
+                            },
+                            query: {
+                                type: 'object',
+                                description: '查询对象（用于 find/update/delete），支持操作符和条件',
+                            },
+                            data: {
+                                type: 'object',
+                                description: '数据对象或数组（用于 insert/update）',
+                            },
+                        },
+                        required: ['table'],
+                    },
+                };
+                console.log(`[MCP] getAllTools: Adding built-in explore_table tool`);
+                tools.push(exploreTableTool);
+            }
+            catch (error) {
+                console.error(`[MCP] getAllTools: Failed to add explore_table tool:`, error);
+            }
+        }
+        else {
+            console.log(`[MCP] getAllTools: explore_table tool is disabled by configuration`);
+        }
+        console.log(`[MCP] getAllTools: Total ${tools.length} tools (${mcpToolsCount} from MCP components, ${customToolsFiltered.length} custom, 1 built-in explore_table)`);
+        return tools;
+    }
+    /**
+     * 获取所有提示
+     */
+    async getAllPrompts() {
+        const allPrompts = [];
+        console.log(`[MCP] getAllPrompts: Starting, ${this.components.size} components loaded`);
+        // 从组件获取提示
+        for (const [name, component] of this.components) {
+            // 通过 component name 在配置中查找原始配置
+            const originalComponent = this.config.components.find(c => c.name === name);
+            // 跳过禁用的组件（双重检查，防止配置更新后组件仍被加载）
+            if (originalComponent?.disabled) {
+                console.log(`[MCP] getAllPrompts: Skipping disabled component ${name}`);
+                continue;
+            }
+            try {
+                console.log(`[MCP] getAllPrompts: Fetching prompts from component ${name}`);
+                // 添加超时保护（10秒）
+                const componentPrompts = await Promise.race([
+                    component.client.listPrompts(),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout fetching prompts from component ${name}`)), 10000))
+                ]);
+                console.log(`[MCP] getAllPrompts: Component ${name} returned ${componentPrompts.length} prompts`);
+                // 应用命名空间前缀：只有在明确设置了命名空间时才使用，否则不添加前缀
+                const namespace = originalComponent?.namespace && originalComponent.namespace.trim() !== ''
+                    ? originalComponent.namespace.trim()
+                    : null;
+                for (const prompt of componentPrompts) {
+                    allPrompts.push({
+                        name: namespace ? `${namespace}.${prompt.name}` : prompt.name,
+                        description: prompt.description || '',
+                        arguments: prompt.arguments || [],
+                    });
+                }
+            }
+            catch (error) {
+                const errorMessage = error.message || String(error);
+                console.error(`[MCP] Failed to get prompts from component ${name}:`, errorMessage);
+                // 继续处理其他组件，不中断
+            }
+        }
+        // 从数据库获取用户自定义的 prompts
+        try {
+            const userPrompts = await db
+                .select()
+                .from(prompts)
+                .where(eq(prompts.userId, this.userId));
+            for (const row of userPrompts) {
+                allPrompts.push({
+                    name: row.name,
+                    description: row.description || undefined,
+                    arguments: JSON.parse(row.arguments),
+                });
+            }
+        }
+        catch (error) {
+            console.error(`Failed to load user prompts:`, error);
+        }
+        console.log(`[MCP] getAllPrompts: Total ${allPrompts.length} prompts`);
+        return allPrompts;
+    }
+    /**
+     * 替换消息模板中的变量（支持条件逻辑）
+     */
+    replaceVariables(text, args) {
+        return processPromptTemplate(text, args);
+    }
+    /**
+     * 获取提示内容
+     * @param promptName 提示名称
+     * @param args 可选参数，用于填充 prompt 模板。如果 prompt 不需要参数，可以不传或传空对象 {}
+     */
+    async getPrompt(promptName, args) {
+        // 先检查是否是用户自定义的 prompt（从数据库加载）
+        try {
+            const userPrompts = await db
+                .select()
+                .from(prompts)
+                .where(and(eq(prompts.userId, this.userId), eq(prompts.name, promptName)))
+                .limit(1);
+            if (userPrompts.length > 0) {
+                const promptRow = userPrompts[0];
+                const promptMessages = JSON.parse(promptRow.messages);
+                const promptArgs = args || {};
+                console.log(`[MCP] getPrompt: Loading user prompt "${promptName}" with ${promptMessages.length} messages`);
+                // 替换消息中的变量，确保格式符合 MCP 协议规范
+                const processedMessages = promptMessages.map((msg) => {
+                    // 确保消息格式符合 MCP 协议：role 和 content 是必需的
+                    // content 必须包含 type 和 text 字段
+                    return {
+                        role: msg.role || 'user',
+                        content: {
+                            type: msg.content?.type || 'text',
+                            text: this.replaceVariables(msg.content?.text || '', promptArgs),
+                        },
+                    };
+                });
+                const result = {
+                    description: promptRow.description || undefined,
+                    messages: processedMessages,
+                };
+                console.log(`[MCP] getPrompt: Returning prompt "${promptName}" with ${processedMessages.length} messages`);
+                console.log(`[MCP] getPrompt: Sample message format:`, JSON.stringify(processedMessages[0] || {}, null, 2));
+                return result;
+            }
+        }
+        catch (error) {
+            console.error(`Failed to load user prompt ${promptName}:`, error);
+        }
+        // 调用组件提示
+        const parts = promptName.split('.');
+        if (parts.length >= 2) {
+            const namespace = parts[0];
+            const actualPromptName = parts.slice(1).join('.');
+            // 查找匹配的组件（通过命名空间或组件名称）
+            for (const [name, component] of this.components) {
+                const originalComponent = this.config.components.find(c => c.name === name);
+                // 检查组件是否被禁用
+                if (originalComponent?.disabled) {
+                    continue;
+                }
+                // 匹配命名空间：只有在明确设置了命名空间时才匹配命名空间，否则匹配组件名称
+                const componentNamespace = originalComponent?.namespace && originalComponent.namespace.trim() !== ''
+                    ? originalComponent.namespace.trim()
+                    : null;
+                if (componentNamespace === namespace || (!componentNamespace && name === namespace)) {
+                    try {
+                        return await component.client.getPrompt(actualPromptName, args);
+                    }
+                    catch (error) {
+                        throw new Error(`Failed to get prompt "${promptName}": ${error.message}`);
+                    }
+                }
+            }
+        }
+        else {
+            // 没有命名空间，尝试在所有组件中查找（只查找没有设置命名空间的组件）
+            for (const [name, component] of this.components) {
+                const originalComponent = this.config.components.find(c => c.name === name);
+                // 检查组件是否被禁用
+                if (originalComponent?.disabled) {
+                    continue;
+                }
+                // 只在没有设置命名空间的组件中查找
+                const componentNamespace = originalComponent?.namespace && originalComponent.namespace.trim() !== ''
+                    ? originalComponent.namespace.trim()
+                    : null;
+                if (componentNamespace) {
+                    // 如果组件设置了命名空间，跳过（因为提示名称应该包含命名空间）
+                    continue;
+                }
+                try {
+                    const prompts = await component.client.listPrompts();
+                    const prompt = prompts.find((p) => p.name === promptName);
+                    if (prompt) {
+                        return await component.client.getPrompt(promptName, args);
+                    }
+                }
+                catch (error) {
+                    // 继续查找
+                }
+            }
+        }
+        throw new Error(`Prompt ${promptName} not found`);
+    }
+    /**
+     * 从数据库检查工具是否被禁用
+     */
+    async isToolDisabledInDB(toolName) {
+        try {
+            const dbTool = await db
+                .select()
+                .from(mcpComponentTools)
+                .where(and(eq(mcpComponentTools.configId, this.config.id), eq(mcpComponentTools.toolName, toolName)))
+                .limit(1);
+            if (dbTool.length > 0) {
+                return dbTool[0].disabled;
+            }
+        }
+        catch (error) {
+            console.error(`[MCP] Failed to check tool disabled status:`, error);
+        }
+        return false;
+    }
+    /**
+     * 调用工具（实时转发到 MCP 组件）
+     */
+    async callTool(toolName, args, allowDisabled = false) {
+        // 检查是否是内置的 explore_table 工具
+        if (toolName === 'explore_table') {
+            // 从数据库重新加载最新配置，检查是否启用了 explore_table 工具
+            let enableExploreTable = true; // 默认为 true
+            try {
+                const configResult = await db
+                    .select()
+                    .from(mcpConfigs)
+                    .where(eq(mcpConfigs.id, this.config.id))
+                    .limit(1);
+                if (configResult.length > 0) {
+                    const row = configResult[0];
+                    enableExploreTable = row.enableExploreTable !== undefined ? Boolean(row.enableExploreTable) : true;
+                }
+            }
+            catch (error) {
+                console.error(`[MCP] callTool: Failed to reload config from database:`, error);
+                // 如果加载失败，使用缓存的配置
+                enableExploreTable = this.config.enableExploreTable !== false;
+            }
+            if (enableExploreTable === false) {
+                throw new Error('Tool "explore_table" is disabled');
+            }
+            // 检查表是否允许探索
+            if (args.table) {
+                const tableDef = await db
+                    .select()
+                    .from(tableDefinitions)
+                    .where(and(eq(tableDefinitions.userId, this.userId), eq(tableDefinitions.name, args.table)))
+                    .limit(1);
+                if (tableDef.length === 0) {
+                    throw new Error(`Table "${args.table}" not found`);
+                }
+                const allowExploreValue = tableDef[0].allowExplore;
+                const allowExplore = allowExploreValue !== null && allowExploreValue !== undefined ? Boolean(allowExploreValue) : true;
+                if (!allowExplore) {
+                    throw new Error(`Table "${args.table}" is not allowed to be explored`);
+                }
+            }
+            // 创建临时的自定义工具对象来执行脚本
+            const exploreTableTool = {
+                id: 'builtin-explore-table',
+                name: 'explore_table',
+                description: await this.generateExploreTableDescription(),
+                serverScript: this.generateExploreTableScript(),
+                parameters: [
+                    {
+                        name: 'table',
+                        type: 'string',
+                        description: '表名',
+                        required: true,
+                    },
+                    {
+                        name: 'operation',
+                        type: 'string',
+                        description: '操作类型: find(查询), get(获取所有), insert(插入), update(更新), delete(删除)',
+                        required: false,
+                    },
+                    {
+                        name: 'query',
+                        type: 'object',
+                        description: '查询对象（用于 find/update/delete），支持操作符和条件',
+                        required: false,
+                    },
+                    {
+                        name: 'data',
+                        type: 'object',
+                        description: '数据对象或数组（用于 insert/update）',
+                        required: false,
+                    },
+                ],
+            };
+            const result = await this.scriptExecutor.executeTool(exploreTableTool, args);
+            // 上报 explore_table 工具调用统计
+            report('tool_called', {
+                tool_name: 'explore_table',
+                component_type: 'builtin',
+                is_custom_tool: true,
+                operation: args.operation || 'unknown',
+                has_table: !!args.table,
+            }, this.userId);
+            return result;
+        }
+        // 检查是否是自定义工具（排除 explore_table，因为它已经作为内置工具处理）
+        const customTool = this.config.customTools.find((t) => t.name === toolName && t.name !== 'explore_table');
+        if (customTool) {
+            // 自定义工具统一为单一脚本（运行在服务端），执行即可（缺失脚本在执行器内抛错）
+            const result = await this.scriptExecutor.executeTool(customTool, args);
+            // 上报自定义工具调用统计
+            report('tool_called', {
+                tool_name: toolName,
+                component_type: 'custom',
+                is_custom_tool: true,
+                has_parameters: (customTool.parameters?.length || 0) > 0,
+            }, this.userId);
+            return result;
+        }
+        // 检查工具是否在数据库中被禁用
+        const isDisabled = await this.isToolDisabledInDB(toolName);
+        if (isDisabled) {
+            throw new Error(`Tool "${toolName}" is disabled`);
+        }
+        // 从数据库查找工具信息，确定组件名称
+        // 首先尝试直接匹配 toolName（可能包含命名空间前缀）
+        console.log(`[MCP] callTool: Looking up tool "${toolName}" in database`);
+        let dbTool = await db
+            .select()
+            .from(mcpComponentTools)
+            .where(and(eq(mcpComponentTools.configId, this.config.id), eq(mcpComponentTools.toolName, toolName)))
+            .limit(1);
+        if (dbTool.length > 0) {
+            console.log(`[MCP] callTool: Found tool directly by toolName: ${dbTool[0].toolName} (original: ${dbTool[0].originalToolName}, component: ${dbTool[0].componentName})`);
+        }
+        // 如果直接匹配失败，尝试通过 originalToolName 查找（处理命名空间不一致的情况）
+        if (dbTool.length === 0) {
+            console.log(`[MCP] callTool: Direct lookup failed, trying to find by originalToolName "${toolName}"`);
+            // 首先尝试：如果 toolName 看起来像带命名空间的（包含下横线），
+            // 尝试提取命名空间和原始工具名称，然后查找
+            if (toolName.includes('_')) {
+                const parts = toolName.split('_');
+                // 尝试不同的分割方式：可能是 "namespace_tool" 或 "namespace_tool_name"
+                for (let i = 1; i < parts.length; i++) {
+                    const possibleNamespace = parts.slice(0, i).join('_');
+                    const possibleOriginalName = parts.slice(i).join('_');
+                    // 查找匹配命名空间和原始工具名称的工具
+                    const namespaceMatchedTools = await db
+                        .select()
+                        .from(mcpComponentTools)
+                        .where(and(eq(mcpComponentTools.configId, this.config.id), eq(mcpComponentTools.originalToolName, possibleOriginalName)));
+                    for (const tool of namespaceMatchedTools) {
+                        const component = this.config.components.find(c => c.name === tool.componentName);
+                        if (component) {
+                            const namespace = component.namespace && component.namespace.trim() !== ''
+                                ? component.namespace.trim()
+                                : component.name;
+                            if (namespace === possibleNamespace) {
+                                dbTool = [tool];
+                                console.log(`[MCP] callTool: Found tool by namespace "${possibleNamespace}" and originalToolName "${possibleOriginalName}": ${tool.toolName}`);
+                                break;
+                            }
+                        }
+                    }
+                    if (dbTool.length > 0)
+                        break;
+                }
+            }
+            // 如果还是没找到，尝试直接通过 originalToolName 查找
+            if (dbTool.length === 0) {
+                const allTools = await db
+                    .select()
+                    .from(mcpComponentTools)
+                    .where(and(eq(mcpComponentTools.configId, this.config.id), eq(mcpComponentTools.originalToolName, toolName)));
+                console.log(`[MCP] callTool: Found ${allTools.length} tools with originalToolName "${toolName}"`);
+                if (allTools.length > 0) {
+                    // 如果只有一个匹配，直接使用
+                    if (allTools.length === 1) {
+                        dbTool = allTools;
+                        console.log(`[MCP] callTool: Using single match: ${allTools[0].toolName} (original: ${allTools[0].originalToolName}, component: ${allTools[0].componentName})`);
+                    }
+                    else {
+                        // 如果找到多个匹配，优先选择与组件命名空间匹配的
+                        // 否则使用第一个匹配项
+                        let matchedTool = allTools[0];
+                        // 尝试找到命名空间匹配的工具
+                        for (const tool of allTools) {
+                            const component = this.config.components.find(c => c.name === tool.componentName);
+                            if (component) {
+                                const namespace = component.namespace && component.namespace.trim() !== ''
+                                    ? component.namespace.trim()
+                                    : component.name;
+                                const expectedToolName = `${namespace}_${tool.originalToolName}`;
+                                console.log(`[MCP] callTool: Checking tool "${tool.toolName}" (component: ${tool.componentName}, namespace: ${namespace}, expected: ${expectedToolName})`);
+                                if (expectedToolName === toolName) {
+                                    matchedTool = tool;
+                                    console.log(`[MCP] callTool: Found namespace-matched tool: ${matchedTool.toolName}`);
+                                    break;
+                                }
+                            }
+                        }
+                        dbTool = [matchedTool];
+                        console.log(`[MCP] callTool: Using tool "${matchedTool.toolName}" (original: ${matchedTool.originalToolName}, component: ${matchedTool.componentName})`);
+                    }
+                }
+            }
+        }
+        if (dbTool.length === 0) {
+            throw new Error(`Tool "${toolName}" not found in database`);
+        }
+        const toolInfo = dbTool[0];
+        const componentName = toolInfo.componentName;
+        const originalToolName = toolInfo.originalToolName;
+        // 前置校验：检查组件是否被禁用
+        const componentConfig = this.config.components.find(c => c.name === componentName);
+        if (!componentConfig) {
+            throw new Error(`Component "${componentName}" not found in config`);
+        }
+        // 如果 allowDisabled 为 false，检查组件是否被禁用
+        if (!allowDisabled && componentConfig.disabled) {
+            throw new Error(`Component "${componentName}" is disabled`);
+        }
+        // 前置校验：检查工具是否在组件配置中被禁用
+        // 如果 allowDisabled 为 false，检查工具是否被禁用
+        if (!allowDisabled) {
+            const disabledTools = Array.isArray(componentConfig.config?.disabledTools)
+                ? componentConfig.config.disabledTools
+                : [];
+            if (disabledTools.includes(originalToolName)) {
+                throw new Error(`Tool "${toolName}" is disabled in component configuration`);
+            }
+        }
+        // 按需加载组件（传递 allowDisabled 参数）
+        const component = await this.ensureComponentLoaded(componentName, allowDisabled);
+        // 调用组件的工具（实时转发）
+        try {
+            const result = await component.client.callTool(originalToolName, args);
+            // 上报工具调用统计
+            report('tool_called', {
+                tool_name: toolName,
+                original_tool_name: originalToolName,
+                component_name: componentName,
+                component_type: componentConfig.type,
+                has_namespace: !!componentConfig.namespace,
+                is_custom_tool: toolName === 'explore_table' || this.config.customTools.some(t => t.name === toolName),
+            }, this.userId);
+            return result;
+        }
+        catch (error) {
+            // 上报工具调用失败
+            report('tool_call_failed', {
+                tool_name: toolName,
+                component_name: componentName,
+                error_type: error.constructor?.name || 'Unknown',
+            }, this.userId);
+            throw new Error(`Failed to call tool "${toolName}": ${error.message}`);
+        }
+    }
+    /**
+     * 处理 MCP 协议请求
+     */
+    async handleRequest(request) {
+        const { method, params } = request;
+        try {
+            switch (method) {
+                case 'initialize': {
+                    // 初始化请求
+                    // 注意：initialize 响应中不返回工具列表，工具列表通过 tools/list 请求获取
+                    // 调用 getAllTools 以确保配置已重新加载
+                    const tools = await this.getAllTools();
+                    console.log(`[MCP] Initialize: ${tools.length} tools available (will be returned via tools/list)`);
+                    console.log(`[MCP] Initialize: Config has ${this.config.customTools.length} custom tools`);
+                    if (tools.length > 0) {
+                        console.log(`[MCP] Initialize: Tool names:`, tools.map(t => t.name).join(', '));
+                    }
+                    else {
+                        console.warn(`[MCP] Initialize: WARNING - No tools available! This may indicate a configuration issue.`);
+                        console.warn(`[MCP] Initialize: Config ID: ${this.config.id}, Components: ${this.config.components.length}`);
+                    }
+                    return {
+                        result: {
+                            protocolVersion: '2024-11-05',
+                            capabilities: {
+                                tools: {
+                                    listChanged: false, // 声明支持工具列表功能
+                                },
+                                prompts: {},
+                            },
+                            serverInfo: {
+                                name: 'flex-mcp',
+                                version: '1.0.0',
+                            },
+                        },
+                    };
+                }
+                case 'notifications/initialized':
+                    // 初始化完成通知，无需返回结果
+                    return {};
+                case 'ping':
+                    return { result: {} };
+                // 兼容旧版本的协议方法
+                case 'listOfferings':
+                case 'ListOfferings': {
+                    // 返回工具列表（兼容旧协议）
+                    const allToolsCompat = await this.getAllTools();
+                    return {
+                        result: {
+                            tools: allToolsCompat,
+                        },
+                    };
+                }
+                case 'tools/list': {
+                    console.log(`[MCP] tools/list: Request received`);
+                    try {
+                        const allTools = await this.getAllTools();
+                        console.log(`[MCP] tools/list: Returning ${allTools.length} tools`);
+                        if (allTools.length > 0) {
+                            console.log(`[MCP] tools/list: Tool names:`, allTools.map(t => t.name).join(', '));
+                            // 打印第一个工具的详细信息用于调试
+                            console.log(`[MCP] tools/list: First tool details:`, JSON.stringify(allTools[0], null, 2));
+                        }
+                        else {
+                            console.warn(`[MCP] tools/list: No tools found!`);
+                        }
+                        return {
+                            result: { tools: allTools },
+                        };
+                    }
+                    catch (error) {
+                        console.error(`[MCP] tools/list: Error getting tools:`, error);
+                        return {
+                            error: {
+                                code: -32000,
+                                message: `Failed to get tools: ${error.message}`,
+                            },
+                        };
+                    }
+                }
+                case 'tools/call': {
+                    const { name, arguments: args } = params;
+                    if (!name) {
+                        return {
+                            error: {
+                                code: -32602,
+                                message: 'Invalid params: tool name is required',
+                            },
+                        };
+                    }
+                    const result = await this.callTool(name, args || {});
+                    return {
+                        result: {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
+                                },
+                            ],
+                        },
+                    };
+                }
+                case 'resources/list': {
+                    return {
+                        result: { resources: [] },
+                    };
+                }
+                case 'resources/read': {
+                    return {
+                        error: {
+                            code: -32601,
+                            message: 'Resources are not supported',
+                        },
+                    };
+                }
+                case 'prompts/list': {
+                    const allPrompts = await this.getAllPrompts();
+                    console.log(`[MCP] prompts/list: Returning ${allPrompts.length} prompts`);
+                    return {
+                        result: { prompts: allPrompts },
+                    };
+                }
+                case 'prompts/get': {
+                    const { name: promptName, arguments: promptArgs } = params;
+                    console.log(`[MCP] prompts/get: Request for prompt "${promptName}" with args:`, JSON.stringify(promptArgs || {}));
+                    if (!promptName) {
+                        return {
+                            error: {
+                                code: -32602,
+                                message: 'Invalid params: prompt name is required',
+                            },
+                        };
+                    }
+                    try {
+                        // 参数是可选的：如果 prompt 不需要参数，可以不传 arguments 或传空对象 {}
+                        const promptResult = await this.getPrompt(promptName, promptArgs || {});
+                        console.log(`[MCP] prompts/get: Successfully retrieved prompt "${promptName}", messages count: ${promptResult.messages?.length || 0}`);
+                        return {
+                            result: promptResult,
+                        };
+                    }
+                    catch (error) {
+                        console.error(`[MCP] prompts/get: Error retrieving prompt "${promptName}":`, error.message || error);
+                        return {
+                            error: {
+                                code: -32602,
+                                message: error.message || `Failed to get prompt: ${promptName}`,
+                            },
+                        };
+                    }
+                }
+                default:
+                    return {
+                        error: {
+                            code: -32601,
+                            message: `Method not found: ${method}`,
+                        },
+                    };
+            }
+        }
+        catch (error) {
+            return {
+                error: {
+                    code: -32000,
+                    message: error.message || 'Internal error',
+                },
+            };
+        }
+    }
+    /**
+     * 关闭聚合器
+     * 确保所有资源正确释放
+     */
+    async close() {
+        // 关闭所有组件连接
+        const closePromises = [];
+        for (const [name, component] of this.components) {
+            closePromises.push((async () => {
+                try {
+                    await component.client.close();
+                }
+                catch (error) {
+                    console.error(`Failed to close component ${name}:`, error.message || error);
+                }
+            })());
+        }
+        // 并行关闭所有组件，但设置总体超时（10秒）
+        try {
+            await Promise.race([
+                Promise.all(closePromises),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Aggregator close timeout')), 10000))
+            ]);
+        }
+        catch (error) {
+            if (error.message === 'Aggregator close timeout') {
+                console.warn(`[MCP] Some components did not close within timeout, forcing cleanup`);
+            }
+            else {
+                console.error(`[MCP] Error closing aggregator:`, error.message || error);
+            }
+        }
+        this.components.clear();
+        this.failedComponents.clear();
+        await this.scriptExecutor.cleanup();
+    }
+}
+//# sourceMappingURL=aggregator.js.map