foliko 1.0.53 → 1.0.55

package/plugins/email.js

@@ -1,6 +1,6 @@
 /**
  * Email 插件
- * 邮件收发插件 - 支持读取和发送电子邮件
+ * 邮件收发插件 - 支持读取和发送电子邮件、监控新邮件
  */
 
 const { Plugin } = require('../src/core/plugin-base')
@@ -10,16 +10,27 @@ class EmailPlugin extends Plugin {
   constructor(config = {}) {
     super()
     this.name = 'email'
-    this.version = '1.0.0'
-    this.description = `邮件收发插件 - 支持读取和发送电子邮件
+    this.version = '1.1.0'
+    this.description = `邮件收发插件 - 支持读取和发送电子邮件、监控新邮件、自动回复，配置已经预设，不用获取配置
+功能：
+- 发送邮件支持附件（本地文件、远程URL、Base64）
+- 读取邮件（IMAP协议）
+- 监控新邮件（支持IMAP IDLE推送和定时轮询）
+- 自动回复邮件（AI分析内容并发送回复，无需用户确认）
 发送邮件支持附件：
 - attachments.path: 本地文件路径
 - attachments.url: 远程图片/文件URL（自动下载）
 - attachments.content: Base64内容
 - attachments.cid: 嵌入式图片CID（HTML中用 <img src="cid:xxx"> 引用）`
     this.priority = 10
-    // 默认不启用，需要在 plugins.json 中设置 enabled: true
     this.enabled = false
+
+    // 邮件监控状态
+    this._watchInterval = null
+    this._lastSeenUid = null
+    this._watchConfig = null
+    this._watchEnabled = false
+    this._checking = false  // 防止并发检查
   }
 
   install(framework) {
@@ -28,6 +39,41 @@ class EmailPlugin extends Plugin {
     return this
   }
 
+  start(framework) {
+    // 自动启动邮件监控（如果配置了 IMAP 且尚未运行）
+    if (this._watchEnabled) {
+      console.log('[Email] Email watch already running, skipping auto-start')
+      return this
+    }
+
+    // if (process.env.IMAP_USER && process.env.IMAP_PASS) {
+    //   console.log('[Email] Auto-starting email watch...')
+    //   this._startEmailWatch({
+    //     interval: 60,
+    //     host: process.env.IMAP_HOST,
+    //     port: parseInt(process.env.IMAP_PORT) || 993,
+    //     user: process.env.IMAP_USER,
+    //     password: process.env.IMAP_PASS,
+    //     box: 'INBOX'
+    //   })
+    // } else {
+    //   console.log('[Email] IMAP credentials not configured, skipping auto-start')
+    // }
+    return this
+  }
+
+  /**
+   * 发送邮件事件
+   */
+  _emitEmailReceived(email) {
+    if (this._framework) {
+      this._framework.emit('email:received', {
+        email,
+        timestamp: new Date()
+      })
+    }
+  }
+
   _registerTools() {
     // 发送邮件工具
     this._framework.registerTool({
@@ -105,26 +151,413 @@ class EmailPlugin extends Plugin {
     })
 
     // 配置邮箱连接
+    // this._framework.registerTool({
+    //   name: 'email_configure',
+    //   description: '查看邮箱配置（实际配置通过环境变量设置）',
+    //   inputSchema: z.object({}),
+    //   execute: async () => {
+    //     return {
+    //       success: true,
+    //       message: '邮箱配置通过环境变量设置',
+    //       config: {
+    //         smtp_host: process.env.SMTP_HOST || 'smtp.gmail.com',
+    //         smtp_port: process.env.SMTP_PORT || 587,
+    //         smtp_secure: process.env.SMTP_SECURE || 'false',
+    //         imap_host: process.env.IMAP_HOST || 'imap.gmail.com',
+    //         imap_port: process.env.IMAP_PORT || 993,
+    //         from_email: process.env.FROM_EMAIL || '(未设置)',
+    //         client_name: process.env.IMAP_CLIENT_NAME || 'FolikoAgent',
+    //         client_version: process.env.IMAP_CLIENT_VERSION || '1.0.0'
+    //       }
+    //     }
+    //   }
+    // })
+
+    // 监控新邮件
     this._framework.registerTool({
-      name: 'email_configure',
-      description: '查看邮箱配置（实际配置通过环境变量设置）',
-      inputSchema: z.object({}),
-      execute: async () => {
+      name: 'email_watch',
+      description: '启动/停止邮件监控，检测新邮件并发送事件通知',
+      inputSchema: z.object({
+        action: z.enum(['start', 'stop', 'status']).describe('操作：启动监控、停止监控、查看状态'),
+        interval: z.number().optional().describe('轮询间隔（秒），默认60秒，适用于不支持IDLE的服务器'),
+        // host: z.string().optional().describe('IMAP服务器地址'),
+        // port: z.number().optional().describe('IMAP端口'),
+        // user: z.string().optional().describe('邮箱用户名'),
+        // password: z.string().optional().describe('邮箱密码'),
+        box: z.string().optional().describe('邮箱文件夹，默认INBOX')
+      }),
+      execute: async (args) => {
+
+        return this._handleEmailWatch({
+          ...args,
+          host: process.env.IMAP_HOST,
+          port: parseInt(process.env.IMAP_PORT) || 993,
+          user: process.env.IMAP_USER,
+          password: process.env.IMAP_PASS,
+        })
+      }
+    })
+
+    // 自动回复邮件
+    this._framework.registerTool({
+      name: 'email_auto_reply',
+      description: '自动分析邮件内容并发送回复（无需用户确认）',
+      inputSchema: z.object({
+        to: z.string().describe('收件人邮箱地址'),
+        subject: z.string().describe('原始邮件主题'),
+        body: z.string().describe('原始邮件内容'),
+        from: z.string().optional().describe('发件人邮箱地址（可选）')
+      }),
+      execute: async (args) => {
+        return this._handleAutoReply(args)
+      }
+    })
+  }
+
+  /**
+   * 处理自动回复
+   */
+  async _handleAutoReply(args) {
+    // 支持两种模式：
+    // 1. 直接传参数: { to, subject, body, from }
+    // 2. 从 _event 提取: { _event } (来自 ambient agent 的事件触发)
+    let { to, subject, body, from, _event } = args
+
+    // 如果没有直接参数，尝试从 _event 提取
+    if (!to && !subject && !body && _event) {
+      const email = _event.data?.email || _event.email || {}
+      from = email.from?.text || email.from || ''
+      to = email.to?.text || email.to || ''
+      subject = email.subject || ''
+      body = email.text || email.body || ''
+    }
+
+    // 检查必要参数
+    if (!from && !to) {
+      return { success: false, error: '缺少收件人地址' }
+    }
+    if (!body) {
+      return { success: false, error: '缺少邮件内容' }
+    }
+
+    try {
+      // 获取活跃的 Agent
+      const agent = this._getActiveAgent()
+      if (!agent) {
+        return { success: false, error: 'No active agent found' }
+      }
+
+      // 构建提示让 LLM 生成回复
+      const prompt = `你是一封邮件自动回复助手。请根据以下邮件内容，生成一封专业的回复邮件。
+
+【原始邮件】
+发件人: ${from || to}
+主题: ${subject}
+内容:
+${body}
+
+【要求】
+1. 回复内容要针对邮件中的问题或内容进行回复
+2. 语言要专业、礼貌、简洁
+3. 只输出邮件正文内容，不要额外解释
+4. 回复语言应与原邮件一致（如果原邮件是中文，则用中文回复）`
+
+      // 等待 Agent 生成回复（带超时保护）
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error('AI回复生成超时（30秒）')), 30000)
+      })
+
+      const replyPromise = agent.pushMessage(prompt, { maxSteps: 3 })
+      const replyResult = await Promise.race([replyPromise, timeoutPromise])
+
+      // 提取回复内容
+      let replyContent = ''
+      if (typeof replyResult === 'string') {
+        replyContent = replyResult.trim()
+      } else if (replyResult && replyResult.content) {
+        replyContent = replyResult.content.trim()
+      } else if (replyResult && replyResult.message) {
+        replyContent = replyResult.message.trim()
+      } else {
+        replyContent = JSON.stringify(replyResult).trim()
+      }
+
+      // 去掉 <</think> 思考过程标签
+      replyContent = replyContent.replace(/<think>[\s\S]*?<\/think>/g, '').trim()
+
+      // 如果去完后内容为空或太短，说明提取失败
+      if (replyContent.length < 5) {
+        return { success: false, error: 'AI回复内容太短或无效' }
+      }
+
+      if (!replyContent) {
+        return { success: false, error: 'AI未能生成有效的回复内容' }
+      }
+
+      // 发送回复邮件
+      const sendResult = await this._sendEmail({
+        to: from || to,
+        subject: `Re: ${subject}`,
+        body: replyContent
+      })
+
+      if (sendResult.success) {
+        console.log(`[Email] Auto reply sent to ${from || to}`)
         return {
           success: true,
-          message: '邮箱配置通过环境变量设置',
-          config: {
-            smtp_host: process.env.SMTP_HOST || 'smtp.gmail.com',
-            smtp_port: process.env.SMTP_PORT || 587,
-            smtp_secure: process.env.SMTP_SECURE || 'false',
-            imap_host: process.env.IMAP_HOST || 'imap.gmail.com',
-            imap_port: process.env.IMAP_PORT || 993,
-            from_email: process.env.FROM_EMAIL || '(未设置)',
-            client_name: process.env.IMAP_CLIENT_NAME || 'FolikoAgent',
-            client_version: process.env.IMAP_CLIENT_VERSION || '1.0.0'
-          }
+          message: `自动回复已发送至 ${from || to}`,
+          replyContent
         }
+      } else {
+        return { success: false, error: sendResult.error || '发送失败' }
       }
+    } catch (err) {
+      console.error('[Email] Auto reply error:', err.message)
+      return { success: false, error: err.message }
+    }
+  }
+
+  /**
+   * 获取活跃的 Agent
+   */
+  _getActiveAgent() {
+    if (this._framework._mainAgent) {
+      return this._framework._mainAgent
+    }
+    const agents = this._framework._agents || []
+    return agents.length > 0 ? agents[agents.length - 1] : null
+  }
+
+  /**
+   * 处理邮件监控
+   */
+  async _handleEmailWatch(args) {
+    const { action, interval, host, port, user, password, box } = args
+
+    switch (action) {
+      case 'start':
+        return this._startEmailWatch({ interval, host, port, user, password, box })
+
+      case 'stop':
+        return this._stopEmailWatch()
+
+      case 'status':
+        return this._getEmailWatchStatus()
+
+      default:
+        return { success: false, error: `Unknown action: ${action}` }
+    }
+  }
+
+  /**
+   * 启动邮件监控
+   */
+  _startEmailWatch(config) {
+    if (this._watchEnabled) {
+      return { success: false, error: 'Email watch is already running' }
+    }
+
+    this._watchConfig = {
+      host: config.host || process.env.IMAP_HOST,
+      port: config.port || parseInt(process.env.IMAP_PORT) || 993,
+      user: config.user || process.env.IMAP_USER,
+      password: config.password || process.env.IMAP_PASS,
+      box: config.box || 'INBOX',
+      interval: (config.interval || 60) * 1000 // 转换为毫秒
+    }
+
+    if (!this._watchConfig.user || !this._watchConfig.password) {
+      return { success: false, error: 'IMAP user/password is required' }
+    }
+
+    this._watchEnabled = true
+    console.log('[Email] Starting email watch...')
+
+    // 立即执行一次检查
+    this._checkNewEmails().catch(err => {
+      console.error('[Email] Initial check failed:', err.message)
+    })
+
+    // 启动轮询
+    this._watchInterval = setInterval(() => {
+      this._checkNewEmails().catch(err => {
+        console.error('[Email] Watch check failed:', err.message)
+      })
+    }, this._watchConfig.interval)
+
+    return {
+      success: true,
+      message: `Email watch started (interval: ${this._watchConfig.interval / 1000}s)`,
+      config: {
+        host: this._watchConfig.host,
+        box: this._watchConfig.box,
+        interval: this._watchConfig.interval / 1000
+      }
+    }
+  }
+
+  /**
+   * 停止邮件监控
+   */
+  _stopEmailWatch() {
+    if (!this._watchEnabled) {
+      return { success: false, error: 'Email watch is not running' }
+    }
+
+    if (this._watchInterval) {
+      clearInterval(this._watchInterval)
+      this._watchInterval = null
+    }
+
+    this._watchEnabled = false
+    this._watchConfig = null
+
+    console.log('[Email] Email watch stopped')
+    return { success: true, message: 'Email watch stopped' }
+  }
+
+  /**
+   * 获取监控状态
+   */
+  _getEmailWatchStatus() {
+    return {
+      success: true,
+      watching: this._watchEnabled,
+      config: this._watchConfig ? {
+        host: this._watchConfig.host,
+        box: this._watchConfig.box,
+        interval: this._watchConfig.interval / 1000,
+        lastSeenUid: this._lastSeenUid
+      } : null
+    }
+  }
+
+  /**
+   * 检查新邮件
+   */
+  async _checkNewEmails() {
+    if (!this._watchConfig) return
+    if (this._checking) return  // 防止并发检查
+    this._checking = true
+
+    const Imap = require('imap-mkl')
+    const { simpleParser } = require('mailparser')
+
+    const imapConfig = {
+      user: this._watchConfig.user,
+      password: this._watchConfig.password,
+      host: this._watchConfig.host,
+      port: this._watchConfig.port,
+      tls: true,
+      tlsOptions: { rejectUnauthorized: false },
+      id: {
+        name: process.env.IMAP_CLIENT_NAME || 'FolikoAgent',
+        version: process.env.IMAP_CLIENT_VERSION || '1.0.0',
+        vendor: process.env.IMAP_CLIENT_VENDOR || 'Foliko'
+      }
+    }
+
+    return new Promise((resolve, reject) => {
+      const imap = new Imap(imapConfig)
+
+      const cleanup = () => {
+        try { imap.end() } catch (e) {}
+        this._checking = false
+      }
+
+      imap.on('ready', () => {
+        imap.openBox(this._watchConfig.box, true, (err, box) => {
+          if (err) {
+            cleanup()
+            return reject(err)
+          }
+
+          // 搜索未读邮件
+          imap.search(['UNSEEN'], (err, results) => {
+            if (err) {
+              cleanup()
+              return reject(err)
+            }
+
+            if (!results || results.length === 0) {
+              cleanup()
+              return resolve({ success: true, newEmails: 0 })
+            }
+
+            // 找出新的未读邮件（比上次看到的更新）
+            const newEmails = results.filter(uid => !this._lastSeenUid || uid > this._lastSeenUid)
+
+            if (newEmails.length > 0) {
+              // 获取最新邮件
+              const latestUid = Math.max(...newEmails)
+              const f = imap.fetch(latestUid, { bodies: '' })
+
+              f.on('message', (msg) => {
+                let email = {}
+                let bodyParsed = false
+
+                msg.on('body', (stream) => {
+                  simpleParser(stream).then(mail => {
+                    email = {
+                      uid: mail.uid || latestUid,
+                      subject: mail.subject,
+                      from: mail.from?.text || '',
+                      to: mail.to?.text || '',
+                      date: mail.date?.toISOString() || '',
+                      text: mail.text || mail.textAsHtml || '',
+                      html: mail.html,
+                      attachments: mail.attachments?.map(a => ({
+                        filename: a.filename,
+                        contentType: a.contentType
+                      })) || []
+                    }
+                    bodyParsed = true
+                  }).catch(err => {
+                    email.error = err.message
+                    bodyParsed = true
+                  })
+                })
+
+                msg.on('end', () => {
+                  const checkDone = () => {
+                    if (bodyParsed) {
+                      // 更新最后看到的 UID
+                      this._lastSeenUid = latestUid
+
+                      // 发送事件通知
+                      this._emitEmailReceived(email)
+
+                      console.log(`[Email] New email received: ${email.subject}`)
+                      cleanup()
+                      resolve({ success: true, newEmails: newEmails.length, email })
+                    } else {
+                      setTimeout(checkDone, 10)
+                    }
+                  }
+                  checkDone()
+                })
+              })
+
+              f.on('error', (err) => {
+                cleanup()
+                reject(err)
+              })
+            } else {
+              cleanup()
+              resolve({ success: true, newEmails: 0 })
+            }
+          })
+        })
+      })
+
+      imap.on('error', (err) => {
+        cleanup()
+        reject(err)
+      })
+
+      imap.on('end', () => {})
+
+      imap.connect()
     })
   }
 
@@ -308,6 +741,17 @@ class EmailPlugin extends Plugin {
     try {
       const Imap = require('imap-mkl')
 
+      // 支持从 _event 提取邮件 UID
+      let { messageId, _event } = args
+      if (!messageId && _event) {
+        const email = _event.data?.email || _event.email || {}
+        messageId = email.uid || email.messageId
+      }
+
+      if (!messageId) {
+        return { success: false, error: '缺少邮件标识（messageId 或 uid）' }
+      }
+
       const imapConfig = {
         user: args.user || process.env.IMAP_USER,
         password: args.password || process.env.IMAP_PASS,
@@ -323,7 +767,7 @@ class EmailPlugin extends Plugin {
         }
       }
 
-      await this._markEmailAsRead(imapConfig, args.messageId)
+      await this._markEmailAsRead(imapConfig, messageId)
 
       return {
         success: true,
@@ -355,11 +799,19 @@ class EmailPlugin extends Plugin {
             return reject(err)
           }
 
-          let searchFilter = searchCriteria
-            ? searchCriteria.split(' ').filter(Boolean)
-            : ['ALL']
+          let searchFilter
           if (unreadOnly) {
-            searchFilter = ['UNSEEN']
+            searchFilter = [['UNSEEN']]
+          } else if (searchCriteria) {
+            // 将 "FROM sender@example.com" 转换为 [['FROM', 'sender@example.com']]
+            const parts = searchCriteria.split(' ').filter(Boolean)
+            if (parts.length >= 2) {
+              searchFilter = [[parts[0], parts.slice(1).join(' ')]]
+            } else {
+              searchFilter = [parts]
+            }
+          } else {
+            searchFilter = [['ALL']]
           }
 
           imap.search(searchFilter, (err, results) => {
@@ -505,7 +957,14 @@ class EmailPlugin extends Plugin {
   }
 
   uninstall(framework) {
-    // 清理资源
+    // 停止邮件监控
+    if (this._watchInterval) {
+      clearInterval(this._watchInterval)
+      this._watchInterval = null
+    }
+    this._watchEnabled = false
+    this._watchConfig = null
+    this._framework = null
   }
 }
 

package/plugins/feishu-plugin.js

@@ -294,6 +294,8 @@ class FeishuPlugin extends Plugin {
       }
 
       if (fullResponse) {
+        // 去掉思考过程标签
+        fullResponse = fullResponse.replace(/<think>[\s\S]*?<\/think>/g, '').trim()
         await this._sendMessage(openId, fullResponse, originalMsg)
       } else {
         await this._sendMessage(openId, '抱歉，我没有收到有效的回复。', originalMsg)

package/plugins/file-system-plugin.js

@@ -332,7 +332,63 @@ class FileSystemPlugin extends Plugin {
             day: String(beijingTime.getUTCDate()).padStart(2, '0'),
             hour: String(beijingTime.getUTCHours()).padStart(2, '0'),
             minute: String(beijingTime.getUTCMinutes()).padStart(2, '0'),
-            second: String(beijingTime.getUTCSeconds()).padStart(2, '0')
+            second: String(beijingTime.getUTCMinutes()).padStart(2, '0')
+          }
+        }
+      }
+    })
+
+    // HTTP 请求
+    framework.registerTool({
+      name: 'fetch',
+      description: '发送 HTTP 请求获取远程数据。如果访问失败或超时，LLM 应自动使用 proxy: true 重试（代理会绕过网络限制）。',
+      inputSchema: z.object({
+        url: z.string().describe('请求 URL'),
+        method: z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']).optional().describe('请求方法，默认 GET'),
+        headers: z.record(z.string()).optional().describe('请求头'),
+        body: z.string().optional().describe('请求体（POST/PUT/PATCH 时使用）'),
+        timeout: z.number().optional().describe('超时时间(ms)，默认 30000'),
+        proxy: z.boolean().optional().describe('是否使用代理，默认 false。访问失败时可自动设为 true 重试')
+      }),
+      execute: async (args, framework) => {
+        const { url, method = 'GET', headers = {}, body, timeout = 30000, proxy = false } = args
+        try {
+          const controller = new AbortController()
+          const timeoutId = setTimeout(() => controller.abort(), timeout)
+          const fetchUrl = proxy ? `https://fcdn.foliko.com?url=${encodeURIComponent(url)}` : url
+
+          const response = await fetch(fetchUrl, {
+            method,
+            headers,
+            body: body || undefined,
+            signal: controller.signal
+          })
+
+          clearTimeout(timeoutId)
+
+          const text = await response.text()
+          let data
+          try {
+            data = JSON.parse(text)
+          } catch {
+            data = text
+          }
+
+          return {
+            success: true,
+            status: response.status,
+            statusText: response.statusText,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: data,
+            usedProxy: proxy
+          }
+        } catch (error) {
+          return {
+            success: false,
+            error: error.message,
+            url,
+            method,
+            hint: '如果访问失败，可尝试设置 proxy: true'
           }
         }
       }

