koishi-plugin-group-control 0.2.10 → 0.2.12

package/lib/config.d.ts

@@ -21,6 +21,7 @@ export interface GroupInviteConfig {
     inviteRequestMessage: string;
     autoApprove: boolean;
     showDetailedLog: boolean;
+    inviteExpireDays: number;
 }
 export interface FrequencyConfig {
     enabled: boolean;

package/lib/database.d.ts

@@ -19,11 +19,26 @@ export interface GroupBotStatus {
     guildId: string;
     botEnabled: boolean;
 }
+export interface SmallGroupWhitelist {
+    platform: string;
+    guildId: string;
+}
+export interface PendingInvite {
+    platform: string;
+    groupId: string;
+    userId: string;
+    userName: string;
+    groupName: string;
+    time: number;
+    flag: string;
+}
 declare module 'koishi' {
     interface Tables {
         blacklisted_guild: BlacklistedGuild;
         command_frequency_record: CommandFrequencyRecord;
         group_bot_status: GroupBotStatus;
+        small_group_whitelist: SmallGroupWhitelist;
+        pending_invite: PendingInvite;
     }
 }
 export declare const name = "group-control-database";
@@ -38,3 +53,12 @@ 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[]>;
+export declare function getPendingInvite(ctx: Context, groupId: string): Promise<PendingInvite>;
+export declare function addPendingInvite(ctx: Context, inviteUser: Omit<PendingInvite, 'platform'>): Promise<void>;
+export declare function removePendingInvite(ctx: Context, groupId: string): Promise<void>;
+export declare function getAllPendingInvites(ctx: Context): Promise<PendingInvite[]>;
+export declare function clearExpiredPendingInvites(ctx: Context, expireTimeMs: number): Promise<number>;

package/lib/index.js

@@ -30,15 +30,24 @@ module.exports = __toCommonJS(src_exports);
 var database_exports = {};
 __export(database_exports, {
   BLACKLIST_PLATFORM: () => BLACKLIST_PLATFORM,
+  addPendingInvite: () => addPendingInvite,
+  addToSmallGroupWhitelist: () => addToSmallGroupWhitelist,
   apply: () => apply,
   clearBlacklistedGuilds: () => clearBlacklistedGuilds,
+  clearExpiredPendingInvites: () => clearExpiredPendingInvites,
   createBlacklistedGuild: () => createBlacklistedGuild,
   getAllBlacklistedGuilds: () => getAllBlacklistedGuilds,
+  getAllPendingInvites: () => getAllPendingInvites,
+  getAllSmallGroupWhitelist: () => getAllSmallGroupWhitelist,
   getBlacklistedGuild: () => getBlacklistedGuild,
   getCommandFrequencyRecord: () => getCommandFrequencyRecord,
   getGroupBotStatus: () => getGroupBotStatus,
+  getPendingInvite: () => getPendingInvite,
+  isInSmallGroupWhitelist: () => isInSmallGroupWhitelist,
   name: () => name,
   removeBlacklistedGuild: () => removeBlacklistedGuild,
+  removeFromSmallGroupWhitelist: () => removeFromSmallGroupWhitelist,
+  removePendingInvite: () => removePendingInvite,
   setGroupBotStatus: () => setGroupBotStatus,
   updateCommandFrequencyRecord: () => updateCommandFrequencyRecord
 });
@@ -64,6 +73,19 @@ function apply(ctx) {
     guildId: "string",
     botEnabled: "boolean"
   }, { primary: ["platform", "guildId"] });
+  ctx.model.extend("small_group_whitelist", {
+    platform: "string",
+    guildId: "string"
+  }, { primary: ["platform", "guildId"] });
+  ctx.model.extend("pending_invite", {
+    platform: "string",
+    groupId: "string",
+    userId: "string",
+    userName: "string",
+    groupName: "string",
+    time: "integer",
+    flag: "string"
+  }, { primary: ["platform", "groupId"] });
 }
 __name(apply, "apply");
 var BLACKLIST_PLATFORM = "onebot";
