koishi-plugin-xxfd-1 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,25 @@
+import { Context, Schema } from 'koishi';
+declare module 'koishi' {
+    interface Tables {
+        repeater_record: RepeaterRecord;
+    }
+}
+export declare const name = "xxfd-1";
+interface RepeaterRecord {
+    id?: number;
+    message: string;
+    targetGroup: string;
+    sendTime: number;
+    createdAt: number;
+}
+export interface Config {
+    countFrequency: number;
+    receiveGroups: string[];
+    sendGroups: string[];
+    blockUsers: string[];
+    minDelay: number;
+    maxDelay: number;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;
+export {};

package/lib/index.js

@@ -0,0 +1,116 @@
+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
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var name = "xxfd-1";
+var Config = import_koishi.Schema.object({
+  countFrequency: import_koishi.Schema.number().default(100).required().description("计数频率（每N条消息触发一次复读）"),
+  receiveGroups: import_koishi.Schema.array(import_koishi.Schema.string()).required().description("接收消息的群聊列表（填写群号）"),
+  sendGroups: import_koishi.Schema.array(import_koishi.Schema.string()).required().description("发送复读消息的群聊列表（填写群号）"),
+  blockUsers: import_koishi.Schema.array(import_koishi.Schema.string()).default([]).description("屏蔽消息的QQ号列表（不统计这些人的消息）"),
+  minDelay: import_koishi.Schema.number().default(3).required().description("复读延迟最低时间（单位：秒）"),
+  maxDelay: import_koishi.Schema.number().default(600).required().description("复读延迟最高时间（单位：秒，默认10分钟=600秒）")
+}).description("复读计数插件配置");
+function apply(ctx, config) {
+  if (config.minDelay > config.maxDelay) {
+    ctx.logger("repeater").error("配置错误：复读延迟最低时间不能大于最高时间！");
+    return;
+  }
+  if (!config.receiveGroups.length || !config.sendGroups.length) {
+    ctx.logger("repeater").error("配置错误：接收/发送群聊列表不能为空！");
+    return;
+  }
+  ctx.model.extend("repeater_record", {
+    id: "unsigned",
+    message: "text",
+    targetGroup: "string",
+    sendTime: "unsigned",
+    createdAt: "unsigned"
+  }, {
+    primary: "id",
+    autoInc: true
+  });
+  let messageCount = 0;
+  const sendingTasks = /* @__PURE__ */ new Map();
+  ctx.on("message", async (session) => {
+    try {
+      if (!session.guildId) return;
+      if (!config.receiveGroups.includes(session.guildId)) return;
+      if (config.blockUsers.includes(session.userId ?? "")) return;
+      const rawContent = session.content ?? "";
+      const originalMsg = rawContent;
+      if (!originalMsg) return;
+      messageCount++;
+      ctx.logger("repeater").info(`当前计数：${messageCount}/${config.countFrequency}`);
+      if (messageCount >= config.countFrequency) {
+        messageCount = 0;
+        const delaySeconds = Math.floor(Math.random() * (config.maxDelay - config.minDelay + 1)) + config.minDelay;
+        const sendTimestamp = Date.now() + delaySeconds * 1e3;
+        const randomGroup = config.sendGroups[Math.floor(Math.random() * config.sendGroups.length)];
+        const bot = session.bot;
+        if (!bot) return;
+        const record = await ctx.database.create("repeater_record", {
+          message: originalMsg,
+          targetGroup: randomGroup,
+          sendTime: sendTimestamp,
+          createdAt: Date.now()
+        });
+        ctx.logger("repeater").info(
+          `已触发复读！消息：${originalMsg.slice(0, 20)}... | 延迟：${delaySeconds}s | 目标群：${randomGroup}`
+        );
+        const taskId = record.id;
+        const timeout = setTimeout(async () => {
+          try {
+            await bot.sendMessage(randomGroup, originalMsg);
+            ctx.logger("repeater").info(`复读成功！群：${randomGroup}，内容：${originalMsg.slice(0, 20)}...`);
+            await ctx.database.remove("repeater_record", { id: taskId });
+          } catch (err) {
+            ctx.logger("repeater").error("复读发送失败：", err);
+          } finally {
+            sendingTasks.delete(taskId);
+          }
+        }, delaySeconds * 1e3);
+        sendingTasks.set(taskId, timeout);
+      }
+    } catch (err) {
+      ctx.logger("repeater").error("消息处理异常：", err);
+    }
+  });
+  ctx.on("dispose", () => {
+    sendingTasks.forEach((timeout) => clearTimeout(timeout));
+    sendingTasks.clear();
+    ctx.logger("repeater").info("插件已停止，所有待发送任务已清理");
+  });
+  ctx.logger("repeater").info("复读计数插件已启动！");
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  name
+});

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "koishi-plugin-xxfd-1",
+  "description": "随机延时复读",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "scripts": {},
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin"
+  ],
+  "devDependencies": {},
+  "peerDependencies": {
+    "koishi": "^4.18.7"
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-xxfd-1
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-koishi?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-koishi)
+
+随机延时复读