inspiration-agent 0.0.1

package/dist/channel/feishu-connection.js

@@ -0,0 +1,238 @@
+const logger = require("../utils/logger");
+const FeishuService = require("./feishu.service");
+
+/**
+ * 飞书事件订阅管理器
+ * 使用事件订阅方式接收飞书消息
+ */
+class FeishuEventSubscription {
+  constructor() {
+    this.feishuService = new FeishuService();
+    this.aiAgent = null;
+    this.isRunning = false;
+    this.processedMessages = new Map();
+    this.MESSAGE_TTL = 3 * 60 * 1000; // 3分钟（毫秒）
+  }
+
+  /**
+   * 初始化并启动事件订阅
+   * @param {AIAgent} aiAgent - AI智能体实例
+   */
+  async init(aiAgent) {
+    this.aiAgent = aiAgent;
+    this.isRunning = true;
+
+    logger.info("正在初始化飞书事件订阅...");
+
+    this.aiAgent.setFeishuService(this.feishuService);
+
+    // 启动飞书事件订阅
+    await this.feishuService.startEventSubscription(async (content, context) => {
+      try {
+        const messageId = context.message.message_id;
+        const messageTime = parseInt(context.message.create_time, 10) || Date.now();
+        const currentTime = Date.now();
+        const chatId = context.chatId;
+
+        if (chatId && !this.aiAgent.schedulerTools.defaultChatId) {
+          this.aiAgent.schedulerTools.setDefaultChatId(chatId);
+        }
+
+        // 检查消息是否超过3分钟
+        const timeDiff = currentTime - messageTime;
+        if (timeDiff > this.MESSAGE_TTL && messageTime > 0) {
+          logger.info(
+            `消息已过期，跳过 (消息时间: ${new Date(messageTime).toISOString()}, 距今: ${Math.floor(timeDiff / 1000)}秒)`
+          );
+          return null;
+        }
+
+        // 使用消息ID去重
+        if (this.processedMessages.has(messageId)) {
+          logger.info(`消息已处理，跳过: ${messageId}`);
+          return null;
+        }
+
+        // 记录已处理的消息及其时间
+        this.processedMessages.set(messageId, currentTime);
+
+        // 清理过期的消息记录
+        this.cleanupExpiredMessages(currentTime);
+
+        // 检查是否为特殊命令
+        const trimmedContent = content.trim().toLowerCase();
+
+        if (trimmedContent === "/new") {
+          this.aiAgent.clearContext();
+          await this.feishuService.sendTextMessage(chatId, "会话上下文已清空");
+          return "会话上下文已清空";
+        }
+
+        if (trimmedContent === "/tokens") {
+          const stats = await this.aiAgent.getTokenStats();
+          if (!stats) {
+            await this.feishuService.sendTextMessage(chatId, "无法获取 token 统计信息");
+            return "无法获取 token 统计信息";
+          }
+          const formatNumber = (num) => num.toLocaleString();
+          const tokenText =
+            `========== Token 使用统计 ==========\n\n` +
+            `今日消耗 (${stats.today.date}):\n` +
+            `  输入 Token: ${formatNumber(stats.today.inputTokens)}\n` +
+            `  输出 Token: ${formatNumber(stats.today.outputTokens)}\n` +
+            `  总计 Token: ${formatNumber(stats.today.totalTokens)}\n` +
+            `  请求次数: ${formatNumber(stats.today.requestCount)}\n\n` +
+            `累计消耗:\n` +
+            `  输入 Token: ${formatNumber(stats.total.totalInputTokens)}\n` +
+            `  输出 Token: ${formatNumber(stats.total.totalOutputTokens)}\n` +
+            `  总计 Token: ${formatNumber(stats.total.totalTokens)}\n` +
+            `  请求次数: ${formatNumber(stats.total.totalRequestCount)}\n` +
+            `====================================`;
+          await this.feishuService.sendTextMessage(chatId, tokenText);
+          return tokenText;
+        }
+
+        if (trimmedContent === "/status") {
+          const status = await this.aiAgent.getStatus();
+          const statusText =
+            `========== 服务器状态 ==========\n` +
+            `状态: ${status.status}\n` +
+            `运行时间: ${status.uptime}\n` +
+            `启动时间: ${status.startTime}\n` +
+            `\n记忆:\n` +
+            `  短期记忆: ${status.memory.shortTermCount}/${status.memory.shortTermLimit}\n` +
+            `  长期记忆: ${status.memory.longTermCount}\n` +
+            `  归档队列: ${status.memory.archiveQueueLength}\n` +
+            `\n消息队列:\n` +
+            `  队列长度: ${status.queue.length}\n` +
+            `  处理中: ${status.queue.isProcessing ? "是" : "否"}\n` +
+            `  总接收: ${status.queue.stats.totalReceived}\n` +
+            `  总处理: ${status.queue.stats.totalProcessed}\n` +
+            `  总丢弃: ${status.queue.stats.totalDropped}\n` +
+            `\n配置:\n` +
+            `  流式输出: ${status.config.enableStream ? "启用" : "禁用"}\n` +
+            `  最大上下文 Token: ${status.config.maxContextTokens}\n` +
+            `  记忆过期天数: ${status.config.memoryExpiryDays}\n` +
+            `\n系统信息:\n` +
+            `  Node.js: ${status.system.nodeVersion}\n` +
+            `  平台: ${status.system.platform}\n` +
+            `  架构: ${status.system.arch}\n` +
+            `  CPU 核心数: ${status.system.cpuCores}\n` +
+            `  系统负载: ${status.system.loadAverage}\n` +
+            `  总内存: ${status.system.totalMemory}\n` +
+            `  已用内存: ${status.system.usedMemory} (${status.system.memoryUsagePercent}%)\n` +
+            `  空闲内存: ${status.system.freeMemory}\n` +
+            `\n进程信息:\n` +
+            `  PID: ${status.process.pid}\n` +
+            `  内存占用 (RSS): ${status.process.memoryRSS}\n` +
+            `  堆内存: ${status.process.memoryHeapUsed} / ${status.process.memoryHeapTotal} (${status.process.heapUsagePercent}%)\n` +
+            `  外部内存: ${status.process.memoryExternal}\n` +
+            `  CPU 用户态: ${status.process.cpuUser}ms\n` +
+            `  CPU 内核态: ${status.process.cpuSystem}ms\n` +
+            `===============================`;
+          await this.feishuService.sendTextMessage(chatId, statusText);
+          return statusText;
+        }
+
+        if (trimmedContent === "/shutdown") {
+          await this.feishuService.sendTextMessage(chatId, "服务正在停止...");
+          await this.aiAgent.shutdown();
+          return "服务正在停止...";
+        }
+
+        logger.info(`处理飞书消息: ${content}`);
+
+        const queueStatus = this.aiAgent.getQueueStatus();
+        if (queueStatus.queueLength > 0 || queueStatus.isProcessing) {
+          logger.info(
+            `消息已加入队列 (当前队列长度: ${queueStatus.queueLength}, 处理中: ${queueStatus.isProcessing})`
+          );
+        }
+
+        let responseResult = null;
+
+        const enqueued = this.aiAgent.enqueueMessage(content, "feishu", {
+          chatId: context.chatId,
+          onComplete: async (result) => {
+            logger.info(`飞书消息处理完成，发送回复到飞书`);
+            try {
+              await this.feishuService.sendTextMessage(context.chatId, result);
+              responseResult = result;
+              logger.info(`飞书回复发送成功`);
+            } catch (sendError) {
+              logger.error(`飞书回复发送失败: ${sendError.message}`);
+              responseResult = `处理完成，但回复发送失败: ${sendError.message}`;
+            }
+          },
+        });
+
+        if (!enqueued) {
+          return "系统繁忙，请稍后重试";
+        }
+
+        return new Promise((resolve) => {
+          const maxWait = 1000 * 60 * 300;
+          const startTime = Date.now();
+
+          const checkWithTimeout = async () => {
+            const status = this.aiAgent.getQueueStatus();
+            if (status.queueLength === 0 && !status.isProcessing) {
+              resolve(responseResult || "处理完成");
+            } else if (Date.now() - startTime > maxWait) {
+              resolve("处理超时，请稍后查看结果");
+            } else {
+              setTimeout(checkWithTimeout, 100);
+            }
+          };
+
+          checkWithTimeout();
+        });
+      } catch (error) {
+        logger.error(`AI处理消息失败: ${error}`);
+        return `处理消息时发生错误: ${error.message}`;
+      }
+    });
+
+    logger.info("飞书事件订阅已启动，正在监听消息...");
+  }
+
+  /**
+   * 清理过期的消息记录
+   * @param {number} currentTime - 当前时间戳
+   */
+  cleanupExpiredMessages(currentTime) {
+    const expiredThreshold = currentTime - this.MESSAGE_TTL;
+
+    for (const [messageId, processTime] of this.processedMessages.entries()) {
+      if (processTime < expiredThreshold) {
+        this.processedMessages.delete(messageId);
+      }
+    }
+
+    // 限制缓存大小，避免内存泄漏
+    if (this.processedMessages.size > 1000) {
+      const entries = Array.from(this.processedMessages.entries());
+      entries.sort((a, b) => a[1] - b[1]);
+
+      // 删除最旧的 20% 记录
+      const deleteCount = Math.floor(entries.length * 0.2);
+      for (let i = 0; i < deleteCount; i++) {
+        this.processedMessages.delete(entries[i][0]);
+      }
+    }
+  }
+
+  /**
+   * 停止事件订阅
+   */
+  async stop() {
+    if (this.isRunning) {
+      this.isRunning = false;
+      this.processedMessages.clear();
+      await this.feishuService.stopEventSubscription();
+      logger.info("飞书事件订阅已停止");
+    }
+  }
+}
+
+module.exports = FeishuEventSubscription;