@@ -114,6 +136,50 @@ 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");
+async function getPendingInvite(ctx, groupId) {
+  const records = await ctx.model.get("pending_invite", { platform: BLACKLIST_PLATFORM, groupId });
+  return records.length > 0 ? records[0] : null;
+}
+__name(getPendingInvite, "getPendingInvite");
+async function addPendingInvite(ctx, inviteUser) {
+  await ctx.model.upsert("pending_invite", [{ platform: BLACKLIST_PLATFORM, ...inviteUser }]);
+}
+__name(addPendingInvite, "addPendingInvite");
+async function removePendingInvite(ctx, groupId) {
+  await ctx.model.remove("pending_invite", { platform: BLACKLIST_PLATFORM, groupId });
+}
+__name(removePendingInvite, "removePendingInvite");
+async function getAllPendingInvites(ctx) {
+  return await ctx.model.get("pending_invite", { platform: BLACKLIST_PLATFORM });
+}
+__name(getAllPendingInvites, "getAllPendingInvites");
+async function clearExpiredPendingInvites(ctx, expireTimeMs) {
+  const cutoff = Date.now() - expireTimeMs;
+  const all = await ctx.model.get("pending_invite", { platform: BLACKLIST_PLATFORM });
+  const expired = all.filter((r) => r.time < cutoff);
+  for (const record of expired) {
+    await ctx.model.remove("pending_invite", { platform: BLACKLIST_PLATFORM, groupId: record.groupId });
+  }
+  return expired.length;
+}
+__name(clearExpiredPendingInvites, "clearExpiredPendingInvites");
 
 // src/modules/basic.ts
 var basic_exports = {};
