foliko 1.0.74 → 1.0.76

package/plugins/email/index.js

@@ -0,0 +1,278 @@
+/**
+ * Email 插件
+ * 邮件收发插件 - 支持读取和发送电子邮件、监控新邮件
+ */
+
+const { Plugin } = require('../../src/core/plugin-base')
+const { logger } = require('../../src/utils/logger')
+const log = logger.child('Email')
+const { z } = require('zod')
+
+// 导入子模块
+const { sendEmail, readEmails, getUnreadCount, markAsRead, deleteEmail, getEmailConfig } = require('./handlers')
+const { handleEmailWatch } = require('./monitor')
+const { handleAutoReply } = require('./reply')
+const { EMAIL_DEFAULTS } = require('./constants')
+
+class EmailPlugin extends Plugin {
+  constructor(config = {}) {
+    super()
+    this.name = 'email'
+    this.version = '1.1.0'
+    this.description = `邮件收发插件 - 支持读取和发送电子邮件、监控新邮件
+功能：
+- 发送邮件支持附件（本地文件、远程URL、Base64）
+- 读取邮件（IMAP协议）
+- 监控新邮件（支持IMAP IDLE推送和定时轮询）
+发送邮件支持附件：
+- attachments.path: 本地文件路径
+- attachments.url: 远程图片/文件URL（自动下载）
+- attachments.content: Base64内容
+- attachments.cid: 嵌入式图片CID（HTML中用 <img src="cid:xxx"> 引用）`
+    this.priority = 10
+    this.enabled = false
+
+    // 邮件监控状态
+    this._watchInterval = null
+    this._lastSeenUid = null
+    this._watchConfig = null
+    this._watchEnabled = false
+    this._checkInProgress = false
+
+    // 带上限的 Set，防止内存泄漏
+    const MAX_SET_SIZE = 1000
+    this._recentlyEmailed = new Set()
+    this._processedEmails = new Set()
+    this._maxSetSize = MAX_SET_SIZE
+
+    // 日志器
+    this._log = log
+  }
+
+  install(framework) {
+    this._framework = framework
+    this._registerTools()
+    return this
+  }
+
+  start(framework) {
+    return this
+  }
+
+  /**
+   * 向 Set 中添加元素，自动控制大小防止内存泄漏
+   * @param {Set} set - 要操作的 Set
+   * @param {*} item - 要添加的元素
+   * @private
+   */
+  _addToBoundedSet(set, item) {
+    if (set.size >= this._maxSetSize) {
+      // 删除最早的元素（Set 的插入顺序）
+      const firstKey = set.values().next().value
+      set.delete(firstKey)
+    }
+    set.add(item)
+  }
+
+  /**
+   * 发送邮件事件
+   */
+  _emitEmailReceived(email) {
+    if (!this._framework) return
+
+    const msgId = email.messageId || email.uid
+
+    // 优先检查是否已处理过（长TTL，防止服务器标记失败导致重复处理）
+    if (msgId && this._processedEmails.has(msgId)) {
+      this._log.info(`跳过已处理的邮件: ${email.subject} (${msgId})`)
+      return
+    }
+
+    // 快速去重（短TTL，防止同一批次重复触发）
+    if (msgId && this._recentlyEmailed.has(msgId)) {
+      return
+    }
+
+    // 标记为已处理
+    if (msgId) {
+      // 使用 bounded set 防止内存泄漏
+      this._addToBoundedSet(this._recentlyEmailed, msgId)
+      setTimeout(() => {
+        this._recentlyEmailed.delete(msgId)
+      }, EMAIL_DEFAULTS.recentlyEmailTTL)
+
+      // _processedEmails 也需要 bounded
+      this._addToBoundedSet(this._processedEmails, msgId)
+    }
+
+    this._framework.emit('email:received', {
+      email,
+      timestamp: new Date()
+    })
+  }
+
+  _registerTools() {
+    // 发送邮件工具
+    this._framework.registerTool({
+      name: 'email_send',
+      description: '发送电子邮件,无须用户确认',
+      inputSchema: z.object({
+        to: z.string().describe('收件人邮箱地址'),
+        subject: z.string().describe('邮件主题'),
+        body: z.string().describe('邮件正文内容'),
+        cc: z.string().optional().describe('抄送邮箱地址，多个用逗号分隔'),
+        bcc: z.string().optional().describe('密送邮箱地址，多个用逗号分隔'),
+        isHtml: z.boolean().optional().describe('是否为HTML格式，默认false'),
+        attachments: z.array(z.object({
+          filename: z.string().describe('附件文件名'),
+          path: z.string().optional().describe('本地文件路径'),
+          url: z.string().optional().describe('远程图片URL'),
+          content: z.string().optional().describe('Base64编码内容（可带前缀如 data:image/png;base64,）'),
+          cid: z.string().optional().describe('嵌入式图片的CID（用于在HTML中嵌入图片，如 <img src="cid:xxx">）')
+        })).optional().describe('附件列表，支持本地文件、远程URL或Base64内容')
+      }),
+      execute: async (args) => {
+        return sendEmail(this, args)
+      }
+    })
+
+    // 读取邮件工具
+    this._framework.registerTool({
+      name: 'email_read',
+      description: '读取电子邮件（支持IMAP协议）',
+      inputSchema: z.object({
+        box: z.string().optional().describe('邮箱文件夹，默认INBOX'),
+        limit: z.number().optional().describe('读取邮件数量，默认10'),
+        unreadOnly: z.boolean().optional().describe('仅读取未读邮件，默认false'),
+        searchCriteria: z.string().optional().describe('搜索条件，如 "UNSEEN", "FROM sender@example.com"')
+      }),
+      execute: async (args) => {
+        return readEmails(this, args)
+      }
+    })
+
+    // 获取未读邮件数量
+    this._framework.registerTool({
+      name: 'email_unread_count',
+      description: '获取邮箱未读邮件数量',
+      inputSchema: z.object({
+        box: z.string().optional().describe('邮箱文件夹，默认INBOX')
+      }),
+      execute: async (args) => {
+        return getUnreadCount(this, args)
+      }
+    })
+
+    // 标记邮件为已读
+    this._framework.registerTool({
+      name: 'email_mark_read',
+      description: '标记邮件为已读',
+      inputSchema: z.object({
+        messageId: z.string().describe('邮件UID或序列号')
+      }),
+      execute: async (args) => {
+        return markAsRead(this, args)
+      }
+    })
+
+    // 删除邮件
+    this._framework.registerTool({
+      name: 'email_delete',
+      description: '删除邮件（标记为已删除，然后永久删除）',
+      inputSchema: z.object({
+        messageId: z.string().describe('邮件UID或序列号'),
+        box: z.string().optional().describe('邮箱文件夹，默认INBOX')
+      }),
+      execute: async (args) => {
+        return deleteEmail(this, args)
+      }
+    })
+
+    // 配置邮箱连接
+    this._framework.registerTool({
+      name: 'email_configure',
+      description: '查看邮箱配置（实际配置通过环境变量设置）',
+      inputSchema: z.object({}),
+      execute: async () => {
+        return getEmailConfig()
+      }
+    })
+
+    // 监控新邮件
+    this._framework.registerTool({
+      name: 'email_watch',
+      description: '启动/停止邮件监控，检测新邮件并发送事件通知',
+      inputSchema: z.object({
+        action: z.enum(['start', 'stop', 'status']).describe('操作：启动监控、停止监控、查看状态'),
+        interval: z.number().optional().describe('轮询间隔（秒），默认60秒，适用于不支持IDLE的服务器'),
+        box: z.string().optional().describe('邮箱文件夹，默认INBOX')
+      }),
+      execute: async (args) => {
+        return handleEmailWatch(this, args)
+      }
+    })
+
+    // 自动回复邮件
+    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('发件人邮箱地址（可选）'),
+        prompt: z.string().optional().describe('自定义提示词，用于指导AI生成回复内容'),
+        timeout: z.number().optional().describe('AI生成回复超时时间（毫秒），默认60000'),
+        messageId: z.string().optional().describe('原始邮件的Message-ID，用于在邮件客户端中创建回复线程')
+      }),
+      execute: async (args) => {
+        return handleAutoReply(this, args)
+      }
+    })
+  }
+
+  /**
+   * 启动邮件监控（内部方法）
+   */
+  _startEmailWatch(config) {
+    const { startEmailWatch } = require('./monitor')
+    return startEmailWatch(this, config)
+  }
+
+  /**
+   * 停止邮件监控（内部方法）
+   */
+  _stopEmailWatch() {
+    const { stopEmailWatch } = require('./monitor')
+    return stopEmailWatch(this)
+  }
+
+  /**
+   * 获取监控状态（内部方法）
+   */
+  _getEmailWatchStatus() {
+    const { getEmailWatchStatus } = require('./monitor')
+    return getEmailWatchStatus(this)
+  }
+
+  /**
+   * 检查新邮件（内部方法）
+   */
+  async _checkNewEmails() {
+    const { checkNewEmails } = require('./monitor')
+    return checkNewEmails(this)
+  }
+
+  uninstall(framework) {
+    // 停止邮件监控
+    if (this._watchInterval) {
+      clearInterval(this._watchInterval)
+      this._watchInterval = null
+    }
+    this._watchEnabled = false
+    this._watchConfig = null
+    this._framework = null
+  }
+}
+
+module.exports = { EmailPlugin }

