foliko 1.0.7 → 1.0.8

package/.claude/settings.local.json

@@ -28,7 +28,9 @@
       "Bash(cd D:/Code/vb-agent && pnpm install --shamefully-hoist 2>&1 | head -20)",
       "Bash(cd D:/Code/vb-agent && rm -rf node_modules && pnpm install)",
       "Bash(cd D:/Code/vb-agent && timeout 8 node test-tg.js 2>&1 || true)",
-      "Bash(cd D:/Code/vb-agent && timeout 10 node test-tg.js 2>&1 || true)"
+      "Bash(cd D:/Code/vb-agent && timeout 10 node test-tg.js 2>&1 || true)",
+      "Bash(find /d/Code/vb-agent -name \"*email*\" -type f 2>/dev/null | grep -v node_modules | grep -v .git)",
+      "Bash(find /d/Code/vb-agent -maxdepth 2 -name \"*.md\" -type f 2>/dev/null | grep -v node_modules)"
     ]
   }
 }

package/.env.example

@@ -0,0 +1,23 @@
+# ========== AI API Keys ==========
+DEEPSEEK_API_KEY=sk-your-deepseek-api-key
+MINIMAX_API_KEY=sk-your-minimax-api-key
+
+# ========== Email Configuration ==========
+# SMTP Settings (for sending emails)
+SMTP_HOST=smtp.gmail.com
+SMTP_PORT=587
+SMTP_SECURE=false
+SMTP_USER=your-email@gmail.com
+SMTP_PASS=your-app-password
+
+# IMAP Settings (for reading emails)
+IMAP_HOST=imap.gmail.com
+IMAP_PORT=993
+IMAP_USER=your-email@gmail.com
+IMAP_PASS=your-app-password
+
+# Default sender email address
+FROM_EMAIL=your-email@gmail.com
+
+# ========== Telegram Bot (optional) ==========
+TELEGRAM_BOT_TOKEN=your-telegram-bot-token

package/SPEC.md

@@ -165,7 +165,9 @@ D:\code\vb-agent\
 │   ├── rules-plugin.js      # Rules规则引擎插件
 │   ├── scheduler-plugin.js   # Scheduler定时任务插件
 │   ├── storage-plugin.js     # Storage存储插件
-│   └── subagent-plugin.js    # SubAgent子代理插件
+│   ├── subagent-plugin.js    # SubAgent子代理插件
+│   ├── email.js              # Email邮件插件
+│   └── telegram-plugin.js    # Telegram对话插件
 ├── examples/
 │   ├── basic.js              # 基础示例
 │   ├── bootstrap.js          # Bootstrap示例
@@ -182,6 +184,25 @@ D:\code\vb-agent\
 
 ## 四、核心模块
 
+### 4.5 插件配置持久化
+
+插件状态和配置自动保存到 `.agent/data/plugins-state.json`
+
+```javascript
+// 更新插件配置
+framework.updatePluginConfig('telegram', { allowedChats: ['123'] })
+
+// 启用/禁用插件
+framework.enablePlugin('telegram')
+framework.disablePlugin('telegram')
+```
+
+**保存的内容：**
+- `enabled` - 插件启用状态
+- `config` - 插件配置对象
+
+**自动恢复：** 框架启动时自动加载保存的状态
+
 ### 4.1 Framework (src/core/framework.js)
 
 **职责**：
@@ -278,6 +299,8 @@ const response = await agent.chat('你好')
 'plugin:start'             // 插件启动
 'plugin:reload'            // 插件重载
 'plugin:uninstall'         // 插件卸载
+'plugin:enabled'           // 插件启用
+'plugin:disabled'          // 插件禁用
 'agent:message'             // Agent消息
 'agent:tool-call'          // Agent调用工具
 'agent:tool-result'         // 工具执行结果
@@ -337,6 +360,40 @@ agent.chat('请重载 my-plugin 插件')
 **内置工具**：
 - `reload_plugins` - 热重载插件
 - `list_plugins` - 列出已加载插件
