foliko 1.1.7 → 1.1.8

package/src/executors/mcp-executor.js

@@ -202,6 +202,8 @@ class MCPExecutorPlugin extends Plugin {
     this._framework = null;
     // serverName -> { client, tools: [{ name, description, inputSchema }], toolObjects: { toolName: actualTool } }
     this._clients = new Map();
+    // 保存服务器配置，用于重新启用
+    this._serverConfigs = new Map();
     this._config = config;
     // 注册的工具对象（extension-executor 会扫描这个）
     // 格式: { 'server_toolname': { name, description, inputSchema, execute } }
@@ -217,6 +219,12 @@ class MCPExecutorPlugin extends Plugin {
     // 先连接所有 MCP 服务器
     if (this._config.servers) {
       for (const serverConfig of this._config.servers) {
+        if (serverConfig.enabled === false) {
+          log.info(` Skipping disabled server: ${serverConfig.name}`);
+          // 保存完整配置，以便后续动态启用
+          this._serverConfigs.set(serverConfig.name, { ...serverConfig });
+          continue;
+        }
         await this.addServer(serverConfig);
       }
     }
@@ -409,12 +417,26 @@ class MCPExecutorPlugin extends Plugin {
       inputSchema: z.object({}),
       execute: async () => {
         const servers = [];
+        // 已连接的服务器
         for (const [name, info] of this._clients) {
           servers.push({
             name,
+            enabled: true,
+            connected: true,
             tools: info.tools.map((t) => ({ name: t.name, description: t.description })),
           });
         }
+        // 未连接的服务器（配置中存在但未启用）
+        for (const [name, config] of this._serverConfigs) {
+          if (!this._clients.has(name)) {
+            servers.push({
+              name,
+              enabled: false,
+              connected: false,
+              tools: [],
+            });
+          }
+        }
         return { success: true, servers };
       },
     });
@@ -456,6 +478,77 @@ class MCPExecutorPlugin extends Plugin {
       },
     });
 
