inspiration-agent 0.0.1

package/dist/tools/scheduler.tools.js

@@ -0,0 +1,559 @@
+const cron = require("node-cron");
+const logger = require("../utils/logger");
+
+class SchedulerTools {
+  constructor(dbService, agentCallback, feishuService = null) {
+    this.dbService = dbService;
+    this.agentCallback = agentCallback;
+    this.feishuService = feishuService;
+    this.scheduledJobs = new Map();
+    this.defaultChatId = process.env.FEISHU_DEFAULT_CHAT_ID || null;
+  }
+
+  setFeishuService(feishuService) {
+    this.feishuService = feishuService;
+  }
+
+  setDefaultChatId(chatId) {
+    this.defaultChatId = chatId;
+  }
+
+  async init() {
+    await this.loadAndStartAllTasks();
+    logger.info("定时任务调度器已初始化");
+  }
+
+  async loadAndStartAllTasks() {
+    try {
+      const tasks = await this.dbService.getEnabledScheduledTasks();
+      for (const task of tasks) {
+        this.startTask(task);
+      }
+      logger.info(`已加载 ${tasks.length} 个启用的定时任务`);
+    } catch (error) {
+      logger.error(`加载定时任务失败: ${error.message}`);
+    }
+  }
+
+  startTask(task) {
+    if (this.scheduledJobs.has(task.id)) {
+      this.stopTask(task.id);
+    }
+
+    if (!cron.validate(task.cronExpression)) {
+      logger.error(`无效的 cron 表达式: ${task.cronExpression}`);
+      return false;
+    }
+
+    const job = cron.schedule(task.cronExpression, async () => {
+      await this.executeTask(task);
+    });
+
+    this.scheduledJobs.set(task.id, job);
+    logger.info(`定时任务已启动: ${task.name} (ID: ${task.id}, Cron: ${task.cronExpression})`);
+    return true;
+  }
+
+  stopTask(taskId) {
+    const job = this.scheduledJobs.get(taskId);
+    if (job) {
+      job.stop();
+      this.scheduledJobs.delete(taskId);
+      logger.info(`定时任务已停止: ID ${taskId}`);
+      return true;
+    }
+    return false;
+  }
+
+  async executeTask(task) {
+    logger.info(`执行定时任务: ${task.name} (ID: ${task.id})`);
+
+    try {
+      let result = null;
+      if (this.agentCallback) {
+        result = await this.agentCallback(task.prompt);
+      }
+
+      const now = new Date();
+      const nextRun = this.getNextRunTime(task.cronExpression);
+      await this.dbService.updateTaskRunInfo(task.id, now.toISOString(), nextRun);
+
+      if (result && this.feishuService && this.defaultChatId) {
+        const title = `⏰ 定时任务执行结果: ${task.name}`;
+        const content = `**执行时间:** ${now.toLocaleString("zh-CN")}\n\n**提示词:**\n${task.prompt}\n\n**执行结果:**\n${result}`;
+
+        try {
+          await this.feishuService.sendRichTextMessage(this.defaultChatId, title, content);
+          logger.info(`定时任务结果已发送到飞书: ${task.name}`);
+        } catch (sendError) {
+          logger.error(`发送定时任务结果到飞书失败: ${sendError.message}`);
+        }
+      }
+
+      logger.info(`定时任务执行完成: ${task.name}`);
+    } catch (error) {
+      logger.error(`定时任务执行失败: ${task.name} - ${error.message}`);
+
+      if (this.feishuService && this.defaultChatId) {
+        try {
+          const errorTitle = `❌ 定时任务执行失败: ${task.name}`;
+          const errorContent = `**执行时间:** ${new Date().toLocaleString("zh-CN")}\n\n**错误信息:**\n${error.message}`;
+          await this.feishuService.sendRichTextMessage(
+            this.defaultChatId,
+            errorTitle,
+            errorContent
+          );
+        } catch (sendError) {
+          logger.error(`发送错误信息到飞书失败: ${sendError.message}`);
+        }
+      }
+    }
+  }
+
+  getNextRunTime(cronExpression) {
+    try {
+      const interval = cron.parseExpression(cronExpression);
+      const next = interval.next();
+      return next.toISOString();
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async createScheduledTask(args) {
+    try {
+      const { name, description, cronExpression, prompt, enabled = true } = args;
+
+      if (!name || !cronExpression || !prompt) {
+        return {
+          success: false,
+          error: "缺少必要参数: name, cronExpression, prompt",
+          message: "创建定时任务失败: 缺少必要参数",
+        };
+      }
+
+      if (!cron.validate(cronExpression)) {
+        return {
+          success: false,
+          error: `无效的 cron 表达式: ${cronExpression}`,
+          message: "创建定时任务失败: 无效的 cron 表达式",
+        };
+      }
+
+      const nextRunAt = this.getNextRunTime(cronExpression);
+
+      const result = await this.dbService.saveScheduledTask({
+        name,
+        description: description || "",
+        cronExpression,
+        prompt,
+        enabled,
+        nextRunAt,
+      });
+
+      if (enabled) {
+        const task = await this.dbService.getScheduledTaskById(result.id);
+        this.startTask(task);
+      }
+
+      return {
+        success: true,
+        id: result.id,
+        name,
+        cronExpression,
+        nextRunAt,
+        message: `成功创建定时任务: ${name} (ID: ${result.id})，下次执行时间: ${nextRunAt || "未知"}`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        message: `创建定时任务失败: ${error.message}`,
+      };
+    }
+  }
+
+  async getAllScheduledTasks(args) {
+    try {
+      const tasks = await this.dbService.getAllScheduledTasks();
+
+      const taskList = tasks.map((task) => ({
+        id: task.id,
+        name: task.name,
+        description: task.description,
+        cronExpression: task.cronExpression,
+        prompt: task.prompt,
+        enabled: task.enabled,
+        lastRunAt: task.lastRunAt,
+        nextRunAt: task.nextRunAt,
+        runCount: task.runCount,
+        isRunning: this.scheduledJobs.has(task.id),
+      }));
+
+      return {
+        success: true,
+        count: taskList.length,
+        tasks: taskList,
+        message: `成功获取 ${taskList.length} 个定时任务`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        message: `获取定时任务列表失败: ${error.message}`,
+      };
+    }
+  }
+
+  async getScheduledTask(args) {
+    try {
+      const { id } = args;
+
+      if (!id) {
+        return {
+          success: false,
+          error: "缺少 id 参数",
+          message: "获取定时任务失败: 缺少 id 参数",
+        };
+      }
+
+      const task = await this.dbService.getScheduledTaskById(id);
+
+      if (!task) {
+        return {
+          success: false,
+          error: "未找到指定的定时任务",
+          message: `获取定时任务失败: ID ${id} 的定时任务不存在`,
+        };
+      }
+
+      return {
+        success: true,
+        task: {
+          ...task,
+          isRunning: this.scheduledJobs.has(task.id),
+        },
+        message: `成功获取定时任务: ${task.name} (ID: ${task.id})`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        message: `获取定时任务失败: ${error.message}`,
+      };
+    }
+  }
+
+  async updateScheduledTask(args) {
+    try {
+      const { id, name, description, cronExpression, prompt, enabled } = args;
+
+      if (!id) {
+        return {
+          success: false,
+          error: "缺少 id 参数",
+          message: "更新定时任务失败: 缺少 id 参数",
+        };
+      }
+
+      const existingTask = await this.dbService.getScheduledTaskById(id);
+      if (!existingTask) {
+        return {
+          success: false,
+          error: "未找到指定的定时任务",
+          message: `更新定时任务失败: ID ${id} 的定时任务不存在`,
+        };
+      }
+
+      if (cronExpression && !cron.validate(cronExpression)) {
+        return {
+          success: false,
+          error: `无效的 cron 表达式: ${cronExpression}`,
+          message: "更新定时任务失败: 无效的 cron 表达式",
+        };
+      }
+
+      const newCronExpression = cronExpression || existingTask.cronExpression;
+      const nextRunAt = this.getNextRunTime(newCronExpression);
+
+      const updateData = {};
+      if (name !== undefined) updateData.name = name;
+      if (description !== undefined) updateData.description = description;
+      if (cronExpression !== undefined) updateData.cronExpression = cronExpression;
+      if (prompt !== undefined) updateData.prompt = prompt;
+      if (enabled !== undefined) updateData.enabled = enabled;
+      updateData.nextRunAt = nextRunAt;
+
+      await this.dbService.updateScheduledTask(id, updateData);
+
+      this.stopTask(id);
+
+      const newEnabled = enabled !== undefined ? enabled : existingTask.enabled;
+      if (newEnabled) {
+        const updatedTask = await this.dbService.getScheduledTaskById(id);
+        this.startTask(updatedTask);
+      }
+
+      return {
+        success: true,
+        id,
+        name: name || existingTask.name,
+        message: `成功更新定时任务 (ID: ${id})`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        message: `更新定时任务失败: ${error.message}`,
+      };
+    }
+  }
+
+  async deleteScheduledTask(args) {
+    try {
+      const { id } = args;
+
+      if (!id) {
+        return {
+          success: false,
+          error: "缺少 id 参数",
+          message: "删除定时任务失败: 缺少 id 参数",
+        };
+      }
+
+      const task = await this.dbService.getScheduledTaskById(id);
+      if (!task) {
+        return {
+          success: false,
+          error: "未找到指定的定时任务",
+          message: `删除定时任务失败: ID ${id} 的定时任务不存在`,
+        };
+      }
+
+      this.stopTask(id);
+
+      const result = await this.dbService.deleteScheduledTask(id);
+
+      if (!result.deleted) {
+        return {
+          success: false,
+          error: "删除失败",
+          message: `删除定时任务失败: ID ${id}`,
+        };
+      }
+
+      return {
+        success: true,
+        id,
+        name: task.name,
+        message: `成功删除定时任务: ${task.name} (ID: ${id})`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        message: `删除定时任务失败: ${error.message}`,
+      };
+    }
+  }
+
+  async toggleScheduledTask(args) {
+    try {
+      const { id, enabled } = args;
+
+      if (!id || enabled === undefined) {
+        return {
+          success: false,
+          error: "缺少必要参数: id 或 enabled",
+          message: "切换定时任务状态失败: 缺少必要参数",
+        };
+      }
+
+      const task = await this.dbService.getScheduledTaskById(id);
+      if (!task) {
+        return {
+          success: false,
+          error: "未找到指定的定时任务",
+          message: `切换定时任务状态失败: ID ${id} 的定时任务不存在`,
+        };
+      }
+
+      const nextRunAt = enabled ? this.getNextRunTime(task.cronExpression) : null;
+
+      await this.dbService.updateScheduledTask(id, { enabled, nextRunAt });
+
+      if (enabled) {
+        this.startTask(task);
+      } else {
+        this.stopTask(id);
+      }
+
+      return {
+        success: true,
+        id,
+        name: task.name,
+        enabled,
+        message: `成功${enabled ? "启用" : "禁用"}定时任务: ${task.name} (ID: ${id})`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        message: `切换定时任务状态失败: ${error.message}`,
+      };
+    }
+  }
+
+  stopAllTasks() {
+    for (const [id, job] of this.scheduledJobs) {
+      job.stop();
+    }
+    this.scheduledJobs.clear();
+    logger.info("所有定时任务已停止");
+  }
+
+  getFunctionDefinitions() {
+    return [
+      {
+        type: "function",
+        function: {
+          name: "create_scheduled_task",
+          description:
+            "创建一个新的定时任务，定时发起 AI Agent 调用。cron 表达式格式: 秒 分 时 日 月 星期 (例如: '0 9 * * *' 表示每天早上9点执行)",
+          parameters: {
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "定时任务名称",
+              },
+              description: {
+                type: "string",
+                description: "定时任务描述",
+              },
+              cronExpression: {
+                type: "string",
+                description:
+                  "Cron 表达式，格式: 秒 分 时 日 月 星期。例如: '0 9 * * *' 每天早上9点, '0 */30 * * * *' 每30分钟, '0 9 * * 1-5' 工作日早上9点",
+              },
+              prompt: {
+                type: "string",
+                description: "定时任务执行时发送给 AI Agent 的提示词/指令",
+              },
+              enabled: {
+                type: "boolean",
+                description: "是否启用该定时任务，默认为 true",
+              },
+            },
+            required: ["name", "cronExpression", "prompt"],
+          },
+        },
+      },
+      {
+        type: "function",
+        function: {
+          name: "get_all_scheduled_tasks",
+          description: "查询所有定时任务",
+          parameters: {
+            type: "object",
+            properties: {},
+          },
+        },
+      },
+      {
+        type: "function",
+        function: {
+          name: "get_scheduled_task",
+          description: "根据 ID 查询单个定时任务详情",
+          parameters: {
+            type: "object",
+            properties: {
+              id: {
+                type: "integer",
+                description: "定时任务 ID",
+              },
+            },
+            required: ["id"],
+          },
+        },
+      },
+      {
+        type: "function",
+        function: {
+          name: "update_scheduled_task",
+          description: "更新定时任务配置",
+          parameters: {
+            type: "object",
+            properties: {
+              id: {
+                type: "integer",
+                description: "定时任务 ID",
+              },
+              name: {
+                type: "string",
+                description: "新的任务名称",
+              },
+              description: {
+                type: "string",
+                description: "新的任务描述",
+              },
+              cronExpression: {
+                type: "string",
+                description: "新的 Cron 表达式",
+              },
+              prompt: {
+                type: "string",
+                description: "新的提示词/指令",
+              },
+              enabled: {
+                type: "boolean",
+                description: "是否启用",
+              },
+            },
+            required: ["id"],
+          },
+        },
+      },
+      {
+        type: "function",
+        function: {
+          name: "delete_scheduled_task",
+          description: "删除指定的定时任务",
+          parameters: {
+            type: "object",
+            properties: {
+              id: {
+                type: "integer",
+                description: "要删除的定时任务 ID",
+              },
+            },
+            required: ["id"],
+          },
+        },
+      },
+      {
+        type: "function",
+        function: {
+          name: "toggle_scheduled_task",
+          description: "启用或禁用定时任务",
+          parameters: {
+            type: "object",
+            properties: {
+              id: {
+                type: "integer",
+                description: "定时任务 ID",
+              },
+              enabled: {
+                type: "boolean",
+                description: "true 启用，false 禁用",
+              },
+            },
+            required: ["id", "enabled"],
+          },
+        },
+      },
+    ];
+  }
+}
+
+module.exports = SchedulerTools;