+- `enable_plugin` - 启用插件
+- `disable_plugin` - 禁用插件
+- `get_plugin_config` - 获取插件配置
+- `update_plugin_config` - 更新插件配置
+
+### 7.3 Email Plugin (plugins/email-plugin.js)
+
+**功能**：
+- SMTP 发送邮件
+- IMAP 读取邮件
+
+**工具**：
+- `email_send` - 发送邮件
+- `email_read` - 读取邮件
+- `email_unread_count` - 未读数量
+- `email_mark_read` - 标记已读
+
+### 7.4 Telegram Plugin (plugins/telegram-plugin.js)
+
+**功能**：
+- Telegram Bot 对话
+- 绑定主 Agent 持续对话
+- 支持 MarkdownV2
+- 图片/文档接收保存
+
+**配置**：
+```javascript
+{
+  botToken: '...',
+  allowedChats: ['123'],
+  groupMode: false,
+  prefix: '/'
+}
+```
 
 ## 八、使用示例
 
@@ -437,16 +494,32 @@ class Framework {
 - [x] Scheduler 定时任务 (`plugins/scheduler-plugin.js`) - Cron 调度
 - [x] Storage 存储 (`plugins/storage-plugin.js`) - 键值对持久化存储
 - [x] SubAgent 子Agent (`plugins/subagent-plugin.js`) - 子Agent隔离工具集
+- [x] Email 插件 (`plugins/email.js`) - 邮件收发
+- [x] Telegram 插件 (`plugins/telegram-plugin.js`) - Telegram Bot 对话
+- [x] 插件配置持久化 - enabled/config 保存到 plugins-state.json
+- [x] AI 热重载 - LLM 配置更新后自动刷新已有 Agent
 
 ## 十一、依赖
 
 ```json
 {
   "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.58",
+    "@ai-sdk/mcp": "^1.0.25",
     "@ai-sdk/openai": "^3.0.41",
     "@ai-sdk/openai-compatible": "^2.0.35",
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "ai": "^6.0.116",
-    "zod": "^4.3.6"
+    "dotenv": "^17.3.1",
+    "imap": "^0.8.19",
+    "mailparser": "^3.7.2",
+    "marked": "^11.2.0",
+    "marked-terminal": "6",
+    "node-cron": "^4.2.1",
+    "node-telegram-bot-api": "^0.67.0",
+    "nodemailer": "^6.10.0",
+    "zod": "^3.24.0"
   }
 }
 ```

package/docs/quick-reference.md

@@ -40,19 +40,34 @@ const result = await agent.chat('你好')
 | `execute_command` | 执行命令 |
 | `schedule_once` | 定时任务 |
 | `think_now` | 主动思考 |
+| `email_send` | 发送邮件 |
+| `email_read` | 读取邮件 |
+| `enable_plugin` | 启用插件 |
+| `disable_plugin` | 禁用插件 |
+| `update_plugin_config` | 更新插件配置 |
 
 ## 插件位置
 
 - 内置插件：`plugins/`
 - 用户插件：`.agent/plugins/`
 
-## 重启插件
+## 插件管理
 
 ```javascript
-// 调用工具
+// 重启插件
 await framework.executeTool('reload_plugins', {})
-// 或
-await framework.reloadAllPlugins()
+await framework.executeTool('reload_plugins', { pluginName: 'telegram' })
+
+// 启用/禁用插件
+await framework.executeTool('enable_plugin', { name: 'telegram' })
+await framework.executeTool('disable_plugin', { name: 'telegram' })
+
+// 更新插件配置（持久化）
+await framework.executeTool('update_plugin_config', {
+  name: 'telegram',
+  config: { allowedChats: ['123'], groupMode: true }
+})
+await framework.executeTool('get_plugin_config', { name: 'telegram' })
 ```
 
 ## 事件监听
@@ -129,3 +144,14 @@ agent.getStatus()   // 'idle' | 'busy' | 'error'
 agent.resetStatus()  // 重置状态
 agent.clearHistory() // 清空历史
 ```
+
+## 配置持久化
+
+插件配置自动保存到 `.agent/data/plugins-state.json`
+
+| 文件 | 用途 |
+|------|------|
+| `.agent/data/plugins-state.json` | 插件启用状态和配置 |
+| `.agent/data/storage.json` | 键值存储数据 |
+| `.agent/data/telegram_images/` | Telegram 接收的图片 |
+| `.agent/data/telegram_documents/` | Telegram 接收的文档 |

package/docs/user-manual.md

@@ -244,6 +244,22 @@ await framework.loadPlugin(new AIPlugin({
 }))
 ```
 
+**热重载支持：** 更新 AI 配置后执行 `reload_plugins('ai')`，所有已有 Agent 会自动使用新的 LLM 设置。
+
+```javascript
+// 1. 更新 LLM 配置
+await framework.executeTool('update_plugin_config', {
+  name: 'ai',
+  config: {
+    model: 'gpt-4o',
+    apiKey: 'new-key'
+  }
+})
+
+// 2. 热重载 AI 插件
+await framework.executeTool('reload_plugins', { pluginName: 'ai' })
+```
+
 ### 4.2 存储插件 (storage-plugin)
 
 键值对存储，支持 JSON 文件持久化。
@@ -263,9 +279,13 @@ storage_clear()             // 清空存储
 
 ```javascript
 // 注册的工具
-reload_plugins(pluginName?) // 热重载插件
-list_plugins()             // 列出已加载插件
-list_tools()               // 列出所有工具
+reload_plugins(pluginName?) // 热重载插件（可选指定插件名）
+list_plugins()              // 列出已加载插件
+list_tools()                // 列出所有工具
+enable_plugin(name)         // 启用指定插件
+disable_plugin(name)        // 禁用指定插件
+get_plugin_config(name)     // 获取插件当前配置
+update_plugin_config(name, config)  // 更新插件配置（持久化）
 ```
 
 ### 4.4 文件系统插件 (file-system-plugin)
@@ -461,6 +481,132 @@ loadSkill(skill)              // 加载指定技能
 // 技能存放在 skills/ 或 .agent/skills/ 目录
 ```
 
+### 4.14 Email 插件 (email-plugin)
+
+邮件收发插件，支持 SMTP 发送和 IMAP 读取。
+
+```javascript
+// 配置
+await framework.loadPlugin(new EmailPlugin({
+  smtp_host: 'smtp.gmail.com',
+  smtp_port: 587,
+  smtp_secure: false,
+  smtp_user: 'your-email@gmail.com',
+  smtp_pass: 'your-app-password',
+  imap_host: 'imap.gmail.com',
+  imap_port: 993,
+  imap_user: 'your-email@gmail.com',
+  imap_pass: 'your-app-password',
+  from_email: 'your-email@gmail.com'
+}))
+
+// 或通过工具配置
+email_configure({
+  smtp_host: 'smtp.gmail.com',
+  smtp_user: 'your-email@gmail.com',
+  smtp_pass: 'your-app-password'
+})
+```
+
+**注册的工具：**
+
+| 工具 | 说明 |
+|------|------|
+| `email_send` | 发送电子邮件 |
+| `email_read` | 读取电子邮件（IMAP） |
+| `email_unread_count` | 获取未读邮件数量 |
+| `email_mark_read` | 标记邮件为已读 |
+| `email_configure` | 配置邮箱连接参数 |
+
+```javascript
+// 发送邮件
+email_send({
+  to: 'recipient@example.com',
+  subject: '主题',
+  body: '正文内容',
+  cc: 'cc@example.com',  // 可选
+  isHtml: false
+})
+
+// 读取邮件
+email_read({
+  box: 'INBOX',
+  limit: 10,
+  unreadOnly: false
+})
+
+// 获取未读数量
+email_unread_count({ box: 'INBOX' })
+
+// 标记为已读
+email_mark_read({ messageId: '12345' })
+```
+
+### 4.15 Telegram 插件 (telegram-plugin)
+
+Telegram 对话插件，绑定主 Agent 进行持续对话。
+
+```javascript
+// 配置
+await framework.loadPlugin(new TelegramPlugin({
+  botToken: 'YOUR_BOT_TOKEN',           // 必需
+  allowedChats: ['123456789'],          // 可选：允许的聊天ID
+  groupMode: false,                      // 可选：是否启用群组模式
+  prefix: '/',                           // 可选：命令前缀
+  systemPrompt: '你是一个有帮助的AI助手。'
+}))
+```
+
+**功能特性：**
+
+- 支持私聊和群组模式
+- MarkdownV2 格式支持（自动转义特殊字符）
+- 持续对话（基于 sessionId）
+- 支持图片和文档接收
+- 媒体文件自动保存到 `.agent/data/`
+
+**命令：**
+
+| 命令 | 说明 |
+|------|------|
+| `/start` | 显示帮助信息 |
+| `/clear` | 清除对话历史 |
+| `/history` | 查看对话状态 |
+
+### 4.16 插件管理扩展
+
+#### 插件启用/禁用
+
+```javascript
+// 启用插件
+await framework.enablePlugin('telegram')
+
+// 禁用插件
+await framework.disablePlugin('telegram')
+```
+
+#### 插件配置更新
+
+```javascript
+// 更新插件配置（会自动保存到 .agent/data/plugins-state.json）
+await framework.executeTool('update_plugin_config', {
+  name: 'telegram',
+  config: {
+    allowedChats: ['123456789', '987654321'],
+    groupMode: true
+  }
+})
+
+// 获取插件当前配置
+await framework.executeTool('get_plugin_config', {
+  name: 'telegram'
+})
+```
+
+**配置持久化：**
+- 插件的 `enabled` 状态和 `config` 会自动保存到 `.agent/data/plugins-state.json`
+- 重启后自动恢复配置
+
 ---
 
 ## 5. 插件开发
@@ -792,6 +938,8 @@ agent.emit('eventName', { key: 'value' })
 | `plugin:loaded` | `plugin` | 插件加载完成 |
 | `plugin:unloaded` | `plugin` | 插件卸载 |
 | `plugin:reloaded` | `plugin` | 插件重载 |
+| `plugin:enabled` | `plugin` | 插件启用 |
+| `plugin:disabled` | `plugin` | 插件禁用 |
 | `tool:registered` | `tool` | 工具注册 |
 | `agent:created` | `agent` | Agent 创建 |
 
@@ -998,6 +1146,13 @@ await framework.loadPlugin(plugin)
 await framework.reloadPlugin(name)
 await framework.reloadAllPlugins()
 
+// 启用/禁用插件
+await framework.enablePlugin(name)
+await framework.disablePlugin(name)
+
+// 更新插件配置
+framework.updatePluginConfig(name, config)
+
 // 执行工具
 const result = await framework.executeTool(name, args)
 

package/{test-chat.js → examples/test-chat.js}

@@ -4,7 +4,7 @@
  * 支持多行输入：连续按两次回车结束输入
  */
 
-const { Framework } = require('./src')
+const { Framework } = require('../src')
 const readline = require('readline')
 require('dotenv').config()
 

package/{test-mcp.js → examples/test-mcp.js}

@@ -2,8 +2,8 @@
  * MCP 插件测试脚本
  */
 
-const { Framework } = require('./src')
-const { MCPExecutorPlugin } = require('./src/executors/mcp-executor')
+const { Framework } = require('../src')
+const { MCPExecutorPlugin } = require('../src/executors/mcp-executor')
 
 async function test() {
   console.log('=== MCP Plugin Test ===\n')

package/{test-reload.js → examples/test-reload.js}

@@ -2,8 +2,8 @@
  * MCP mcp_reload 功能测试
  */
 
-const { Framework } = require('./src')
-const { MCPExecutorPlugin } = require('./src/executors/mcp-executor')
+const { Framework } = require('../src')
+const { MCPExecutorPlugin } = require('../src/executors/mcp-executor')
 const fs = require('fs')
 const path = require('path')
 

package/{test-telegram.js → examples/test-telegram.js}

@@ -1,5 +1,5 @@
 require('dotenv').config();
-const { Framework } = require('./src');
+const { Framework } = require('../src');
 
 async function main() {
   const framework = new Framework({ debug: false });

package/{test-tg-bot.js → examples/test-tg-bot.js}

@@ -1,5 +1,5 @@
 require('dotenv').config();
-const { Framework } = require('./src');
+const { Framework } = require('../src');
 
 async function main() {
   console.log('Starting test...\n');

package/{test-tg.js → examples/test-tg.js}

@@ -1,5 +1,5 @@
 require('dotenv').config();
-const { Framework } = require('./src');
+const { Framework } = require('../src');
 
 async function main() {
   const framework = new Framework({ debug: true });

package/{test-think.js → examples/test-think.js}

@@ -1,5 +1,5 @@
 require('dotenv').config();
-const { Framework } = require('./src');
+const { Framework } = require('../src');
 
 async function main() {
   const framework = new Framework({ debug: false });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foliko",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "简约的插件化 Agent 框架",
   "main": "src/index.js",
   "bin": {
@@ -28,10 +28,13 @@
     "@modelcontextprotocol/sdk": "^1.27.1",
     "ai": "^6.0.116",
     "dotenv": "^17.3.1",
+    "imap": "^0.8.19",
+    "mailparser": "^3.7.2",
     "marked": "^11.2.0",
     "marked-terminal": "6",
     "node-cron": "^4.2.1",
     "node-telegram-bot-api": "^0.67.0",
+    "nodemailer": "^6.10.0",
     "zod": "^3.24.0"
   }
 }

package/plugins/ai-plugin.js

@@ -79,6 +79,14 @@ class AIPlugin extends Plugin {
     console.log('[AIPlugin] Reloading...')
     this._framework = framework
     this._initAIClient()
+
+    // 刷新所有已有 Agent 的 AI client
+    for (const agent of framework._agents || []) {
+      if (agent._chatHandler) {
+        agent._chatHandler.setAIClient(this._aiClient)
+        console.log(`[AIPlugin] Refreshed AI client for agent: ${agent.name}`)
+      }
+    }
   }
 
   uninstall(framework) {

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/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
   }
 }

package/src/core/framework.js

@@ -89,6 +89,33 @@ class Framework extends EventEmitter {
     return this
   }
 
+  /**
+   * 启用插件
+   * @param {string} name - 插件名称
+   */
+  async enablePlugin(name) {
+    await this.pluginManager.enable(name)
+    return this
+  }
+
+  /**
+   * 禁用插件
+   * @param {string} name - 插件名称
+   */
+  async disablePlugin(name) {
+    await this.pluginManager.disable(name)
+    return this
+  }
+
+  /**
+   * 更新插件配置
+   * @param {string} name - 插件名称
+   * @param {Object} config - 新配置
+   */
+  updatePluginConfig(name, config) {
+    return this.pluginManager.updatePluginConfig(name, config)
+  }
+
   /**
    * 注册工具
    * @param {Object} tool - 工具定义

package/src/core/plugin-manager.js

@@ -4,6 +4,8 @@
  */
 
 const { Plugin } = require('./plugin-base')
+const fs = require('fs')
+const path = require('path')
 
 class PluginManager {
   /**
@@ -13,6 +15,53 @@ class PluginManager {
     this.framework = framework
     this._plugins = new Map()
     this._loading = false
+    this._stateFile = path.join(process.cwd(), '.agent', 'data', 'plugins-state.json')
+  }
+
+  /**
+   * 获取状态文件路径
+   */
+  _getStateFile() {
+    const dir = path.dirname(this._stateFile)
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true })
+    }
+    return this._stateFile
+  }
+
+  /**
+   * 保存插件状态到文件
+   */
+  _saveState() {
+    try {
+      const state = {}
+      for (const [name, entry] of this._plugins) {
+        state[name] = {
+          enabled: entry.enabled,
+          config: entry.instance?.config || {}
+        }
+      }
+      fs.writeFileSync(this._getStateFile(), JSON.stringify(state, null, 2))
+    } catch (err) {
+      console.error('[PluginManager] Failed to save state:', err.message)
+    }
+  }
+
+  /**
+   * 加载插件状态从文件
+   */
+  _loadState() {
+    try {
+      const stateFile = this._getStateFile()
+      if (fs.existsSync(stateFile)) {
+        const state = JSON.parse(fs.readFileSync(stateFile, 'utf-8'))
+        console.log('[PluginManager] Loaded plugin state from file')
+        return state
+      }
+    } catch (err) {
+      console.error('[PluginManager] Failed to load state:', err.message)
+    }
+    return {}
   }
 
   /**
@@ -30,9 +79,20 @@ class PluginManager {
       pluginInstance = this._createFromObject(plugin)
     }
 
+    // 加载保存的状态
+    const savedState = this._loadState()
+    const savedEnabled = savedState[pluginInstance.name]?.enabled
+    const savedConfig = savedState[pluginInstance.name]?.config
+
+    // 恢复保存的配置到插件实例
+    if (savedConfig && pluginInstance.config) {
+      pluginInstance.config = { ...pluginInstance.config, ...savedConfig }
+    }
+
     this._plugins.set(pluginInstance.name, {
       instance: pluginInstance,
-      status: 'registered'
+      status: 'registered',
+      enabled: savedEnabled !== undefined ? savedEnabled : true  // 使用保存的状态，默认启用
     })
 
     this.framework.emit('plugin:registered', pluginInstance)
@@ -61,6 +121,12 @@ class PluginManager {
       if (existing) {
         pluginInstance = existing.instance
 
+        // 如果插件被禁用，跳过加载
+        if (!existing.enabled) {
+          console.log(`[PluginManager] Plugin '${pluginInstance.name}' is disabled`)
+          return pluginInstance
+        }
+
         // 如果已加载且已启动，直接返回
         if (existing.status === 'loaded' && pluginInstance._started) {
           console.warn(`[PluginManager] Plugin '${pluginInstance.name}' already loaded`)
@@ -270,11 +336,11 @@ class PluginManager {
   }
 
   /**
-   * 获取所有已加载插件
+   * 获取所有已加载且已启用的插件
    */
   getAll() {
     return Array.from(this._plugins.values())
-      .filter(e => e.status === 'loaded')
+      .filter(e => e.status === 'loaded' && e.enabled)
       .map(e => ({ name: e.instance.name, instance: e.instance }))
   }
 
@@ -294,12 +360,119 @@ class PluginManager {
     return this._plugins.get(name)?.status === 'loaded'
   }
 
+  /**
+   * 检查插件是否启用
+   * @param {string} name - 插件名称
+   */
+  isEnabled(name) {
+    return this._plugins.get(name)?.enabled === true
+  }
+
+  /**
+   * 启用插件
+   * @param {string} name - 插件名称
+   */
+  async enable(name) {
+    const entry = this._plugins.get(name)
+    if (!entry) {
+      throw new Error(`Plugin '${name}' not found`)
+    }
+
+    if (entry.enabled) {
+      console.log(`[PluginManager] Plugin '${name}' already enabled`)
+      return
+    }
+
+    entry.enabled = true
+
+    // 如果插件已加载但未启动，启动它
+    if (entry.status === 'loaded' && !entry.instance._started) {
+      try {
+        if (typeof entry.instance.start === 'function') {
+          await entry.instance.start(this.framework)
+          entry.instance._started = true
+        }
+      } catch (err) {
+        console.error(`[PluginManager] Start failed for '${name}':`, err.message)
+      }
+    }
+
+    this.framework.emit('plugin:enabled', entry.instance)
+    this._saveState()
+    console.log(`[PluginManager] Plugin '${name}' enabled`)
+  }
+
+  /**
+   * 禁用插件
+   * @param {string} name - 插件名称
+   */
+  async disable(name) {
+    const entry = this._plugins.get(name)
+    if (!entry) {
+      throw new Error(`Plugin '${name}' not found`)
+    }
+
+    if (!entry.enabled) {
+      console.log(`[PluginManager] Plugin '${name}' already disabled`)
+      return
+    }
+
+    entry.enabled = false
+
+    // 如果插件正在运行，停止它
+    if (entry.instance._started) {
+      try {
+        // 优先调用 stop 方法，其次调用 stopBot 方法
+        if (typeof entry.instance.stop === 'function') {
+          await entry.instance.stop()
+        } else if (typeof entry.instance.stopBot === 'function') {
+          await entry.instance.stopBot()
+        }
+        if (typeof entry.instance.uninstall === 'function') {
+          await entry.instance.uninstall(this.framework)
+        }
+        entry.instance._started = false
+      } catch (err) {
+        console.error(`[PluginManager] Stop failed for '${name}':`, err.message)
+      }
+    }
+
+    this.framework.emit('plugin:disabled', entry.instance)
+    this._saveState()
+    console.log(`[PluginManager] Plugin '${name}' disabled`)
+  }
+
+  /**
+   * 更新插件配置
+   * @param {string} name - 插件名称
+   * @param {Object} config - 新配置（会合并到现有配置）
+   */
+  updatePluginConfig(name, config) {
+    const entry = this._plugins.get(name)
+    if (!entry) {
+      throw new Error(`Plugin '${name}' not found`)
+    }
+
+    if (!entry.instance.config) {
+      entry.instance.config = {}
+    }
+
+    // 合并配置
+    entry.instance.config = { ...entry.instance.config, ...config }
+
+    // 保存状态
+    this._saveState()
+    console.log(`[PluginManager] Plugin '${name}' config updated`)
+
+    return entry.instance.config
+  }
+
   /**
    * 启动所有已加载但未启动的插件（按优先级排序）
    */
   async startAll() {
     const entries = Array.from(this._plugins.values())
-      .filter(e => e.status === 'loaded')
+      .filter(e => e.status === 'loaded' && e.enabled)  // 只启动已启用且已加载的插件
       .sort((a, b) => (a.instance.priority || 100) - (b.instance.priority || 100))
 
     for (const entry of entries) {