koishi-plugin-group-control 0.2.9 → 0.2.11

package/lib/database.d.ts

@@ -19,11 +19,16 @@ export interface GroupBotStatus {
     guildId: string;
     botEnabled: boolean;
 }
+export interface SmallGroupWhitelist {
+    platform: string;
+    guildId: string;
+}
 declare module 'koishi' {
     interface Tables {
         blacklisted_guild: BlacklistedGuild;
         command_frequency_record: CommandFrequencyRecord;
         group_bot_status: GroupBotStatus;
+        small_group_whitelist: SmallGroupWhitelist;
     }
 }
 export declare const name = "group-control-database";
@@ -38,3 +43,7 @@ export declare function getCommandFrequencyRecord(ctx: Context, platform: string
 export declare function updateCommandFrequencyRecord(ctx: Context, platform: string, guildId: string, data: Partial<CommandFrequencyRecord>): Promise<void>;
 export declare function getGroupBotStatus(ctx: Context, platform: string, guildId: string): Promise<GroupBotStatus | null>;
 export declare function setGroupBotStatus(ctx: Context, platform: string, guildId: string, botEnabled: boolean): Promise<void>;
+export declare function isInSmallGroupWhitelist(ctx: Context, guildId: string): Promise<boolean>;
+export declare function addToSmallGroupWhitelist(ctx: Context, guildId: string): Promise<void>;
+export declare function removeFromSmallGroupWhitelist(ctx: Context, guildId: string): Promise<void>;
+export declare function getAllSmallGroupWhitelist(ctx: Context): Promise<SmallGroupWhitelist[]>;

package/lib/index.js

@@ -30,15 +30,19 @@ module.exports = __toCommonJS(src_exports);
 var database_exports = {};
 __export(database_exports, {
   BLACKLIST_PLATFORM: () => BLACKLIST_PLATFORM,
+  addToSmallGroupWhitelist: () => addToSmallGroupWhitelist,
   apply: () => apply,
   clearBlacklistedGuilds: () => clearBlacklistedGuilds,
   createBlacklistedGuild: () => createBlacklistedGuild,
   getAllBlacklistedGuilds: () => getAllBlacklistedGuilds,
+  getAllSmallGroupWhitelist: () => getAllSmallGroupWhitelist,
   getBlacklistedGuild: () => getBlacklistedGuild,
   getCommandFrequencyRecord: () => getCommandFrequencyRecord,
   getGroupBotStatus: () => getGroupBotStatus,
+  isInSmallGroupWhitelist: () => isInSmallGroupWhitelist,
   name: () => name,
   removeBlacklistedGuild: () => removeBlacklistedGuild,
+  removeFromSmallGroupWhitelist: () => removeFromSmallGroupWhitelist,
   setGroupBotStatus: () => setGroupBotStatus,
   updateCommandFrequencyRecord: () => updateCommandFrequencyRecord
 });
@@ -64,6 +68,10 @@ function apply(ctx) {
     guildId: "string",
     botEnabled: "boolean"
   }, { primary: ["platform", "guildId"] });
+  ctx.model.extend("small_group_whitelist", {
+    platform: "string",
+    guildId: "string"
+  }, { primary: ["platform", "guildId"] });
 }
 __name(apply, "apply");
 var BLACKLIST_PLATFORM = "onebot";
@@ -114,6 +122,23 @@ async function setGroupBotStatus(ctx, platform, guildId, botEnabled) {
   await ctx.model.upsert("group_bot_status", [{ platform, guildId, botEnabled }]);
 }
 __name(setGroupBotStatus, "setGroupBotStatus");
+async function isInSmallGroupWhitelist(ctx, guildId) {
+  const records = await ctx.model.get("small_group_whitelist", { platform: BLACKLIST_PLATFORM, guildId });
+  return records.length > 0;
+}
+__name(isInSmallGroupWhitelist, "isInSmallGroupWhitelist");
+async function addToSmallGroupWhitelist(ctx, guildId) {
+  await ctx.model.upsert("small_group_whitelist", [{ platform: BLACKLIST_PLATFORM, guildId }]);
+}
+__name(addToSmallGroupWhitelist, "addToSmallGroupWhitelist");
+async function removeFromSmallGroupWhitelist(ctx, guildId) {
+  await ctx.model.remove("small_group_whitelist", { platform: BLACKLIST_PLATFORM, guildId });
+}
+__name(removeFromSmallGroupWhitelist, "removeFromSmallGroupWhitelist");
+async function getAllSmallGroupWhitelist(ctx) {
+  return await ctx.model.get("small_group_whitelist", { platform: BLACKLIST_PLATFORM });
+}
+__name(getAllSmallGroupWhitelist, "getAllSmallGroupWhitelist");
 
 // src/modules/basic.ts
 var basic_exports = {};
