koishi-plugin-maple-schedule 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,28 @@
+import { Context, Schema } from 'koishi';
+export declare const name = "maple-schedule";
+export declare const using: readonly ["database"];
+interface ScheduleTask {
+    id: number;
+    platform: string;
+    botId: string;
+    channelId: string | null;
+    userId: string;
+    content: string;
+    nextExecutionTime: Date;
+    intervalMs: number | null;
+}
+declare module 'koishi' {
+    interface Tables {
+        'maple-schedule-tasks': ScheduleTask;
+    }
+}
+export interface Config {
+    maxContentLength: number;
+    maxPreviewLength: number;
+    sendInterval: number;
+    scanInterval: number;
+    timeTolerance: number;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;
+export {};

package/lib/index.js

@@ -0,0 +1,445 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  name: () => name,
+  using: () => using
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var name = "maple-schedule";
+var using = ["database"];
+var Config = import_koishi.Schema.object({
+  maxContentLength: import_koishi.Schema.number().default(500).min(50).max(2e3).description("任务内容最大长度（字）（50-2000）"),
+  maxPreviewLength: import_koishi.Schema.number().default(8).min(3).max(50).description("定时列表最大预览长度（字）（3-50）"),
+  sendInterval: import_koishi.Schema.number().default(1e3).min(100).max(1e4).description("任务发送间隔（毫秒）（100-10000）"),
+  scanInterval: import_koishi.Schema.number().default(1).min(1).max(86400).description("检查器扫描时间（秒）（1-86400）"),
+  timeTolerance: import_koishi.Schema.number().default(30).min(1).max(3600).description("定时时间容错（秒）（1-3600）")
+});
+function parseTimeToMs(timeStr) {
+  if (!timeStr) return null;
+  const regex = /^(\d+)([smhd])$/i;
+  const match = timeStr.match(regex);
+  if (!match) return null;
+  const value = parseInt(match[1]);
+  const unit = match[2].toLowerCase();
+  switch (unit) {
+    case "s":
+      return value * 1e3;
+    case "m":
+      return value * 60 * 1e3;
+    case "h":
+      return value * 60 * 60 * 1e3;
+    case "d":
+      return value * 24 * 60 * 60 * 1e3;
+    default:
+      return null;
+  }
+}
+__name(parseTimeToMs, "parseTimeToMs");
+function parseCombinedTimeToMs(timeStr) {
+  const regex = /(\d+)([smhd])/gi;
+  let totalMs = 0;
+  let match;
+  while ((match = regex.exec(timeStr)) !== null) {
+    const value = parseInt(match[1]);
+    const unit = match[2].toLowerCase();
+    switch (unit) {
+      case "s":
+        totalMs += value * 1e3;
+        break;
+      case "m":
+        totalMs += value * 60 * 1e3;
+        break;
+      case "h":
+        totalMs += value * 60 * 60 * 1e3;
+        break;
+      case "d":
+        totalMs += value * 24 * 60 * 60 * 1e3;
+        break;
+      default:
+        return null;
+    }
+  }
+  return totalMs > 0 ? totalMs : null;
+}
+__name(parseCombinedTimeToMs, "parseCombinedTimeToMs");
+function parseAbsoluteTime(timeStr, baseDate = /* @__PURE__ */ new Date()) {
+  try {
+    const result = new Date(baseDate);
+    if (/^\d{1,2}:\d{2}$/.test(timeStr)) {
+      const [hours, minutes] = timeStr.split(":").map(Number);
+      if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
+        return null;
+      }
+      result.setHours(hours, minutes, 0, 0);
+      if (result <= baseDate) {
+        result.setDate(result.getDate() + 1);
+      }
+      return result;
+    }
+    if (/^\d{1,2}\.\d{1,2},\d{1,2}:\d{2}$/.test(timeStr)) {
+      const [datePart, timePart] = timeStr.split(",");
+      const [month, day] = datePart.split(".").map(Number);
+      const [hours, minutes] = timePart.split(":").map(Number);
+      if (month < 1 || month > 12 || day < 1 || day > 31 || hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
+        return null;
+      }
+      result.setMonth(month - 1, day);
+      result.setHours(hours, minutes, 0, 0);
+      if (result <= baseDate) {
+        result.setFullYear(result.getFullYear() + 1);
+      }
+      return result;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+__name(parseAbsoluteTime, "parseAbsoluteTime");
+function formatDateTime(date) {
+  const month = (date.getMonth() + 1).toString().padStart(2, "0");
+  const day = date.getDate().toString().padStart(2, "0");
+  const hours = date.getHours().toString().padStart(2, "0");
+  const minutes = date.getMinutes().toString().padStart(2, "0");
+  const seconds = date.getSeconds().toString().padStart(2, "0");
+  return `${month}/${day} ${hours}:${minutes}:${seconds}`;
+}
+__name(formatDateTime, "formatDateTime");
+function formatInterval(intervalMs) {
+  const days = Math.floor(intervalMs / (24 * 60 * 60 * 1e3));
+  const hours = Math.floor(intervalMs % (24 * 60 * 60 * 1e3) / (60 * 60 * 1e3));
+  const minutes = Math.floor(intervalMs % (60 * 60 * 1e3) / (60 * 1e3));
+  const seconds = Math.floor(intervalMs % (60 * 1e3) / 1e3);
+  const parts = [];
+  if (days > 0) parts.push(`${days}天`);
+  if (hours > 0) parts.push(`${hours}小时`);
+  if (minutes > 0) parts.push(`${minutes}分钟`);
+  if (seconds > 0) parts.push(`${seconds}秒`);
+  return parts.join("");
+}
+__name(formatInterval, "formatInterval");
+function calculateNextExecutionTime(timeExpression, baseDate = /* @__PURE__ */ new Date()) {
+  try {
+    const hasInterval = timeExpression.includes("/");
+    if (hasInterval) {
+      const [initialPart, intervalPart] = timeExpression.split("/");
+      let initialTime;
+      const initialMs = parseTimeToMs(initialPart) || parseCombinedTimeToMs(initialPart);
+      if (initialMs) {
+        initialTime = new Date(baseDate.getTime() + initialMs);
+      } else {
+        initialTime = parseAbsoluteTime(initialPart, baseDate);
+        if (!initialTime) return null;
+      }
+      const intervalMs = parseTimeToMs(intervalPart) || parseCombinedTimeToMs(intervalPart);
+      if (!intervalMs) return null;
+      let nextTime = initialTime;
+      while (nextTime <= baseDate) {
+        nextTime = new Date(nextTime.getTime() + intervalMs);
+      }
+      return { nextTime, intervalMs };
+    } else {
+      let nextTime;
+      const ms = parseTimeToMs(timeExpression) || parseCombinedTimeToMs(timeExpression);
+      if (ms) {
+        nextTime = new Date(baseDate.getTime() + ms);
+      } else {
+        nextTime = parseAbsoluteTime(timeExpression, baseDate);
+        if (!nextTime) return null;
+      }
+      return { nextTime, intervalMs: null };
+    }
+  } catch {
+    return null;
+  }
+}
+__name(calculateNextExecutionTime, "calculateNextExecutionTime");
+function getContentPreview(content, maxLength) {
+  if (content.length <= maxLength) {
+    return content;
+  }
+  return content.substring(0, maxLength) + "...";
+}
+__name(getContentPreview, "getContentPreview");
+function apply(ctx, config) {
+  ctx.logger("maple-schedule").info("定时任务插件加载中...");
+  ctx.model.extend("maple-schedule-tasks", {
+    id: "unsigned",
+    platform: "string",
+    botId: "string",
+    channelId: "string",
+    userId: "string",
+    content: "text",
+    nextExecutionTime: "timestamp",
+    intervalMs: "integer"
+  }, {
+    primary: "id",
+    autoInc: true
+  });
+  let timer;
+  let isChecking = false;
+  async function checkAndExecuteTasks() {
+    if (isChecking) {
+      ctx.logger("maple-schedule").debug("任务扫描正在进行中，跳过本次扫描");
+      return;
+    }
+    isChecking = true;
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const expiredTasks = await ctx.database.get("maple-schedule-tasks", {
+        nextExecutionTime: { $lte: now }
+      });
+      if (expiredTasks.length === 0) {
+        ctx.logger("maple-schedule").debug("没有找到到期任务");
+        return;
+      }
+      expiredTasks.sort((a, b) => a.nextExecutionTime.getTime() - b.nextExecutionTime.getTime());
+      ctx.logger("maple-schedule").info(`找到 ${expiredTasks.length} 个到期任务，开始依次发送...`);
+      const toleranceMs = config.timeTolerance * 1e3;
+      ctx.logger("maple-schedule").debug(`当前时间容错: ${config.timeTolerance} 秒 (${toleranceMs} 毫秒)`);
+      for (let i = 0; i < expiredTasks.length; i++) {
+        const task = expiredTasks[i];
+        try {
+          const taskTime = task.nextExecutionTime;
+          const shouldHaveTime = formatDateTime(taskTime);
+          const timeDiff = now.getTime() - taskTime.getTime();
+          const isOverdue = timeDiff > toleranceMs;
+          if (isOverdue) {
+            ctx.logger("maple-schedule").info(`执行任务 #${task.id}，本应在 ${shouldHaveTime} 执行`);
+          } else {
+            ctx.logger("maple-schedule").info(`执行任务 #${task.id}，按时在 ${shouldHaveTime} 执行`);
+          }
+          const botId = `${task.platform}:${task.botId}`;
+          const bot = ctx.bots.find(
+            (bot2) => bot2.sid === botId || bot2.platform === task.platform && bot2.selfId === task.botId
+          );
+          if (!bot) {
+            ctx.logger("maple-schedule").warn(`机器人 ${botId} 不存在，跳过任务 #${task.id}`);
+            continue;
+          }
+          let messageContent = task.content;
+          if (isOverdue) {
+            messageContent = `过期任务: 本应在 ${shouldHaveTime} 执行
+${task.content}`;
+          }
+          if (task.channelId) {
+            await bot.sendMessage(task.channelId, messageContent);
+            ctx.logger("maple-schedule").info(`任务 #${task.id} 已在群聊 ${task.channelId} 执行`);
+          } else {
+            await bot.sendPrivateMessage(task.userId, messageContent);
+            ctx.logger("maple-schedule").info(`任务 #${task.id} 已向用户 ${task.userId} 执行`);
+          }
+          if (task.intervalMs) {
+            let nextTime = new Date(task.nextExecutionTime);
+            let skippedCount = 0;
+            while (nextTime <= now) {
+              nextTime = new Date(nextTime.getTime() + task.intervalMs);
+              skippedCount++;
+            }
+            if (skippedCount > 1) {
+              ctx.logger("maple-schedule").info(`任务 #${task.id} 跳过了 ${skippedCount - 1} 次已过期循环`);
+            }
+            await ctx.database.set("maple-schedule-tasks", { id: task.id }, {
+              nextExecutionTime: nextTime
+            });
+            ctx.logger("maple-schedule").info(`任务 #${task.id} 下次执行时间更新为: ${formatDateTime(nextTime)}`);
+          } else {
+            await ctx.database.remove("maple-schedule-tasks", { id: task.id });
+            ctx.logger("maple-schedule").info(`一次性任务 #${task.id} 已执行并删除`);
+          }
+          if (i < expiredTasks.length - 1 && config.sendInterval > 0) {
+            ctx.logger("maple-schedule").info(`等待 ${config.sendInterval} 毫秒后发送下一个任务...`);
+            await new Promise((resolve) => setTimeout(resolve, config.sendInterval));
+          }
+        } catch (error) {
+          ctx.logger("maple-schedule").error(`执行定时任务 #${task.id} 时出错:`, error);
+        }
+      }
+      if (expiredTasks.length > 0) {
+        ctx.logger("maple-schedule").info(`已处理完 ${expiredTasks.length} 个到期任务`);
+      }
+    } catch (error) {
+      ctx.logger("maple-schedule").error("检查定时任务时出错:", error);
+    } finally {
+      isChecking = false;
+      ctx.logger("maple-schedule").debug("任务扫描已完成，互斥锁已释放");
+    }
+  }
+  __name(checkAndExecuteTasks, "checkAndExecuteTasks");
+  ctx.command("定时", "定时任务相关指令").action(({ session }) => {
+    return session.execute("help 定时");
+  });
+  ctx.command("定时/定时任务 <timeExpression:string> <content:text>", "创建定时任务").alias("定时任务").example("定时任务 1m 该喝水啦！").example("定时任务 10:00 起床时间到！").action(async ({ session }, timeExpression, content) => {
+    try {
+      if (!content || content.trim().length === 0) {
+        return "任务内容不能为空！\n格式：定时任务 时间 任务内容\n示例：定时任务 1m 该喝水啦！";
+      }
+      const trimmedContent = content.trim();
+      if (trimmedContent.length > config.maxContentLength) {
+        return `任务内容太长了！最多只能输入${config.maxContentLength}个字（当前: ${trimmedContent.length}）。`;
+      }
+      if (!timeExpression || timeExpression.trim().length === 0) {
+        return "时间表达式不能为空！\n格式：定时任务 时间 任务内容\n示例：定时任务 1m 该喝水啦！";
+      }
+      const result = calculateNextExecutionTime(timeExpression.trim());
+      if (!result) {
+        return "时间表达式格式错误！\n支持的格式：\n1m (1分钟后)\n2h30m (2小时30分钟后)\n10:00 (今天10点)\n12.23,23:00 (12月23日23点)\n1m/10s (1分钟后每隔10秒)\n10:00/1d (从今天起每天10点)";
+      }
+      const newTask = await ctx.database.create("maple-schedule-tasks", {
+        platform: session.platform,
+        botId: session.bot.selfId,
+        channelId: session.channelId,
+        userId: session.userId,
+        content: trimmedContent,
+        nextExecutionTime: result.nextTime,
+        intervalMs: result.intervalMs
+      });
+      const timeDisplay = formatDateTime(result.nextTime);
+      const taskType = result.intervalMs ? "循环任务" : "一次性任务";
+      let intervalDisplay = "";
+      if (result.intervalMs) {
+        intervalDisplay = `
+循环间隔: 每${formatInterval(result.intervalMs)}`;
+      }
+      ctx.logger("maple-schedule").info(`用户 ${session.userId} 创建了定时任务 #${newTask.id}`);
+      ctx.logger("maple-schedule").info(`任务 #${newTask.id} 类型: ${taskType}, 执行时间: ${timeDisplay}`);
+      return `定时任务创建成功！
+任务ID: #${newTask.id}
+任务类型: ${taskType}
+执行时间: ${timeDisplay}${intervalDisplay}
+任务内容: ${trimmedContent}`;
+    } catch (error) {
+      ctx.logger("maple-schedule").error("创建定时任务时出错:", error);
+      return "创建定时任务时出错了，请稍后再试。";
+    }
+  });
+  ctx.command("定时/定时列表 [page:number]", "查看当前聊天中的所有定时任务").alias("定时列表").example("定时列表").example("定时列表 2").action(async ({ session }, page = 1) => {
+    try {
+      if (page < 1) {
+        return "页码必须是正整数！";
+      }
+      const query = {
+        platform: session.platform,
+        botId: session.bot.selfId
+      };
+      if (session.channelId) {
+        query.channelId = session.channelId;
+      } else {
+        query.userId = session.userId;
+        query.channelId = null;
+      }
+      const tasks = await ctx.database.get("maple-schedule-tasks", query);
+      if (tasks.length === 0) {
+        return '当前聊天中没有定时任务。\n使用"定时任务"指令创建一个吧！';
+      }
+      tasks.sort((a, b) => a.nextExecutionTime.getTime() - b.nextExecutionTime.getTime());
+      const pageSize = 10;
+      const totalPages = Math.ceil(tasks.length / pageSize);
+      if (page > totalPages) {
+        return `只有 ${totalPages} 页定时任务，请输入 1-${totalPages} 之间的页码。`;
+      }
+      const startIndex = (page - 1) * pageSize;
+      const endIndex = Math.min(startIndex + pageSize, tasks.length);
+      const currentPageTasks = tasks.slice(startIndex, endIndex);
+      let output = `【定时任务列表】第 ${page}/${totalPages} 页（共 ${tasks.length} 条）
+
+`;
+      currentPageTasks.forEach((task, index) => {
+        const displayIndex = startIndex + index + 1;
+        const timeDisplay = formatDateTime(task.nextExecutionTime);
+        const contentPreview = getContentPreview(task.content, config.maxPreviewLength);
+        let intervalInfo = "";
+        if (task.intervalMs) {
+          intervalInfo = `(每${formatInterval(task.intervalMs)}) `;
+        }
+        output += `${displayIndex}. #${task.id} ${timeDisplay}${intervalInfo}${contentPreview}
+`;
+      });
+      output += "\n──────────\n";
+      if (page > 1) {
+        output += `输入"定时列表 ${page - 1}"查看上一页
+`;
+      }
+      if (page < totalPages) {
+        output += `输入"定时列表 ${page + 1}"查看下一页
+`;
+      }
+      output += `输入"删除定时 编号"删除任务`;
+      return output.trim();
+    } catch (error) {
+      ctx.logger("maple-schedule").error("查看定时列表时出错:", error);
+      return "查看定时列表时出错了，请稍后再试。";
+    }
+  });
+  ctx.command("定时/删除定时 <id:number>", "删除指定编号的定时任务").alias("删除定时").example("删除定时 1").action(async ({ session }, id) => {
+    try {
+      if (!id) {
+        return '请提供任务编号！\n格式：删除定时 编号\n可以发送"定时列表"查看所有任务编号。';
+      }
+      const tasks = await ctx.database.get("maple-schedule-tasks", { id });
+      if (tasks.length === 0) {
+        return `没有找到ID为 #${id} 的定时任务。
+可以发送"定时列表"查看所有任务编号。`;
+      }
+      const task = tasks[0];
+      const timeDisplay = formatDateTime(task.nextExecutionTime);
+      const contentPreview = task.content.length > 50 ? task.content.substring(0, 50) + "..." : task.content;
+      ctx.logger("maple-schedule").info(`用户 ${session.userId} 删除了定时任务 #${id}`);
+      await ctx.database.remove("maple-schedule-tasks", { id });
+      return `已成功删除定时任务 #${id}
+执行时间: ${timeDisplay}
+任务内容: ${contentPreview}`;
+    } catch (error) {
+      ctx.logger("maple-schedule").error("删除定时任务时出错:", error);
+      return "删除定时任务时出错了，请稍后再试。";
+    }
+  });
+  ctx.on("ready", async () => {
+    ctx.logger("maple-schedule").info("定时任务插件已加载完成");
+    ctx.logger("maple-schedule").info(`任务内容最大长度: ${config.maxContentLength} 字`);
+    ctx.logger("maple-schedule").info(`定时列表最大预览长度: ${config.maxPreviewLength} 字`);
+    ctx.logger("maple-schedule").info(`任务发送间隔: ${config.sendInterval} 毫秒`);
+    ctx.logger("maple-schedule").info(`检查器扫描时间: ${config.scanInterval} 秒`);
+    ctx.logger("maple-schedule").info(`定时时间容错: ${config.timeTolerance} 秒`);
+    const scanIntervalMs = config.scanInterval * 1e3;
+    timer = setInterval(checkAndExecuteTasks, scanIntervalMs);
+    ctx.logger("maple-schedule").info(`定时任务检查器已启动，扫描间隔: ${config.scanInterval} 秒`);
+    await checkAndExecuteTasks();
+  });
+  ctx.on("dispose", () => {
+    if (timer) {
+      clearInterval(timer);
+      ctx.logger("maple-schedule").info("定时任务检查器已停止");
+    }
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  name,
+  using
+});

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "koishi-plugin-maple-schedule",
+  "description": "-",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "maple"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.18.7"
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-maple-schedule
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-maple-schedule?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-maple-schedule)
+
+-