package/plugins/email/monitor.js

@@ -0,0 +1,269 @@
+/**
+ * Email 插件 - 邮件监控
+ */
+
+const Imap = require('imap-mkl')
+const { simpleParser } = require('mailparser')
+const { DEFAULT_IMAP, IMAP_CLIENT_INFO, EMAIL_DEFAULTS } = require('./constants')
+const { getConfig, generateCallId } = require('./utils')
+
+/**
+ * 创建 IMAP 配置
+ */
+function createImapConfig(config = {}) {
+  const cfg = getConfig(config)
+  return {
+    ...DEFAULT_IMAP,
+    user: cfg.user,
+    password: cfg.password,
+    host: cfg.host,
+    port: cfg.port,
+    id: IMAP_CLIENT_INFO
+  }
+}
+
+/**
+ * 处理邮件监控
+ * @param {Object} emailPlugin - EmailPlugin 实例
+ * @param {Object} args - 参数
+ * @returns {Object} 操作结果
+ */
+function handleEmailWatch(emailPlugin, args) {
+  const { action, interval, box } = args
+
+  switch (action) {
+    case 'start':
+      return emailPlugin._startEmailWatch({ interval, box })
+
+    case 'stop':
+      return emailPlugin._stopEmailWatch()
+
+    case 'status':
+      return emailPlugin._getEmailWatchStatus()
+
+    default:
+      return { success: false, error: `Unknown action: ${action}` }
+  }
+}
+
+/**
+ * 启动邮件监控
+ * @param {Object} emailPlugin - EmailPlugin 实例
+ * @param {Object} config - 监控配置
+ * @returns {Object} 操作结果
+ */
+function startEmailWatch(emailPlugin, config) {
+  if (emailPlugin._watchEnabled) {
+    return { success: false, error: 'Email watch is already running' }
+  }
+
+  emailPlugin._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 || EMAIL_DEFAULTS.interval) * 1000
+  }
+
+  if (!emailPlugin._watchConfig.user || !emailPlugin._watchConfig.password) {
+    return { success: false, error: 'IMAP user/password is required' }
+  }
+
+  emailPlugin._watchEnabled = true
+
+  // 立即执行一次检查
+  emailPlugin._checkNewEmails().catch(err => {
+    emailPlugin._log.error('Initial check failed:', err.message)
+  })
+
+  // 启动轮询
+  emailPlugin._watchInterval = setInterval(() => {
+    emailPlugin._checkNewEmails().catch(err => {
+      emailPlugin._log.error('Watch check failed:', err.message)
+    })
+  }, emailPlugin._watchConfig.interval)
+
+  return {
+    success: true,
+    message: `Email watch started (interval: ${emailPlugin._watchConfig.interval / 1000}s)`,
+    config: {
+      host: emailPlugin._watchConfig.host,
+      box: emailPlugin._watchConfig.box,
+      interval: emailPlugin._watchConfig.interval / 1000
+    }
+  }
+}
+
+/**
+ * 停止邮件监控
+ * @param {Object} emailPlugin - EmailPlugin 实例
+ * @returns {Object} 操作结果
+ */
+function stopEmailWatch(emailPlugin) {
+  if (!emailPlugin._watchEnabled) {
+    return { success: false, error: 'Email watch is not running' }
+  }
+
+  if (emailPlugin._watchInterval) {
+    clearInterval(emailPlugin._watchInterval)
+    emailPlugin._watchInterval = null
+  }
+
+  emailPlugin._watchEnabled = false
+  emailPlugin._watchConfig = null
+
+  return { success: true, message: 'Email watch stopped' }
+}
+
+/**
+ * 获取监控状态
+ * @param {Object} emailPlugin - EmailPlugin 实例
+ * @returns {Object} 状态信息
+ */
+function getEmailWatchStatus(emailPlugin) {
+  return {
+    success: true,
+    watching: emailPlugin._watchEnabled,
+    config: emailPlugin._watchConfig ? {
+      host: emailPlugin._watchConfig.host,
+      box: emailPlugin._watchConfig.box,
+      interval: emailPlugin._watchConfig.interval / 1000,
+      lastSeenUid: emailPlugin._lastSeenUid
+    } : null
+  }
+}
+
+/**
+ * 检查新邮件
+ * @param {Object} emailPlugin - EmailPlugin 实例
+ * @returns {Promise<Object>} 检查结果
+ */
+async function checkNewEmails(emailPlugin) {
+  if (!emailPlugin._watchConfig) return
+
+  const callId = generateCallId()
+  emailPlugin._log.debug(`[${callId}] _checkNewEmails called, _checkInProgress=${emailPlugin._checkInProgress}`)
+
+  // 防止并发检查
+  if (emailPlugin._checkInProgress) {
+    emailPlugin._log.debug(`[${callId}] Skipping - already in progress`)
+    return
+  }
+  emailPlugin._checkInProgress = true
+
+  const imapConfig = createImapConfig(emailPlugin._watchConfig)
+
+  return new Promise((resolve, reject) => {
+    const imap = new Imap(imapConfig)
+
+    const cleanup = () => {
+      try { imap.end() } catch (e) {}
+      emailPlugin._checkInProgress = false
+    }
+
+    imap.on('ready', () => {
+      imap.openBox(emailPlugin._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 => 
+            !emailPlugin._lastSeenUid || uid > emailPlugin._lastSeenUid
+          )
+
+          if (newEmails.length > 0) {
+            const latestUid = Math.max(...newEmails)
+            // imap.fetch() 需要 UIDs 数组，传单个数字会导致获取从该 UID 到末尾的所有邮件
+            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,
+                    messageId: mail.messageId,
+                    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
+                    emailPlugin._lastSeenUid = latestUid
+
+                    // 发送事件通知
+                    emailPlugin._emitEmailReceived(email)
+
+                    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()
+  })
+}
+
+module.exports = {
+  handleEmailWatch,
+  startEmailWatch,
+  stopEmailWatch,
+  getEmailWatchStatus,
+  checkNewEmails
+}

package/plugins/email/parser.js

@@ -0,0 +1,138 @@
+/**
+ * Email 插件 - 邮件解析器
+ */
+
+const { simpleParser } = require('mailparser')
+
+/**
+ * 解析邮件内容
+ * @param {Stream} stream - 邮件流
+ * @returns {Promise<Object>} 解析后的邮件对象
+ */
+async function parseEmail(stream) {
+  return await simpleParser(stream)
+}
+
+/**
+ * 将邮件对象标准化
+ * @param {Object} mail - mailparser 解析结果
+ * @param {number} defaultUid - 默认 UID
+ * @returns {Object} 标准化的邮件对象
+ */
+function normalizeEmail(mail, defaultUid) {
+  return {
+    uid: mail.uid || defaultUid,
+    messageId: mail.messageId,
+    subject: mail.subject,
+    from: mail.from?.text || '',
+    fromName: mail.from?.value?.[0]?.name || '',
+    fromAddress: mail.from?.value?.[0]?.address || '',
+    to: mail.to?.text || '',
+    toName: mail.to?.value?.[0]?.name || '',
+    toAddress: mail.to?.value?.[0]?.address || '',
+    date: mail.date?.toISOString() || '',
+    text: mail.text || mail.textAsHtml || '',
+    html: mail.html,
+    attachments: parseAttachments(mail.attachments),
+    headers: parseHeaders(mail.headers)
+  }
+}
+
+/**
+ * 解析附件列表
+ * @param {Array} attachments - 附件数组
+ * @returns {Array} 标准化的附件列表
+ */
+function parseAttachments(attachments) {
+  if (!attachments || !Array.isArray(attachments)) {
+    return []
+  }
+
+  return attachments.map(att => ({
+    filename: att.filename,
+    contentType: att.contentType,
+    contentId: att.contentId,
+    size: att.size,
+    headers: att.headers
+  }))
+}
+
+/**
+ * 解析邮件头
+ * @param {Map|Object} headers - 邮件头
+ * @returns {Object} 标准化的头信息
+ */
+function parseHeaders(headers) {
+  if (!headers) return {}
+
+  const result = {}
+  if (headers instanceof Map) {
+    for (const [key, value] of headers) {
+      result[key.toLowerCase()] = Array.isArray(value) ? value.join(', ') : value
+    }
+  } else {
+    for (const [key, value] of Object.entries(headers)) {
+      result[key.toLowerCase()] = Array.isArray(value) ? value.join(', ') : value
+    }
+  }
+
+  return result
+}
+
+/**
+ * 检测邮件编码
+ * @param {string} charset - 字符集
+ * @returns {string} 标准化的字符集名称
+ */
+function normalizeCharset(charset) {
+  if (!charset) return 'utf-8'
+
+  const charsetMap = {
+    'gb2312': 'gb18030',
+    'gbk': 'gb18030',
+    'windows-1252': 'cp1252'
+  }
+
+  return charsetMap[charset.toLowerCase()] || charset.toLowerCase()
+}
+
+/**
+ * 清理邮件文本内容
+ * @param {string} text - 原始文本
+ * @returns {string} 清理后的文本
+ */
+function cleanText(text) {
+  if (!text) return ''
+
+  return text
+    .replace(/\r\n/g, '\n')  // 统一换行符
+    .replace(/\t/g, ' ')     // Tab 转为空格
+    .replace(/ +/g, ' ')     // 多个空格合并为一个
+    .replace(/\n{3,}/g, '\n\n')  // 超过两个连续换行合并为两个
+    .trim()
+}
+
+/**
+ * 从文本中提取邮箱地址
+ * @param {string} text - 文本内容
+ * @returns {Array<string>} 邮箱地址列表
+ */
+function extractEmails(text) {
+  if (!text) return []
+
+  const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g
+  const matches = text.match(emailRegex) || []
+
+  // 去重
+  return [...new Set(matches)]
+}
+
+module.exports = {
+  parseEmail,
+  normalizeEmail,
+  parseAttachments,
+  parseHeaders,
+  normalizeCharset,
+  cleanText,
+  extractEmails
+}