+    // 注册 mcp_set_enabled 工具 - 动态开启/关闭 MCP 服务器
+    framework.registerTool({
+      name: 'mcp_set_enabled',
+      description: '动态开启或关闭某个 MCP 服务器',
+      inputSchema: z.object({
+        server: z.string().describe('MCP 服务器名称'),
+        enabled: z.boolean().describe('true=开启，false=关闭'),
+      }),
+      execute: async (args) => {
+        const { server, enabled } = args;
+        const clientInfo = this._clients.get(server);
+        const serverConfig = this._serverConfigs.get(server);
+
+        if (enabled) {
+          // 启用服务器
+          if (clientInfo && clientInfo.enabled) {
+            return { success: true, message: `MCP 服务器 '${server}' 已经是开启状态` };
+          }
+          // 如果服务器从未连接过，也检查配置中的 enabled 状态
+          if (!clientInfo && serverConfig && serverConfig.enabled === false) {
+            // 服务器是被禁用的，可以尝试启用
+          }
+          log.info(
+            `[MCP] Enabling server: ${server}, clientInfo=${!!clientInfo}, serverConfig.enabled=${serverConfig?.enabled}`
+          );
+          try {
+            if (serverConfig) {
+              const result = await this.addServer({ ...serverConfig, enabled: true });
+              log.info(`[MCP] addServer result:`, JSON.stringify(result));
+              if (!result || result.success === false) {
+                this._refreshAllAgentsMCPPrompt(this._framework);
+                return result;
+              }
+              // 保存 enabled 状态到配置文件
+              await this._saveMCPServerEnabled(server, true);
+              this._refreshAllAgentsMCPPrompt(this._framework);
+              return { success: true, message: `MCP 服务器 '${server}' 已开启` };
+            } else {
+              return { success: false, error: '服务器配置不存在，需要重载配置' };
+            }
+          } catch (err) {
+            log.error(`[MCP] Enabling failed:`, err.message);
+            return { success: false, error: `开启失败: ${err.message}` };
+          }
+        } else {
+          // 禁用服务器
+          if (!clientInfo) {
+            return { success: false, error: `MCP server '${server}' not found` };
+          }
+          log.info(` Disabling MCP server: ${server}`);
+          try {
+            clientInfo.client.close?.();
+          } catch (e) {}
+          // 从 clients 中移除
+          this._clients.delete(server);
+          // 移除该服务器注册的工具
+          for (const key of Object.keys(this.tools)) {
+            if (key.startsWith(`${server}_`)) {
+              delete this.tools[key];
+            }
+          }
+          // 保存 enabled 状态到配置文件
+          await this._saveMCPServerEnabled(server, false);
+          this._refreshAllAgentsMCPPrompt(this._framework);
+          return { success: true, message: `MCP 服务器 '${server}' 已关闭` };
+        }
+
+        return { success: true, message: `MCP 服务器 '${server}' 状态未变化` };
+      },
+    });
+
     // 监听 agent 创建事件，附加 MCP 信息到系统提示词
     framework.on('agent:created', (agent) => {
       if (!this._mainAgent) {
@@ -485,7 +578,7 @@ class MCPExecutorPlugin extends Plugin {
     const traverse = (agent) => {
       if (!agent || visited.has(agent)) return;
       visited.add(agent);
-      this._refreshAgentMCPPrompt(agent);
+      //this._refreshAgentMCPPrompt(agent);
 
       // 递归处理子 agent
       const subAgents = agent.getSubAgents?.() || agent._subAgents || new Map();
@@ -509,11 +602,11 @@ class MCPExecutorPlugin extends Plugin {
       return;
     }
 
-    const mcpDesc = this._buildMCPServersDescription();
-    if (!mcpDesc) return;
+    // const mcpDesc = this._buildMCPServersDescription();
+    // if (!mcpDesc) return;
 
     // 将 MCP 描述追加到系统提示词
-    agent.setSystemPrompt(existingPrompt + '\n\n' + mcpDesc);
+    //agent.setSystemPrompt(existingPrompt + '\n\n' + mcpDesc);
   }
 
   /**
@@ -592,8 +685,12 @@ class MCPExecutorPlugin extends Plugin {
               }
             }
           } catch (e) {
-            // 如果转换失败，使用简化格式
-            desc += this._fallbackParamsDesc(zodSchemaForFallback || schema);
+            // 如果转换失败，使用 fallback
+            try {
+              desc += this._fallbackParamsDesc(zodSchemaForFallback || schema);
+            } catch (e2) {
+              // fallback 也失败，忽略参数描述
+            }
           }
         }
       }
@@ -606,6 +703,61 @@ class MCPExecutorPlugin extends Plugin {
     return desc.trim();
   }
 
+  _bindMcpParamsDesc(rawSchema) {
+    let desc = '';
+    const schema = this._extractSchema(rawSchema);
+    if (!schema) return desc;
+    try {
+      let schemaResult = null;
+      let zodSchemaForFallback = null; // 保存 Zod schema 供 fallback 使用
+      // 检查是否是 Zod schema (有 shape 方法或 _def 属性)
+      const isZodSchema =
+        typeof schema.shape === 'function' || (schema._def && schema._def.typeName);
+      if (isZodSchema) {
+        // Zod schema 直接转换
+        schemaResult = zodSchemaToMarkdown(schema);
+        zodSchemaForFallback = schema;
+      } else if (schema.jsonSchema) {
+        // JSON Schema 格式，尝试转换为 Zod schema
+        const zodSchema = this._jsonSchemaToZod(schema.jsonSchema || schema);
+        if (zodSchema) {
+          schemaResult = zodSchemaToMarkdown(zodSchema);
+          zodSchemaForFallback = zodSchema;
+        }
+      } else if (schema.properties) {
+        // 已经是对象格式
+        const zodSchema = this._jsonSchemaToZod(schema);
+        if (zodSchema) {
+          schemaResult = zodSchemaToMarkdown(zodSchema);
+          zodSchemaForFallback = zodSchema;
+        }
+      }
+
+      // 检查是否包含未解析的原始 Zod 类型名或只有类型信息没有参数
+      if (schemaResult) {
+        const hasUnparsedTypes = /\|.*\bZod\w+\b.*\|/.test(schemaResult);
+        // 检查是否只有类型信息而没有实际参数（如 "Type: Object" 或 "Type: ZodAny"）
+        const hasOnlyType =
+          /^-\s+\w+:\s+.+\n?$/.test(schemaResult.trim()) && !schemaResult.includes('`');
+        if (hasUnparsedTypes || hasOnlyType) {
+          // zodSchemaToMarkdown 未正确解析，使用 fallback
+          desc += this._fallbackParamsDesc(zodSchemaForFallback || schema);
+        } else {
+          desc += `**参数:**\n\n`;
+          desc += schemaResult + '\n\n';
+        }
+      }
+    } catch (e) {
+      // 如果转换失败，使用 fallback
+      try {
+        desc += this._fallbackParamsDesc(zodSchemaForFallback || schema);
+      } catch (e2) {
+        // fallback 也失败，忽略参数描述
+      }
+    }
+    return desc;
+  }
+
   /**
    * 将 JSON Schema 转换为 Zod schema
    */
@@ -711,20 +863,31 @@ class MCPExecutorPlugin extends Plugin {
    * 从 Zod schema 字段提取类型信息
    */
   _extractZodFieldType(field) {
+    if (!field) {
+      return { type: 'unknown', isOptional: false, description: '' };
+    }
+
     const typeName = field._def?.typeName || field.constructor?.name || '';
     const description = field.description || field._def?.description || '';
 
     switch (typeName) {
       case 'ZodOptional': {
-        const inner = field._def.innerType;
+        const inner = field._def?.innerType;
+        if (!inner) return { type: 'optional', isOptional: true, description };
         return this._extractZodFieldType(inner);
       }
       case 'ZodArray': {
-        const innerInfo = this._extractZodFieldType(field._def.type);
+        const inner = field._def?.type;
+        if (!inner) return { type: 'array', isOptional: false, description };
+        const innerInfo = this._extractZodFieldType(inner);
         return { type: `${innerInfo.type}[]`, isOptional: false, description };
       }
       case 'ZodObject': {
-        const shape = field._def.shape();
+        const shapeFn = field._def?.shape;
+        if (typeof shapeFn !== 'function')
+          return { type: 'object', isOptional: false, description };
+        const shape = shapeFn();
+        if (!shape) return { type: 'object', isOptional: false, description };
         const props = Object.keys(shape).join(', ');
         return { type: `object{${props}}`, isOptional: false, description };
       }
@@ -734,31 +897,44 @@ class MCPExecutorPlugin extends Plugin {
         return { type: 'number', isOptional: false, description };
       case 'ZodBoolean':
         return { type: 'boolean', isOptional: false, description };
-      case 'ZodEnum':
+      case 'ZodEnum': {
+        const values = field._def?.values;
+        if (!values) return { type: 'enum', isOptional: false, description };
         return {
-          type: field._def.values.map((v) => `"${v}"`).join(' | '),
+          type: values.map((v) => `"${v}"`).join(' | '),
           isOptional: false,
           description,
         };
+      }
       case 'ZodUnion': {
-        const types = field._def.options.map((opt) => this._extractZodFieldType(opt).type);
+        const options = field._def?.options;
+        if (!options) return { type: 'union', isOptional: false, description };
+        const types = options.map((opt) => this._extractZodFieldType(opt).type);
         return { type: `union(${types.join(' | ')})`, isOptional: false, description };
       }
       case 'ZodLiteral':
-        return { type: JSON.stringify(field._def.value), isOptional: false, description };
+        return { type: JSON.stringify(field._def?.value), isOptional: false, description };
       case 'ZodRecord': {
-        const keyType = this._extractZodFieldType(field._def.keyType).type;
-        const valueType = this._extractZodFieldType(field._def.valueType).type;
-        return { type: `record<${keyType}, ${valueType}>`, isOptional: false, description };
+        const keyType = this._extractZodFieldType(field._def?.keyType);
+        const valueType = this._extractZodFieldType(field._def?.valueType);
+        return {
+          type: `record<${keyType?.type || 'any'}, ${valueType?.type || 'any'}>`,
+          isOptional: false,
+          description,
+        };
       }
       case 'ZodMap': {
-        const keyType = this._extractZodFieldType(field._def.keyType).type;
-        const valueType = this._extractZodFieldType(field._def.valueType).type;
-        return { type: `map<${keyType}, ${valueType}>`, isOptional: false, description };
+        const keyType = this._extractZodFieldType(field._def?.keyType);
+        const valueType = this._extractZodFieldType(field._def?.valueType);
+        return {
+          type: `map<${keyType?.type || 'any'}, ${valueType?.type || 'any'}>`,
+          isOptional: false,
+          description,
+        };
       }
       case 'ZodSet': {
-        const valueType = this._extractZodFieldType(field._def.valueType).type;
-        return { type: `set<${valueType}>`, isOptional: false, description };
+        const valueType = this._extractZodFieldType(field._def?.valueType);
+        return { type: `set<${valueType?.type || 'any'}>`, isOptional: false, description };
       }
       case 'ZodAny':
         return { type: 'any', isOptional: false, description };
@@ -781,7 +957,9 @@ class MCPExecutorPlugin extends Plugin {
       case 'ZodNativeEnum':
         return { type: 'nativeEnum', isOptional: false, description };
       case 'ZodDefault': {
-        const innerInfo = this._extractZodFieldType(field._def.innerType);
+        const inner = field._def?.innerType;
+        if (!inner) return { type: 'default', isOptional: false, description };
+        const innerInfo = this._extractZodFieldType(inner);
         return { type: innerInfo.type, isOptional: false, description };
       }
       case 'ZodEffects':
@@ -835,11 +1013,44 @@ class MCPExecutorPlugin extends Plugin {
    * 添加 MCP 服务器
    */
   async addServer(config) {
-    const { name, command, args = [], env, url, type, headers = {}, authProvider } = config;
+    const {
+      name,
+      command,
+      args = [],
+      env,
+      url,
+      type,
+      headers = {},
+      authProvider,
+      enabled,
+    } = config;
+    log.info(
+      `[MCP] addServer called: ${name}, enabled=${enabled}, hasClient=${this._clients.has(name)}`
+    );
+
     if (this._clients.has(name)) {
       log.warn(` Server '${name}' already exists, skipping`);
-      return;
+      return { success: false, error: `Server '${name}' already connected` };
     }
+
+    // 如果 enabled === false，跳过连接（用于 mcp_set_enabled 禁用后再开启的场景）
+    if (enabled === false) {
+      log.info(` Server '${name}' is disabled, skipping connection`);
+      return { success: false, error: `Server '${name}' is disabled` };
+    }
+
+    // 保存配置，用于重新启用
+    this._serverConfigs.set(name, {
+      name,
+      command,
+      args,
+      env,
+      url,
+      type,
+      headers,
+      authProvider,
+      enabled,
+    });
     log.info(` Connecting to ${name}...`);
     let client;
     try {
@@ -873,7 +1084,7 @@ class MCPExecutorPlugin extends Plugin {
       }
     } catch (err) {
       log.error(` Failed to create client '${name}':`, err.message);
-      return;
+      return { success: false, error: `创建客户端失败: ${err.message}` };
     }
 
     // 获取 MCP 服务器的工具列表
@@ -882,7 +1093,8 @@ class MCPExecutorPlugin extends Plugin {
       mcpTools = await this._withTimeout(client.tools(), 10000, `client.tools ${name}`);
     } catch (err) {
       log.error(` Failed to get tools from '${name}':`, err.message);
-      return;
+      client.close?.();
+      return { success: false, error: `获取工具列表失败: ${err.message}` };
     }
 
     // 提取工具信息和实际工具对象
@@ -921,6 +1133,7 @@ class MCPExecutorPlugin extends Plugin {
       client,
       tools: toolsInfo,
       toolObjects, // 实际工具对象，供 mcp_call 直接调用
+      enabled: config.enabled !== false,
     });
 
     log.info(
@@ -930,6 +1143,8 @@ class MCPExecutorPlugin extends Plugin {
         .filter((k) => k.startsWith(name + '_'))
         .join(', ')})`
     );
+
+    return { success: true, name, toolsCount: toolsInfo.length };
   }
 
   /**
@@ -994,10 +1209,18 @@ class MCPExecutorPlugin extends Plugin {
       } catch (e) {}
     }
     this._clients.clear();
+    // 清理服务器配置
+    this._serverConfigs.clear();
 
     // 2. 并行添加新服务器
     log.info(' Adding new servers...');
     const addPromises = Object.entries(newServers).map(async ([name, serverConfig]) => {
+      if (serverConfig.enabled === false) {
+        log.info(` Skipping disabled server: ${name}`);
+        // 仍保存配置，以便后续动态启用
+        this._serverConfigs.set(name, { name, ...serverConfig });
+        return;
+      }
       const normalizedConfig = {
         name,
         type: serverConfig.type,
@@ -1007,6 +1230,7 @@ class MCPExecutorPlugin extends Plugin {
         command: serverConfig.command,
         args: serverConfig.args,
         env: serverConfig.env,
+        enabled: true,
       };
       await this.addServer(normalizedConfig);
     });
@@ -1020,6 +1244,38 @@ class MCPExecutorPlugin extends Plugin {
     }
   }
 
+  /**
+   * 保存 MCP 服务器的 enabled 状态到配置文件
+   */
+  async _saveMCPServerEnabled(serverName, enabled) {
+    const fs = require('fs');
+    const path = require('path');
+    const configPath = path.resolve('.agent/mcp_config.json');
+
+    try {
+      if (!fs.existsSync(configPath)) {
+        log.warn(` MCP config file not found: ${configPath}`);
+        return false;
+      }
+
+      const configContent = fs.readFileSync(configPath, 'utf8');
+      const config = JSON.parse(configContent);
+
+      if (!config.mcpServers || !config.mcpServers[serverName]) {
+        log.warn(` Server '${serverName}' not found in MCP config`);
+        return false;
+      }
+
+      config.mcpServers[serverName].enabled = enabled;
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+      log.info(` Saved enabled=${enabled} for server '${serverName}' to config`);
+      return true;
+    } catch (err) {
+      log.error(` Failed to save MCP config:`, err.message);
+      return false;
+    }
+  }
+
   async uninstall(framework) {
     // 断开所有 MCP 连接
     for (const [name, clientInfo] of this._clients) {