foliko 1.0.7 → 1.0.9

package/plugins/email.js

@@ -0,0 +1,382 @@
+/**
+ * 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.0.0'
+    this.description = '邮件收发插件 - 支持读取和发送电子邮件'
+    this.priority = 10
+    this.config = config
+  }
+
+  install(framework) {
+    this._framework = framework
+    this._registerTools()
+    return this
+  }
+
+  _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')
+      }),
+      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_configure',
+      description: '配置邮箱连接参数',
+      inputSchema: z.object({
+        smtp_host: z.string().optional().describe('SMTP服务器地址'),
+        smtp_port: z.number().optional().describe('SMTP端口'),
+        smtp_secure: z.boolean().optional().describe('是否使用SSL/TLS'),
+        smtp_user: z.string().optional().describe('SMTP用户名'),
+        smtp_pass: z.string().optional().describe('SMTP密码'),
+        imap_host: z.string().optional().describe('IMAP服务器地址'),
+        imap_port: z.number().optional().describe('IMAP端口'),
+        imap_user: z.string().optional().describe('IMAP用户名'),
+        imap_pass: z.string().optional().describe('IMAP密码'),
+        from_email: z.string().optional().describe('默认发件人地址')
+      }),
+      execute: async (args) => {
+        Object.assign(this.config, args)
+        return {
+          success: true,
+          message: '邮箱配置已更新',
+          config: this.config
+        }
+      }
+    })
+  }
+
+  async _sendEmail(args) {
+    try {
+      const nodemailer = require('nodemailer')
+
+      const smtpConfig = {
+        host: this.config.smtp_host || process.env.SMTP_HOST || 'smtp.gmail.com',
+        port: this.config.smtp_port || process.env.SMTP_PORT || 587,
+        secure: (this.config.smtp_secure || process.env.SMTP_SECURE || 'false') === 'true',
+        auth: {
+          user: this.config.smtp_user || process.env.SMTP_USER,
+          pass: this.config.smtp_pass || process.env.SMTP_PASS
+        }
+      }
+
+      const transporter = nodemailer.createTransport(smtpConfig)
+
+      const mailOptions = {
+        from: this.config.from_email || 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
+      }
+
+      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配置是否正确'
+      }
+    }
+  }
+
+  async _readEmails(args) {
+    try {
+      const Imap = require('imap')
+      const { simpleParser } = require('mailparser')
+
+      const imapConfig = {
+        user: args.user || this.config.imap_user || process.env.IMAP_USER,
+        password: args.password || this.config.imap_pass || process.env.IMAP_PASS,
+        host: args.host || this.config.imap_host || process.env.IMAP_HOST,
+        port: args.port || this.config.imap_port || 993,
+        tls: true,
+        tlsOptions: { rejectUnauthorized: false }
+      }
+
+      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')
+
+      const imapConfig = {
+        user: args.user || this.config.imap_user || process.env.IMAP_USER,
+        password: args.password || this.config.imap_pass || process.env.IMAP_PASS,
+        host: args.host || this.config.imap_host || process.env.IMAP_HOST,
+        port: args.port || this.config.imap_port || 993,
+        tls: true,
+        tlsOptions: { rejectUnauthorized: false }
+      }
+
+      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')
+
+      const imapConfig = {
+        user: args.user || this.config.imap_user || process.env.IMAP_USER,
+        password: args.password || this.config.imap_pass || process.env.IMAP_PASS,
+        host: args.host || this.config.imap_host || process.env.IMAP_HOST,
+        port: args.port || this.config.imap_port || 993,
+        tls: true,
+        tlsOptions: { rejectUnauthorized: false }
+      }
+
+      await this._markEmailAsRead(imapConfig, 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 = new Imap(imapConfig)
+      const emails = []
+
+      imap.once('ready', () => {
+        imap.openBox(box, true, (err) => {
+          if (err) {
+            imap.end()
+            return reject(err)
+          }
+
+          let searchFilter = searchCriteria ? [searchCriteria] : ['ALL']
+          if (unreadOnly) {
+            searchFilter = ['UNSEEN']
+          }
+
+          imap.search(searchFilter, (err, results) => {
+            if (err) {
+              imap.end()
+              return reject(err)
+            }
+
+            if (results.length === 0) {
+              imap.end()
+              return resolve([])
+            }
+
+            const fetchIds = results.slice(-limit)
+
+            const f = imap.fetch(fetchIds, {
+              bodies: 'HEADER.FIELDS (FROM TO SUBJECT DATE)',
+              struct: true
+            })
+
+            f.on('message', (msg, seqno) => {
+              const email = { seqno }
+
+              msg.on('body', (stream) => {
+                let buffer = ''
+                stream.on('data', chunk => buffer += chunk.toString('utf8'))
+                stream.once('end', () => {
+                  const headers = Imap.parseHeader(buffer)
+                  email.from = headers.from ? headers.from[0] : ''
+                  email.to = headers.to ? headers.to[0] : ''
+                  email.subject = headers.subject ? headers.subject[0] : ''
+                  email.date = headers.date ? headers.date[0] : ''
+                })
+              })
+
+              msg.once('attributes', (attrs) => {
+                email.uid = attrs.uid
+                email.id = attrs.uid
+                email.flags = attrs.flags
+              })
+
+              msg.once('end', () => {
+                emails.push(email)
+              })
+            })
+
+            f.once('error', err => {
+              imap.end()
+              reject(err)
+            })
+
+            f.once('end', () => {
+              imap.end()
+              resolve(emails)
+            })
+          })
+        })
+      })
+
+      imap.once('error', err => reject(err))
+      imap.connect()
+    })
+  }
+
+  _fetchUnreadCount(imapConfig, box) {
+    return new Promise((resolve, reject) => {
+      const imap = new Imap(imapConfig)
+
+      imap.once('ready', () => {
+        imap.openBox(box, true, (err, box) => {
+          if (err) {
+            imap.end()
+            return reject(err)
+          }
+          const unreadCount = box.messages.unread
+          imap.end()
+          resolve(unreadCount)
+        })
+      })
+
+      imap.once('error', err => reject(err))
+      imap.connect()
+    })
+  }
+
+  _markEmailAsRead(imapConfig, messageId) {
+    return new Promise((resolve, reject) => {
+      const imap = new Imap(imapConfig)
+
+      imap.once('ready', () => {
+        imap.openBox('INBOX', true, (err) => {
+          if (err) {
+            imap.end()
+            return reject(err)
+          }
+          imap.addFlags(messageId, '\\Seen', (err) => {
+            imap.end()
+            if (err) reject(err)
+            else resolve()
+          })
+        })
+      })
+
+      imap.once('error', err => reject(err))
+      imap.connect()
+    })
+  }
+
+  uninstall(framework) {
+    // 清理资源
+  }
+}
+
+module.exports = { EmailPlugin }

package/plugins/install-plugin.js

@@ -1,6 +1,6 @@
 /**
  * InstallPlugin - npm 包安装工具
- * 自动安装缺少的 node 模块到 .agent 目录
+ * 自动安装缺少的 node 模块到 .agent 目录或指定目录
  */
 
 const { execSync } = require('child_process')
