foliko 1.0.84 → 1.0.86

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foliko",
-  "version": "1.0.84",
+  "version": "1.0.86",
   "description": "简约的插件化 Agent 框架",
   "main": "src/index.js",
   "type": "commonjs",
@@ -53,7 +53,7 @@
     "@ai-sdk/openai": "^3.0.41",
     "@ai-sdk/openai-compatible": "^2.0.35",
     "@anthropic-ai/sdk": "^0.39.0",
-    "@chnak/weixin-bot": "^1.2.1",
+    "@chnak/weixin-bot": "^1.2.7",
     "@chnak/zod-to-markdown": "^1.0.1",
     "@hono/node-server": "^1.19.11",
     "@larksuiteoapi/node-sdk": "^1.59.0",

package/plugins/ambient-agent/EventWatcher.js

@@ -53,17 +53,17 @@ class EventWatcher {
    */
   _handleEvent(type, data) {
     const activeGoals = this._goalManager.getActiveGoals()
-    log.info(`_handleEvent: type=${type}, activeGoals=${activeGoals.length}`)
+    // log.info(`_handleEvent: type=${type}, activeGoals=${activeGoals.length}`)
 
     for (const goal of activeGoals) {
       // 检查目标条件是否匹配此事件
       const isRelevant = this._isRelevantToGoal(goal, type, data)
-      log.info(`goal=${goal.id}, isRelevant=${isRelevant}, conditions=${JSON.stringify(goal.conditions)}`)
+      // log.info(`goal=${goal.id}, isRelevant=${isRelevant}, conditions=${JSON.stringify(goal.conditions)}`)
 
       if (isRelevant) {
         // 将 data 展平到事件对象中，方便通过 {{_event.xxx}} 访问
         this._goalManager.addEventToGoal(goal.id, { type, ...data })
-        log.info(`Event added to goal ${goal.id}`)
+        // log.info(`Event added to goal ${goal.id}`)
       }
     }
 
@@ -75,7 +75,7 @@ class EventWatcher {
         this._goalManager.activateGoal(goal.id)
         // 添加事件
         this._goalManager.addEventToGoal(goal.id, { type, ...data })
-        log.info(`事件触发激活目标: ${goal.id} (事件: ${type})`)
+        // log.info(`事件触发激活目标: ${goal.id} (事件: ${type})`)
       }
     }
   }

package/plugins/extension-executor-plugin.js

@@ -31,6 +31,11 @@ class ExtensionExecutorPlugin extends Plugin {
       this._scanPluginTools(plugin);
     });
 
+    // 监听插件重载事件，重新扫描工具
+    framework.on('plugin:reloaded', (plugin) => {
+      this._rescanPluginTools(plugin);
+    });
+
     return this;
   }
 
@@ -72,6 +77,34 @@ class ExtensionExecutorPlugin extends Plugin {
     }
   }
 