@@ -158,6 +224,9 @@ async function notifyAdmins(bot, config, message) {
 }
 __name(notifyAdmins, "notifyAdmins");
 async function hasPermission(session, config) {
+  if (config.invite.adminQQs?.includes(session.userId)) {
+    return true;
+  }
   if (config.permission.mode === "koishi") {
     try {
       const user = session.user;
@@ -169,9 +238,6 @@ async function hasPermission(session, config) {
     return false;
   }
   const userId = session.userId;
-  if (config.invite.adminQQs?.includes(userId)) {
-    return true;
-  }
   try {
     const member = await session.bot.getGuildMember(session.guildId, userId);
     const roles = member?.roles || member?.role;
@@ -198,17 +264,31 @@ async function hasPermission(session, config) {
   return false;
 }
 __name(hasPermission, "hasPermission");
+function isGlobalAdmin(session, config) {
+  if (config.invite.adminQQs?.includes(session.userId)) {
+    return true;
+  }
+  const user = session.user;
+  if (config.permission.mode === "koishi" && user && typeof user.authority === "number") {
+    return user.authority >= 4;
+  }
+  return false;
+}
+__name(isGlobalAdmin, "isGlobalAdmin");
 var ADMIN_COMMANDS = /* @__PURE__ */ new Set([
   "bot-on",
   "bot-off",
   "quit",
-  "view-blacklist",
-  "remove-from-blacklist",
-  "add-to-blacklist",
-  "clear-blacklist",
+  "banlist",
+  "unban",
+  "ban",
+  "clearban",
   "approve",
   "reject",
-  "pending-invites"
+  "pending",
+  "sg-add",
+  "sg-rm",
+  "sg-list"
 ]);
 
 // src/state.ts
@@ -263,8 +343,10 @@ function apply2(ctx, config) {
       }
     }
     if (config.basic.smallGroupAutoQuit) {
-      if (approvedGroups.has(guildId)) {
-        approvedGroups.delete(guildId);
+      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 () => {
@@ -397,19 +479,17 @@ __export(invite_exports, {
 var name3 = "group-control-invite";
 function apply3(ctx, config) {
   if (!config.invite.enabled) return;
-  const pendingInvites = /* @__PURE__ */ new Map();
-  const INVITE_TIMEOUT = 10 * 60 * 1e3;
-  setInterval(() => {
-    const now = Date.now();
-    for (const [key, invite] of pendingInvites) {
-      if (now - invite.time > INVITE_TIMEOUT) {
-        pendingInvites.delete(key);
-        if (config.invite.showDetailedLog) {
-          console.log(`邀请超时已清理: 群号=${invite.groupId}, 邀请者=${invite.userId}`);
-        }
+  setInterval(async () => {
+    const expireMs = config.invite.inviteExpireDays * 24 * 60 * 60 * 1e3;
+    try {
+      const count = await clearExpiredPendingInvites(ctx, expireMs);
+      if (count > 0 && config.invite.showDetailedLog) {
+        console.log(`已自动清理 ${count} 个过期邀请`);
       }
+    } catch (error) {
+      console.error("清理过期邀请失败:", error);
     }
-  }, 60 * 1e3);
+  }, 60 * 60 * 1e3);
   ctx.on("guild-request", async (session) => {
     const raw = session.original || session.raw || session.event?._data || {};
     const flag = raw.flag || session.flag || session.messageId;
@@ -456,7 +536,7 @@ function apply3(ctx, config) {
       }
       return;
     }
-    pendingInvites.set(rawGroupId, {
+    await addPendingInvite(ctx, {
       groupId: rawGroupId,
       userId: rawUserId,
       userName,
@@ -494,14 +574,15 @@ function apply3(ctx, config) {
       console.warn("群邀请请求发送失败：未配置通知群且管理员私聊发送失败");
     }
   });
-  ctx.command("approve <groupId:string>", "同意群聊邀请", { authority: 4 }).action(async ({ session }, groupId) => {
+  ctx.command("approve <groupId:string>", "同意群聊邀请").action(async ({ session }, groupId) => {
     if (!groupId) return "请指定群号。用法：approve <群号>";
     if (!config.invite.adminQQs.includes(session.userId)) {
       return "权限不足，只有管理员可以审核邀请。";
     }
-    const inviteData = pendingInvites.get(groupId);
+    const inviteData = await getPendingInvite(ctx, groupId);
     if (!inviteData) {
-      return `未找到群号 ${groupId} 的待处理邀请。当前待处理邀请：${pendingInvites.size > 0 ? Array.from(pendingInvites.values()).map((i) => `${i.groupId}(${i.groupName})`).join(", ") : "无"}`;
+      const allInvites = await getAllPendingInvites(ctx);
+      return `未找到群号 ${groupId} 的待处理邀请。当前待处理邀请：${allInvites.length > 0 ? allInvites.map((i) => `${i.groupId}(${i.groupName})`).join(", ") : "无"}`;
     }
     try {
       await session.bot.internal.setGroupAddRequest(inviteData.flag, "invite", true, "");
@@ -511,21 +592,22 @@ function apply3(ctx, config) {
       } catch (error) {
         console.error("通知邀请者失败:", error);
       }
-      pendingInvites.delete(groupId);
+      await removePendingInvite(ctx, groupId);
       return `已同意加入群 ${groupId}（${inviteData.groupName}），邀请者：${inviteData.userName}`;
     } catch (error) {
       console.error("处理同意邀请失败:", error);
       return `处理同意邀请失败: ${error.message}`;
     }
   });
-  ctx.command("reject <groupId:string>", "拒绝群聊邀请", { authority: 4 }).action(async ({ session }, groupId) => {
+  ctx.command("reject <groupId:string>", "拒绝群聊邀请").action(async ({ session }, groupId) => {
     if (!groupId) return "请指定群号。用法：reject <群号>";
     if (!config.invite.adminQQs.includes(session.userId)) {
       return "权限不足，只有管理员可以审核邀请。";
     }
-    const inviteData = pendingInvites.get(groupId);
+    const inviteData = await getPendingInvite(ctx, groupId);
     if (!inviteData) {
-      return `未找到群号 ${groupId} 的待处理邀请。当前待处理邀请：${pendingInvites.size > 0 ? Array.from(pendingInvites.values()).map((i) => `${i.groupId}(${i.groupName})`).join(", ") : "无"}`;
+      const allInvites = await getAllPendingInvites(ctx);
+      return `未找到群号 ${groupId} 的待处理邀请。当前待处理邀请：${allInvites.length > 0 ? allInvites.map((i) => `${i.groupId}(${i.groupName})`).join(", ") : "无"}`;
     }
     try {
       await session.bot.internal.setGroupAddRequest(inviteData.flag, "invite", false, "已拒绝");
@@ -534,22 +616,23 @@ function apply3(ctx, config) {
       } catch (error) {
         console.error("通知邀请者失败:", error);
       }
-      pendingInvites.delete(groupId);
+      await removePendingInvite(ctx, groupId);
       return `已拒绝加入群 ${groupId}（${inviteData.groupName}），邀请者：${inviteData.userName}`;
     } catch (error) {
       console.error("处理拒绝邀请失败:", error);
       return `处理拒绝邀请失败: ${error.message}`;
     }
   });
-  ctx.command("pending-invites", "查看待处理的群聊邀请", { authority: 4 }).action(async ({ session }) => {
+  ctx.command("pending", "查看待处理的群聊邀请").action(async ({ session }) => {
     if (!config.invite.adminQQs.includes(session.userId)) {
       return "权限不足，只有管理员可以查看待处理邀请。";
     }
-    if (pendingInvites.size === 0) {
+    const allInvites = await getAllPendingInvites(ctx);
+    if (allInvites.length === 0) {
       return "当前没有待处理的群聊邀请。";
     }
     const lines = ["待处理的群聊邀请列表："];
-    for (const [, invite] of pendingInvites) {
+    for (const invite of allInvites) {
       const elapsed = Math.floor((Date.now() - invite.time) / 1e3 / 60);
       lines.push(`- 群：${invite.groupName}（${invite.groupId}）`);
       lines.push(`  邀请者：${invite.userName}（${invite.userId}）`);
@@ -643,7 +726,8 @@ __export(commands_exports, {
 });
 var name5 = "group-control-commands";
 function apply5(ctx, config) {
-  async function viewBlacklist() {
+  async function viewBlacklist({ session }) {
+    if (!isGlobalAdmin(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
     const errorMsg = isBlacklistEnabled(config.basic);
     if (errorMsg) return errorMsg;
     const records = await getAllBlacklistedGuilds(ctx);
@@ -651,8 +735,9 @@ function apply5(ctx, config) {
     return "黑名单列表：\n" + records.map((r) => `- ${r.guildId} (时间: ${formatDate(r.timestamp)})`).join("\n");
   }
   __name(viewBlacklist, "viewBlacklist");
-  ctx.command("view-blacklist", "查看被拉黑的群聊列表", { authority: 4 }).action(viewBlacklist);
-  async function removeFromBlacklist({}, input) {
+  ctx.command("banlist", "查看被拉黑的群聊列表").action(viewBlacklist);
+  async function removeFromBlacklist({ session }, input) {
+    if (!isGlobalAdmin(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
     const errorMsg = isBlacklistEnabled(config.basic);
     if (errorMsg) return errorMsg;
     const guildId = parseGuildId(input);
@@ -661,8 +746,9 @@ function apply5(ctx, config) {
     return removed ? `已移除群聊 ${guildId}` : `群聊 ${guildId} 不在黑名单中。`;
   }
   __name(removeFromBlacklist, "removeFromBlacklist");
-  ctx.command("remove-from-blacklist <groupId:text>", "从黑名单移除指定群聊", { authority: 4 }).action(removeFromBlacklist);
-  async function addToBlacklist({}, input) {
+  ctx.command("unban <groupId:text>", "从黑名单移除指定群聊").action(removeFromBlacklist);
+  async function addToBlacklist({ session }, input) {
+    if (!isGlobalAdmin(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
     const errorMsg = isBlacklistEnabled(config.basic);
     if (errorMsg) return errorMsg;
     const guildId = parseGuildId(input);
@@ -673,8 +759,9 @@ function apply5(ctx, config) {
     return `已添加群聊 ${guildId} 到黑名单。`;
   }
   __name(addToBlacklist, "addToBlacklist");
-  ctx.command("add-to-blacklist <groupId:text>", "手动添加群聊到黑名单", { authority: 4 }).action(addToBlacklist);
-  async function clearBlacklist() {
+  ctx.command("ban <groupId:text>", "手动添加群聊到黑名单").action(addToBlacklist);
+  async function clearBlacklist({ session }) {
+    if (!isGlobalAdmin(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
     const errorMsg = isBlacklistEnabled(config.basic);
     if (errorMsg) return errorMsg;
     const records = await getAllBlacklistedGuilds(ctx);
@@ -683,7 +770,31 @@ function apply5(ctx, config) {
     return `已清空黑名单，共移除 ${records.length} 个群聊。`;
   }
   __name(clearBlacklist, "clearBlacklist");
-  ctx.command("clear-blacklist", "清空黑名单", { authority: 4 }).action(clearBlacklist);
+  ctx.command("clearban", "清空黑名单").action(clearBlacklist);
+  ctx.command("sg-add <groupId:text>", "解除指定群聊的小群人数限制").action(async ({ session }, input) => {
+    if (!isGlobalAdmin(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    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("sg-rm <groupId:text>", "恢复指定群聊的小群人数限制").action(async ({ session }, input) => {
+    if (!isGlobalAdmin(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    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("sg-list", "查看小群白名单").action(async ({ session }) => {
+    if (!isGlobalAdmin(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    const records = await getAllSmallGroupWhitelist(ctx);
+    if (records.length === 0) return "小群白名单为空。";
+    return "小群白名单列表（以下群不受小群人数限制）：\n" + records.map((r) => `- ${r.guildId}`).join("\n");
+  });
 }
 __name(apply5, "apply");
 
@@ -820,7 +931,8 @@ var Config = import_koishi.Schema.intersect([
       inviteWaitMessage: import_koishi.Schema.string().default("已收到您的群聊邀请，正在等待管理员审核，请耐心等待。").description("发送给邀请者的等待审核提示消息"),
       inviteRequestMessage: import_koishi.Schema.string().default("收到新的群聊邀请请求：\n群名称：{groupName}\n群号：{groupId}\n邀请者：{userName} (QQ: {userId})\n\n请管理员使用指令 approve {groupId} 同意或 reject {groupId} 拒绝。").description("发送给管理员的邀请请求消息模板，支持变量{groupName}, {groupId}, {userName}, {userId}"),
       autoApprove: import_koishi.Schema.boolean().default(false).description("是否自动同意邀请（仅在没有指定管理员时）"),
-      showDetailedLog: import_koishi.Schema.boolean().default(false).description("是否显示详细日志")
+      showDetailedLog: import_koishi.Schema.boolean().default(false).description("是否显示详细日志"),
+      inviteExpireDays: import_koishi.Schema.number().default(3).description("邀请记录过期时间（天），超过此时间未处理的邀请将被自动清理")
     }).description("群聊邀请审核")
   }),
   import_koishi.Schema.object({

package/lib/utils.d.ts

@@ -10,5 +10,10 @@ export declare function notifyAdmins(bot: any, config: Config, message: string):
  * - builtin 模式: 检查用户是否为群管理员/群主，或在管理员QQ列表中
  */
 export declare function hasPermission(session: Session, config: Config): Promise<boolean>;
+/**
+ * 检查当前用户是否拥有全局管理权限
+ * （供独立于群聊的全局指令（如黑名单、白名单）使用）
+ */
+export declare function isGlobalAdmin(session: Session, config: Config): boolean;
 /** 管理指令列表 - 这些指令始终不受 bot-off 影响 */
 export declare const ADMIN_COMMANDS: Set<string>;

package/package.json

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