foliko 1.0.64 → 1.0.66

package/plugins/email.js

@@ -44,19 +44,19 @@ class EmailPlugin extends Plugin {
       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')
-    // }
+    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
   }
 
@@ -201,6 +201,158 @@ class EmailPlugin extends Plugin {
         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生成回复内容')
+      }),
+      execute: async (args) => {
+        return this._handleAutoReply(args)
+      }
+    })
+  }
+
+  /**
+   * 处理自动回复
+   */
+  async _handleAutoReply(args) {
+    let { to, subject, body, from, _event, prompt } = args
+
+    // 如果没有直接参数，尝试从 _event 提取
+    // _event 格式: { type: 'email:received', email: {...}, timestamp: ... }
+    if (!to && !subject && !body && _event) {
+      const email = _event.email || _event.data?.email || {}
+      from = email.from?.text || email.from || ''
+      to = email.to?.text || email.to || ''
+      subject = email.subject || ''
+      body = email.text || email.body || ''
+    }
+
+    // 检查必要参数
+    if (!from && !to) {
+      return { success: false, error: '缺少收件人地址' }
+    }
+    if (!body) {
+      return { success: false, error: '缺少邮件内容' }
+    }
+
+    try {
+      // 获取活跃的 Agent
+      const agent = this._getActiveAgent()
+      if (!agent) {
+        return { success: false, error: 'No active agent found' }
+      }
+
+      // 构建提示让 LLM 生成回复
+      const finalPrompt = prompt || `你是一封邮件自动回复助手。请根据以下邮件内容，生成一封专业的回复邮件。
+
+【原始邮件】
+发件人: ${from || to}
+主题: ${subject}
+内容:
+${body}
+
+【要求】
+1. 回复内容要针对邮件中的问题或内容进行回复
+2. 语言要专业、礼貌、简洁
+3. 只输出邮件正文内容，不要额外解释
+4. 回复语言应与原邮件一致（如果原邮件是中文，则用中文回复）`
+
+      // 等待 Agent 生成回复（带超时保护）
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error('AI回复生成超时（30秒）')), 30000)
+      })
+
+      const replyPromise = agent.pushMessage(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
+      })
+
+      if (sendResult.success) {
+        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
   }
 
   /**
@@ -209,10 +361,10 @@ class EmailPlugin extends Plugin {
   async _handleEmailWatch(args) {
     args={
       ...args,
-      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
+      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
@@ -407,7 +559,7 @@ class EmailPlugin extends Plugin {
                       // 发送事件通知
                       this._emitEmailReceived(email)
 
-                      //console.log(`[Email] New email received: ${email.subject}`)
+                      console.log(`[Email] New email received: ${email.subject}`)
                       cleanup()
                       resolve({ success: true, newEmails: newEmails.length, email })
                     } else {

package/plugins/file-system-plugin.js

@@ -401,10 +401,10 @@ class FileSystemPlugin extends Plugin {
       inputSchema: z.object({
         title: z.string().describe('通知标题'),
         message: z.string().describe('通知内容'),
-        source: z.string().optional().describe('通知来源标识，默认 file-system')
+        source: z.string().optional().describe('通知来源标识，默认 系统消息')
       }),
       execute: async (args, framework) => {
-        const { title, message, source = 'file-system' } = args
+        const { title, message, source = '系统消息' } = args
         try {
           // 获取当前执行上下文中的 sessionId，只发送到当前会话
           const ctx = framework.getExecutionContext()

package/skills/ambient-agent/SKILL.md

@@ -0,0 +1,234 @@
+---
+name: ambient-agent
+description: Ambient Agent - 持续后台运行的智能代理，用于主动监控事件和执行操作
+allowed-tools: ambient_goals,ambient_status,ambient_think,ambient_remember,ambient_control
+---
+
+# Ambient Agent
+
+Ambient Agent 是一个持续后台运行的智能代理，监控事件并主动执行操作。
+
+## 核心概念
+
+### Goal（目标）
+目标是对话式 LLM 派发的任务，包含：
+- `title` - 目标标题
+- `description` - 目标描述
+- `priority` - 优先级 1-10
+- `actions` - 要执行的操作列表
+- `conditions` - 激活条件（如监听特定事件）
+- `state` - 状态：`pending` | `active` | `completed` | `failed`
+
+### Action（操作）
+操作是目标的最小执行单元，有三种类型：
+
+| 类型 | 说明 | 参数 |
+|------|------|------|
+| `tool` | 调用工具 | `name` 工具名, `args` 参数 |
+| `message` | 发送消息 | `content` 消息内容 |
+| `think` | 触发思考 | `topic` 主题, `mode` 模式, `depth` 深度 |
+
+### Event（事件）
+目标可以监听框架事件：
+- `tool:result` - 工具执行结果
+- `scheduler:reminder` - 定时提醒
+- `agent:message` - 代理消息
+- `email:received` - 收到邮件
+- `webhook:received` - Webhook 接收
+
+## 工具
+
+### ambient_goals - 目标管理
+
+```javascript
+// 列出所有目标
+await ambient_goals({ action: 'list' })
+
+// 创建目标
+await ambient_goals({
+  action: 'create',
+  title: '监控邮件',
+  description: '定期检查新邮件',
+  priority: 8,
+  actions: [
+    { id: 'check-email', type: 'tool', name: 'email_list', args: { box: 'INBOX' } }
+  ],
+  conditions: {
+    events: ['email:received']
+  }
+})
+
+// 更新目标
+await ambient_goals({
+  action: 'update',
+  goalId: 'xxx-xxx',
+  title: '新标题',
+  actions: [...]  // 新操作列表
+})
+
+// 删除目标
+await ambient_goals({ action: 'delete', goalId: 'xxx-xxx' })
+
+// 激活目标
+await ambient_goals({ action: 'activate', goalId: 'xxx-xxx' })
+```
+
+### ambient_status - 获取状态
+
+```javascript
+await ambient_status({})
+// 返回: { running, tickCount, activeGoals, pendingGoals, recentActivities }
+```
+
+### ambient_think - 触发思考
+
+```javascript
+await ambient_think({
+  goalId: 'xxx-xxx',  // 可选，关联目标
+  mode: 'reflect',     // reflect | brainstorm | plan | analyze
+  topic: '反思主题',    // 可选
+  depth: 2              // 可选，1-5
+})
+```
+
+### ambient_remember - 记忆管理
+
+```javascript
+// 存储记忆
+await ambient_remember({
+  action: 'store',
+  key: 'user-preference',
+  content: '用户喜欢在早上收到摘要'
+})
+
+// 检索最近记忆
+await ambient_remember({
+  action: 'retrieve',
+  limit: 10
+})
+
+// 搜索记忆
+await ambient_remember({
+  action: 'search',
+  query: '邮件'
+})
+```
+
+### ambient_control - 控制循环
+
+```javascript
+// 暂停
+await ambient_control({ action: 'pause' })
+
+// 恢复
+await ambient_control({ action: 'resume' })
+
+// 调整参数
+await ambient_control({
+  action: 'adjust',
+  tickInterval: 10000,    // 新 tick 间隔（毫秒）
+  cooldownPeriod: 5000    // 新冷却时间（毫秒）
+})
+```
+
+## action 与 step 的关系
+
+Ambient Agent 的 action 与 Workflow Engine 的 step 共用 `StepExecutor` 执行：
+
+```
+action.type → step.type
+───────────────────────
+tool      → tool
+message   → message
+think     → think
+```
+
+这意味着：
+- 变量引用语法一致：`{{variableName}}`
+- sessionId 传递机制一致
+- 错误处理方式一致
+
+## action 执行上下文
+
+当 action 执行时，可用的上下文：
+
+```javascript
+// context.variables 中可用
+context.variables._event      // 触发的事件数据（如果有）
+context.variables._action     // 当前执行的 action 对象
+context.variables.loopIndex   // 循环索引（如果被 loop 执行）
+
+// context.input 中可用
+context.input                 // 工作流/目标输入参数
+```
+
+## 创建目标的最佳实践
+
+1. **明确目标标题** - 让用户清楚知道目标意图
+2. **设置合适优先级** - 高优先级目标会被优先处理
+3. **操作要原子化** - 每个 action 只做一件事
+4. **设置冷却时间** - 避免同一目标过度频繁执行
+5. **检查循环** - 同一 action 连续失败 3 次会判定为循环
+
+## 示例：创建邮件自动回复目标
+
+**重要**：`email:received` 事件的 `email` 对象包含：
+- `email.from` - 发件人地址
+- `email.to` - 收件人地址
+- `email.subject` - 邮件主题
+- `email.body` - 邮件正文
+
+使用 `{{}}` 语法从事件中提取参数：
+
+```javascript
+await ambient_goals({
+  action: 'create',
+  title: '邮件自动回复',
+  description: '收到邮件后自动回复发件人',
+  priority: 8,
+  actions: [
+    {
+      id: 'auto-reply',
+      type: 'tool',
+      name: 'email_auto_reply',
+      args: {
+        to: '{{_event.email.from}}',
+        subject: '{{_event.email.subject}}',
+        body: '{{_event.email.body}}'
+      }
+    }
+  ],
+  conditions: {
+    events: ['email:received']
+  }
+})
+```
+
+**错误示例**（缺少参数）：
+```javascript
+// ❌ 错误 - 没有传递必需参数
+{ type: 'tool', name: 'email_auto_reply', args: {} }
+
+// ✅ 正确 - 从事件中提取参数
+{ type: 'tool', name: 'email_auto_reply', args: {
+    to: '{{_event.email.from}}',
+    subject: '{{_event.email.subject}}',
+    body: '{{_event.email.body}}'
+  }
+}
+```
+
+**注意**：`email_auto_reply` 需要 `to`、`subject`、`body` 三个必需参数，必须从 `{{_event.email.xxx}}` 提取。
+
+## 生命周期
+
+```
+Goal 创建 → [条件满足] → ACTIVE → 执行 actions → COMPLETED/FAILED
+                ↑                              ↓
+                └────── 重新激活 ← ─────────────┘
+```
+
+- **pending** - 待激活，满足条件后自动变为 active
+- **active** - 执行中，循环处理 actions
+- **completed** - 所有 actions 执行完毕
+- **failed** - 达到最大尝试次数或检测到循环