package/dist/channel/feishu.service.js

@@ -0,0 +1,222 @@
+const lark = require("@larksuiteoapi/node-sdk");
+const logger = require("../utils/logger");
+
+/**
+ * 飞书服务类
+ * 负责与飞书开放平台 API 交互，使用长连接接收消息
+ */
+class FeishuService {
+  constructor() {
+    this.wsClient = null;
+    this.eventDispatcher = null;
+    this.appId = process.env.FEISHU_APP_ID;
+    this.appSecret = process.env.FEISHU_APP_SECRET;
+    this.messageHandler = null;
+  }
+
+  /**
+   * 初始化飞书 WebSocket 客户端
+   */
+  init() {
+    this.wsClient = new lark.WSClient({
+      appId: this.appId,
+      appSecret: this.appSecret,
+    });
+
+    logger.info("飞书 WebSocket 客户端初始化成功");
+  }
+
+  /**
+   * 获取飞书客户端实例
+   */
+  getClient() {
+    if (!this.wsClient) {
+      this.init();
+    }
+    return this.wsClient;
+  }
+
+  /**
+   * 启动事件订阅监听
+   * @param {Function} messageHandler - 消息处理函数
+   */
+  async startEventSubscription(messageHandler) {
+    try {
+      this.messageHandler = messageHandler;
+      const wsClient = this.getClient();
+
+      // 创建事件分发器并注册消息事件处理器
+      this.eventDispatcher = new lark.EventDispatcher({}).register({
+        "im.message.receive_v1": async (data) => {
+          logger.debug(`收到飞书消息事件，数据结构: ${JSON.stringify(data, null, 2)}`);
+          await this.handleMessageEvent(data);
+        },
+      });
+
+      // 启动 WebSocket 长连接
+      logger.info("正在启动飞书长连接...");
+      await wsClient.start({ eventDispatcher: this.eventDispatcher });
+
+      logger.info("飞书长连接已建立");
+    } catch (error) {
+      logger.error(`飞书长连接启动失败: ${error}`);
+      throw error;
+    }
+  }
+
+  /**
+   * 停止事件订阅
+   */
+  async stopEventSubscription() {
+    try {
+      if (this.wsClient) {
+        await this.wsClient.stop();
+        logger.info("飞书长连接已关闭");
+      }
+    } catch (error) {
+      logger.error(`关闭飞书长连接失败: ${error}`);
+    }
+  }
+
+  /**
+   * 发送文本消息到飞书
+   * @param {string} chatId - 聊天ID
+   * @param {string} content - 消息内容
+   * @returns {Promise<Object>} 发送结果
+   */
+  async sendTextMessage(chatId, content) {
+    try {
+      if (!content || typeof content !== "string") {
+        logger.error(`消息内容无效: ${typeof content}`);
+        throw new Error("消息内容无效");
+      }
+
+      const trimmedContent = content.trim();
+      if (trimmedContent.length === 0) {
+        logger.error("消息内容为空");
+        throw new Error("消息内容为空");
+      }
+
+      const client = new lark.Client({
+        appId: this.appId,
+        appSecret: this.appSecret,
+      });
+
+      const response = await client.im.message.create({
+        params: {
+          receive_id_type: "chat_id",
+        },
+        data: {
+          receive_id: chatId,
+          content: JSON.stringify({
+            text: trimmedContent,
+          }),
+          msg_type: "text",
+        },
+      });
+
+      logger.info(`消息发送成功: ${JSON.stringify(response.data)}`);
+      return response.data;
+    } catch (error) {
+      logger.error(`消息发送失败: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * 发送富文本消息到飞书
+   * @param {string} chatId - 聊天ID
+   * @param {string} title - 消息标题
+   * @param {string} content - 消息内容
+   * @returns {Promise<Object>} 发送结果
+   */
+  async sendRichTextMessage(chatId, title, content) {
+    try {
+      const client = new lark.Client({
+        appId: this.appId,
+        appSecret: this.appSecret,
+      });
+
+      const response = await client.im.message.create({
+        params: {
+          receive_id_type: "chat_id",
+        },
+        data: {
+          receive_id: chatId,
+          content: JSON.stringify({
+            elements: [
+              {
+                tag: "div",
+                text: {
+                  content: title,
+                  tag: "lark_md",
+                },
+              },
+              {
+                tag: "div",
+                text: {
+                  content: content,
+                  tag: "lark_md",
+                },
+              },
+            ],
+            header: {
+              template: "blue",
+              title: {
+                content: title,
+                tag: "plain_text",
+              },
+            },
+          }),
+          msg_type: "interactive",
+        },
+      });
+
+      logger.info(`富文本消息发送成功: ${response.data}`);
+      return response.data;
+    } catch (error) {
+      logger.error(`富文本消息发送失败: ${error}`);
+      throw error;
+    }
+  }
+
+  /**
+   * 处理飞书消息事件
+   * @param {Object} data - 事件数据
+   * @returns {Promise<Object>} 处理结果
+   */
+  async handleMessageEvent(data) {
+    try {
+      // 兼容不同的数据结构
+      const event = data.event || data;
+      const message = event.message;
+      const chatId = message.chat_id;
+      const content = JSON.parse(message.content).text;
+      const senderId = event.sender.sender_id.user_id;
+
+      logger.info("收到飞书消息:", {
+        chatId,
+        senderId,
+        content,
+      });
+
+      if (this.messageHandler) {
+        const replyContent = await this.messageHandler(content, {
+          chatId,
+          senderId,
+          message,
+          event,
+        });
+
+        return { success: true, chatId, senderId, replyContent };
+      }
+
+      return { success: true, chatId, senderId };
+    } catch (error) {
+      logger.error(`消息事件处理失败: ${error}`);
+      return { success: false, error: error.message };
+    }
+  }
+}
+
+module.exports = FeishuService;