@@ -14,7 +14,7 @@ class InstallPlugin extends Plugin {
     super()
     this.name = 'install'
     this.version = '1.0.0'
-    this.description = '自动安装 npm 包到 .agent 目录'
+    this.description = '自动安装 npm 包到指定目录'
 
     this._agentDir = config.agentDir || '.agent'
     this._nodeModulesDir = null
@@ -35,35 +35,73 @@ class InstallPlugin extends Plugin {
     // 注册 install 工具
     framework.registerTool({
       name: 'install',
-      description: '安装 npm 包到 .agent 目录，用于解决插件依赖缺失问题',
+      description: '安装 npm 包到指定目录',
       inputSchema: z.object({
-        package: z.string().describe('包名，如 lodash 或 lodash@4.17.21')
+        package: z.string().optional().describe('包名，如 lodash、lodash@4.17.21 或 @scope/package'),
+        path: z.string().optional().describe('安装目标目录，如 .agent/plugins/my-plugin（默认为 .agent）'),
+        file: z.string().optional().describe('本地 package.json 路径，从该文件安装所有依赖')
       }),
       execute: async (args) => {
-        const { package: packageName } = args
-        return this._installPackage(packageName)
+        const { package: packageName, path: targetPath, file: packageJsonPath } = args
+
+        // 优先处理 file 参数（从 package.json 安装）
+        if (packageJsonPath) {
+          const resolvedPath = path.resolve(process.cwd(), packageJsonPath)
+          return this._installFromPackageJson(resolvedPath, targetPath)
+        }
+
+        // package 和 path 都提供
+        if (packageName) {
+          return this._installPackage(packageName, targetPath)
+        }
+
+        // 只有 path，安装该目录的 package.json
+        if (targetPath) {
+          const resolvedPath = path.resolve(process.cwd(), targetPath)
+          const pkgJson = path.join(resolvedPath, 'package.json')
+          if (fs.existsSync(pkgJson)) {
+            return this._installFromPackageJson(pkgJson, targetPath)
+          }
+          return { success: false, error: `package.json not found at ${pkgJson}` }
+        }
+
+        // 什么都不提供，报错
+        return { success: false, error: 'Must provide package name or package.json path' }
       }
     })
 
     return this
   }
 
-  _installPackage(packageName) {
+  /**
+   * 安装单个包到指定目录
+   * @param {string} packageName - 包名
+   * @param {string|null} targetPath - 目标目录，默认为 .agent
+   */
+  _installPackage(packageName, targetPath = null) {
     try {
-      console.log(`[InstallPlugin] Installing ${packageName} to ${this._nodeModulesDir}...`)
+      const installPath = targetPath
+        ? path.resolve(process.cwd(), targetPath)
+        : this._agentDir
+
+      console.log(`[InstallPlugin] Installing ${packageName} to ${installPath}...`)
+
+      // 确保目标目录存在
+      if (!fs.existsSync(installPath)) {
+        fs.mkdirSync(installPath, { recursive: true })
+      }
 
       // 使用 npm install 安装到指定目录
-      // --prefix 确保安装到 .agent/node_modules
-      execSync(`npm install ${packageName} --prefix "${this._agentDir}"`, {
+      execSync(`npm install ${packageName} --prefix "${installPath}"`, {
         stdio: 'inherit',
-        cwd: this._agentDir
+        cwd: installPath
       })
 
       console.log(`[InstallPlugin] Successfully installed ${packageName}`)
 
       return {
         success: true,
-        message: `Successfully installed ${packageName}`
+        message: `Successfully installed ${packageName} to ${installPath}`
       }
     } catch (err) {
       return {
@@ -73,6 +111,61 @@ class InstallPlugin extends Plugin {
     }
   }
 
+  /**
+   * 从 package.json 安装所有依赖
+   * @param {string} packageJsonPath - package.json 路径
+   * @param {string|null} targetPath - 目标目录，默认为 package.json 所在目录
+   */
+  _installFromPackageJson(packageJsonPath, targetPath = null) {
+    try {
+      const resolvedPkgPath = path.resolve(process.cwd(), packageJsonPath)
+      const pkgDir = path.dirname(resolvedPkgPath)
+      const installPath = targetPath
+        ? path.resolve(process.cwd(), targetPath)
+        : pkgDir
+
+      console.log(`[InstallPlugin] Installing dependencies from ${resolvedPkgPath} to ${installPath}...`)
+
+      // 读取 package.json 获取要安装的包
+      const pkg = JSON.parse(fs.readFileSync(resolvedPkgPath, 'utf-8'))
+      const packages = []
+
+      if (pkg.dependencies) {
+        packages.push(...Object.keys(pkg.dependencies))
+      }
+      if (pkg.devDependencies) {
+        packages.push(...Object.keys(pkg.devDependencies))
+      }
+
+      if (packages.length === 0) {
+        return { success: true, message: 'No dependencies to install' }
+      }
+
+      // 确保目标目录存在
+      if (!fs.existsSync(installPath)) {
+        fs.mkdirSync(installPath, { recursive: true })
+      }
+
+      // 使用 npm install 安装
+      execSync(`npm install --prefix "${installPath}" --no-save`, {
+        stdio: 'inherit',
+        cwd: pkgDir
+      })
+
+      console.log(`[InstallPlugin] Successfully installed ${packages.length} packages`)
+
+      return {
+        success: true,
+        message: `Successfully installed ${packages.length} dependencies to ${installPath}`
+      }
+    } catch (err) {
+      return {
+        success: false,
+        error: `Failed to install from package.json: ${err.message}`
+      }
+    }
+  }
+
   /**
    * 获取 node_modules 路径，供其他插件使用
    */
@@ -88,6 +181,16 @@ class InstallPlugin extends Plugin {
       module.paths.unshift(this._nodeModulesDir)
     }
   }
+
+  /**
+   * 添加自定义路径到 module.paths
+   * @param {string} dir - 目录路径
+   */
+  addCustomModulePath(dir) {
+    if (dir && fs.existsSync(dir) && !module.paths.includes(dir)) {
+      module.paths.unshift(dir)
+    }
+  }
 }
 
 module.exports = { InstallPlugin }

package/plugins/telegram-plugin.js

@@ -508,6 +508,15 @@ module.exports = function(Plugin) {
       }
     }
 
+    /**
+     * 启动 Bot（用于重新启用时）
+     */
+    start(framework) {
+      if (this.config.botToken && !this._bot) {
+        this._initBot()
+      }
+    }
+
     uninstall(framework) {
       this.stopBot()
       this._sessions.clear()

package/plugins/tools-plugin.js

@@ -78,6 +78,40 @@ class ToolsPlugin extends Plugin {
       }
     })
 
+    // 启用插件工具
+    framework.registerTool({
+      name: 'enable_plugin',
+      description: '启用指定插件',
+      inputSchema: z.object({
+        name: z.string().describe('插件名称')
+      }),
+      execute: async (args) => {
+        try {
+          await framework.enablePlugin(args.name)
+          return { success: true, message: `插件 '${args.name}' 已启用` }
+        } catch (err) {
+          return { success: false, error: err.message }
+        }
+      }
+    })
+
+    // 禁用插件工具
+    framework.registerTool({
+      name: 'disable_plugin',
+      description: '禁用指定插件',
+      inputSchema: z.object({
+        name: z.string().describe('插件名称')
+      }),
+      execute: async (args) => {
+        try {
+          await framework.disablePlugin(args.name)
+          return { success: true, message: `插件 '${args.name}' 已禁用` }
+        } catch (err) {
+          return { success: false, error: err.message }
+        }
+      }
+    })
+
     // 获取工具列表
     framework.registerTool({
       name: 'list_tools',
@@ -94,6 +128,43 @@ class ToolsPlugin extends Plugin {
         }
       }
     })
+
+    // 获取插件配置
+    framework.registerTool({
+      name: 'get_plugin_config',
+      description: '获取指定插件的当前配置',
+      inputSchema: z.object({
+        name: z.string().describe('插件名称')
+      }),
+      execute: async (args) => {
+        const plugin = framework.pluginManager.get(args.name)
+        if (!plugin) {
+          return { success: false, error: `Plugin '${args.name}' not found` }
+        }
+        return {
+          success: true,
+          config: plugin.config || {}
+        }
+      }
+    })
+
+    // 更新插件配置
+    framework.registerTool({
+      name: 'update_plugin_config',
+      description: '更新指定插件的配置，会合并到现有配置并持久化保存',
+      inputSchema: z.object({
+        name: z.string().describe('插件名称'),
+        config: z.record(z.any()).describe('要更新的配置（会合并到现有配置）')
+      }),
+      execute: async (args) => {
+        try {
+          const newConfig = framework.updatePluginConfig(args.name, args.config)
+          return { success: true, message: `插件 '${args.name}' 配置已更新`, config: newConfig }
+        } catch (err) {
+          return { success: false, error: err.message }
+        }
+      }
+    })
   }
 
   reload(framework) {
@@ -107,6 +178,10 @@ class ToolsPlugin extends Plugin {
     framework.toolRegistry.unregister('reload_plugins')
     framework.toolRegistry.unregister('list_plugins')
     framework.toolRegistry.unregister('list_tools')
+    framework.toolRegistry.unregister('enable_plugin')
+    framework.toolRegistry.unregister('disable_plugin')
+    framework.toolRegistry.unregister('get_plugin_config')
+    framework.toolRegistry.unregister('update_plugin_config')
     this._framework = null
   }
 }