+  /**
+   * 重新扫描插件的工具（用于热重载）
+   */
+  _rescanPluginTools(plugin) {
+    if (!plugin || !plugin.tools || typeof plugin.tools !== 'object') {
+      return;
+    }
+
+    const pluginName = plugin.name;
+    if (!pluginName) return;
+
+    // 先移除旧工具
+    if (this._extensions.has(pluginName)) {
+      const ext = this._extensions.get(pluginName);
+      for (const tool of ext.tools || []) {
+        // 从 toolRouter 移除
+        if (this._framework?.toolRouter) {
+          this._framework.toolRouter.unregister(`ext_${tool.name}`);
+        }
+      }
+      this._extensions.delete(pluginName);
+    }
+
+    // 重新扫描工具
+    this._scanPluginTools(plugin);
+    log.info(` Rescanned tools from plugin '${pluginName}'`);
+  }
+
   async start(framework) {
     // 扫描所有已加载插件的 tools
     const plugins = framework.pluginManager.getAll();
@@ -217,7 +250,17 @@ class ExtensionExecutorPlugin extends Plugin {
     }
 
     const ext = this._extensions.get(pluginName);
-    if (!ext.tools.find((t) => t.name === toolDef.name)) {
+    const existingIdx = ext.tools.findIndex((t) => t.name === toolDef.name);
+    if (existingIdx >= 0) {
+      // 更新已存在的工具
+      ext.tools[existingIdx] = {
+        name: toolDef.name,
+        description: toolDef.description || '',
+        inputSchema: toolDef.inputSchema,
+        execute: toolDef.execute,
+      };
+    } else {
+      // 添加新工具
       ext.tools.push({
         name: toolDef.name,
         description: toolDef.description || '',
@@ -345,6 +388,14 @@ class ExtensionExecutorPlugin extends Plugin {
 
   reload(framework) {
     this._framework = framework;
+    // 重新扫描所有已加载插件的 tools
+    this._extensions.clear();
+    const plugins = framework.pluginManager.getAll();
+    for (const { instance: plugin } of plugins) {
+      this._scanPluginTools(plugin);
+    }
+    // 刷新所有 Agent 的扩展提示词
+    this._refreshAllAgentsExtPrompt(framework);
   }
 
   async uninstall(framework) {

package/plugins/file-system-plugin.js

@@ -154,11 +154,10 @@ class FileSystemPlugin extends Plugin {
     // 写入文件
     framework.registerTool({
       name: 'write_file',
-      description: `创建或写入文件内容。
-      
-    注意：
-    - 对于大文件（>100MB），建议分多次调用 append_to_file
-    - 支持覆盖写入和追加写入`,
+      description: `创建或写入文件内容（仅适用于小文件，建议小于10KB）。
+
+重要：大文件必须使用 append_to_file 分多次写入，每次追加一部分内容。
+禁止将大段内容作为 content 参数传入，这会导致工具调用失败。`,
       inputSchema: z.object({
         path: z.string().describe('文件路径'),
         content: z.string().describe('文件内容'),
@@ -225,6 +224,46 @@ class FileSystemPlugin extends Plugin {
       }
     })
 
+    // 追加文件内容（用于大文件分段写入）
+    framework.registerTool({
+      name: 'append_to_file',
+      description: `追加内容到文件末尾。适用于大文件写入，每次最多追加约64KB内容。
+
+使用方式：
+1. 先用 write_file 创建新文件（或清空现有文件）
+2. 多次调用 append_to_file 追加内容，每次 content 不超过 64KB
+3. 追加顺序很重要，content 应该按文件顺序排列`,
+      inputSchema: z.object({
+        path: z.string().describe('文件路径'),
+        content: z.string().describe('要追加的内容（建议不超过64KB）')
+      }),
+      execute: async (args, framework) => {
+        const { path: filePath, content } = args
+
+        const pathCheck = validatePath(filePath)
+        if (!pathCheck.valid) {
+          return { success: false, error: pathCheck.error }
+        }
+
+        try {
+          // 如果文件不存在，返回错误（应该先用 write_file 创建）
+          if (!fs.existsSync(pathCheck.resolved)) {
+            return { success: false, error: '文件不存在，请先用 write_file 创建文件' }
+          }
+
+          fs.appendFileSync(pathCheck.resolved, content, 'utf8')
+          return {
+            success: true,
+            message: `已追加内容到: ${pathCheck.resolved}`,
+            filePath: pathCheck.resolved,
+            appendedSize: content.length
+          }
+        } catch (error) {
+          return { success: false, error: error.message }
+        }
+      }
+    })
+
     // 删除文件
     framework.registerTool({
       name: 'delete_file',

package/plugins/session-plugin.js

@@ -272,9 +272,9 @@ class SessionPlugin extends Plugin {
     }
 
     // 如果会话数超过限制，清理最老的
-    if (this._sessions.size >= this.config.maxSessions) {
-      this._cleanupLRU()
-    }
+    // if (this._sessions.size >= this.config.maxSessions) {
+    //   this._cleanupLRU()
+    // }
 
     const session = {
       id,

package/plugins/weixin-plugin.js

@@ -14,6 +14,8 @@ const {cleanResponse} =require('../src/utils')
 const removeMarkdown = require('remove-markdown');
 const { z } = require('zod')
 const { WeixinBot } = require('@chnak/weixin-bot')
+const fs = require('fs')
+const path = require('path')
 
 class WeixinPlugin extends Plugin {
   constructor(config = {}) {
@@ -26,7 +28,7 @@ class WeixinPlugin extends Plugin {
     this.enabled = false
     this.path=`.agent/data`
     this.systemPrompt=`你是一个微信助手。
-    
+
 **重要:** 子Agent 匹配规则必须遵守：
 - 根据【子 Agent 匹配表】，将任务委托给最匹配的子Agent处理
 - 使用 subagent_call 工具并指定 agentName 来委托任务
@@ -45,6 +47,7 @@ class WeixinPlugin extends Plugin {
 
     this._framework = null
     this._bot = null
+    this._myUserId = null  // 机器人自己的 userId
     this._sessionPlugin = null
     this._sessionDeleteHandler = null
     this._sessionAgents = new Map()  // userId -> Agent
@@ -55,9 +58,190 @@ class WeixinPlugin extends Plugin {
 
   install(framework) {
     this._framework = framework
+    // 注册微信发送工具
+    this._registerTools()
     return this
   }
 
+  /**
+   * 注册微信发送工具（发送给自己）
+   */
+  _registerTools() {
+    // 发送文本消息给自己
+    this.registerTool({
+      name: 'weixin_send_message',
+      description: '发送文本消息到微信（发给登录的账号）',
+      inputSchema: z.object({
+        message: z.string().describe('要发送的文本内容')
+      }),
+      execute: async (args) => {
+        return this._sendMessage(args.message)
+      }
+    })
+
+    // 发送图片给自己
+    this.registerTool({
+      name: 'weixin_send_image',
+      description: '发送图片到微信（发给登录的账号）',
+      inputSchema: z.object({
+        imagePath: z.string().describe('本地图片文件路径')
+      }),
+      execute: async (args) => {
+        return this._sendImage(args.imagePath)
+      }
+    })
+
+    // 发送文件给自己
+    this.registerTool({
+      name: 'weixin_send_file',
+      description: '发送文件到微信（发给登录的账号）',
+      inputSchema: z.object({
+        filePath: z.string().describe('本地文件路径'),
+        fileName: z.string().optional().describe('文件名（可选，默认从路径推断）')
+      }),
+      execute: async (args) => {
+        return this._sendFile(args.filePath, args.fileName)
+      }
+    })
+
+    // 发送视频给自己
+    this.registerTool({
+      name: 'weixin_send_video',
+      description: '发送视频到微信（发给登录的账号）',
+      inputSchema: z.object({
+        videoPath: z.string().describe('本地视频文件路径'),
+        playLength: z.number().optional().describe('视频时长（秒）')
+      }),
+      execute: async (args) => {
+        return this._sendVideo(args.videoPath, args.playLength)
+      }
+    })
+
+    // 发送语音给自己
+    this.registerTool({
+      name: 'weixin_send_voice',
+      description: '发送语音到微信（发给登录的账号，silk格式）',
+      inputSchema: z.object({
+        voicePath: z.string().describe('本地语音文件路径（silk格式）')
+      }),
+      execute: async (args) => {
+        return this._sendVoice(args.voicePath)
+      }
+    })
+  }
+
+  /**
+   * 发送图片给自己
+   */
+  async _sendImage(imagePath) {
+    if (!this._bot) {
+      return { error: '微信机器人未连接' }
+    }
+    if (!this._myUserId) {
+      return { error: '未记录机器人用户ID' }
+    }
+    try {
+      if (!fs.existsSync(imagePath)) {
+        return { error: `文件不存在: ${imagePath}` }
+      }
+      await this._bot.sendImage(this._myUserId, imagePath)
+      // log.info(` 图片发送成功: ${path.basename(imagePath)}`)
+      return { success: true, message: '图片发送成功' }
+    } catch (err) {
+      log.error(` 图片发送失败: ${err.message}`)
+      return { error: err.message }
+    }
+  }
+
+  /**
+   * 发送文件给自己
+   */
+  async _sendFile(filePath, fileName) {
+    if (!this._bot) {
+      return { error: '微信机器人未连接' }
+    }
+    if (!this._myUserId) {
+      return { error: '未记录机器人用户ID' }
+    }
+    try {
+      if (!fs.existsSync(filePath)) {
+        return { error: `文件不存在: ${filePath}` }
+      }
+      await this._bot.sendFile(this._myUserId, filePath, fileName)
+      // log.info(` 文件发送成功: ${fileName || path.basename(filePath)}`)
+      return { success: true, message: '文件发送成功' }
+    } catch (err) {
+      log.error(` 文件发送失败: ${err.message}`)
+      return { error: err.message }
+    }
+  }
+
+  /**
+   * 发送视频给自己
+   */
+  async _sendVideo(videoPath, playLength) {
+    if (!this._bot) {
+      return { error: '微信机器人未连接' }
+    }
+    if (!this._myUserId) {
+      return { error: '未记录机器人用户ID' }
+    }
+    try {
+      if (!fs.existsSync(videoPath)) {
+        return { error: `文件不存在: ${videoPath}` }
+      }
+      const opts = playLength ? { playLength } : {}
+      await this._bot.sendVideo(this._myUserId, videoPath, opts)
+      // log.info(` 视频发送成功: ${path.basename(videoPath)}`)
+      return { success: true, message: '视频发送成功' }
+    } catch (err) {
+      log.error(` 视频发送失败: ${err.message}`)
+      return { error: err.message }
+    }
+  }
+
+  /**
+   * 发送语音给自己
+   */
+  async _sendVoice(voicePath) {
+    if (!this._bot) {
+      return { error: '微信机器人未连接' }
+    }
+    if (!this._myUserId) {
+      return { error: '未记录机器人用户ID' }
+    }
+    try {
+      if (!fs.existsSync(voicePath)) {
+        return { error: `文件不存在: ${voicePath}` }
+      }
+      await this._bot.sendVoice(this._myUserId, voicePath)
+      // log.info(` 语音发送成功: ${path.basename(voicePath)}`)
+      return { success: true, message: '语音发送成功' }
+    } catch (err) {
+      log.error(` 语音发送失败: ${err.message}`)
+      return { error: err.message }
+    }
+  }
+
+  /**
+   * 发送文本消息给自己
+   */
+  async _sendMessage(message) {
+    if (!this._bot) {
+      return { error: '微信机器人未连接' }
+    }
+    if (!this._myUserId) {
+      return { error: '未记录机器人用户ID' }
+    }
+    try {
+      await this._bot.send(this._myUserId, message)
+      return { success: true, message: '消息发送成功' }
+    } catch (err) {
+      log.error(` 消息发送失败: ${err.message}`)
+      return { error: err.message }
+    }
+  }
+
   async start(framework) {
     // 防止重复初始化
     if (this._initialized) return this
@@ -71,7 +255,7 @@ class WeixinPlugin extends Plugin {
       this._sessionDeleteHandler = (sessionId) => {
         // 只处理 weixin 会话的删除
         if (sessionId.startsWith('weixin_')) {
-          log.info(` Session deleted: ${sessionId}`)
+          // log.info(` Session deleted: ${sessionId}`)
         }
       }
       this._sessionPlugin.on('session:deleted', this._sessionDeleteHandler)
@@ -80,19 +264,19 @@ class WeixinPlugin extends Plugin {
     // 监听定时提醒事件
     if (this._framework) {
       this._framework.on('scheduler:reminder', async (data) => {
-        log.info(' Received scheduler reminder:', data)
+        // log.info(' Received scheduler reminder:', data)
         await this._handleScheduledReminder(data)
       })
 
       // 监听 webhook 事件
       this._framework.on('webhook:received', async (data) => {
-        log.info(' Received webhook event:', data)
+        // log.info(' Received webhook event:', data)
         await this._handleWebhookNotification(data)
       })
 
       // 监听统一通知事件
       this._framework.on('notification', async (data) => {
-        log.info(' Received notification:', data)
+        // log.info(' Received notification:', data)
         await this._handleNotification(data)
       })
     }
@@ -119,17 +303,21 @@ class WeixinPlugin extends Plugin {
     this._bot = new WeixinBot({
       tokenPath:`${this.path}/${this.name}.json`,
       onError: (err) => {
-        log.error(' Error:', err instanceof Error ? err.stack ?? err.message : String(err))
+        log.error(' Error:', err.message)
       },
     })
 
     const loginOptions = { force: this.config.forceLogin }
-    log.info('', this.config.forceLogin ? '强制重新扫码登录...' : '正在登录（已有凭证则自动跳过扫码）...')
+    // log.info('', this.config.forceLogin ? '强制重新扫码登录...' : '正在登录（已有凭证则自动跳过扫码）...')
 
     const creds = await this._bot.login(loginOptions)
-    log.info(' 登录成功 — Bot ID:', creds.accountId)
-    log.info(' 关联用户:', creds.userId)
-    log.info(' API 地址:', creds.baseUrl)
+    // log.info(' 登录成功 — Bot ID:', creds.accountId)
+    // log.info(' 关联用户:', creds.userId)
+    // log.info(' API 地址:', creds.baseUrl)
+
+    // 记录机器人自己的 userId（用于发送媒体）
+    this._myUserId = creds.userId
+    // log.info(' 已记录机器人 userId:', this._myUserId)
 
     // 注册消息处理
     this._bot.onMessage(async (msg) => {
@@ -138,7 +326,7 @@ class WeixinPlugin extends Plugin {
 
     // 启动Bot
     await this._bot.run()
-    log.info(' 开始接收微信消息')
+    // log.info(' 开始接收微信消息')
   }
 
   /**
@@ -180,7 +368,7 @@ class WeixinPlugin extends Plugin {
     // 检查缓存
     if (this._sessionAgents.has(userId)) {
       const agent = this._sessionAgents.get(userId)
-      log.info(' Reusing cached session agent for userId:', userId)
+      // log.info(' Reusing cached session agent for userId:', userId)
       return { agent, sessionId: `weixin_${userId}` }
     }
 
@@ -191,7 +379,7 @@ class WeixinPlugin extends Plugin {
       metadata: { WORK_DIR: process.cwd() }
     })
     this._sessionAgents.set(userId, agent)
-    log.info(' Created new session agent for userId:', userId)
+    // log.info(' Created new session agent for userId:', userId)
 
     // 使用 SessionPlugin 管理会话历史
     if (this._sessionPlugin) {
@@ -201,7 +389,7 @@ class WeixinPlugin extends Plugin {
       })
     }
 
-    log.info(` Session ready for user: ${userId}`)
+    // log.info(` Session ready for user: ${userId}`)
     return { agent, sessionId: `weixin_${userId}` }
   }
 
@@ -219,17 +407,78 @@ class WeixinPlugin extends Plugin {
       messageCount = session?.messages?.length || 0
     }
 
-    log.info(` #${messageCount + 1} | 类型: ${msg.type} | 用户: ${userId}`)
-    log.info(` 内容: ${msg.text}`)
+    //log.info(` #${messageCount + 1} | 类型: ${msg.type} | 用户: ${userId}`)
+
+    // 处理不同类型的消息
+    switch (msg.type) {
+      case 'text':
+        // log.info(` 内容: ${msg.text}`)
+        if (msg.text) {
+          await this._processChat(userId, msg.text.trim(), msg)
+        }
+        break
+
+      case 'image':
+        // log.info(` 收到图片消息`)
+        await this._processMediaChat(userId, '[用户发送了图片]', msg)
+        break
+
+      case 'file':
+        // log.info(` 收到文件消息: ${msg.fileName || 'unknown'}`)
+        await this._processMediaChat(userId, `[用户发送了文件: ${msg.fileName || 'unknown'}]`, msg)
+        break
+
+      case 'video':
+        // log.info(` 收到视频消息`)
+        await this._processMediaChat(userId, '[用户发送了视频]', msg)
+        break
+
+      case 'voice':
+        // log.info(` 收到语音消息`)
+        await this._processMediaChat(userId, '[用户发送了语音消息]', msg)
+        break
+
+      default:
+        // log.info(` 不支持的消息类型: ${msg.type}`)
+        if (msg.text) {
+          await this._processChat(userId, msg.text.trim(), msg)
+        }
+    }
+  }
 
-    // 非文本消息暂不处理
-    if (msg.type !== 'text' || !msg.text) {
-      log.info(' Unsupported message type or no text')
+  /**
+   * 处理媒体消息（图片/文件/视频/语音）
+   */
+  async _processMediaChat(userId, text, originalMsg) {
+    const sessionInfo = this._getSessionAgent(userId)
+    if (!sessionInfo) {
+      log.error(' No session agent available')
       return
     }
 
-    const text = msg.text.trim()
-    await this._processChat(userId, text, msg)
+    const { agent, sessionId } = sessionInfo
+
+    // 发送正在输入状态
+    try {
+      await this._bot.sendTyping(userId)
+    } catch { /* typing 失败不影响回复 */ }
+
+    await new Promise((resolve) => setTimeout(resolve, 1000))
+
+    try {
+      const result = await agent.chat(text, {
+        sessionId: sessionId
+      })
+      const fullResponse = cleanResponse(result.message || '')
+
+      if (fullResponse) {
+        await this._sendMessageBatch(originalMsg, userId, fullResponse, true)
+        // log.info(` 回复成功 (${fullResponse.length} 字符)`)
+      }
+    } catch (err) {
+      log.error(' Media chat error:', err)
+      await this._sendMessageBatch(originalMsg, userId, `发生错误：${err.message}`, true)
+    }
   }
 
   /**
@@ -271,13 +520,13 @@ class WeixinPlugin extends Plugin {
       // 发送回复（超过500字自动分批）
       if (fullResponse) {
         await this._sendMessageBatch(originalMsg, userId, fullResponse, true)
-        log.info(` 回复成功 (${fullResponse.length} 字符)`)
+        // log.info(` 回复成功 (${fullResponse.length} 字符)`)
       } else {
         await this._sendMessageBatch(originalMsg, userId, '抱歉，我没有收到有效的回复。', true)
       }
 
     } catch (err) {
-      log.error(' Chat error:', err)
+      log.error(' Chat error:', err.message)
       await this._sendMessageBatch(originalMsg, userId, `发生错误：${err.message}`, true)
     }
   }
@@ -317,7 +566,7 @@ class WeixinPlugin extends Plugin {
       chunks.push(text.slice(i, i + MAX_LEN))
     }
 
-    log.info(` Message too long (${text.length}), splitting into ${chunks.length} parts`)
+    // log.info(` Message too long (${text.length}), splitting into ${chunks.length} parts`)
 
     for (let i = 0; i < chunks.length; i++) {
       const chunk = `[${i + 1}/${chunks.length}]\n${chunks[i]}`
@@ -363,7 +612,7 @@ class WeixinPlugin extends Plugin {
       const userId = sessionId.replace('weixin_', '')
       try {
         await this._sendMessageBatch(null, userId, reminderText, false)
-        log.info(` Reminder sent to user ${userId}`)
+        // log.info(` Reminder sent to user ${userId}`)
       } catch (err) {
         log.error(` Failed to send reminder:`, err.message)
       }
@@ -381,7 +630,7 @@ class WeixinPlugin extends Plugin {
         const userId = weixinSessions[0].id.replace('weixin_', '')
         try {
           await this._sendMessageBatch(null, userId, reminderText, false)
-          log.info(` Reminder sent to recent user ${userId}`)
+          // log.info(` Reminder sent to recent user ${userId}`)
         } catch (err) {
           log.error(` Failed to send reminder:`, err.message)
         }
@@ -412,7 +661,7 @@ class WeixinPlugin extends Plugin {
 
     try {
       await this._sendMessageBatch(null, userId, notificationText, false)
-      log.info(` Webhook notification sent to user ${userId}`)
+      // log.info(` Webhook notification sent to user ${userId}`)
     } catch (err) {
       log.error(` Failed to send webhook notification:`, err.message)
     }
@@ -470,7 +719,7 @@ class WeixinPlugin extends Plugin {
 
     try {
       await this._sendMessageBatch(null, userId, notificationText, false)
-      log.info(` Notification sent to user ${userId}`)
+      // log.info(` Notification sent to user ${userId}`)
     } catch (err) {
       log.error(` Failed to send notification:`, err.message)
     }
@@ -511,7 +760,7 @@ class WeixinPlugin extends Plugin {
     if (this._bot) {
       this._bot.stop()
       this._bot = null
-      log.info(' Bot stopped')
+      // log.info(' Bot stopped')
     }
   }