@@ -208,11 +233,32 @@ var ADMIN_COMMANDS = /* @__PURE__ */ new Set([
   "clear-blacklist",
   "approve",
   "reject",
-  "pending-invites"
+  "pending-invites",
+  "allow-small-group",
+  "disallow-small-group",
+  "view-small-group-whitelist"
 ]);
 
+// src/state.ts
+var approvedGroups = /* @__PURE__ */ new Set();
+
 // src/modules/basic.ts
 var name2 = "group-control-basic";
+async function getGroupName(bot, guildId) {
+  try {
+    const info = await bot.internal?.getGroupInfo?.(parseInt(guildId));
+    if (info?.group_name) return info.group_name;
+  } catch {
+  }
+  try {
+    const info = await bot.getGuild(guildId);
+    if (info?.name) return info.name;
+    if (info?.group_name) return info.group_name;
+  } catch {
+  }
+  return "未知";
+}
+__name(getGroupName, "getGroupName");
 function apply2(ctx, config) {
   const quittingGuilds = /* @__PURE__ */ new Map();
   const processedKicks = /* @__PURE__ */ new Map();
@@ -245,54 +291,67 @@ function apply2(ctx, config) {
       }
     }
     if (config.basic.smallGroupAutoQuit) {
-      const delay = config.basic.smallGroupCheckDelay || 3e3;
-      setTimeout(async () => {
-        try {
-          let memberCount = 0;
+      const inWhitelist = await isInSmallGroupWhitelist(ctx, guildId);
+      const wasApproved = approvedGroups.has(guildId);
+      if (wasApproved) approvedGroups.delete(guildId);
+      if (inWhitelist || wasApproved) {
+      } else {
+        const delay = config.basic.smallGroupCheckDelay || 3e3;
+        setTimeout(async () => {
           try {
-            const groupInfo = await session.bot.internal?.getGroupInfo?.(parseInt(guildId));
-            memberCount = groupInfo?.member_count || 0;
-          } catch {
-          }
-          if (memberCount === 0) {
+            let memberCount = 0;
+            let groupName = "未知";
             try {
-              const guildInfo = await session.bot.getGuild(guildId);
-              memberCount = guildInfo?.member_count || guildInfo?.memberCount || 0;
+              const groupInfo = await session.bot.internal?.getGroupInfo?.(parseInt(guildId));
+              memberCount = groupInfo?.member_count || 0;
+              if (groupInfo?.group_name) groupName = groupInfo.group_name;
             } catch {
             }
-          }
-          if (memberCount === 0) {
-            try {
-              const memberList = await session.bot.getGuildMemberList(guildId);
-              memberCount = memberList?.data?.length || 0;
-            } catch {
+            if (memberCount === 0) {
+              try {
+                const guildInfo = await session.bot.getGuild(guildId);
+                memberCount = guildInfo?.member_count || guildInfo?.memberCount || 0;
+                if (guildInfo?.name) groupName = guildInfo.name;
+              } catch {
+              }
             }
-          }
-          if (memberCount > 0 && memberCount <= config.basic.smallGroupThreshold) {
-            const quitMsg = config.basic.smallGroupQuitMessage.replace("{memberCount}", memberCount.toString()).replace("{threshold}", config.basic.smallGroupThreshold.toString());
-            try {
-              await session.bot.sendMessage(guildId, quitMsg, platform);
-            } catch (e) {
+            if (memberCount === 0) {
+              try {
+                const memberList = await session.bot.getGuildMemberList(guildId);
+                memberCount = memberList?.data?.length || 0;
+              } catch {
+              }
             }
-            if (config.basic.smallGroupNotifyAdmin) {
-              const adminMsg = `小群自动退群
+            if (groupName === "未知") {
+              groupName = await getGroupName(session.bot, guildId);
+            }
+            if (memberCount > 0 && memberCount <= config.basic.smallGroupThreshold) {
+              const quitMsg = config.basic.smallGroupQuitMessage.replaceAll("{memberCount}", memberCount.toString()).replaceAll("{threshold}", config.basic.smallGroupThreshold.toString()).replaceAll("{groupName}", groupName).replaceAll("{groupId}", guildId);
+              try {
+                await session.bot.sendMessage(guildId, quitMsg, platform);
+              } catch (e) {
+              }
+              if (config.basic.smallGroupNotifyAdmin) {
+                const adminMsg = `小群自动退群
+群名称：${groupName}
 群号：${guildId}
 群成员数：${memberCount}人（阈值：${config.basic.smallGroupThreshold}人）
 机器人已自动退出该群。`;
-              await notifyAdmins(session.bot, config, adminMsg);
-            }
-            quittingGuilds.set(`${platform}:${guildId}`, Date.now());
-            try {
-              await session.bot.internal.setGroupLeave(parseInt(guildId));
-            } catch (e) {
-              console.error(`小群自动退群失败 (群号: ${guildId}):`, e);
-              quittingGuilds.delete(`${platform}:${guildId}`);
+                await notifyAdmins(session.bot, config, adminMsg);
+              }
+              quittingGuilds.set(`${platform}:${guildId}`, Date.now());
+              try {
+                await session.bot.internal.setGroupLeave(parseInt(guildId));
+              } catch (e) {
+                console.error(`小群自动退群失败 (群号: ${guildId}):`, e);
+                quittingGuilds.delete(`${platform}:${guildId}`);
+              }
             }
+          } catch (error) {
+            console.error(`小群自动退群检测失败 (群号: ${guildId}):`, error);
           }
-        } catch (error) {
-          console.error(`小群自动退群检测失败 (群号: ${guildId}):`, error);
-        }
-      }, delay);
+        }, delay);
+      }
     }
     if (config.basic.welcomeMessage) {
       try {
@@ -311,6 +370,7 @@ function apply2(ctx, config) {
       return;
     }
     processedKicks.set(quittingKey, Date.now());
+    const groupName = await getGroupName(session.bot, guildId);
     if (config.basic.enableBlacklist) {
       await ctx.model.upsert("blacklisted_guild", [{
         platform,
@@ -320,7 +380,7 @@ function apply2(ctx, config) {
       }]);
     }
     if (config.basic.notifyAdminOnKick) {
-      const kickMsg = config.basic.kickNotificationMessage.replace("{groupId}", guildId);
+      const kickMsg = config.basic.kickNotificationMessage.replaceAll("{groupId}", guildId).replaceAll("{groupName}", groupName);
       await notifyAdmins(session.bot, config, kickMsg);
     }
   });
@@ -336,7 +396,9 @@ function apply2(ctx, config) {
         if (!hasPerm) return "权限不足，只有群管理员可以使用此指令。";
       }
       const { guildId, platform, userId } = session;
+      const groupName = await getGroupName(session.bot, guildId);
       const adminMsg = `收到来自 ${userId} 的退群指令
+群名称：${groupName}
 群号：${guildId}`;
       await notifyAdmins(session.bot, config, adminMsg);
       quittingGuilds.set(`${platform}:${guildId}`, Date.now());
@@ -414,6 +476,7 @@ function apply3(ctx, config) {
       if (config.invite.autoApprove) {
         try {
           await session.bot.internal.setGroupAddRequest(flag, "invite", true, "");
+          approvedGroups.add(rawGroupId);
           if (config.invite.showDetailedLog) {
             console.log(`自动同意群聊邀请: 群号 ${rawGroupId}, 邀请者 ${rawUserId}`);
           }
@@ -472,6 +535,7 @@ function apply3(ctx, config) {
     }
     try {
       await session.bot.internal.setGroupAddRequest(inviteData.flag, "invite", true, "");
+      approvedGroups.add(groupId);
       try {
         await session.bot.sendPrivateMessage(inviteData.userId, `您的群聊邀请已通过管理员审核，机器人已加入群聊。`);
       } catch (error) {
@@ -650,6 +714,27 @@ function apply5(ctx, config) {
   }
   __name(clearBlacklist, "clearBlacklist");
   ctx.command("clear-blacklist", "清空黑名单", { authority: 4 }).action(clearBlacklist);
+  ctx.command("allow-small-group <groupId:text>", "解除指定群聊的小群人数限制", { authority: 4 }).action(async ({}, input) => {
+    const guildId = parseGuildId(input);
+    if (!guildId) return "输入格式错误，请输入群号。";
+    const exists = await isInSmallGroupWhitelist(ctx, guildId);
+    if (exists) return `群聊 ${guildId} 已在小群白名单中。`;
+    await addToSmallGroupWhitelist(ctx, guildId);
+    return `已将群聊 ${guildId} 加入小群白名单，该群不再受小群人数限制。`;
+  });
+  ctx.command("disallow-small-group <groupId:text>", "恢复指定群聊的小群人数限制", { authority: 4 }).action(async ({}, input) => {
+    const guildId = parseGuildId(input);
+    if (!guildId) return "输入格式错误，请输入群号。";
+    const exists = await isInSmallGroupWhitelist(ctx, guildId);
+    if (!exists) return `群聊 ${guildId} 不在小群白名单中。`;
+    await removeFromSmallGroupWhitelist(ctx, guildId);
+    return `已将群聊 ${guildId} 从小群白名单移除，该群将恢复小群人数限制。`;
+  });
+  ctx.command("view-small-group-whitelist", "查看小群白名单", { authority: 4 }).action(async () => {
+    const records = await getAllSmallGroupWhitelist(ctx);
+    if (records.length === 0) return "小群白名单为空。";
+    return "小群白名单列表（以下群不受小群人数限制）：\n" + records.map((r) => `- ${r.guildId}`).join("\n");
+  });
 }
 __name(apply5, "apply");
 
@@ -757,10 +842,10 @@ var Config = import_koishi.Schema.intersect([
       enableBlacklist: import_koishi.Schema.boolean().default(true).description('启用"被踢出自动拉黑"功能'),
       quitCommandEnabled: import_koishi.Schema.boolean().default(true).description("启用quit"),
       notifyAdminOnKick: import_koishi.Schema.boolean().default(true).description("被踢出群时通知管理员（需要在群聊邀请审核中配置管理员QQ）"),
-      kickNotificationMessage: import_koishi.Schema.string().default("机器人已被踢出群聊\n群号：{groupId}\n该群已被自动加入黑名单。").description("被踢出群通知消息模板，支持变量{groupId}"),
+      kickNotificationMessage: import_koishi.Schema.string().default("机器人已被踢出群聊\n群名称：{groupName}\n群号：{groupId}\n该群已被自动加入黑名单。").description("被踢出群通知消息模板，支持变量{groupId}, {groupName}"),
       smallGroupAutoQuit: import_koishi.Schema.boolean().default(false).description("启用小群自动退群功能"),
       smallGroupThreshold: import_koishi.Schema.number().default(30).description("小群人数阈值（群成员数小于等于此值时自动退群）"),
-      smallGroupQuitMessage: import_koishi.Schema.string().default("该群人数过少（{memberCount}人），不满足最低人数要求（{threshold}人），机器人将自动退出。").description("小群自动退群时在群内发送的提示，支持变量{memberCount}, {threshold}"),
+      smallGroupQuitMessage: import_koishi.Schema.string().default("该群人数过少（{memberCount}人），不满足最低人数要求（{threshold}人），机器人将自动退出。").description("小群自动退群时在群内发送的提示，支持变量{memberCount}, {threshold}, {groupName}, {groupId}"),
       smallGroupNotifyAdmin: import_koishi.Schema.boolean().default(true).description("小群自动退群时通知管理员"),
       smallGroupCheckDelay: import_koishi.Schema.number().default(3e3).description("小群检测延迟（毫秒），加入群聊后等待一段时间再获取群信息以确保数据准确")
     }).description("基础群组管理")

package/lib/state.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 跨模块共享状态
+ * 用于在 invite 和 basic 等模块间传递信息
+ */
+/** 管理员已审核通过的群号集合（approve 指令通过后添加） */
+export declare const approvedGroups: Set<string>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-group-control",
   "description": "Koishi 插件，一个多功能的群聊自管理工具。支持被踢出自动拉黑、刷屏自动屏蔽、开关控制等功能。(仅支持 OneBot 适配器)",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [