foliko 2.0.4 → 2.0.6

package/src/common/error-capture.js

@@ -0,0 +1,91 @@
+'use strict';
+
+/**
+ * 全局错误捕获 — 把 uncaughtException 和 unhandledRejection 的完整堆栈落盘
+ * 下次出现 Cannot read properties of undefined (reading 'delete') 这类异步错误,
+ * 用户直接看 .foliko/error.log 即可拿到带文件名/行号的完整堆栈,无需复现。
+ *
+ * 设计要点:
+ * - 静默写文件,不污染 console(避免和 TUI / CLI 抢输出)
+ * - 同时保留原始 process 监听器(若用户已注册),不会覆盖
+ * - 一次安装,重复 require 不会重复绑定
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const INSTALLED = Symbol.for('foliko.error-capture.installed');
+const PROJECT_LOG = path.join(process.cwd(), '.foliko', 'error.log');
+
+/**
+ * 获取当前活跃的 sessionId (兼容 AsyncLocalStorage)
+ */
+function getActiveSessionId() {
+  try {
+    const { requestContext, sessionContext } = require('./context-helpers');
+    if (typeof sessionContext?.getStore === 'function') {
+      const store = sessionContext.getStore();
+      if (store?.sessionId) return store.sessionId;
+    }
+  } catch (_) { /* 未安装 context 系统时跳过 */ }
+  return null;
+}
+
+/**
+ * 把一个事件载荷写为单条记录到 .foliko/error.log
+ */
+function dumpEvent(kind, error) {
+  let record;
+  try {
+    const ts = new Date().toISOString();
+    const sid = getActiveSessionId();
+    const cwd = process.cwd();
+    const node = process.version;
+    const pid = process.pid;
+
+    const errObj = error instanceof Error ? error : new Error(String(error));
+    const stack = errObj.stack || `(no stack; value=${String(error)})`;
+
+    record =
+      `\n${'='.repeat(72)}\n` +
+      `[${ts}] [pid=${pid}] [node=${node}] [cwd=${cwd}] [sessionId=${sid || '(none)'}] kind=${kind}\n` +
+      `error.name=${errObj.name || 'Error'}  error.message=${errObj.message || '(no message)'}\n` +
+      `stack:\n${stack}\n`;
+  } catch (innerErr) {
+    record = `\n[${new Date().toISOString()}] dump failed: ${innerErr?.message || innerErr}\n`;
+  }
+
+  try {
+    fs.mkdirSync(path.dirname(PROJECT_LOG), { recursive: true });
+    fs.appendFileSync(PROJECT_LOG, record, 'utf8');
+  } catch (_) {
+    // 连日志都写不了就别折腾了
+  }
+}
+
+/**
+ * 安装全局错误捕获。重复调用安全(no-op)。
+ */
+function install(options = {}) {
+  const logFile = options.logFile || PROJECT_LOG;
+
+  // 用 global symbol 标记,避免重复 require 时再次 process.on
+  if (process[INSTALLED]) return process[INSTALLED];
+  if (!process[INSTALLED]) process[INSTALLED] = new Set();
+  if (process[INSTALLED].has('core')) return 'core';
+  process[INSTALLED].add('core');
+
+  // 捕获 unhandledRejection —— 这正是用户报的 Promise 拒绝
+  process.on('unhandledRejection', (reason, promise) => {
+    dumpEvent('unhandledRejection', reason);
+  });
+
+  // 捕获 uncaughtException —— 同步抛错兜底
+  process.on('uncaughtException', (err, origin) => {
+    dumpEvent(`uncaughtException(${origin})`, err);
+  });
+
+  return 'core';
+}
+
+module.exports = { install, dumpEvent, PROJECT_LOG };

package/src/common/logger.js

