koishi-plugin-group-control 0.2.7 → 0.2.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 muyni
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/config.d.ts

@@ -5,13 +5,13 @@ export interface GroupConfig {
     quitMessage: string;
     enableBlacklist: boolean;
     quitCommandEnabled: boolean;
-    quitCommandAuthority: number;
     notifyAdminOnKick: boolean;
     kickNotificationMessage: string;
     smallGroupAutoQuit: boolean;
     smallGroupThreshold: number;
     smallGroupQuitMessage: string;
     smallGroupNotifyAdmin: boolean;
+    smallGroupCheckDelay: number;
 }
 export interface GroupInviteConfig {
     enabled: boolean;
@@ -37,12 +37,17 @@ export interface BotSwitchConfig {
     enabled: boolean;
     defaultState: boolean;
     disabledMessage: string;
-    toggleAuthority: number;
+}
+export interface PermissionConfig {
+    mode: 'koishi' | 'builtin';
+    koishiAuthority: number;
+    protectedCommands: string[];
 }
 export interface Config {
     basic: GroupConfig;
     frequency: FrequencyConfig;
     invite: GroupInviteConfig;
     botSwitch: BotSwitchConfig;
+    permission: PermissionConfig;
 }
 export declare const Config: Schema<Config>;

package/lib/database.d.ts

@@ -31,7 +31,7 @@ export declare function apply(ctx: Context): void;
 export declare const BLACKLIST_PLATFORM = "onebot";
 export declare function getBlacklistedGuild(ctx: Context, guildId: string): Promise<BlacklistedGuild[]>;
 export declare function removeBlacklistedGuild(ctx: Context, guildId: string): Promise<import("minato").Driver.WriteResult>;
-export declare function createBlacklistedGuild(ctx: Context, guildId: string, reason: string): Promise<BlacklistedGuild>;
+export declare function createBlacklistedGuild(ctx: Context, guildId: string, reason: string): Promise<import("minato").Driver.WriteResult>;
 export declare function getAllBlacklistedGuilds(ctx: Context): Promise<BlacklistedGuild[]>;
 export declare function clearBlacklistedGuilds(ctx: Context): Promise<import("minato").Driver.WriteResult>;
 export declare function getCommandFrequencyRecord(ctx: Context, platform: string, guildId: string): Promise<CommandFrequencyRecord>;

package/lib/index.js

@@ -76,12 +76,12 @@ async function removeBlacklistedGuild(ctx, guildId) {
 }
 __name(removeBlacklistedGuild, "removeBlacklistedGuild");
 async function createBlacklistedGuild(ctx, guildId, reason) {
-  return await ctx.model.create("blacklisted_guild", {
+  return await ctx.model.upsert("blacklisted_guild", [{
     platform: BLACKLIST_PLATFORM,
     guildId,
     timestamp: Math.floor(Date.now() / 1e3),
     reason
-  });
+  }]);
 }
 __name(createBlacklistedGuild, "createBlacklistedGuild");
 async function getAllBlacklistedGuilds(ctx) {
@@ -157,11 +157,76 @@ async function notifyAdmins(bot, config, message) {
   }
 }
 __name(notifyAdmins, "notifyAdmins");
+async function hasPermission(session, config) {
+  if (config.permission.mode === "koishi") {
+    try {
+      const user = session.user;
+      if (user && typeof user.authority === "number") {
+        return user.authority >= config.permission.koishiAuthority;
+      }
+    } catch {
+    }
+    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;
+    if (roles) {
+      if (Array.isArray(roles)) {
+        return roles.some((r) => r === "admin" || r === "owner");
+      }
+      return roles === "admin" || roles === "owner" || roles === "administrator";
+    }
+    const role = member?.role;
+    if (role === "admin" || role === "owner") return true;
+  } catch (error) {
+    try {
+      const info = await session.bot.internal?.getGroupMemberInfo?.(
+        parseInt(session.guildId),
+        parseInt(userId)
+      );
+      if (info) {
+        return info.role === "admin" || info.role === "owner";
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+__name(hasPermission, "hasPermission");
+var ADMIN_COMMANDS = /* @__PURE__ */ new Set([
+  "bot-on",
+  "bot-off",
+  "quit",
+  "view-blacklist",
+  "remove-from-blacklist",
+  "add-to-blacklist",
+  "clear-blacklist",
+  "approve",
+  "reject",
+  "pending-invites"
+]);
 
 // src/modules/basic.ts
 var name2 = "group-control-basic";
 function apply2(ctx, config) {
-  const quittingGuilds = /* @__PURE__ */ new Set();
+  const quittingGuilds = /* @__PURE__ */ new Map();
+  const processedKicks = /* @__PURE__ */ new Map();
+  const QUITTING_EXPIRE_MS = 60 * 1e3;
+  const KICK_DEDUP_MS = 60 * 1e3;
+  setInterval(() => {
+    const now = Date.now();
+    for (const [key, time] of quittingGuilds) {
+      if (now - time > QUITTING_EXPIRE_MS) quittingGuilds.delete(key);
+    }
+    for (const [key, time] of processedKicks) {
+      if (now - time > KICK_DEDUP_MS) processedKicks.delete(key);
+    }
+  }, 30 * 1e3);
   ctx.on("guild-added", async (session) => {
     const { guildId, platform } = session;
     if (config.basic.enableBlacklist) {
@@ -171,7 +236,7 @@ function apply2(ctx, config) {
           await session.bot.sendMessage(guildId, config.basic.blacklistMessage, platform);
         } catch (e) {
         }
-        quittingGuilds.add(`${platform}:${guildId}`);
+        quittingGuilds.set(`${platform}:${guildId}`, Date.now());
         try {
           await session.bot.internal.setGroupLeave(parseInt(guildId));
         } catch (e) {
@@ -180,34 +245,54 @@ function apply2(ctx, config) {
       }
     }
     if (config.basic.smallGroupAutoQuit) {
-      try {
-        const guildInfo = await session.bot.getGuild(guildId);
-        const memberCount = guildInfo?.member_count || guildInfo?.memberCount || 0;
-        if (memberCount > 0 && memberCount <= config.basic.smallGroupThreshold) {
-          const quitMsg = config.basic.smallGroupQuitMessage.replace("{memberCount}", memberCount.toString()).replace("{threshold}", config.basic.smallGroupThreshold.toString());
+      const delay = config.basic.smallGroupCheckDelay || 3e3;
+      setTimeout(async () => {
+        try {
+          let memberCount = 0;
           try {
-            await session.bot.sendMessage(guildId, quitMsg, platform);
-          } catch (e) {
+            const groupInfo = await session.bot.internal?.getGroupInfo?.(parseInt(guildId));
+            memberCount = groupInfo?.member_count || 0;
+          } catch {
           }
-          if (config.basic.smallGroupNotifyAdmin) {
-            const adminMsg = `小群自动退群
+          if (memberCount === 0) {
+            try {
+              const guildInfo = await session.bot.getGuild(guildId);
+              memberCount = guildInfo?.member_count || guildInfo?.memberCount || 0;
+            } catch {
+            }
+          }
+          if (memberCount === 0) {
+            try {
+              const memberList = await session.bot.getGuildMemberList(guildId);
+              memberCount = memberList?.data?.length || 0;
+            } 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 (config.basic.smallGroupNotifyAdmin) {
+              const adminMsg = `小群自动退群
 群号：${guildId}
 群成员数：${memberCount}人（阈值：${config.basic.smallGroupThreshold}人）
 机器人已自动退出该群。`;
-            await notifyAdmins(session.bot, config, adminMsg);
-          }
-          quittingGuilds.add(`${platform}:${guildId}`);
-          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}`);
+            }
           }
-          return;
+        } catch (error) {
+          console.error(`小群自动退群检测失败 (群号: ${guildId}):`, error);
         }
-      } catch (error) {
-        console.error(`获取群信息失败 (群号: ${guildId}):`, error);
-      }
+      }, delay);
     }
     if (config.basic.welcomeMessage) {
       try {
@@ -220,9 +305,12 @@ function apply2(ctx, config) {
     const { guildId, platform } = session;
     const quittingKey = `${platform}:${guildId}`;
     if (quittingGuilds.has(quittingKey)) {
-      quittingGuilds.delete(quittingKey);
       return;
     }
+    if (processedKicks.has(quittingKey)) {
+      return;
+    }
+    processedKicks.set(quittingKey, Date.now());
     if (config.basic.enableBlacklist) {
       await ctx.model.upsert("blacklisted_guild", [{
         platform,
@@ -237,10 +325,21 @@ function apply2(ctx, config) {
     }
   });
   if (config.basic.quitCommandEnabled) {
-    ctx.command("quit", "让机器人主动退出当前群聊", { authority: config.basic.quitCommandAuthority }).action(async ({ session }) => {
+    const cmdOpts = {};
+    if (config.permission.mode === "koishi") {
+      cmdOpts.authority = config.permission.koishiAuthority;
+    }
+    ctx.command("quit", "让机器人主动退出当前群聊", cmdOpts).action(async ({ session }) => {
       if (!session.guildId) return "quit 指令只能在群聊中使用。";
+      if (config.permission.mode === "builtin") {
+        const hasPerm = await hasPermission(session, config);
+        if (!hasPerm) return "权限不足，只有群管理员可以使用此指令。";
+      }
       const { guildId, platform, userId } = session;
-      quittingGuilds.add(`${platform}:${guildId}`);
+      const adminMsg = `收到来自 ${userId} 的退群指令
+群号：${guildId}`;
+      await notifyAdmins(session.bot, config, adminMsg);
+      quittingGuilds.set(`${platform}:${guildId}`, Date.now());
       try {
         await session.bot.sendMessage(session.guildId, config.basic.quitMessage.replace("{userId}", userId), platform);
       } catch (e) {
@@ -267,6 +366,18 @@ 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}`);
+        }
+      }
+    }
+  }, 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;
@@ -294,7 +405,7 @@ function apply3(ctx, config) {
       console.error("获取群信息失败:", error);
     }
     try {
-      const waitMessage = config.invite.inviteWaitMessage.replace("{groupName}", groupName).replace("{groupId}", rawGroupId).replace("{userName}", userName).replace("{userId}", rawUserId);
+      const waitMessage = config.invite.inviteWaitMessage.replaceAll("{groupName}", groupName).replaceAll("{groupId}", rawGroupId).replaceAll("{userName}", userName).replaceAll("{userId}", rawUserId);
       await session.bot.sendPrivateMessage(rawUserId, waitMessage);
     } catch (error) {
       console.error(`发送等待审核提示给 ${rawUserId} 失败:`, error);
@@ -302,12 +413,7 @@ function apply3(ctx, config) {
     if (!config.invite.adminQQs || config.invite.adminQQs.length === 0) {
       if (config.invite.autoApprove) {
         try {
-          await session.bot.internal.setGroupAddRequest({
-            flag,
-            sub_type: "invite",
-            approve: true,
-            reason: ""
-          });
+          await session.bot.internal.setGroupAddRequest(flag, "invite", true, "");
           if (config.invite.showDetailedLog) {
             console.log(`自动同意群聊邀请: 群号 ${rawGroupId}, 邀请者 ${rawUserId}`);
           }
@@ -317,15 +423,15 @@ function apply3(ctx, config) {
       }
       return;
     }
-    const inviteId = `${rawGroupId}_${rawUserId}_${Date.now()}`;
-    pendingInvites.set(inviteId, {
+    pendingInvites.set(rawGroupId, {
       groupId: rawGroupId,
       userId: rawUserId,
       userName,
+      groupName,
       time: Date.now(),
       flag
     });
-    const requestMessage = config.invite.inviteRequestMessage.replace("{groupName}", groupName).replace("{groupId}", rawGroupId).replace("{userName}", userName).replace("{userId}", rawUserId);
+    const requestMessage = config.invite.inviteRequestMessage.replaceAll("{groupName}", groupName).replaceAll("{groupId}", rawGroupId).replaceAll("{userName}", userName).replaceAll("{userId}", rawUserId);
     let requestSent = false;
     if (config.invite.notificationGroupId) {
       try {
@@ -355,117 +461,69 @@ function apply3(ctx, config) {
       console.warn("群邀请请求发送失败：未配置通知群且管理员私聊发送失败");
     }
   });
-  ctx.on("message", async (session) => {
-    const { userId, guildId } = session;
-    if (!config.invite.adminQQs.includes(userId)) return;
-    const isNotificationGroup = config.invite.notificationGroupId && guildId === config.invite.notificationGroupId;
-    const isPrivate = !guildId;
-    if (!isNotificationGroup && !isPrivate && config.invite.notificationGroupId) return;
-    const hasQuote = session.elements.some((element) => element.type === "quote");
-    if (!hasQuote) return;
-    const textContent = session.elements.filter((element) => element.type === "text").map((element) => element.attrs?.content || "").join("").trim();
-    if (config.invite.showDetailedLog) {
-      console.log(`管理员审核回复 - 原始content: "${session.content}", 提取文本: "${textContent}"`);
+  ctx.command("approve <groupId:string>", "同意群聊邀请", { authority: 4 }).action(async ({ session }, groupId) => {
+    if (!groupId) return "请指定群号。用法：approve <群号>";
+    if (!config.invite.adminQQs.includes(session.userId)) {
+      return "权限不足，只有管理员可以审核邀请。";
     }
-    if (!["同意", "拒绝", "accept", "reject"].includes(textContent)) return;
-    const quoteElement = session.elements.find((element) => element.type === "quote");
-    if (!quoteElement) return;
-    let quoteMessageContent = "";
-    if (session.quote?.content) {
-      quoteMessageContent = session.quote.content;
+    const inviteData = pendingInvites.get(groupId);
+    if (!inviteData) {
+      return `未找到群号 ${groupId} 的待处理邀请。当前待处理邀请：${pendingInvites.size > 0 ? Array.from(pendingInvites.values()).map((i) => `${i.groupId}(${i.groupName})`).join(", ") : "无"}`;
     }
-    if (!quoteMessageContent) {
-      quoteMessageContent = quoteElement.attrs?.content || quoteElement.attrs?.text || "";
+    try {
+      await session.bot.internal.setGroupAddRequest(inviteData.flag, "invite", true, "");
+      try {
+        await session.bot.sendPrivateMessage(inviteData.userId, `您的群聊邀请已通过管理员审核，机器人已加入群聊。`);
+      } catch (error) {
+        console.error("通知邀请者失败:", error);
+      }
+      pendingInvites.delete(groupId);
+      return `已同意加入群 ${groupId}（${inviteData.groupName}），邀请者：${inviteData.userName}`;
+    } catch (error) {
+      console.error("处理同意邀请失败:", error);
+      return `处理同意邀请失败: ${error.message}`;
     }
-    if (!quoteMessageContent && quoteElement.children?.length > 0) {
-      quoteMessageContent = quoteElement.children.filter((child) => child.type === "text").map((child) => child.attrs?.content || "").join("");
+  });
+  ctx.command("reject <groupId:string>", "拒绝群聊邀请", { authority: 4 }).action(async ({ session }, groupId) => {
+    if (!groupId) return "请指定群号。用法：reject <群号>";
+    if (!config.invite.adminQQs.includes(session.userId)) {
+      return "权限不足，只有管理员可以审核邀请。";
     }
-    if (!quoteMessageContent) {
-      const quoteId = quoteElement.attrs?.id || session.quote?.id;
-      if (quoteId) {
-        try {
-          const channelId = guildId || session.channelId;
-          if (channelId) {
-            const originalMsg = await session.bot.getMessage(channelId, quoteId);
-            if (originalMsg?.content) {
-              quoteMessageContent = originalMsg.content;
-            }
-          }
-        } catch (error) {
-          if (config.invite.showDetailedLog) {
-            console.error("通过消息ID获取引用消息内容失败:", error);
-          }
-        }
-      }
+    const inviteData = pendingInvites.get(groupId);
+    if (!inviteData) {
+      return `未找到群号 ${groupId} 的待处理邀请。当前待处理邀请：${pendingInvites.size > 0 ? Array.from(pendingInvites.values()).map((i) => `${i.groupId}(${i.groupName})`).join(", ") : "无"}`;
     }
-    if (config.invite.showDetailedLog) {
-      console.log(`引用消息内容: "${quoteMessageContent}"`);
-    }
-    const groupIdMatch = quoteMessageContent.match(/群号[：:]\s*(\d+)/i);
-    const userIdMatch = quoteMessageContent.match(/QQ[：:]\s*(\d+)/i);
-    if (groupIdMatch && userIdMatch) {
-      const extractedGroupId = groupIdMatch[1];
-      const extractedUserId = userIdMatch[1];
-      if (config.invite.showDetailedLog) {
-        console.log(`提取到群号: ${extractedGroupId}, QQ: ${extractedUserId}`);
-      }
-      let targetInviteId = null;
-      for (const [inviteId, inviteData] of pendingInvites) {
-        if (inviteData.groupId === extractedGroupId && inviteData.userId === extractedUserId) {
-          targetInviteId = inviteId;
-          break;
-        }
-      }
-      if (targetInviteId) {
-        const inviteData = pendingInvites.get(targetInviteId);
-        if (inviteData) {
-          if (textContent === "同意" || textContent === "accept") {
-            try {
-              await session.bot.internal.setGroupAddRequest({
-                flag: inviteData.flag,
-                sub_type: "invite",
-                approve: true,
-                reason: ""
-              });
-              await session.send(`已同意加入群 ${inviteData.groupId}`);
-              try {
-                await session.bot.sendPrivateMessage(inviteData.userId, `您的群聊邀请已通过管理员审核，机器人已加入群聊。`);
-              } catch (error) {
-                console.error("通知邀请者失败:", error);
-              }
-            } catch (error) {
-              console.error("处理同意邀请失败:", error);
-              await session.send(`处理同意邀请失败: ${error.message}`);
-            }
-          } else {
-            try {
-              await session.bot.internal.setGroupAddRequest({
-                flag: inviteData.flag,
-                sub_type: "invite",
-                approve: false,
-                reason: "已拒绝"
-              });
-              await session.send(`已拒绝加入群 ${inviteData.groupId}`);
-              try {
-                await session.bot.sendPrivateMessage(inviteData.userId, `您的群聊邀请未通过管理员审核，机器人将不会加入该群聊。`);
-              } catch (error) {
-                console.error("通知邀请者失败:", error);
-              }
-            } catch (error) {
-              console.error("处理拒绝邀请失败:", error);
-              await session.send(`处理拒绝邀请失败: ${error.message}`);
-            }
-          }
-          pendingInvites.delete(targetInviteId);
-        }
-      } else if (config.invite.showDetailedLog) {
-        console.log(`未找到匹配的待处理邀请: 群号=${extractedGroupId}, QQ=${extractedUserId}`);
-        console.log(`当前待处理邀请列表:`, Array.from(pendingInvites.entries()));
+    try {
+      await session.bot.internal.setGroupAddRequest(inviteData.flag, "invite", false, "已拒绝");
+      try {
+        await session.bot.sendPrivateMessage(inviteData.userId, `您的群聊邀请未通过管理员审核，机器人将不会加入该群聊。`);
+      } catch (error) {
+        console.error("通知邀请者失败:", error);
       }
-    } else if (config.invite.showDetailedLog) {
-      console.log(`无法从引用消息中提取群号或QQ号，引用内容: "${quoteMessageContent}"`);
+      pendingInvites.delete(groupId);
+      return `已拒绝加入群 ${groupId}（${inviteData.groupName}），邀请者：${inviteData.userName}`;
+    } catch (error) {
+      console.error("处理拒绝邀请失败:", error);
+      return `处理拒绝邀请失败: ${error.message}`;
     }
   });
+  ctx.command("pending-invites", "查看待处理的群聊邀请", { authority: 4 }).action(async ({ session }) => {
+    if (!config.invite.adminQQs.includes(session.userId)) {
+      return "权限不足，只有管理员可以查看待处理邀请。";
+    }
+    if (pendingInvites.size === 0) {
+      return "当前没有待处理的群聊邀请。";
+    }
+    const lines = ["待处理的群聊邀请列表："];
+    for (const [, invite] of pendingInvites) {
+      const elapsed = Math.floor((Date.now() - invite.time) / 1e3 / 60);
+      lines.push(`- 群：${invite.groupName}（${invite.groupId}）`);
+      lines.push(`  邀请者：${invite.userName}（${invite.userId}）`);
+      lines.push(`  ${elapsed} 分钟前`);
+      lines.push(`  同意：approve ${invite.groupId} | 拒绝：reject ${invite.groupId}`);
+    }
+    return lines.join("\n");
+  });
 }
 __name(apply3, "apply");
 
@@ -603,42 +661,62 @@ __export(switch_exports, {
 });
 var name6 = "group-control-switch";
 function apply6(ctx, config) {
+  if (config.permission.protectedCommands?.length > 0) {
+    const protectedSet = new Set(config.permission.protectedCommands);
+    ctx.on("command/before-execute", async (argv) => {
+      const session = argv.session;
+      if (!session.guildId) return;
+      const commandName = argv.command.name;
+      if (!protectedSet.has(commandName)) return;
+      const hasPerm = await hasPermission(session, config);
+      if (!hasPerm) {
+        return "权限不足，只有群管理员可以使用此指令。";
+      }
+    }, true);
+  }
   if (!config.botSwitch?.enabled) return;
-  ctx.command("bot-on", "开启机器人", { authority: config.botSwitch.toggleAuthority }).action(async ({ session }) => {
+  const cmdOpts = {};
+  if (config.permission.mode === "koishi") {
+    cmdOpts.authority = config.permission.koishiAuthority;
+  }
+  ctx.command("bot-on", "开启机器人", cmdOpts).action(async ({ session }) => {
     if (!session.guildId) return "该指令只能在群聊中使用。";
+    if (config.permission.mode === "builtin") {
+      const hasPerm = await hasPermission(session, config);
+      if (!hasPerm) return "权限不足，只有群管理员可以使用此指令。";
+    }
     await setGroupBotStatus(ctx, session.platform, session.guildId, true);
     return "机器人已在此群开启。";
   });
-  ctx.command("bot-off", "关闭机器人", { authority: config.botSwitch.toggleAuthority }).action(async ({ session }) => {
+  ctx.command("bot-off", "关闭机器人", cmdOpts).action(async ({ session }) => {
     if (!session.guildId) return "该指令只能在群聊中使用。";
+    if (config.permission.mode === "builtin") {
+      const hasPerm = await hasPermission(session, config);
+      if (!hasPerm) return "权限不足，只有群管理员可以使用此指令。";
+    }
     await setGroupBotStatus(ctx, session.platform, session.guildId, false);
-    return "机器人已在此群关闭。";
+    return "机器人已在此群关闭。所有指令和主动响应（入群欢迎、链接解析等）将被阻止。使用 bot-on 重新开启。";
   });
-  ctx.on(
-    "command/before-execute",
-    async (argv) => {
-      const session = argv.session;
-      if (!session.guildId) return;
-      if (argv.command.name === "bot-on" || argv.command.name === "bot-off") {
-        return;
-      }
-      const status = await getGroupBotStatus(ctx, session.platform, session.guildId);
-      const isBotEnabled = status ? status.botEnabled : config.botSwitch.defaultState;
-      if (!isBotEnabled) {
-        const isMentioned = session.elements?.some((e) => e.type === "at" && e.attrs.id === session.bot.userId);
-        if (isMentioned && config.botSwitch.disabledMessage) {
-          try {
-            await session.send(config.botSwitch.disabledMessage);
-          } catch (e) {
-            ctx.logger("group-control-switch").warn("发送关闭提示失败", e);
-          }
+  ctx.on("command/before-execute", async (argv) => {
+    const session = argv.session;
+    if (!session.guildId) return;
+    if (ADMIN_COMMANDS.has(argv.command.name)) {
+      return;
+    }
+    const status = await getGroupBotStatus(ctx, session.platform, session.guildId);
+    const isBotEnabled = status ? status.botEnabled : config.botSwitch.defaultState;
+    if (!isBotEnabled) {
+      const isMentioned = session.elements?.some((e) => e.type === "at" && e.attrs.id === session.bot.userId);
+      if (isMentioned && config.botSwitch.disabledMessage) {
+        try {
+          await session.send(config.botSwitch.disabledMessage);
+        } catch (e) {
+          ctx.logger("group-control-switch").warn("发送关闭提示失败", e);
         }
-        return "";
       }
-    },
-    true
-    /* append，在其他验证之后执行 */
-  );
+      return "";
+    }
+  }, true);
   ctx.middleware(async (session, next) => {
     if (!session.guildId) return next();
     const status = await getGroupBotStatus(ctx, session.platform, session.guildId);
@@ -654,27 +732,37 @@ function apply6(ctx, config) {
       }
     }
     return;
-  });
+  }, true);
 }
 __name(apply6, "apply");
 
 // src/config.ts
 var import_koishi = require("koishi");
 var Config = import_koishi.Schema.intersect([
+  import_koishi.Schema.object({
+    permission: import_koishi.Schema.object({
+      mode: import_koishi.Schema.union([
+        import_koishi.Schema.const("koishi").description("使用 Koishi 自带权限系统 (authority)"),
+        import_koishi.Schema.const("builtin").description("使用插件内置权限管理 (群管理员/群主)")
+      ]).default("builtin").description("权限管理模式"),
+      koishiAuthority: import_koishi.Schema.number().default(3).description("Koishi 模式下，管理指令所需的最低权限等级"),
+      protectedCommands: import_koishi.Schema.array(String).default([]).description("需要群管理员权限才能使用的自定义指令名列表（如来自其他插件的指令）")
+    }).description("权限管理")
+  }),
   import_koishi.Schema.object({
     basic: import_koishi.Schema.object({
       welcomeMessage: import_koishi.Schema.string().default("你好，我是机器人。").description("机器人加入群聊时发送的欢迎消息"),
       blacklistMessage: import_koishi.Schema.string().default("此群聊已被拉黑，机器人将自动退出，请联系管理员移出黑名单。").description("被拉入黑名单群后在群内发送的提示"),
       quitMessage: import_koishi.Schema.string().default("收到来自{userId}的指令，即将退出群聊。").description("用户发送quit指令后在群内发送的提示，支持变量{userId}"),
       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}"),
       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}"),
       smallGroupNotifyAdmin: import_koishi.Schema.boolean().default(true).description("小群自动退群时通知管理员"),
-      quitCommandEnabled: import_koishi.Schema.boolean().default(true).description("启用quit"),
-      quitCommandAuthority: import_koishi.Schema.number().default(3).description("quit指令所需权限")
+      smallGroupCheckDelay: import_koishi.Schema.number().default(3e3).description("小群检测延迟（毫秒），加入群聊后等待一段时间再获取群信息以确保数据准确")
     }).description("基础群组管理")
   }),
   import_koishi.Schema.object({
@@ -696,7 +784,7 @@ var Config = import_koishi.Schema.intersect([
       adminQQs: import_koishi.Schema.array(String).default([]).description("管理员QQ号列表（用于权限验证）"),
       notificationGroupId: import_koishi.Schema.string().description("通知群号（可选：若填写，邀请请求将发送到此群；若不填，则发送私聊给管理员）"),
       inviteWaitMessage: import_koishi.Schema.string().default("已收到您的群聊邀请，正在等待管理员审核，请耐心等待。").description("发送给邀请者的等待审核提示消息"),
-      inviteRequestMessage: import_koishi.Schema.string().default('收到新的群聊邀请请求：\n群名称：{groupName}\n群号：{groupId}\n邀请者：{userName} (QQ: {userId})\n\n请管理员引用此消息回复"同意"或"拒绝"。').description("发送给管理员的邀请请求消息模板，支持变量{groupName}, {groupId}, {userName}, {userId}"),
+      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("是否显示详细日志")
     }).description("群聊邀请审核")
@@ -705,8 +793,7 @@ var Config = import_koishi.Schema.intersect([
     botSwitch: import_koishi.Schema.object({
       enabled: import_koishi.Schema.boolean().default(true).description("启用独立的群聊bot开关功能"),
       defaultState: import_koishi.Schema.boolean().default(true).description("群聊中的默认开启状态"),
-      disabledMessage: import_koishi.Schema.string().default("机器人当前在此群处于关闭状态，请使用bot-on开启。").description("机器人在关闭状态下被@时的提示消息"),
-      toggleAuthority: import_koishi.Schema.number().default(3).description("开关Bot指令(bot-on/bot-off)所需权限")
+      disabledMessage: import_koishi.Schema.string().default("机器人当前在此群处于关闭状态，请使用bot-on开启。").description("机器人在关闭状态下被@时的提示消息")
     }).description("机器人开关控制")
   })
 ]);

package/lib/utils.d.ts

@@ -1,5 +1,14 @@
+import { Session } from 'koishi';
 import { Config } from './config';
 export declare function isBlacklistEnabled(config: Config['basic']): string | null;
 export declare function parseGuildId(input: string): string | null;
 export declare function formatDate(timestamp: number): string;
 export declare function notifyAdmins(bot: any, config: Config, message: string): Promise<void>;
+/**
+ * 检查用户是否有管理权限
+ * - koishi 模式: 使用 Koishi 自带的 authority 系统
+ * - builtin 模式: 检查用户是否为群管理员/群主，或在管理员QQ列表中
+ */
+export declare function hasPermission(session: Session, config: Config): Promise<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.7",
+  "version": "0.2.9",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -23,4 +23,4 @@
   "peerDependencies": {
     "koishi": "^4.18.7"
   }
-}
+}