package/plugins/python-executor-plugin.js

@@ -15,7 +15,7 @@ class PythonExecutorPlugin extends Plugin {
     super()
     this.name = 'python-executor'
     this.version = '1.0.0'
-    this.description = 'Python 执行器，用于运行 Python 代码和脚本'
+    this.description = 'Python 执行器，用于运行 Python 代码和脚本，禁止传入无用的emoji'
     this.priority = 15
 
     this.config = {

package/plugins/python-plugin-loader.js

@@ -54,7 +54,7 @@ class PythonPluginLoader extends Plugin {
     super()
     this.name = 'python-plugin-loader'
     this.version = '1.0.0'
-    this.description = 'Python 插件加载器'
+    this.description = 'Python 插件加载器，属于Python的插件'
 
     this._agentDir = config.agentDir || '.agent'
     this._pythonPlugins = new Map()
@@ -228,7 +228,7 @@ class PythonPluginLoader extends Plugin {
           return this._executePythonTool(pluginName, tool.name, args)
         }
       })
-      console.log(`[PythonPluginLoader] Registered tool: ${tool.name}`)
+      //console.log(`[PythonPluginLoader] Registered tool: ${tool.name}`)
     } catch (err) {
       console.error(`[PythonPluginLoader] Failed to register tool ${tool.name}:`, err.message)
     }