@@ -23,7 +23,7 @@ function ensureLogDir(logDir) {
 function getLogFilePath(logDir) {
   ensureLogDir(logDir);
   const date = new Date().toISOString().split('T')[0];
-  return path.join(logDir, `vb-agent-${date}.log`);
+  return path.join(logDir, `foliko-${date}.log`);
 }
 
 // 当前日志文件路径
@@ -62,7 +62,7 @@ function initLogger(options = {}) {
   const {
     level = process.env.LOG_LEVEL || 'info',
     logDir = DEFAULT_LOG_DIR,
-    name = 'vb-agent',
+    name = 'foliko',
     silent = false, // 是否静默（不输出到控制台）
   } = options;
 

package/src/context/compressor.js

@@ -19,6 +19,10 @@ const {
   TURN_PREFIX_SUMMARIZATION_PROMPT, BRANCH_SUMMARY_PREAMBLE, BRANCH_SUMMARY_PROMPT,
   DEFAULT_COMPACTION_SETTINGS, MODEL_CONTEXT_LIMITS, COMPRESSION_TIMEOUT_MS,
 } = require('./compaction-prompts');
+const {
+  KEEP_RECENT_MESSAGES,
+  COMPRESSION_MESSAGE_THRESHOLD,
+} = require('../common/constants');
 
 // ─── Helper classes ───────────────────────────────────────────────────
 
@@ -184,8 +188,8 @@ class ContextCompressor {
 
     this.model = config.model || 'deepseek-chat';
     this._maxContextTokens = config.maxContextTokens || this._getDefaultContextLimit();
-    this._keepRecentMessages = config.keepRecentMessages || 20;
-    this._compressionMessageThreshold = config.compressionMessageThreshold || 200;
+    this._keepRecentMessages = config.keepRecentMessages || KEEP_RECENT_MESSAGES;
+    this._compressionMessageThreshold = config.compressionMessageThreshold || COMPRESSION_MESSAGE_THRESHOLD;
     this._enableSmartCompress = config.enableSmartCompress !== false;
     this._compactionSettings = config.compactionSettings || DEFAULT_COMPACTION_SETTINGS;
 

package/src/executors/mcp-executor.js

@@ -14,7 +14,7 @@ const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio
 const { zodSchemaToMarkdown } = require('@chnak/zod-to-markdown');
 const { logger } = require('../common/logger');
 const { MCPClientWrapper } = require('./mcp-client');
-const { extractSchema, buildMCPServersDescription, bindMcpParamsDesc } = require('./mcp-desc');
+const { extractSchema } = require('./mcp-desc');
 const { jsonSchemaToZod } = require('../tool/schema');
 
 const log = logger.child('MCPExecutor');
@@ -53,120 +53,6 @@ class MCPExecutorPlugin extends Plugin {
       }
     }
 
-    framework.registerTool({
-      name: 'mcp_tool_schema',
-      description: '查询工具的调用示例，直接复制 example 或 fullExample 字段使用',
-      inputSchema: z.object({
-        server: z.string().describe('MCP 服务器名称'),
-        tool: z.string().describe('工具名称'),
-      }),
-      execute: async (args) => {
-        const { server, tool } = args;
-        const clientInfo = this._clients.get(server);
-        if (!clientInfo) return { success: false, error: `MCP server '${server}' not found` };
-
-        const toolInfo = clientInfo.tools.find((t) => t.name === tool);
-        if (!toolInfo) return { success: false, error: `Tool '${tool}' not found` };
-
-        const schema = extractSchema(toolInfo.inputSchema);
-        const props = schema.properties || {};
-        const required = schema.required || [];
-
-        const generateExample = (prop, depth = 0) => {
-          if (!prop) return null;
-          const type = prop.type || (prop.properties ? 'object' : 'string');
-          if (type === 'string') return prop.description?.split('.')[0] || `${prop.title || '值'}`;
-          if (type === 'number' || type === 'integer') return prop.default || 0;
-          if (type === 'boolean') return false;
-          if (type === 'array') {
-            if (prop.items) {
-              const itemExample = generateExample(prop.items, depth + 1);
-              return depth === 0 ? [itemExample] : itemExample;
-            }
-            return ['示例'];
-          }
-          if (type === 'object' || prop.properties) {
-            const obj = {};
-            for (const [key, val] of Object.entries(prop.properties || {})) {
-              obj[key] = generateExample(val, depth + 1);
-            }
-            return obj;
-          }
-          return null;
-        };
-
-        const exampleArgs = {};
-        for (const key of required) {
-          const prop = props[key];
-          if (prop) exampleArgs[key] = generateExample(prop);
-        }
-
-        return {
-          success: true,
-          data: {
-            name: toolInfo.name, description: toolInfo.description, required,
-            parameters: Object.fromEntries(
-              required.map((key) => [key, {
-                type: props[key]?.type || 'string',
-                description: props[key]?.description || '',
-                example: generateExample(props[key]),
-              }])
-            ),
-            example: JSON.stringify(exampleArgs, null, 2),
-            fullExample: `mcp_call({ server: "${server}", tool: "${tool}", args_json: ${JSON.stringify(JSON.stringify(exampleArgs))} })`,
-          },
-        };
-      },
-    });
-
-    framework.registerTool({
-      name: 'mcp_call',
-      description: '调用 MCP 服务器工具。args_json 是包含实际参数的 JSON 字符串',
-      inputSchema: z.object({
-        server: z.string().describe('MCP 服务器名称'),
-        tool: z.string().describe('工具名称'),
-        args_json: z.string().describe('参数 JSON 字符串'),
-      }),
-      execute: async (args) => {
-        const { server, tool, args_json } = args;
-        const clientInfo = this._clients.get(server);
-        if (!clientInfo) return { success: false, error: `MCP server '${server}' not found` };
-
-        let finalArgs = {};
-        if (args_json) {
-          try { finalArgs = JSON.parse(args_json); }
-          catch (e) { return { success: false, error: `args_json 格式错误: ${args_json}` }; }
-        }
-
-        if (!finalArgs || Object.keys(finalArgs).length === 0) {
-          const toolInfo = clientInfo.tools.find((t) => t.name === tool);
-          if (toolInfo) {
-            const schema = extractSchema(toolInfo.inputSchema);
-            const required = schema.required || [];
-            return { success: false, error: `参数为空！必须提供: ${required.join(', ')}`, hint: `正确格式: {"${required[0]}": "具体值"}` };
-          }
-        }
-
-        try {
-          const mcpTool = clientInfo.toolObjects?.[tool];
-          if (!mcpTool) return { success: false, error: `Tool '${tool}' not found on server '${server}'` };
-
-          const mcpToolName = `${server}:${tool}`;
-          framework.emit('tool:call', { name: mcpToolName, args: finalArgs, source: 'mcp' });
-          framework.emit('tool-call', { name: mcpToolName, args: finalArgs, source: 'mcp' });
-
-          const execResult = await mcpTool.execute(finalArgs);
-
-          framework.emit('tool:result', { name: mcpToolName, args: finalArgs, result: execResult, source: 'mcp' });
-          return { success: true, data: execResult };
-        } catch (err) {
-          log.error(` Tool '${tool}' failed:`, err.message);
-          framework.emit('tool:error', { name: `${server}:${tool}`, args: finalArgs, error: err.message, source: 'mcp' });
-          return { success: false, error: err.message };
-        }
-      },
-    });
-
     framework.registerTool({
       name: 'mcp_list_servers',
       description: '列出已连接的 MCP 服务器及其工具',
@@ -235,9 +121,12 @@ class MCPExecutorPlugin extends Plugin {
           if (!clientInfo) return { success: false, error: `MCP server '${server}' not found` };
           try { clientInfo.client.close?.(); } catch (e) { /* ignore */ }
           this._clients.delete(server);
-          for (const key of Object.keys(this.tools)) {
-            if (key.startsWith(`${server}_`)) delete this.tools[key];
+          // 注销该服务器的所有工具（this.tools 中的 key 就是 MCP 原始工具名）
+          for (const t of clientInfo.tools) {
+            if (this.tools[t.name]) delete this.tools[t.name];
           }
+          // 同时注销对应的扩展（mcp:<server>）
+          this._unregisterExtension(server);
           await this._saveMCPServerEnabled(server, false);
           this._refreshAllAgentsMCPPrompt(this._framework);
           return { success: true, data: `MCP 服务器 '${server}' 已关闭` };
@@ -343,15 +232,23 @@ class MCPExecutorPlugin extends Plugin {
         toolObjects[toolName] = tool;
         toolsInfo.push({ name: toolName, description: tool.description || '', inputSchema: tool.inputSchema || {} });
 
-        const registeredName = `${name}_${toolName}`;
-        this.tools[registeredName] = {
-          name: registeredName,
-          description: `[${name}] ${tool.description || ''}`,
+        // 直接调用底层 MCP 工具（不再走 mcp_call 中转）
+        this.tools[toolName] = {
+          name: toolName,
+          description: tool.description || '',
           inputSchema: tool.inputSchema || {},
           execute: async (args) => {
-            return await this._framework.executeTool('mcp_call', {
-              server: name, tool: toolName, args_json: JSON.stringify(args || {}),
-            });
+            try {
+              const mcpToolName = `${name}:${toolName}`;
+              framework?.emit?.('tool:call', { name: mcpToolName, args: args || {}, source: 'mcp' });
+              const execResult = await tool.execute(args || {});
+              framework?.emit?.('tool:result', { name: mcpToolName, args: args || {}, result: execResult, source: 'mcp' });
+              return { success: true, data: execResult };
+            } catch (err) {
+              log.error(` Tool '${toolName}' failed:`, err.message);
+              framework?.emit?.('tool:error', { name: `${name}:${toolName}`, args: args || {}, error: err.message, source: 'mcp' });
+              return { success: false, error: err.message };
+            }
           },
         };
       }
@@ -359,10 +256,89 @@ class MCPExecutorPlugin extends Plugin {
 
     this._clients.set(name, { client, tools: toolsInfo, toolObjects, enabled: config.enabled !== false });
 
+    // 把整个 MCP 服务器注册为扩展（mcp:<servername>），让 ext_call / ext_skill 统一调度
+    this._registerAsExtension(name, toolsInfo, toolObjects);
+
+    // 触发 mcp 工具变化事件，通知 extension-executor 刷新
+    this._framework?.emit?.('mcp:tools-changed', { name, toolsCount: toolsInfo.length });
+
     log.debug(` Added server '${name}' with ${toolsInfo.length} tools`);
     return { success: true, name, toolsCount: toolsInfo.length };
   }
 
+  /**
+   * 把 MCP 服务器注册为扩展插件（mcp:<servername>）
+   * 使其能通过 ext_call({plugin:'mcp:<server>', tool:'xxx', args:{...}}) 调用
+   * 通过 ext_skill({plugin:'mcp:<server>'}) 获取参数说明
+   */
+  _registerAsExtension(serverName, toolsInfo, toolObjects) {
+    const extExecutor = this._framework?.pluginManager?.get('extension-executor');
+    if (!extExecutor || typeof extExecutor.registerTool !== 'function') return;
+
+    const extName = `mcp:${serverName}`;
+    // 优先从 server config 取 description，否则用 server name
+    const serverConfig = this._serverConfigs.get(serverName) || {};
+    const extDescription = serverConfig.description
+      ? serverConfig.description
+      : `MCP 服务器 ${serverName}`;
+    const pluginInfo = {
+      name: extName,
+      description: extDescription,
+      version: '1.0.0',
+    };
+
+    for (const toolInfo of toolsInfo) {
+      const mcpTool = toolObjects[toolInfo.name];
+      if (!mcpTool) continue;
+
+      // 把 JSON schema 转换为 Zod schema（用于 AI SDK 的工具参数定义）
+      // 同时保留原始 JSON schema 作为 _rawSchema，让 ext_skill 能渲染出清晰的参数说明
+      const rawSchema = extractSchema(toolInfo.inputSchema);
+      let inputSchema = rawSchema;
+      try {
+        if (rawSchema && rawSchema.properties) {
+          const zodSchema = this._jsonSchemaToZod(rawSchema);
+          if (zodSchema) inputSchema = zodSchema;
+        }
+      } catch (e) { /* fallback: 保留原始 schema */ }
+
+      extExecutor.registerTool(extName, pluginInfo, {
+        name: toolInfo.name,
+        description: toolInfo.description || '',
+        inputSchema,
+        _rawSchema: rawSchema,  // 原始 JSON schema，用于 ext_skill 渲染
+        execute: async (args, framework) => {
+          try {
+            const finalArgs = args || {};
+            const mcpToolName = `${serverName}:${toolInfo.name}`;
+            framework?.emit?.('tool:call', { name: mcpToolName, args: finalArgs, source: 'mcp' });
+            const result = await mcpTool.execute(finalArgs);
+            framework?.emit?.('tool:result', { name: mcpToolName, args: finalArgs, result, source: 'mcp' });
+            return { success: true, data: result };
+          } catch (err) {
+            log.error(` Tool '${toolInfo.name}' failed:`, err.message);
+            return { success: false, error: err.message };
+          }
+        },
+      });
+    }
+  }
+
+  /**
+   * 注销 MCP 服务器对应的扩展
+   */
+  _unregisterExtension(serverName) {
+    const extExecutor = this._framework?.pluginManager?.get('extension-executor');
+    if (!extExecutor || typeof extExecutor._unregisterTool !== 'function') return;
+
+    const extName = `mcp:${serverName}`;
+    const clientInfo = this._clients.get(serverName);
+    const toolNames = clientInfo?.tools?.map((t) => t.name) || [];
+    for (const toolName of toolNames) {
+      extExecutor._unregisterTool(extName, toolName);
+    }
+  }
+
   async removeServer(name) {
     const clientInfo = this._clients.get(name);
     if (clientInfo) {
@@ -373,9 +349,13 @@ class MCPExecutorPlugin extends Plugin {
         }
       } catch (e) { /* ignore */ }
       for (const toolName of Object.keys(this.tools)) {
-        if (toolName.startsWith(name + '_')) delete this.tools[toolName];
+        if (this.tools[toolName]?.description?.includes?.(`[${name}]`)) {
+          delete this.tools[toolName];
+        }
       }
       this._clients.delete(name);
+      this._unregisterExtension(name);
+      this._framework?.emit?.('mcp:tools-changed', { name, removed: true });
     }
   }