foliko 1.1.6 → 1.1.7

package/plugins/email/monitor.js

@@ -22,6 +22,70 @@ function createImapConfig(config = {}) {
   }
 }
 
+/**
+ * 标记所有现有未读邮件为已读（启动监控前调用）
+ * @param {Object} emailPlugin - EmailPlugin 实例
+ * @returns {Promise<number>} 标记的邮件数量
+ */
+async function markAllExistingUnreadAsRead(emailPlugin) {
+  const config = emailPlugin._watchConfig
+  if (!config) return 0
+
+  const imapConfig = createImapConfig(config)
+  const box = config.box || 'INBOX'
+
+  return new Promise((resolve, reject) => {
+    const imap = new Imap(imapConfig)
+
+    imap.on('ready', () => {
+      imap.openBox(box, false, (err, boxData) => {
+        if (err) {
+          imap.end()
+          return reject(err)
+        }
+
+        // 搜索所有 UNSEEN 邮件
+        imap.search(['UNSEEN'], (err, results) => {
+          if (err) {
+            imap.end()
+            return reject(err)
+          }
+
+          if (!results || results.length === 0) {
+            imap.end()
+            emailPlugin._log.info(` 没有现有未读邮件需要标记`)
+            return resolve(0)
+          }
+
+          emailPlugin._log.info(` 发现 ${results.length} 封现有未读邮件，开始标记为已读...`)
+
+          // 批量标记为已读
+          if (results.length > 0) {
+            imap.setFlags(results, '\\Seen', (err) => {
+              if (err) {
+                emailPlugin._log.warn(` 标记已读失败: ${err.message}`)
+              } else {
+                emailPlugin._log.info(` 已标记 ${results.length} 封邮件为已读`)
+              }
+              imap.end()
+              resolve(results.length)
+            })
+          } else {
+            imap.end()
+            resolve(0)
+          }
+        })
+      })
+    })
+
+    imap.on('error', (err) => {
+      reject(err)
+    })
+
+    imap.connect()
+  })
+}
+
 /**
  * 处理邮件监控
  * @param {Object} emailPlugin - EmailPlugin 实例
@@ -52,7 +116,7 @@ function handleEmailWatch(emailPlugin, args) {
  * @param {Object} config - 监控配置
  * @returns {Object} 操作结果
  */
