foliko 1.0.40 → 1.0.41

package/plugins/feishu-plugin.js

@@ -3,628 +3,382 @@
  * 使用 @larksuiteoapi/node-sdk 的 WebSocket 长连接模式
  *
  * 配置：
- * - appId: 飞书应用 ID (默认从 FEISHU_APP_ID 环境变量获取)
- * - appSecret: 飞书应用密钥 (默认从 FEISHU_APP_SECRET 环境变量获取)
- * - allowedUsers: 允许的用户 openId 数组，为空则允许所有用户
+ * - appId: 飞书应用 ID
+ * - appSecret: 飞书应用密钥
+ * - allowedUsers: 允许的用户 openId 数组
  */
 
 const { Plugin } = require('../src/core/plugin-base')
 
-module.exports = function(Plugin) {
-  return class FeishuPlugin extends Plugin {
-    constructor(config = {}) {
-      super()
-      this.name = 'feishu'
-      this.version = '1.0.0'
-      this.description = '飞书对话插件，使用 WebSocket 长连接接收消息'
-      this.priority = 80
-      // 默认不启用，需要在 plugins.json 中设置 enabled: true
-      this.enabled = false
-      this.systemPrompt='你是一个飞书助手。回复内容不要使用markdown格式文本。'
-
-      this.config = {
-        appId: config.appId || process.env.FEISHU_APP_ID,
-        appSecret: config.appSecret || process.env.FEISHU_APP_SECRET,
-        allowedUsers: config.allowedUsers || []
-      }
-
-      this._framework = null
-      this._client = null
-      this._wsClient = null
-      this._sessionPlugin = null
-      this._sessionDeleteHandler = null
-      this._sessionAgents = new Map()  // openId -> Agent
-      this._initialized = false
-      this._processedMessages = new Set()  // 消息去重
-      this._messageCleanupInterval = null
-      this._processingLock = new Map()  // openId -> boolean (是否正在处理)
+class FeishuPlugin extends Plugin {
+  constructor(config = {}) {
+    super()
+    this.name = 'feishu'
+    this.version = '1.1.0'
+    this.description = '飞书对话插件，使用 WebSocket 长连接接收消息'
+    this.priority = 80
+    this.enabled = false
+    this.systemPrompt = '你是一个飞书助手。回复内容不要使用markdown格式文本。'
+
+    this.config = {
+      appId: config.appId || process.env.FEISHU_APP_ID,
+      appSecret: config.appSecret || process.env.FEISHU_APP_SECRET,
+      allowedUsers: config.allowedUsers || []
     }
 
-    install(framework) {
-      this._framework = framework
-      return this
-    }
-
-    start(framework) {
-      // 防止重复初始化
-      if (this._initialized) return this
-      this._initialized = true
-
-      if (!this.config.appId || !this.config.appSecret) {
-        console.warn('[Feishu] No appId or appSecret. Set FEISHU_APP_ID and FEISHU_APP_SECRET env vars.')
-        return this
-      }
+    this._framework = null
+    this._client = null
+    this._wsClient = null
+    this._sessionPlugin = null
+    this._sessionDeleteHandler = null
+    this._sessionAgents = new Map()
+    this._initialized = false
+    this._processedMessages = new Set()
+    this._messageCleanupInterval = null
+    this._processingLock = new Map()
+  }
 
-      // 获取 SessionPlugin 引用
-      this._sessionPlugin = framework.pluginManager.get('session')
+  install(framework) {
+    this._framework = framework
+    return this
+  }
 
-      // 监听 SessionPlugin 的会话删除事件
-      if (this._sessionPlugin) {
-        this._sessionDeleteHandler = (sessionId) => {
-          // 只处理 feishu 会话的删除
-          if (sessionId.startsWith('feishu_')) {
-            console.log(`[Feishu] Session deleted: ${sessionId}`)
-          }
-        }
-        this._sessionPlugin.on('session:deleted', this._sessionDeleteHandler)
-      }
+  start(framework) {
+    if (this._initialized) return this
+    this._initialized = true
 
-      this._initClient()
+    if (!this.config.appId || !this.config.appSecret) {
+      console.warn('[Feishu] No appId or appSecret.')
       return this
     }
 
-    /**
-     * 初始化飞书 WebSocket 客户端
-     */
-    _initClient() {
-      try {
-        const { Client, WSClient, EventDispatcher } = require('@larksuiteoapi/node-sdk')
+    this._framework = framework
+    this._sessionPlugin = framework.pluginManager.get('session')
 
-        this._client = new Client({
-          appId: this.config.appId,
-          appSecret: this.config.appSecret,
-          logger: console
-        })
-
-        this._wsClient = new WSClient({
-          appId: this.config.appId,
-          appSecret: this.config.appSecret,
-          logger: console
-        })
-
-        // 创建事件分发器并注册处理器
-        const eventDispatcher = new EventDispatcher({}).register({
-          'im.message.receive_v1': async (data) => {
-            await this._handleMessage(data)
-          }
-        })
-
-        // 启动 WebSocket 连接
-        this._wsClient.start({ eventDispatcher })
-
-        // 启动消息去重清理定时器（每分钟清理一次）
-        this._messageCleanupInterval = setInterval(() => {
-          this._processedMessages.clear()
-        }, 60000)
-
-        // 监听定时提醒事件
-        if (this._framework) {
-          this._framework.on('scheduler:reminder', async (data) => {
-            console.log('[Feishu] Received scheduler reminder:', data)
-            await this._handleScheduledReminder(data)
-          })
+    if (this._sessionPlugin) {
+      this._sessionDeleteHandler = (sessionId) => {
+        if (sessionId.startsWith('feishu_')) {
+          console.log(`[Feishu] Session deleted: ${sessionId}`)
         }
-
-        console.log('[Feishu] WebSocket client started')
-      } catch (err) {
-        console.error('[Feishu] Failed to initialize client:', err.message, err.stack)
       }
+      this._sessionPlugin.on('session:deleted', this._sessionDeleteHandler)
     }
 
-    /**
-     * 处理飞书消息
-     */
-    async _handleMessage(data) {
-      try {
-        // 解析消息数据 - SDK 事件格式
-        // data 结构: { message: { chat_id, content, sender: { sender_id: { open_id }, ... }, message_type } }
-        if (!data || !data.message || Object.keys(data.message).length === 0) {
-          console.log('[Feishu] Invalid or empty message data:', JSON.stringify(data).substring(0, 500))
-          return
-        }
-
-        const message = data.message
-        const chatId = message.chat_id
-        const messageId = message.message_id
-        // 飞书消息结构: sender.sender_id.open_id 或 sender.open_id
-        // 注意: 群组消息可能没有 sender 字段，此时使用 chat_id 作为会话标识
-        const openId = message.sender?.sender_id?.open_id || message.sender?.open_id || message.open_id || chatId
-        const messageType = message.message_type
-        let content = {}
-        try {
-          content = message.content ? JSON.parse(message.content) : {}
-        } catch (e) {
-          console.log('[Feishu] Failed to parse message content:', message.content?.substring?.(0, 100))
-          return
-        }
-
-        // 消息去重
-        if (messageId && this._processedMessages.has(messageId)) {
-          console.log(`[Feishu] Duplicate message ignored: ${messageId}`)
-          return
-        }
-        if (messageId) {
-          this._processedMessages.add(messageId)
-        }
-
-        // 忽略非文本消息
-        if (messageType !== 'text') {
-          console.log(`[Feishu] Unsupported message type: ${messageType}`)
-          return
-        }
-
-        const text = content.text?.trim()
-        if (!text) {
-          console.log('[Feishu] Empty text message')
-          return
-        }
+    this._initClient()
+    return this
+  }
 
-        // 权限检查
-        if (!this._checkPermission(openId)) {
-          console.log(`[Feishu] User ${openId} not allowed`)
-          return
-        }
+  _initClient() {
+    try {
+      const { Client, WSClient, EventDispatcher } = require('@larksuiteoapi/node-sdk')
 
-        // 获取历史消息数量
-        let messageCount = 0
-        if (this._sessionPlugin) {
-          const session = this._sessionPlugin.getSession(`feishu_${openId}`)
-          messageCount = session?.messages?.length || 0
-        }
+      this._client = new Client({
+        appId: this.config.appId,
+        appSecret: this.config.appSecret,
+        logger: console
+      })
 
-        console.log(`[Feishu] #${messageCount + 1} | Chat: ${chatId} | User: ${openId}`)
-        console.log(`[Feishu] Content: ${text}`)
+      this._wsClient = new WSClient({
+        appId: this.config.appId,
+        appSecret: this.config.appSecret,
+        logger: console
+      })
 
-        // 命令处理
-        if (text.startsWith('/')) {
-          await this._handleCommand(openId, text, message)
-          return
+      const eventDispatcher = new EventDispatcher({}).register({
+        'im.message.receive_v1': async (data) => {
+          await this._handleMessage(data)
         }
+      })
 
-        // 检查是否正在处理，防止并发
-        if (this._processingLock.get(openId)) {
-          console.log(`[Feishu] Session ${openId} is busy, ignoring message`)
-          return
-        }
-        this._processingLock.set(openId, true)
+      this._wsClient.start({ eventDispatcher })
 
-        try {
-          await this._processChat(openId, text, message)
-        } finally {
-          this._processingLock.set(openId, false)
-        }
+      this._messageCleanupInterval = setInterval(() => {
+        this._processedMessages.clear()
+      }, 60000)
 
-      } catch (err) {
-        console.error('[Feishu] Error handling message:', err.message, err.stack)
+      if (this._framework) {
+        this._framework.on('scheduler:reminder', async (data) => {
+          await this._handleScheduledReminder(data)
+        })
       }
-    }
 
-    /**
-     * 处理命令
-     */
-    async _handleCommand(openId, text, originalMsg) {
-      const parts = text.split(' ')
-      const command = parts[0].substring(1)
-      const args = parts.slice(1).join(' ')
-
-      switch (command.toLowerCase()) {
-        case 'start':
-        case 'help':
-          await this._sendMessage(openId,
-            '👋 欢迎使用 AI 助手！\n\n' +
-            '直接发送消息即可与我对话。\n\n' +
-            '可用命令：\n' +
-            '/start - 显示帮助\n' +
-            '/clear - 清除对话历史\n' +
-            '/history - 查看历史消息数',
-            originalMsg)
-          break
-
-        case 'clear':
-          this._clearSession(openId)
-          await this._sendMessage(openId, '✅ 对话历史已清除', originalMsg)
-          break
-
-        case 'history':
-          if (this._sessionPlugin) {
-            const sessionId = `feishu_${openId}`
-            const session = this._sessionPlugin.getSession(sessionId)
-            const allSessions = this._sessionPlugin.listSessions()
-            const feishuSessionCount = allSessions.filter(s => s.id.startsWith('feishu_')).length
-            await this._sendMessage(openId,
-              `📊 当前状态\n\n会话数：${feishuSessionCount}\n` +
-              `历史消息：${session?.messages?.length || 0}\n` +
-              `最后活跃：${session?.lastActive?.toLocaleString() || '无'}`,
-              originalMsg)
-          } else {
-            await this._sendMessage(openId, '❌ 会话服务不可用', originalMsg)
-          }
-          break
-
-        default:
-          // 未识别命令，作为普通消息处理
-          await this._processChat(openId, text, originalMsg)
-      }
+      console.log('[Feishu] WebSocket client started')
+    } catch (err) {
+      console.error('[Feishu] Failed to initialize client:', err.message, err.stack)
     }
+  }
 
-    /**
-     * 获取或创建会话 Agent
-     * 使用 SessionPlugin 统一管理会话历史
-     */
-    _getSessionAgent(openId) {
-      // 检查缓存
-      if (this._sessionAgents.has(openId)) {
-        const agent = this._sessionAgents.get(openId)
-        console.log('[Feishu] Reusing cached session agent for openId:', openId)
-        return { agent, sessionId: `feishu_${openId}` }
+  async _handleMessage(data) {
+    try {
+      if (!data || !data.message || Object.keys(data.message).length === 0) {
+        return
       }
 
-      // 创建新 agent
-      const agent = this._framework.createSessionAgent(`feishu_${openId}`, {
-        systemPrompt: this.systemPrompt
-      })
-      this._sessionAgents.set(openId, agent)
-      console.log('[Feishu] Created new session agent for openId:', openId)
+      const message = data.message
+      const chatId = message.chat_id
+      const messageId = message.message_id
+      const openId = message.sender?.sender_id?.open_id || message.sender?.open_id || message.open_id || chatId
+      const messageType = message.message_type
+      let content = {}
 
-      // 使用 SessionPlugin 管理会话历史
-      if (this._sessionPlugin) {
-        const sessionId = `feishu_${openId}`
-        this._sessionPlugin.getOrCreateSession(sessionId, {
-          metadata: { platform: 'feishu', openId }
-        })
+      try {
+        content = message.content ? JSON.parse(message.content) : {}
+      } catch (e) {
+        return
       }
 
-      console.log(`[Feishu] Session ready for openId: ${openId}`)
-      return { agent, sessionId: `feishu_${openId}` }
-    }
+      if (messageId && this._processedMessages.has(messageId)) {
+        return
+      }
+      if (messageId) this._processedMessages.add(messageId)
 
-    /**
-     * 处理定时提醒
-     */
-    async _handleScheduledReminder(data) {
-      const { taskName, message, sessionId } = data
+      if (messageType !== 'text') return
 
-      // 构建提醒消息
-      const reminderText = `🔔 [${taskName}]\n\n${message}`
+      const text = content.text?.trim()
+      if (!text) return
 
-      // 如果有 sessionId 是 feishu 类型的，发送到对应用户
-      if (sessionId && sessionId.startsWith('feishu_')) {
-        const openId = sessionId.replace('feishu_', '')
-        try {
-          await this._sendTextMessage(openId, reminderText)
-          console.log(`[Feishu] Reminder sent to ${openId}`)
-        } catch (err) {
-          console.error(`[Feishu] Failed to send reminder:`, err.message)
-        }
-        return
-      }
+      if (!this._checkPermission(openId)) return
 
-      // 其他情况，发送到最近的 Feishu 会话
-      if (this._sessionPlugin) {
-        const allSessions = this._sessionPlugin.listSessions()
-        const feishuSessions = allSessions
-          .filter(s => s.id.startsWith('feishu_'))
-          .sort((a, b) => new Date(b.lastActive).getTime() - new Date(a.lastActive).getTime())
-
-        if (feishuSessions.length > 0) {
-          const openId = feishuSessions[0].id.replace('feishu_', '')
-          try {
-            await this._sendTextMessage(openId, reminderText)
-            console.log(`[Feishu] Reminder sent to ${openId}`)
-          } catch (err) {
-            console.error(`[Feishu] Failed to send reminder to ${openId}:`, err.message)
-          }
-        } else {
-          console.log('[Feishu] No active Feishu sessions to send reminder')
-        }
-      } else {
-        console.log('[Feishu] No active Feishu sessions to send reminder')
+      if (text.startsWith('/')) {
+        await this._handleCommand(openId, text, message)
+        return
       }
-    }
 
-    /**
-     * 发送纯文本消息（内部使用，不经过 markdown 处理）
-     */
-    async _sendTextMessage(openId, text) {
-      if (!this._client) return
+      if (this._processingLock.get(openId)) return
+      this._processingLock.set(openId, true)
 
       try {
-        await this._client.im.message.create({
-          params: {
-            receive_id_type: 'chat_id'
-          },
-          data: {
-            receive_id: openId,
-            content: JSON.stringify({ text: text }),
-            msg_type: 'text'
-          }
-        })
-      } catch (err) {
-        console.error('[Feishu] Failed to send text message:', err.message)
-        throw err
+        await this._processChat(openId, text, message)
+      } finally {
+        this._processingLock.set(openId, false)
       }
+    } catch (err) {
+      console.error('[Feishu] Error handling message:', err.message)
     }
+  }
 
-    /**
-     * 处理对话
-     */
-    async _processChat(openId, text, originalMsg) {
-      const sessionInfo = this._getSessionAgent(openId)
-      if (!sessionInfo) {
-        console.error('[Feishu] No session agent available')
-        return
-      }
+  async _handleCommand(openId, text, originalMsg) {
+    const parts = text.split(' ')
+    const command = parts[0].substring(1)
+    const args = parts.slice(1).join(' ')
+
+    switch (command.toLowerCase()) {
+      case 'start':
+      case 'help':
+        await this._sendMessage(openId,
+          '👋 欢迎使用 AI 助手！\n\n直接发送消息即可与我对话。\n\n可用命令：\n/start - 显示帮助\n/clear - 清除对话历史\n/history - 查看历史消息数',
+          originalMsg)
+        break
+      case 'clear':
+        this._clearSession(openId)
+        await this._sendMessage(openId, '✅ 对话历史已清除', originalMsg)
+        break
+      case 'history':
+        if (this._sessionPlugin) {
+          const session = this._sessionPlugin.getSession(`feishu_${openId}`)
+          const sessions = this._sessionPlugin.listSessions().filter(s => s.id.startsWith('feishu_'))
+          await this._sendMessage(openId,
+            `📊 当前状态\n\n会话数：${sessions.length}\n历史消息：${session?.messages?.length || 0}\n最后活跃：${session?.lastActive?.toLocaleString() || '无'}`,
+            originalMsg)
+        } else {
+          await this._sendMessage(openId, '❌ 会话服务不可用', originalMsg)
+        }
+        break
+      default:
+        await this._processChat(openId, text, originalMsg)
+    }
+  }
 
-      const { agent, sessionId } = sessionInfo
+  _getSessionAgent(openId) {
+    if (this._sessionAgents.has(openId)) {
+      return { agent: this._sessionAgents.get(openId), sessionId: `feishu_${openId}` }
+    }
 
-      // 使用 SessionPlugin 添加用户消息到历史
-      if (this._sessionPlugin) {
-        this._sessionPlugin.addMessage(sessionId, { role: 'user', content: text })
-      }
+    const agent = this._framework.createSessionAgent(`feishu_${openId}`, {
+      systemPrompt: this.systemPrompt
+    })
+    this._sessionAgents.set(openId, agent)
 
-      try {
-        let fullResponse = ''
-
-        // 使用流式响应
-        for await (const chunk of agent.chatStream(text, {
-          sessionId: sessionId
-        })) {
-          if (chunk.type === 'text' && chunk.text) {
-            fullResponse += chunk.text
-          }
-        }
+    if (this._sessionPlugin) {
+      this._sessionPlugin.getOrCreateSession(`feishu_${openId}`, {
+        metadata: { platform: 'feishu', openId }
+      })
+    }
 
-        // 保存助手回复到历史（使用 SessionPlugin）
-        if (this._sessionPlugin) {
-          this._sessionPlugin.addMessage(sessionId, { role: 'assistant', content: fullResponse })
-        }
+    return { agent, sessionId: `feishu_${openId}` }
+  }
 
-        // 发送回复
-        if (fullResponse) {
-          await this._sendMessage(openId, fullResponse, originalMsg)
-          console.log(`[Feishu] Reply sent (${fullResponse.length} characters)`)
-        } else {
-          await this._sendMessage(openId, '抱歉，我没有收到有效的回复。', originalMsg)
-        }
+  async _handleScheduledReminder(data) {
+    const { taskName, message, sessionId } = data
+    const reminderText = `🔔 [${taskName}]\n\n${message}`
 
+    if (sessionId && sessionId.startsWith('feishu_')) {
+      const openId = sessionId.replace('feishu_', '')
+      try {
+        await this._sendTextMessage(openId, reminderText)
       } catch (err) {
-        console.error('[Feishu] Chat error:', err)
-        await this._sendMessage(openId, `发生错误：${err.message}`, originalMsg)
+        console.error(`[Feishu] Failed to send reminder:`, err.message)
       }
+      return
     }
 
-    /**
-     * 发送消息到飞书
-     * 使用 post 富文本类型
-     */
-    async _sendMessage(openId, text, originalMsg) {
-      if (!this._client) return
+    if (this._sessionPlugin) {
+      const sessions = this._sessionPlugin.listSessions()
+        .filter(s => s.id.startsWith('feishu_'))
+        .sort((a, b) => new Date(b.lastActive).getTime() - new Date(a.lastActive).getTime())
 
-      try {
-        // 获取用户所在的聊天 ID（回复到原消息所在的聊天）
-        const chatId = originalMsg?.chat_id || originalMsg?.message?.chat_id
-        if (!chatId) {
-          console.error('[Feishu] No chat_id found for reply')
-          return
+      if (sessions.length > 0) {
+        const openId = sessions[0].id.replace('feishu_', '')
+        try {
+          await this._sendTextMessage(openId, reminderText)
+        } catch (err) {
+          console.error(`[Feishu] Failed to send reminder:`, err.message)
         }
-
-        // 暂时用 text 类型，等解决 post 权限问题后再切换
-        await this._client.im.message.create({
-          params: {
-            receive_id_type: 'chat_id'
-          },
-          data: {
-            receive_id: chatId,
-            content: JSON.stringify({ text: text }),
-            msg_type: 'text'
-          }
-        })
-      } catch (err) {
-        console.error('[Feishu] Failed to send message:', err.message, err.response?.data)
       }
     }
+  }
 
-    /**
-     * 构建飞书富文本内容
-     */
-    _buildPostContent(text) {
-      const lines = text.split('\n')
-      const paragraphs = []
-
-      for (const line of lines) {
-        if (line.trim() === '') {
-          paragraphs.push([{ tag: 'text', text: ' ' }])
-          continue
-        }
+  async _processChat(openId, text, originalMsg) {
+    const sessionInfo = this._getSessionAgent(openId)
+    if (!sessionInfo) return
 
-        const segments = []
-        let remaining = line
-
-        while (remaining.length > 0) {
-          // 匹配加粗 **text**
-          const boldMatch = remaining.match(/^\*\*(.+?)\*\*/)
-          if (boldMatch) {
-            segments.push({ tag: 'text', text: boldMatch[1], bold: true })
-            remaining = remaining.slice(boldMatch[0].length)
-            continue
-          }
-
-          // 匹配斜体 *text* 或 _text_
-          const italicMatch = remaining.match(/^\*([^*]+?)\*|^_([^_]+?)_/)
-          if (italicMatch) {
-            const italicText = italicMatch[1] !== undefined ? italicMatch[1] : italicMatch[2]
-            segments.push({ tag: 'text', text: italicText, italic: true })
-            remaining = remaining.slice(italicMatch[0].length)
-            continue
-          }
-
-          // 匹配行内代码 `code`
-          const codeMatch = remaining.match(/^`([^`]+?)`/)
-          if (codeMatch) {
-            segments.push({ tag: 'text', text: codeMatch[1], code: true })
-            remaining = remaining.slice(codeMatch[0].length)
-            continue
-          }
-
-          // 匹配删除线 ~~text~~
-          const delMatch = remaining.match(/^~~(.+?)~~/)
-          if (delMatch) {
-            segments.push({ tag: 'text', text: delMatch[1], strikethrough: true })
-            remaining = remaining.slice(delMatch[0].length)
-            continue
-          }
-
-          // 匹配链接 [text](url)
-          const linkMatch = remaining.match(/^\[([^\]]+)\]\(([^)]+)\)/)
-          if (linkMatch) {
-            segments.push({ tag: 'a', text: linkMatch[1], href: linkMatch[2] })
-            remaining = remaining.slice(linkMatch[0].length)
-            continue
-          }
-
-          // 普通文本
-          const nextSpecial = remaining.search(/(\*|_|`|~~|\[)/)
-          if (nextSpecial === -1) {
-            segments.push({ tag: 'text', text: remaining })
-            break
-          } else if (nextSpecial === 0) {
-            segments.push({ tag: 'text', text: remaining[0] })
-            remaining = remaining.slice(1)
-          } else {
-            segments.push({ tag: 'text', text: remaining.slice(0, nextSpecial) })
-            remaining = remaining.slice(nextSpecial)
-          }
-        }
+    const { agent, sessionId } = sessionInfo
+
+    if (this._sessionPlugin) {
+      this._sessionPlugin.addMessage(sessionId, { role: 'user', content: text })
+    }
 
-        if (segments.length > 0) {
-          paragraphs.push(segments)
+    try {
+      let fullResponse = ''
+      for await (const chunk of agent.chatStream(text, { sessionId })) {
+        if (chunk.type === 'text' && chunk.text) {
+          fullResponse += chunk.text
         }
       }
 
-      if (paragraphs.length === 0) {
-        paragraphs.push([{ tag: 'text', text: ' ' }])
+      if (this._sessionPlugin) {
+        this._sessionPlugin.addMessage(sessionId, { role: 'assistant', content: fullResponse })
       }
 
-      return {
-        post: {
-          zh_cn: {
-            title: '',
-            content: paragraphs
-          }
-        }
+      if (fullResponse) {
+        await this._sendMessage(openId, fullResponse, originalMsg)
+      } else {
+        await this._sendMessage(openId, '抱歉，我没有收到有效的回复。', originalMsg)
       }
+    } catch (err) {
+      console.error('[Feishu] Chat error:', err)
+      await this._sendMessage(openId, `发生错误：${err.message}`, originalMsg)
     }
+  }
 
-    /**
-     * 权限检查
-     */
-    _checkPermission(openId) {
-      if (!this.config.allowedUsers || this.config.allowedUsers.length === 0) {
-        return true
-      }
-      return this.config.allowedUsers.includes(openId)
+  async _sendTextMessage(openId, text) {
+    if (!this._client) return
+    try {
+      await this._client.im.message.create({
+        params: { receive_id_type: 'chat_id' },
+        data: {
+          receive_id: openId,
+          content: JSON.stringify({ text }),
+          msg_type: 'text'
+        }
+      })
+    } catch (err) {
+      console.error('[Feishu] Failed to send text message:', err.message)
+      throw err
     }
+  }
 
-    /**
-     * 清除会话
-     */
-    _clearSession(openId) {
-      // 清除 SessionPlugin 中的会话（会触发 session:deleted 事件）
-      if (this._sessionPlugin) {
-        const sessionId = `feishu_${openId}`
-        this._sessionPlugin.deleteSession(sessionId)
-      }
+  async _sendMessage(openId, text, originalMsg) {
+    if (!this._client) return
+    try {
+      const chatId = originalMsg?.chat_id || originalMsg?.message?.chat_id
+      if (!chatId) return
+
+      await this._client.im.message.create({
+        params: { receive_id_type: 'chat_id' },
+        data: {
+          receive_id: chatId,
+          content: JSON.stringify({ text }),
+          msg_type: 'text'
+        }
+      })
+    } catch (err) {
+      console.error('[Feishu] Failed to send message:', err.message)
     }
+  }
 
-    /**
-     * 获取插件状态
-     */
-    getStatus() {
-      // 从 SessionPlugin 获取 Feishu 相关会话
-      let sessions = []
-      if (this._sessionPlugin) {
-        const allSessions = this._sessionPlugin.listSessions()
-        sessions = allSessions
-          .filter(s => s.id.startsWith('feishu_'))
-          .map(s => ({
-            openId: s.id.replace('feishu_', ''),
-            historyLength: s.messageCount,
-            lastActive: s.lastActive
-          }))
-      }
+  _checkPermission(openId) {
+    return this.config.allowedUsers.length === 0 || this.config.allowedUsers.includes(openId)
+  }
 
-      return {
-        connected: !!this._wsClient,
-        sessionCount: sessions.length,
-        sessions,
-        config: {
-          appId: this.config.appId ? `${this.config.appId.substring(0, 10)}...` : null,
-          allowedUsersCount: this.config.allowedUsers.length
-        }
-      }
+  _clearSession(openId) {
+    if (this._sessionPlugin) {
+      this._sessionPlugin.deleteSession(`feishu_${openId}`)
     }
+  }
 
-    /**
-     * 停止客户端
-     */
-    stopClient() {
-      if (this._wsClient) {
-        try {
-          this._wsClient.close()
-        } catch (e) {
-          // ignore close error
-        }
-        this._wsClient = null
-        this._client = null
-        console.log('[Feishu] Client stopped')
+  getStatus() {
+    let sessions = []
+    if (this._sessionPlugin) {
+      sessions = this._sessionPlugin.listSessions()
+        .filter(s => s.id.startsWith('feishu_'))
+        .map(s => ({
+          openId: s.id.replace('feishu_', ''),
+          historyLength: s.messageCount,
+          lastActive: s.lastActive
+        }))
+    }
+    return {
+      connected: !!this._wsClient,
+      sessionCount: sessions.length,
+      sessions,
+      config: {
+        appId: this.config.appId ? `${this.config.appId.substring(0, 10)}...` : null,
+        allowedUsersCount: this.config.allowedUsers.length
       }
     }
+  }
 
-    /**
-     * 停止插件（实现 PluginManager 接口）
-     */
-    stop() {
-      this.stopClient()
+  stopClient() {
+    if (this._wsClient) {
+      try { this._wsClient.close() } catch (e) { /* ignore */ }
+      this._wsClient = null
+      this._client = null
+      console.log('[Feishu] Client stopped')
     }
+  }
 
-    reload(framework) {
-      this._framework = framework
-      this._initialized = false
-      this.stopClient()
-      this.start(framework)
-    }
+  stop() {
+    this.stopClient()
+  }
 
-    uninstall(framework) {
-      // 销毁所有 session agents
-      for (const agent of this._sessionAgents.values()) {
-        agent.destroy()
-      }
-      this._sessionAgents.clear()
+  reload(framework) {
+    this._framework = framework
+    this._initialized = false
+    this.stopClient()
+    this.start(framework)
+  }
 
-      // 清理去重定时器
-      if (this._messageCleanupInterval) {
-        clearInterval(this._messageCleanupInterval)
-        this._messageCleanupInterval = null
-      }
-      this._processedMessages.clear()
+  uninstall() {
+    for (const agent of this._sessionAgents.values()) {
+      agent.destroy()
+    }
+    this._sessionAgents.clear()
 
-      this.stopClient()
-      if (this._sessionPlugin && this._sessionDeleteHandler) {
-        this._sessionPlugin.off('session:deleted', this._sessionDeleteHandler)
-        this._sessionDeleteHandler = null
-      }
-      this._sessionPlugin = null
-      this._framework = null
+    if (this._messageCleanupInterval) {
+      clearInterval(this._messageCleanupInterval)
+      this._messageCleanupInterval = null
     }
+    this._processedMessages.clear()
+
+    this.stopClient()
+    if (this._sessionPlugin && this._sessionDeleteHandler) {
+      this._sessionPlugin.off('session:deleted', this._sessionDeleteHandler)
+      this._sessionDeleteHandler = null
+    }
+    this._sessionPlugin = null
+    this._framework = null
   }
 }
+
+module.exports = { FeishuPlugin }