koishi-plugin-maple-broadcast 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,29 @@
+import { Context, Schema } from 'koishi';
+export declare const using: readonly ["database"];
+declare module 'koishi' {
+    interface Tables {
+        broadcast_groups: BroadcastGroup;
+        broadcast_groups_bots: BroadcastGroupBot;
+    }
+}
+interface BroadcastGroup {
+    id: number;
+    name: string;
+    created_at: Date;
+}
+interface BroadcastGroupBot {
+    id: number;
+    group_id: number;
+    guildId: string;
+    guildName: string;
+    platform: string;
+    created_at: Date;
+}
+export declare const name = "maple-broadcast";
+export interface Config {
+    broadcastInterval: number;
+    broadcastTimeout: number;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;
+export {};

package/lib/index.js

@@ -0,0 +1,370 @@
+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 using = ["database"];
+var name = "maple-broadcast";
+var Config = import_koishi.Schema.object({
+  broadcastInterval: import_koishi.Schema.number().default(1e3).description("广播发送间隔（毫秒）").min(100).max(1e4),
+  broadcastTimeout: import_koishi.Schema.number().default(30).description("广播发送超时时间（秒）").min(5).max(300)
+});
+function separator() {
+  return "──────────";
+}
+__name(separator, "separator");
+async function getQQGroupName(ctx, guildId) {
+  try {
+    const bot = ctx.bots.find((bot2) => bot2.platform === "onebot");
+    if (bot) {
+      const guild = await bot.getGuild(guildId);
+      return guild?.name || `群#${guildId}`;
+    }
+  } catch (error) {
+  }
+  return `群#${guildId}`;
+}
+__name(getQQGroupName, "getQQGroupName");
+function apply(ctx, config) {
+  ctx.model.extend("broadcast_groups", {
+    id: "unsigned",
+    name: "string",
+    created_at: "timestamp"
+  }, {
+    primary: "id",
+    autoInc: true,
+    unique: ["name"]
+  });
+  ctx.model.extend("broadcast_groups_bots", {
+    id: "unsigned",
+    group_id: "unsigned",
+    guildId: "string",
+    guildName: "string",
+    platform: "string",
+    created_at: "timestamp"
+  }, {
+    primary: "id",
+    autoInc: true,
+    foreign: {
+      group_id: ["broadcast_groups", "id"]
+    }
+  });
+  const broadcast = ctx.command("广播", { authority: 2 }).alias("bc").usage("广播管理插件");
+  ctx.command("广播/广播分组", { authority: 2 }).alias("bc/group").usage("广播分组管理");
+  ctx.command("广播/广播群", { authority: 2 }).alias("bc/bot").usage("广播群管理");
+  ctx.command("广播/广播分组/添加广播分组 <分组名:string>", { authority: 2 }).example("添加广播分组 攻略组").example("添加广播分组 活动组").action(async ({ session }, 分组名) => {
+    if (!分组名) return "请输入分组名";
+    try {
+      await ctx.database.create("broadcast_groups", {
+        name: 分组名,
+        created_at: /* @__PURE__ */ new Date()
+      });
+      return `广播分组 "${分组名}" 创建成功`;
+    } catch (error) {
+      if (error.code === 2067) {
+        return `分组名 "${分组名}" 已存在`;
+      }
+      return "创建分组时发生错误";
+    }
+  });
+  ctx.command("广播/广播分组/查看广播分组 [分组名:string]", { authority: 2 }).example("查看广播分组").example("查看广播分组 攻略组").action(async ({ session }, 分组名) => {
+    let groups;
+    if (分组名) {
+      groups = await ctx.database.get("broadcast_groups", { name: 分组名 });
+    } else {
+      groups = await ctx.database.get("broadcast_groups", {});
+    }
+    if (groups.length === 0) {
+      return 分组名 ? `未找到分组 "${分组名}"` : "暂无广播分组";
+    }
+    const results = [];
+    for (const group of groups) {
+      const bots = await ctx.database.get("broadcast_groups_bots", {
+        group_id: group.id
+      });
+      results.push(separator());
+      results.push(`【${group.name}】（共 ${bots.length} 个群）`);
+      if (bots.length > 0) {
+        bots.forEach((bot, index) => {
+          results.push(`${index + 1}. [#${bot.id}] ${bot.guildName} ${bot.guildId}`);
+        });
+      } else {
+        results.push("（暂无群）");
+      }
+    }
+    return results.join("\n");
+  });
+  ctx.command("广播/广播分组/删除广播分组 <分组名:string>", { authority: 2 }).example("删除广播分组 测试组").action(async ({ session }, 分组名) => {
+    if (!分组名) return "请输入分组名";
+    const group = await ctx.database.get("broadcast_groups", { name: 分组名 });
+    if (group.length === 0) {
+      return `未找到分组 "${分组名}"`;
+    }
+    await ctx.database.remove("broadcast_groups_bots", {
+      group_id: group[0].id
+    });
+    await ctx.database.remove("broadcast_groups", {
+      name: 分组名
+    });
+    return `广播分组 "${分组名}" 已删除`;
+  });
+  ctx.command("广播/广播分组/修改广播分组 <旧分组名:string> <新分组名:string>", { authority: 2 }).example("修改广播分组 旧分组 新分组").action(async ({ session }, 旧分组名, 新分组名) => {
+    if (!旧分组名 || !新分组名) return "请提供旧分组名和新分组名";
+    if (旧分组名 === 新分组名) {
+      return "新旧分组名相同";
+    }
+    const group = await ctx.database.get("broadcast_groups", { name: 旧分组名 });
+    if (group.length === 0) {
+      return `未找到分组 "${旧分组名}"`;
+    }
+    try {
+      await ctx.database.set("broadcast_groups", { name: 旧分组名 }, {
+        name: 新分组名
+      });
+      return `分组名已从 "${旧分组名}" 修改为 "${新分组名}"`;
+    } catch (error) {
+      if (error.code === 2067) {
+        return `分组名 "${新分组名}" 已存在`;
+      }
+      return "修改分组名时发生错误";
+    }
+  });
+  ctx.command("广播/广播群/添加广播群 <分组名:string> <群号:string>", { authority: 2 }).example("添加广播群 攻略组 123456789,987654321").example("添加广播群 活动组 111111111").action(async ({ session }, 分组名, 群号) => {
+    if (!分组名 || !群号) return "请输入分组名和群号";
+    const group = await ctx.database.get("broadcast_groups", { name: 分组名 });
+    if (group.length === 0) {
+      return `未找到分组 "${分组名}"`;
+    }
+    const 群号列表 = 群号.split(",").map((id) => id.trim()).filter((id) => id);
+    const 成功列表 = [];
+    const 失败列表 = [];
+    for (const guildId of 群号列表) {
+      try {
+        const exists = await ctx.database.get("broadcast_groups_bots", {
+          group_id: group[0].id,
+          guildId
+        });
+        if (exists.length > 0) {
+          失败列表.push(`${guildId}（已存在于该分组）`);
+          continue;
+        }
+        const guildName = await getQQGroupName(ctx, guildId);
+        await ctx.database.create("broadcast_groups_bots", {
+          group_id: group[0].id,
+          guildId,
+          guildName,
+          platform: "onebot",
+          // 固定为onebot平台
+          created_at: /* @__PURE__ */ new Date()
+        });
+        成功列表.push(guildId);
+      } catch (error) {
+        失败列表.push(`${guildId}（添加失败）`);
+      }
+    }
+    let result = "";
+    if (成功列表.length > 0) {
+      result += `成功添加群：${成功列表.join(", ")}
+`;
+    }
+    if (失败列表.length > 0) {
+      result += `添加失败：${失败列表.join(", ")}`;
+    }
+    return result || "未添加任何群";
+  });
+  ctx.command("广播/广播群/删除广播群 <群编号:string>", { authority: 2 }).example("删除广播群 1,3,5").example("删除广播群 2").action(async ({ session }, 群编号) => {
+    if (!群编号) return "请输入群编号";
+    const 编号列表 = 群编号.split(",").map((id) => parseInt(id.trim())).filter((id) => !isNaN(id));
+    if (编号列表.length === 0) return "请输入有效的群编号";
+    const 删除结果 = await ctx.database.remove("broadcast_groups_bots", {
+      id: { $in: 编号列表 }
+    });
+    return `已删除 ${删除结果} 个群`;
+  });
+  ctx.command("广播/广播群/修改广播群 <群编号:number> <群名:string>", { authority: 2 }).example("修改广播群 1 攻略一群").example("修改广播群 3 活动通知群").action(async ({ session }, 群编号, 群名) => {
+    if (!群编号 || !群名) return "请输入群编号和群名";
+    const bot = await ctx.database.get("broadcast_groups_bots", { id: 群编号 });
+    if (bot.length === 0) {
+      return `未找到群编号 ${群编号}`;
+    }
+    await ctx.database.set("broadcast_groups_bots", { id: 群编号 }, {
+      guildName: 群名
+    });
+    return `群 ${bot[0].guildId} 的群名已修改为 "${群名}"`;
+  });
+  ctx.command("广播/发送广播 <分组名:string> <广播内容:text>", { authority: 3 }).example("发送广播 攻略组,活动组 今日活动：晚上8点公会战").example("发送广播 测试组 这是一条测试广播").action(async ({ session }, 分组名, 广播内容) => {
+    if (!分组名 || !广播内容) return "请输入分组名和广播内容";
+    const 分组名列表 = 分组名.split(",").map((name2) => name2.trim()).filter((name2) => name2);
+    const 群列表 = [];
+    const 去重Map = /* @__PURE__ */ new Map();
+    for (const name2 of 分组名列表) {
+      const group = await ctx.database.get("broadcast_groups", { name: name2 });
+      if (group.length === 0) {
+        return `未找到分组 "${name2}"`;
+      }
+      const bots = await ctx.database.get("broadcast_groups_bots", {
+        group_id: group[0].id
+      });
+      for (const bot of bots) {
+        if (!去重Map.has(bot.guildId)) {
+          去重Map.set(bot.guildId, bot);
+          群列表.push(bot);
+        }
+      }
+    }
+    if (群列表.length === 0) {
+      return "所选分组中没有可发送的群";
+    }
+    const 群信息列表 = 群列表.map(
+      (bot, index) => `${index + 1}. [#${bot.id}] ${bot.guildName} ${bot.guildId}`
+    );
+    const 发送结果 = [`需要发送的群列表（共 ${群列表.length} 个）：`, ...群信息列表];
+    await session?.send(发送结果.join("\n"));
+    const 广播结果 = await 发送广播到群组(ctx, session, 群列表, 广播内容, config.broadcastInterval, config.broadcastTimeout);
+    return 广播结果;
+  });
+  async function 发送广播到群组(ctx2, session, 群列表, 广播内容, 间隔, 超时时间) {
+    const 成功列表 = [];
+    const 失败列表 = [];
+    const 超时列表 = [];
+    const 超时Promise = new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(true);
+      }, 超时时间 * 1e3);
+    });
+    const 开始时间 = Date.now();
+    try {
+      await Promise.race([
+        发送广播任务(ctx2, 群列表, 广播内容, 间隔, 成功列表, 失败列表),
+        超时Promise.then((isTimeout) => {
+          if (isTimeout) {
+            throw new Error(`广播发送超时（${超时时间}秒）`);
+          }
+        })
+      ]);
+      const 总耗时 = Math.round((Date.now() - 开始时间) / 1e3);
+      const 结果消息 = [
+        separator(),
+        "广播发送完成！",
+        `总耗时：${总耗时}秒`,
+        `发送结果：成功 ${成功列表.length} 个，失败 ${失败列表.length} 个`
+      ];
+      if (成功列表.length > 0) {
+        结果消息.push("");
+        结果消息.push("✅ 发送成功：");
+        成功列表.forEach((bot, index) => {
+          结果消息.push(`${index + 1}. [#${bot.guildId}] ${bot.guildName}`);
+        });
+      }
+      if (失败列表.length > 0) {
+        结果消息.push("");
+        结果消息.push("❌ 发送失败：");
+        失败列表.forEach((bot, index) => {
+          结果消息.push(`${index + 1}. [#${bot.guildId}] ${bot.guildName} - ${bot.error}`);
+        });
+      }
+      return 结果消息.join("\n");
+    } catch (error) {
+      if (error.message.includes("超时")) {
+        const 已发送数量 = 成功列表.length + 失败列表.length;
+        const 未发送数量 = 群列表.length - 已发送数量;
+        const 已发送群号 = /* @__PURE__ */ new Set([...成功列表.map((b) => b.guildId), ...失败列表.map((b) => b.guildId)]);
+        for (const bot of 群列表) {
+          if (!已发送群号.has(bot.guildId)) {
+            超时列表.push({ guildId: bot.guildId, guildName: bot.guildName });
+          }
+        }
+        const 总耗时 = Math.round((Date.now() - 开始时间) / 1e3);
+        const 结果消息 = [
+          separator(),
+          `广播发送超时（${超时时间}秒），已终止！`,
+          `总耗时：${总耗时}秒`,
+          `发送结果：成功 ${成功列表.length} 个，失败 ${失败列表.length} 个，超时未发送 ${超时列表.length} 个`
+        ];
+        if (成功列表.length > 0) {
+          结果消息.push("");
+          结果消息.push("✅ 发送成功：");
+          成功列表.forEach((bot, index) => {
+            结果消息.push(`${index + 1}. [#${bot.guildId}] ${bot.guildName}`);
+          });
+        }
+        if (失败列表.length > 0) {
+          结果消息.push("");
+          结果消息.push("❌ 发送失败：");
+          失败列表.forEach((bot, index) => {
+            结果消息.push(`${index + 1}. [#${bot.guildId}] ${bot.guildName} - ${bot.error}`);
+          });
+        }
+        if (超时列表.length > 0) {
+          结果消息.push("");
+          结果消息.push("⏰ 超时未发送：");
+          超时列表.forEach((bot, index) => {
+            结果消息.push(`${index + 1}. [#${bot.guildId}] ${bot.guildName}`);
+          });
+        }
+        return 结果消息.join("\n");
+      }
+      return `广播发送过程中发生错误：${error.message}`;
+    }
+  }
+  __name(发送广播到群组, "发送广播到群组");
+  async function 发送广播任务(ctx2, 群列表, 广播内容, 间隔, 成功列表, 失败列表) {
+    for (let i = 0; i < 群列表.length; i++) {
+      const bot = 群列表[i];
+      try {
+        const botInstance = ctx2.bots.find((bot2) => bot2.platform === "onebot");
+        if (botInstance) {
+          await botInstance.sendMessage(bot.guildId, 广播内容);
+        } else {
+          throw new Error("机器人实例不存在");
+        }
+        console.log(`[广播发送成功] 群号: ${bot.guildId}, 群名: ${bot.guildName}`);
+        成功列表.push({ guildId: bot.guildId, guildName: bot.guildName });
+      } catch (error) {
+        console.log(`[广播发送失败] 群号: ${bot.guildId}, 群名: ${bot.guildName}, 错误: ${error.message}`);
+        失败列表.push({ guildId: bot.guildId, guildName: bot.guildName, error: error.message });
+      }
+      if (i < 群列表.length - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 间隔));
+      }
+    }
+  }
+  __name(发送广播任务, "发送广播任务");
+  ctx.on("ready", () => {
+    ctx.logger("maple-broadcast").info("广播插件已加载");
+    ctx.logger("maple-broadcast").info(`广播发送间隔：${config.broadcastInterval}ms`);
+    ctx.logger("maple-broadcast").info(`广播发送超时时间：${config.broadcastTimeout}秒`);
+  });
+}
+__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-broadcast",
+  "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-broadcast
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-maple-broadcast?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-maple-broadcast)
+
+-