-function startEmailWatch(emailPlugin, config) {
+async function startEmailWatch(emailPlugin, config) {
   if (emailPlugin._watchEnabled) {
     return { success: false, error: 'Email watch is already running' }
   }
@@ -72,6 +136,13 @@ function startEmailWatch(emailPlugin, config) {
 
   emailPlugin._watchEnabled = true
 
+  // 启动监控前，先标记所有现有未读邮件为已读
+  try {
+    await markAllExistingUnreadAsRead(emailPlugin)
+  } catch (err) {
+    emailPlugin._log.warn(' 标记现有邮件已读失败，继续监控:', err.message)
+  }
+
   // 立即执行一次检查
   emailPlugin._checkNewEmails().catch(err => {
     emailPlugin._log.error('Initial check failed:', err.message)
@@ -143,7 +214,7 @@ async function checkNewEmails(emailPlugin) {
   if (!emailPlugin._watchConfig) return
 
   const callId = generateCallId()
-  emailPlugin._log.debug(`[${callId}] _checkNewEmails called, _checkInProgress=${emailPlugin._checkInProgress}`)
+  //emailPlugin._log.info(`[Email] 开始检查新邮件...`)
 
   // 防止并发检查
   if (emailPlugin._checkInProgress) {
@@ -177,6 +248,7 @@ async function checkNewEmails(emailPlugin) {
           }
 
           if (!results || results.length === 0) {
+            emailPlugin._log.info(`[Email] 没有未读邮件`)
             cleanup()
             return resolve({ success: true, newEmails: 0 })
           }
@@ -187,7 +259,12 @@ async function checkNewEmails(emailPlugin) {
           )
 
           if (newEmails.length > 0) {
+            emailPlugin._log.info(`[Email] 发现 ${newEmails.length} 封未读邮件，开始处理...`)
             const latestUid = Math.max(...newEmails)
+
+            // 先更新 _lastSeenUid，防止重复检测
+            emailPlugin._lastSeenUid = latestUid
+
             // imap.fetch() 需要 UIDs 数组，传单个数字会导致获取从该 UID 到末尾的所有邮件
             const f = imap.fetch([latestUid], { bodies: '' })
 
@@ -221,9 +298,6 @@ async function checkNewEmails(emailPlugin) {
               msg.on('end', () => {
                 const checkDone = () => {
                   if (bodyParsed) {
-                    // 更新最后看到的 UID
-                    emailPlugin._lastSeenUid = latestUid
-
                     // 发送事件通知
                     emailPlugin._emitEmailReceived(email)
 

package/plugins/email/reply.js

@@ -13,38 +13,25 @@ const { EMAIL_DEFAULTS } = require('./constants')
 async function handleAutoReply(emailPlugin, args) {
   let { to, subject, body, from, _event, prompt, messageId, inReplyTo } = args
 
-  // 如果没有直接参数，尝试从 _event 提取
-  // 支持多种事件结构：{ email, timestamp } 或 { data: { email } } 或 { data: { ... } }
-  if (!to && !subject && !body && _event) {
+  // 优先使用传入的参数，如果没有则尝试从 _event 提取（兼容旧方式）
+  if ((!to || !subject || !body) && _event) {
     // 兼容多种事件结构
     const email = _event.email || _event.data?.email || _event.data || {}
-    from = email.from?.text || email.from || ''
-    to = email.to?.text || email.to || ''
-    subject = email.subject || ''
-    body = email.text || email.body || ''
-    // 优先使用 _event 中的 uid/messageId
-    if (!messageId) {
-      messageId = email.messageId || email.uid || _event.data?.messageId || _event.data?.uid
-    }
-  }
-
-  // 如果 _event 没有有效数据，不允许自动读取所有邮件
-  if (!_event || (!_event.email && !_event.data)) {
-    return {
-      success: false,
-      error: '缺少邮件数据：_event 中没有有效的邮件信息，无法自动回复。请确认是否在收到新邮件事件时调用此工具。'
-    }
+    to = to || email.from?.text || email.from || ''
+    subject = subject || email.subject || ''
+    body = body || email.text || email.body || ''
+    messageId = messageId || email.messageId || email.uid
   }
 
   // 优先使用传入的 inReplyTo，否则用 messageId
   const replyTo = inReplyTo || messageId
 
   // 检查必要参数
-  if (!from && !to) {
-    return { success: false, error: '缺少收件人地址' }
+  if (!to) {
+    return { success: false, error: '缺少收件人地址（to）' }
   }
   if (!body) {
-    return { success: false, error: '缺少邮件内容' }
+    return { success: false, error: '缺少邮件内容（body）' }
   }
 
   try {
@@ -114,20 +101,23 @@ ${body}
       const msgId = messageId || emailData.messageId || emailData.uid
       if (msgId) {
         emailPlugin._processedEmails.add(msgId)
+        emailPlugin._saveProcessedEmails()
         emailPlugin._log.info(`邮件已处理: ${msgId}`)
 
         // 24小时后从已处理列表中移除
         setTimeout(() => {
           emailPlugin._processedEmails.delete(msgId)
+          emailPlugin._saveProcessedEmails()
         }, EMAIL_DEFAULTS.processedEmailTTL)
       }
 
       // 自动标记原邮件为已读
-      const uid = emailData.uid || msgId
-      if (uid) {
+      // emailData.uid 是数字 UID，emailData.messageId 是字符串
+      const emailUid = emailData.uid
+      if (emailUid) {
         try {
           const { markAsRead } = require('./handlers')
-          await markAsRead(emailPlugin, { uid: uid })  // 使用 uid 而非 messageId
+          await markAsRead(emailPlugin, { uid: emailUid })  // 使用数字 uid
         } catch (err) {
           emailPlugin._log.warn(`自动标记已读失败: ${err.message}`)
         }

package/plugins/extension-executor-plugin.js

@@ -123,11 +123,14 @@ class ExtensionExecutorPlugin extends Plugin {
       this._scanPluginTools(plugin);
     }
 
+    // 获取 MCP executor 引用（用于 ext_call 统一路由）
+    this._mcpExecutor = framework.pluginManager?.get('mcp') || null;
+
     framework.registerTool({
       name: 'ext_call',
-      description: '调用扩展插件的工具',
+      description: '调用扩展插件的工具（包括 MCP 服务器工具）',
       inputSchema: z.object({
-        plugin: z.string().describe('扩展插件名称'),
+        plugin: z.string().describe('插件名称（如 email, gate-trading, mcp）'),
         tool: z.string().describe('工具名称'),
         args: z.record(z.any()).optional().describe('工具参数'),
       }),
@@ -135,6 +138,16 @@ class ExtensionExecutorPlugin extends Plugin {
         const { plugin, tool, args: toolArgs = {} } = args;
         log.info(` ext_call: plugin=${plugin}, tool=${tool}, args=${JSON.stringify(toolArgs)}`);
 
+        // MCP 服务器工具（已注册为 server_toolname 格式，如 github_search）
+        if (plugin === 'mcp' && this._mcpExecutor) {
+          const mcpToolDef = this._mcpExecutor.tools?.[tool];
+          if (mcpToolDef && mcpToolDef.execute) {
+            log.info(` ext_call [MCP]: tool=${tool}`);
+            return await mcpToolDef.execute(toolArgs || {});
+          }
+          return { success: false, error: `MCP tool '${tool}' not found` };
+        }
+
         const ext = this._extensions.get(plugin);
         if (!ext) {
           // 触发错误事件
@@ -337,7 +350,7 @@ class ExtensionExecutorPlugin extends Plugin {
     const existingPrompt = agent._originalPrompt || '';
 
     // 如果已有 [Extensions] 部分，替换它
-    const extStartIdx = existingPrompt.indexOf('[Extensions]');
+    const extStartIdx = existingPrompt.indexOf('【Extensions】');
     if (extStartIdx !== -1) {
       const extEndMarker = '\n\n【';
       let extEndIdx = existingPrompt.indexOf(extEndMarker, extStartIdx);
@@ -358,48 +371,162 @@ class ExtensionExecutorPlugin extends Plugin {
   }
 
   _buildExtensionsDescription() {
-    if (this._extensions.size === 0) {
-      return '';
-    }
+    let desc = '';
+
+    // 1. 扩展插件工具（包括 MCP，已通过 this.tools 注册为 server_toolname 格式）
+    if (this._extensions.size > 0 || (this._mcpExecutor && Object.keys(this._mcpExecutor.tools || {}).length > 0)) {
+      desc += '## 【Extensions】扩展插件工具\n\n';
+      desc += '你可以通过 `ext_call` 工具调用以下扩展插件的功能。\n\n';
+
+      for (const [name, ext] of this._extensions) {
+        desc += `### ${ext.name || name}\n\n`;
+        desc += `${ext.description || ''}\n\n`;
+        for (const tool of ext.tools) {
+          desc += `- **${tool.name}**: ${tool.description || '无描述'}\n`;
+          // 添加参数描述
+          if (tool.inputSchema) {
+            try {
+              if (typeof tool.inputSchema.toJSON === 'function') {
+                desc += `**参数:**\n\n`;
+                desc += zodSchemaToMarkdown(tool.inputSchema) + '\n\n';
+              } else if (tool.inputSchema.properties) {
+                // JSON Schema 格式
+                desc += `**参数:**\n\n`;
+                desc += zodSchemaToMarkdown(tool.inputSchema) + '\n\n';
+              }
+            } catch (e) {
+              // 忽略转换错误
+            }
+          }
+        }
+        desc += '\n';
+      }
 
-    let desc = '[Extensions]\n\n';
-    desc += '你可以通过 `ext_call` 工具调用以下扩展插件的功能。\n\n';
-
-    for (const [name, ext] of this._extensions) {
-      desc += `### ${ext.name || name}\n\n`;
-      desc += `${ext.description || ''}\n\n`;
-      for (const tool of ext.tools) {
-        desc += `- **${tool.name}**: ${tool.description || '无描述'}\n`;
-        // 添加参数描述
-        if (tool.inputSchema) {
-          try {
-            if (typeof tool.inputSchema.toJSON === 'function') {
-              desc += `**参数:**\n\n`;
-              desc += zodSchemaToMarkdown(tool.inputSchema) + '\n\n';
-            } else if (tool.inputSchema.properties) {
-              // JSON Schema 格式
-              desc += `**参数:**\n\n`;
-              desc += this._schemaToMarkdown(tool.inputSchema) + '\n\n';
+      // MCP 服务器工具（已注册为 server_toolname 格式）
+      if (this._mcpExecutor && Object.keys(this._mcpExecutor.tools || {}).length > 0) {
+        desc += '### mcp (MCP 服务器工具)\n\n';
+        desc += 'MCP 服务器工具已注册为 `服务器_工具名` 格式（如 github_search）。\n\n';
+        for (const [toolName, toolDef] of Object.entries(this._mcpExecutor.tools)) {
+          desc += `- **${toolName}**: ${toolDef.description || '无描述'}\n`;
+          // 添加参数描述
+          if (toolDef.inputSchema) {
+            try {
+              const schemaResult = this._convertSchemaToMarkdown(toolDef.inputSchema);
+              if (schemaResult) {
+                desc += `**参数:**\n\n`;
+                desc += schemaResult + '\n\n';
+              }
+            } catch (e) {
+              // 忽略转换错误
             }
-          } catch (e) {
-            // 忽略转换错误
           }
         }
+        desc += '\n';
       }
-      desc += '\n';
     }
 
-    desc += '**调用格式:**\n';
+    if (!desc) {
+      return '';
+    }
+
+    desc += '**统一调用格式:**\n';
     desc += '```\next_call({ plugin: "插件名", tool: "工具名", args: {参数} })\n';
     desc += '```\n';
     return desc.trim();
   }
 
   /**
-   * 将 JSON Schema 转换为 Markdown
+   * 将 Schema 转换为 Markdown 格式的参数描述
+   * 支持 Zod schema 和 JSON Schema
+   */
+  _convertSchemaToMarkdown(inputSchema) {
+    if (!inputSchema) return null;
+
+    // 提取实际 schema（处理 { jsonSchema: {...} } 或 { inputSchema: {...} } 格式）
+    let schema = inputSchema;
+    if (inputSchema.jsonSchema) schema = inputSchema.jsonSchema;
+    if (inputSchema.inputSchema) schema = inputSchema.inputSchema;
+
+    // 检查是否是 Zod schema
+    const isZodSchema = typeof schema.shape === 'function' || (schema._def && schema._def.typeName);
+    if (isZodSchema) {
+      // Zod schema 直接转换
+      return zodSchemaToMarkdown(schema);
+    }
+
+    // JSON Schema 转换为 Zod 再转换
+    if (schema.properties) {
+      const zodSchema = this._jsonSchemaToZod(schema);
+      if (zodSchema) {
+        return zodSchemaToMarkdown(zodSchema);
+      }
+    }
+
+    // 如果都没有，回退到简单格式
+    return this._schemaToMarkdown(schema);
+  }
+
+  /**
+   * 将 JSON Schema 转换为 Zod schema
+   */
+  _jsonSchemaToZod(jsonSchema) {
+    if (!jsonSchema || !jsonSchema.properties) return null;
+
+    try {
+      const shape = {};
+      const properties = jsonSchema.properties;
+      const required = jsonSchema.required || [];
+
+      for (const [key, prop] of Object.entries(properties)) {
+        shape[key] = this._jsonSchemaPropToZod(prop, required.includes(key));
+      }
+
+      return z.object(shape);
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /**
+   * 将 JSON Schema 属性转换为 Zod 类型
+   */
+  _jsonSchemaPropToZod(prop, isRequired) {
+    if (prop.enum) {
+      let zodType = z.string().enum(prop.enum);
+      if (prop.nullable) zodType = zodType.nullable();
+      return isRequired ? zodType : zodType.optional();
+    }
+
+    const type = prop.type || 'string';
+    switch (type) {
+      case 'string':
+        return isRequired ? z.string() : z.string().optional();
+      case 'number':
+      case 'integer':
+        return isRequired ? z.number() : z.number().optional();
+      case 'boolean':
+        return isRequired ? z.boolean() : z.boolean().optional();
+      case 'array':
+        return isRequired ? z.array(z.any()) : z.array(z.any()).optional();
+      case 'object':
+        if (prop.properties) {
+          const nested = {};
+          for (const [k, v] of Object.entries(prop.properties)) {
+            nested[k] = this._jsonSchemaPropToZod(v, prop.required?.includes(k) || false);
+          }
+          return isRequired ? z.object(nested) : z.object(nested).optional();
+        }
+        return isRequired ? z.record(z.any()) : z.record(z.any()).optional();
+      default:
+        return isRequired ? z.any() : z.any().optional();
+    }
+  }
+
+  /**
+   * 将 JSON Schema 转换为 Markdown（简单格式）
    */
   _schemaToMarkdown(schema) {
-    if (!schema || !schema.properties) return '';
+    if (!schema || !schema.properties) return null;
 
     const props = schema.properties || {};
     const required = schema.required || [];
@@ -411,7 +538,7 @@ class ExtensionExecutorPlugin extends Plugin {
       const descText = prop.description || '';
       md += `- \`${key}\`${isRequired ? ' (必填)' : ''}: ${type} ${descText}\n`;
     }
-    return md;
+    return md || null;
   }
 
   getExtensions() {
@@ -431,6 +558,8 @@ class ExtensionExecutorPlugin extends Plugin {
     for (const { instance: plugin } of plugins) {
       this._scanPluginTools(plugin);
     }
+    // 重新获取 MCP executor 引用
+    this._mcpExecutor = framework.pluginManager?.get('mcp') || null;
     // 刷新所有 Agent 的扩展提示词
     this._refreshAllAgentsExtPrompt(framework);
   }

package/plugins/file-system-plugin.js

@@ -818,7 +818,7 @@ class FileSystemPlugin extends Plugin {
     // HTTP 请求
     framework.registerTool({
       name: 'fetch',
-      description: '发送 HTTP 请求获取远程数据。如果访问失败或超时，LLM 应自动使用 proxy: true 重试（代理会绕过网络限制）。',
+      description: '发送 HTTP 请求获取远程数据。HTML 内容会保存到临时文件并返回路径；非 HTML 内容可选择转换为 Markdown。注意：如果访问失败或超时，LLM 应自动使用 proxy: true 重试。',
       inputSchema: z.object({
         url: z.string().describe('请求 URL'),
         method: z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']).optional().describe('请求方法，默认 GET'),
@@ -831,6 +831,10 @@ class FileSystemPlugin extends Plugin {
       }),
       execute: async (args, framework) => {
         const { url, method = 'GET', headers = {}, body, timeout = 30000, proxy = false, toMarkdown = true, maxLength } = args
+        const fs = require('fs')
+        const path = require('path')
+        const os = require('os')
+
         try {
           const controller = new AbortController()
           const timeoutId = setTimeout(() => controller.abort(), timeout)
@@ -853,50 +857,79 @@ class FileSystemPlugin extends Plugin {
             data = text
           }
 
-          // 如果 toMarkdown 为 true 且响应是 HTML，则转换为 Markdown
-          if (toMarkdown && typeof data === 'string') {
-            // 检测是否为 HTML 内容
-            const isHtml = /<[a-z][\s\S]*>/i.test(data) || data.trim().startsWith('<')
-            if (isHtml) {
+          // 检测是否为 HTML 内容
+          const isHtml = typeof data === 'string' && (/<[a-z][\s\S]*>/i.test(data) || data.trim().startsWith('<'))
+
+          // HTML 内容统一保存到临时文件
+          if (isHtml) {
+            const tmpDir = os.tmpdir()
+            const filename = `fetch_${Date.now()}_${Math.random().toString(36).slice(2, 8)}.html`
+            const filePath = path.join(tmpDir, filename)
+            fs.writeFileSync(filePath, data, 'utf-8')
+
+            // toMarkdown 为 true 时返回 markdown
+            if (toMarkdown) {
               try {
-                
                 const markdown = NodeHtmlMarkdown.translate(data)
-                // 限制返回长度
-                const truncatedMarkdown = maxLength && markdown.length > maxLength 
-                  ? markdown.substring(0, maxLength) + '\n\n...(truncated)' 
-                  : markdown
                 return {
                   success: true,
                   status: response.status,
                   statusText: response.statusText,
                   headers: Object.fromEntries(response.headers.entries()),
                   usedProxy: proxy,
-                  markdown: truncatedMarkdown,
-                  originalLength: markdown.length,
-                  truncated: maxLength && markdown.length > maxLength
+                  filePath: filePath,
+                  markdown: markdown,
+                  content: markdown
                 }
               } catch (e) {
-                // 转换失败时返回原始 body
-                const truncatedBody = maxLength && data.length > maxLength
-                  ? data.substring(0, maxLength) + '\n\n...(truncated)'
-                  : data
+                // 转换失败时只返回路径
                 return {
                   success: true,
                   status: response.status,
                   statusText: response.statusText,
                   headers: Object.fromEntries(response.headers.entries()),
                   usedProxy: proxy,
-                  markdown: null,
-                  body: truncatedBody,
-                  originalLength: data.length,
-                  truncated: maxLength && data.length > maxLength,
-                  markdownError: e.message
+                  filePath: filePath,
+                  content: `[HTML已保存到文件: ${filePath}]`
                 }
               }
             }
+
+            return {
+              success: true,
+              status: response.status,
+              statusText: response.statusText,
+              headers: Object.fromEntries(response.headers.entries()),
+              usedProxy: proxy,
+              filePath: filePath,
+              content: `[HTML已保存到文件: ${filePath}]`
+            }
+          }
+
+          // 非 HTML 内容
+          if (toMarkdown && typeof data === 'string') {
+            try {
+              const markdown = NodeHtmlMarkdown.translate(data)
+              const truncatedMarkdown = maxLength && markdown.length > maxLength
+                ? markdown.substring(0, maxLength) + '\n\n...(truncated)'
+                : markdown
+              return {
+                success: true,
+                status: response.status,
+                statusText: response.statusText,
+                headers: Object.fromEntries(response.headers.entries()),
+                usedProxy: proxy,
+                markdown: truncatedMarkdown,
+                content: truncatedMarkdown,
+                originalLength: markdown.length,
+                truncated: maxLength && markdown.length > maxLength
+              }
+            } catch (e) {
+              // 转换失败时返回原始 body
+            }
           }
 
-          // toMarkdown 为 false 或非 HTML 内容时，返回原始内容
+          // 返回原始内容
           const truncatedData = maxLength && typeof data === 'string' && data.length > maxLength
             ? data.substring(0, maxLength) + '\n\n...(truncated)'
             : data