foliko 1.0.73 → 1.0.75

package/plugins/email.js

@@ -1,1142 +0,0 @@
-/**
- * Email 插件
- * 邮件收发插件 - 支持读取和发送电子邮件、监控新邮件
- */
-
-const { Plugin } = require('../src/core/plugin-base')
-const { z } = require('zod')
-
-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  // 防止并发检查
-    this._recentlyEmailed = new Set()  // 去重：最近已处理的 messageId（短TTL，用于快速去重）
-    this._processedEmails = new Set()  // 已处理（已回复）的邮件，不会重复处理（长TTL）
-  }
-
-  install(framework) {
-    this._framework = framework
-    this._registerTools()
-    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) return
-    // 去重：如果最近已处理过这个 messageId，跳过
-    const msgId = email.messageId || email.uid
-    //console.log(`[Email] _emitEmailReceived: msgId=${msgId}, messageId=${email.messageId}, uid=${email.uid}`)
-
-    // 优先检查是否已处理过（长TTL，防止服务器标记失败导致重复处理）
-    if (msgId && this._processedEmails.has(msgId)) {
-      console.log(`[Email] 跳过已处理的邮件: ${email.subject} (${msgId})`)
-      return
-    }
-
-    // 快速去重（短TTL，防止同一批次重复触发）
-    if (msgId && this._recentlyEmailed.has(msgId)) {
-      //console.log(`[Email] 跳过重复邮件: ${email.subject} (${msgId})`)
-      return
-    }
-
-    // 标记为已处理
-    if (msgId) {
-      this._recentlyEmailed.add(msgId)
-      // 5分钟后从 Set 中移除，允许重新处理（适用于邮件被删除后重新收到的极端情况）
-      setTimeout(() => {
-        this._recentlyEmailed.delete(msgId)
-      }, 5 * 60 * 1000)
-    }
-
-    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 this._sendEmail(args)
-      }
-    })
-
-    // 读取邮件工具
-    this._framework.registerTool({
-      name: 'email_read',
-      description: '读取电子邮件（支持IMAP协议）',
-      inputSchema: z.object({
-        // host: z.string().optional().describe('IMAP服务器地址，默认从配置获取'),
-        // port: z.number().optional().describe('IMAP端口，默认993'),
-        // user: z.string().optional().describe('邮箱用户名，默认从配置获取'),
-        // password: z.string().optional().describe('邮箱密码，默认从配置获取'),
-        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 this._readEmails(args)
-      }
-    })
-
-    // 获取未读邮件数量
-    this._framework.registerTool({
-      name: 'email_unread_count',
-      description: '获取邮箱未读邮件数量',
-      inputSchema: z.object({
-        // 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._getUnreadCount(args)
-      }
-    })
-
-    // 标记邮件为已读
-    this._framework.registerTool({
-      name: 'email_mark_read',
-      description: '标记邮件为已读',
-      inputSchema: z.object({
-        // host: z.string().optional().describe('IMAP服务器地址'),
-        // port: z.number().optional().describe('IMAP端口'),
-        // user: z.string().optional().describe('邮箱用户名'),
-        // password: z.string().optional().describe('邮箱密码'),
-        messageId: z.string().describe('邮件UID或序列号')
-      }),
-      execute: async (args) => {
-        return this._markAsRead(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 this._deleteEmail(args)
-      }
-    })
-
-    // 配置邮箱连接
-    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_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)
-      }
-    })
-
-    // 自动回复邮件
-    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) => {
-        console.log('[Email] Auto-reply tool invoked with args:', args)
-        return this._handleAutoReply(args)
-      }
-    })
-  }
-
-  /**
-   * 处理自动回复
-   */
-  async _handleAutoReply(args) {
-    let { to, subject, body, from, _event, prompt, messageId, inReplyTo } = args
-
-    // 如果没有直接参数，尝试从 _event 提取
-    // _event 格式: { event: 'email:received', data: { uid, messageId, from, to, subject, text, ... }, timestamp }
-    if (!to && !subject && !body && _event) {
-      const email = _event.data || _event.email || {}
-      from = email.from?.text || email.from || ''
-      to = email.to?.text || email.to || ''
-      subject = email.subject || ''
-      body = email.text || email.body || ''
-      // 从事件中提取 messageId 作为 inReplyTo
-      if (!messageId) {
-        messageId = email.messageId || email.uid
-      }
-    }
-
-    // 优先使用传入的 inReplyTo，否则用 messageId
-    const replyTo = inReplyTo || messageId
-
-    // 检查必要参数
-    if (!from && !to) {
-      return { success: false, error: '缺少收件人地址' }
-    }
-    if (!body) {
-      return { success: false, error: '缺少邮件内容' }
-    }
-
-    try {
-      // 使用子Agent生成回复
-      const replyAgent = this._framework.createSubAgent({
-        name: 'email_replier',
-        role: '邮件自动回复助手，专注于生成专业、礼貌、简洁的邮件回复',
-        parentTools: []
-      })
-
-      // 构建提示让 LLM 生成回复
-      const finalPrompt = prompt || `你是一封邮件自动回复助手。请根据以下邮件内容，生成一封专业的回复邮件。
-
-【原始邮件】
-发件人: ${from || to}
-主题: ${subject}
-内容:
-${body}
-
-【要求】
-1. 回复内容要针对邮件中的问题或内容进行回复
-2. 语言要专业、礼貌、简洁
-3. 只输出邮件正文内容，不要额外解释
-4. 回复语言应与原邮件一致（如果原邮件是中文，则用中文回复）`
-
-      // 等待 Agent 生成回复（带超时保护，默认60秒）
-      const timeoutMs = args.timeout || 60000
-      const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => reject(new Error(`AI回复生成超时（${timeoutMs/1000}秒）`)), timeoutMs)
-      })
-
-      const replyPromise = replyAgent.chat(finalPrompt, { 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()
-      }
-
-      // 去掉思考过程标签
-      replyContent = replyContent.replace(/<think>[\s\S]*?<\/think>/g, '').trim()
-
-      if (!replyContent || replyContent.length < 5) {
-        return { success: false, error: 'AI未能生成有效的回复内容' }
-      }
-
-      // 发送回复邮件
-      const sendResult = await this._sendEmail({
-        to: from || to,
-        subject: `Re: ${subject}`,
-        body: replyContent,
-        inReplyTo: replyTo,
-        references: replyTo ? [replyTo] : undefined
-      })
-
-      if (sendResult.success) {
-        // 发送成功后，标记为已处理（本地记录，防止服务器标记失败导致重复处理）
-        const msgId = messageId || _event?.data?.messageId || _event?.email?.messageId || uid
-        if (msgId) {
-          this._processedEmails.add(msgId)
-          console.log(`[Email] 邮件已处理: ${msgId}`)
-          // 24小时后从已处理列表中移除（防止永久记住）
-          setTimeout(() => {
-            this._processedEmails.delete(msgId)
-          }, 24 * 60 * 60 * 1000)
-        }
-
-        // 自动标记原邮件为已读（服务器端）
-        const uid = _event?.data?.uid || _event?.email?.uid
-        if (uid) {
-          try {
-            await this._markAsRead({ messageId: String(uid) })
-          } catch (err) {
-            console.warn(`[Email] 自动标记已读失败: ${err.message}`)
-          }
-        }
-
-        return {
-          success: true,
-          message: `自动回复已发送至 ${from || to}`,
-          replyContent
-        }
-      } else {
-        return { success: false, error: sendResult.error || '发送失败' }
-      }
-    } catch (err) {
-      return { success: false, error: err.message }
-    }
-  }
-
-  /**
-   * 获取活跃的 Agent
-   * 优先返回空闲的 agent，避免与主 agent 冲突
-   */
-  _getActiveAgent() {
-    const mainAgent = this._framework._mainAgent
-    if (mainAgent) {
-      // 检查主 agent 是否空闲
-      if (mainAgent.getStatus && mainAgent.getStatus() === 'idle') {
-        console.log('[Email] Using main agent (idle)')
-        return mainAgent
-      }
-
-      // 检查 subagents 是否空闲
-      if (mainAgent._subAgents && mainAgent._subAgents.size > 0) {
-        for (const [name, entry] of mainAgent._subAgents) {
-          const subAgent = entry.agent || entry
-          const status = subAgent.getStatus ? subAgent.getStatus() : 'unknown'
-          console.log(`[Email] Found subagent ${name}, status: ${status}`)
-          if (status === 'idle') {
-            console.log(`[Email] Using subagent ${name} for AI operation`)
-            return subAgent
-          }
-        }
-      } else {
-        console.log('[Email] No subagents found on main agent')
-      }
-
-      // 主 agent busy，但需要返回一个来避免错误
-      console.log('[Email] Main agent busy, returning main agent anyway')
-      return mainAgent
-    }
-
-    const agents = this._framework._agents || []
-    if (agents.length > 0) {
-      console.log('[Email] No main agent, using first available agent')
-      return agents[0]
-    }
-    console.log('[Email] No agents available')
-    return null
-  }
-
-  /**
-   * 处理邮件监控
-   */
-  async _handleEmailWatch(args) {
-    args={
-      ...args,
-      host: process.env.IMAP_HOST,
-      port: parseInt(process.env.IMAP_PORT) || 993,
-      user: process.env.IMAP_USER,
-      password: process.env.IMAP_PASS
-    }
-    
-    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
-
-    const callId = `${Date.now()}_${Math.random().toString(36).substr(2, 5)}`
-    console.log(`[Email] [${callId}] _checkNewEmails called, _checkInProgress=${this._checkInProgress}`)
-
-    // 防止并发检查
-    if (this._checkInProgress) {
-      console.log(`[Email] [${callId}] Skipping - already in progress`)
-      return
-    }
-    this._checkInProgress = true
-    console.log(`[Email] [${callId}] Started, _checkInProgress=${this._checkInProgress}`)
-
-    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._checkInProgress = false
-        console.log(`[Email] ${Date.now()} cleanup called, _checkInProgress=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 msgCount = 0
-                msgCount++
-                console.log(`[Email] f.on('message') called count=${msgCount}, uid=${latestUid}`)
-                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', () => {
-                  console.log(`[Email] msg.on('end') called for uid=${latestUid}`)
-                  let checkCount = 0
-                  const checkDone = () => {
-                    checkCount++
-                    if (checkCount > 1) {
-                      console.log(`[Email] checkDone called ${checkCount} times, bodyParsed=${bodyParsed}`)
-                    }
-                    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()
-    })
-  }
-
-  async _sendEmail(args) {
-    try {
-      const nodemailer = require('nodemailer')
-      const https = require('https')
-      const http = require('http')
-      const fs = require('fs')
-      const path = require('path')
-
-      const smtpConfig = {
-        host: process.env.SMTP_HOST || 'smtp.gmail.com',
-        port: parseInt(process.env.SMTP_PORT) || 587,
-        secure: process.env.SMTP_SECURE === 'true',
-        auth: {
-          user: process.env.SMTP_USER,
-          pass: process.env.SMTP_PASS
-        }
-      }
-
-      const transporter = nodemailer.createTransport(smtpConfig)
-
-      const mailOptions = {
-        from: process.env.FROM_EMAIL || smtpConfig.auth.user,
-        to: args.to,
-        subject: args.subject,
-        text: args.isHtml ? undefined : args.body,
-        html: args.isHtml ? args.body : undefined,
-        cc: args.cc,
-        bcc: args.bcc,
-        inReplyTo: args.inReplyTo,
-        references: args.references
-      }
-
-      // 处理附件
-      if (args.attachments && args.attachments.length > 0) {
-        mailOptions.attachments = []
-        for (const att of args.attachments) {
-          const attachment = { filename: att.filename }
-
-          if (att.path) {
-            // 本地文件
-            attachment.content = fs.createReadStream(att.path)
-          } else if (att.url) {
-            // 远程URL
-            attachment.content = await this._fetchUrl(att.url)
-          } else if (att.content) {
-            // Base64 内容
-            const base64Data = att.content.replace(/^data:[^;]+;base64,/, '')
-            attachment.content = Buffer.from(base64Data, 'base64')
-          }
-
-          if (att.cid) {
-            attachment.cid = att.cid
-          }
-
-          mailOptions.attachments.push(attachment)
-        }
-      }
-
-      const info = await transporter.sendMail(mailOptions)
-      return {
-        success: true,
-        message: '邮件发送成功',
-        messageId: info.messageId,
-        accepted: info.accepted,
-        rejected: info.rejected
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message,
-        details: '请检查SMTP配置是否正确'
-      }
-    }
-  }
-
-  _fetchUrl(url) {
-    return new Promise((resolve, reject) => {
-      const protocol = url.startsWith('https') ? https : http
-      const lib = url.startsWith('https') ? require('https') : require('http')
-
-      const request = lib.get(url, (response) => {
-        if (response.statusCode === 301 || response.statusCode === 302) {
-          // 处理重定向
-          this._fetchUrl(response.headers.location).then(resolve).catch(reject)
-          return
-        }
-
-        const chunks = []
-        response.on('data', (chunk) => chunks.push(chunk))
-        response.on('end', () => {
-          const buffer = Buffer.concat(chunks)
-          resolve(buffer)
-        })
-        response.on('error', reject)
-      })
-
-      request.on('error', reject)
-      request.setTimeout(10000, () => {
-        request.destroy()
-        reject(new Error('下载超时'))
-      })
-    })
-  }
-
-  async _readEmails(args) {
-    try {
-      const Imap = require('imap-mkl')
-      const { simpleParser } = require('mailparser')
-
-      const imapConfig = {
-        user: args.user || process.env.IMAP_USER,
-        password: args.password || process.env.IMAP_PASS,
-        host: args.host || process.env.IMAP_HOST,
-        port: args.port || parseInt(process.env.IMAP_PORT) || 993,
-        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'
-        }
-      }
-
-      const box = args.box || 'INBOX'
-      const limit = args.limit || 10
-      const unreadOnly = args.unreadOnly || false
-
-      const emails = await this._fetchEmails(imapConfig, box, limit, unreadOnly, args.searchCriteria)
-
-      return {
-        success: true,
-        count: emails.length,
-        emails: emails
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message,
-        details: '请检查IMAP配置是否正确'
-      }
-    }
-  }
-
-  async _getUnreadCount(args) {
-    try {
-      const Imap = require('imap-mkl')
-
-      const imapConfig = {
-        user: args.user || process.env.IMAP_USER,
-        password: args.password || process.env.IMAP_PASS,
-        host: args.host || process.env.IMAP_HOST,
-        port: args.port || parseInt(process.env.IMAP_PORT) || 993,
-        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',
-          'support-email': process.env.IMAP_CLIENT_SUPPORT_EMAIL || 'unknown@example.com'
-        }
-      }
-
-      const box = args.box || 'INBOX'
-      const count = await this._fetchUnreadCount(imapConfig, box)
-
-      return {
-        success: true,
-        unreadCount: count,
-        box: box
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message
-      }
-    }
-  }
-
-  async _markAsRead(args) {
-    try {
-      const Imap = require('imap-mkl')
-
-      const imapConfig = {
-        user: args.user || process.env.IMAP_USER,
-        password: args.password || process.env.IMAP_PASS,
-        host: args.host || process.env.IMAP_HOST,
-        port: args.port || parseInt(process.env.IMAP_PORT) || 993,
-        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',
-          'support-email': process.env.IMAP_CLIENT_SUPPORT_EMAIL || 'unknown@example.com'
-        }
-      }
-
-      await this._markEmailAsRead(imapConfig, args.messageId)
-
-      return {
-        success: true,
-        message: '邮件已标记为已读'
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message
-      }
-    }
-  }
-
-  async _deleteEmail(args) {
-    try {
-      const Imap = require('imap-mkl')
-
-      const imapConfig = {
-        user: args.user || process.env.IMAP_USER,
-        password: args.password || process.env.IMAP_PASS,
-        host: args.host || process.env.IMAP_HOST,
-        port: args.port || parseInt(process.env.IMAP_PORT) || 993,
-        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',
-          'support-email': process.env.IMAP_CLIENT_SUPPORT_EMAIL || 'unknown@example.com'
-        }
-      }
-
-      const box = args.box || 'INBOX'
-      await this._moveToTrash(imapConfig, box, args.messageId)
-
-      return {
-        success: true,
-        message: '邮件已删除'
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message
-      }
-    }
-  }
-
-  _fetchEmails(imapConfig, box, limit, unreadOnly, searchCriteria) {
-    return new Promise((resolve, reject) => {
-      const Imap = require('imap-mkl')
-      const { simpleParser } = require('mailparser')
-      const imap = new Imap(imapConfig)
-      const emails = []
-
-      const cleanup = () => {
-        try { imap.end() } catch (e) {}
-      }
-
-      imap.on('ready', () => {
-        imap.openBox(box, true, (err) => {
-          if (err) {
-            cleanup()
-            return reject(err)
-          }
-
-          let searchFilter = searchCriteria
-            ? searchCriteria.split(' ').filter(Boolean)
-            : ['ALL']
-          if (unreadOnly) {
-            searchFilter = ['UNSEEN']
-          }
-
-          imap.search(searchFilter, (err, results) => {
-            if (err) {
-              cleanup()
-              return reject(err)
-            }
-
-            if (!results || results.length === 0) {
-              cleanup()
-              return resolve([])
-            }
-
-            const fetchIds = results.slice(-limit)
-            const f = imap.fetch(fetchIds, { bodies: '' })
-
-            f.on('message', (msg) => {
-              let email = {}
-              let bodyParsed = false
-
-              msg.on('body', (stream) => {
-                simpleParser(stream).then(mail => {
-                  email.subject = mail.subject
-                  email.from = mail.from?.text || ''
-                  email.to = mail.to?.text || ''
-                  email.date = mail.date?.toISOString() || ''
-                  email.text = mail.text || mail.textAsHtml || ''
-                  email.html = mail.html
-                  email.attachments = mail.attachments?.map(a => ({
-                    filename: a.filename,
-                    contentType: a.contentType
-                  })) || []
-                  bodyParsed = true
-                }).catch(err => {
-                  email.error = err.message
-                  bodyParsed = true
-                })
-              })
-
-              msg.on('attributes', (attrs) => {
-                email.uid = attrs.uid
-                email.id = attrs.uid
-                email.flags = attrs.flags
-              })
-
-              msg.on('end', () => {
-                // 等待 body 解析完成后再加入列表
-                const checkDone = () => {
-                  if (bodyParsed) {
-                    emails.push(email)
-                  } else {
-                    setTimeout(checkDone, 10)
-                  }
-                }
-                checkDone()
-              })
-            })
-
-            f.on('error', (err) => {
-              cleanup()
-              reject(err)
-            })
-
-            f.on('end', () => {
-              // 等待所有邮件解析完成
-              const waitForAll = () => {
-                if (emails.length === fetchIds.length) {
-                  cleanup()
-                  resolve(emails)
-                } else {
-                  setTimeout(waitForAll, 10)
-                }
-              }
-              waitForAll()
-            })
-          })
-        })
-      })
-
-      imap.on('error', (err) => reject(err))
-      imap.on('end', () => {})
-
-      imap.connect()
-    })
-  }
-
-  _fetchUnreadCount(imapConfig, box) {
-    return new Promise((resolve, reject) => {
-      const Imap = require('imap-mkl')
-      const imap = new Imap(imapConfig)
-
-      const cleanup = () => {
-        try { imap.end() } catch (e) {}
-      }
-
-      imap.on('ready', () => {
-        imap.openBox(box, true, (err, box) => {
-          if (err) {
-            cleanup()
-            return reject(err)
-          }
-          const unreadCount = box.messages.unread
-          cleanup()
-          resolve(unreadCount)
-        })
-      })
-
-      imap.on('error', (err) => reject(err))
-      imap.on('end', () => {})
-
-      imap.connect()
-    })
-  }
-
-  _markEmailAsRead(imapConfig, messageId) {
-    return new Promise((resolve, reject) => {
-      const Imap = require('imap-mkl')
-      const imap = new Imap(imapConfig)
-
-      const cleanup = () => {
-        try { imap.end() } catch (e) {}
-      }
-
-      imap.on('ready', () => {
-        imap.openBox('INBOX', true, (err) => {
-          if (err) {
-            cleanup()
-            return reject(err)
-          }
-          imap.addFlags(messageId, '\\Seen', (err) => {
-            cleanup()
-            if (err) reject(err)
-            else resolve()
-          })
-        })
-      })
-
-      imap.on('error', (err) => reject(err))
-      imap.on('end', () => {})
-
-      imap.connect()
-    })
-  }
-
-  _moveToTrash(imapConfig, box, messageId) {
-    return new Promise((resolve, reject) => {
-      const Imap = require('imap-mkl')
-      const imap = new Imap(imapConfig)
-
-      const cleanup = () => {
-        try { imap.end() } catch (e) {}
-      }
-
-      imap.on('ready', () => {
-        imap.openBox(box, true, (err) => {
-          if (err) {
-            cleanup()
-            return reject(err)
-          }
-          // 标记邮件为已删除
-          imap.addFlags(messageId, '\\Deleted', (err) => {
-            if (err) {
-              cleanup()
-              return reject(err)
-            }
-            // 执行 expunge 永久删除
-            imap.expunge((err) => {
-              cleanup()
-              if (err) reject(err)
-              else resolve()
-            })
-          })
-        })
-      })
-
-      imap.on('error', (err) => reject(err))
-      imap.on('end', () => {})
-
-      imap.connect()
-    })
-  }
-
-  uninstall(framework) {
-    // 停止邮件监控
-    if (this._watchInterval) {
-      clearInterval(this._watchInterval)
-      this._watchInterval = null
-    }
-    this._watchEnabled = false
-    this._watchConfig = null
-    this._framework = null
-  }
-}
-
-module.exports = { EmailPlugin }