koishi-plugin-group-control 0.2.12 → 1.0.0-alpha.1

package/lib/config.d.ts

@@ -1,10 +1,10 @@
 import { Schema } from 'koishi';
 export interface GroupConfig {
     welcomeMessage: string;
-    blacklistMessage: string;
     quitMessage: string;
-    enableBlacklist: boolean;
     quitCommandEnabled: boolean;
+    enableBlacklist: boolean;
+    blacklistMessage: string;
     notifyAdminOnKick: boolean;
     kickNotificationMessage: string;
     smallGroupAutoQuit: boolean;
@@ -12,6 +12,10 @@ export interface GroupConfig {
     smallGroupQuitMessage: string;
     smallGroupNotifyAdmin: boolean;
     smallGroupCheckDelay: number;
+    smallGroupQualifiedNotifyAdmin: boolean;
+    smallGroupQualifiedMessage: string;
+    notifyAdminOnMute: boolean;
+    muteNotificationMessage: string;
 }
 export interface GroupInviteConfig {
     enabled: boolean;
@@ -29,10 +33,27 @@ export interface FrequencyConfig {
     window: number;
     warnDelay: number;
     blockDur: number;
+    whitelist: string[];
+    privateEnabled: boolean;
+    privateLimit: number;
+    privateWindow: number;
+    privateWarnDelay: number;
+    privateBlockDur: number;
+    privateWhitelist: string[];
+    blockExpBase: number;
+    blockExpWindow: number;
+    blockNotifyCooldown: number;
     warnMsg: string;
     blockMsg: string;
     blockedMsg: string;
-    whitelist: string[];
+}
+export interface FriendConfig {
+    enabled: boolean;
+    autoApprove: boolean;
+    notifyAdminOnApprove: boolean;
+    requestExpireDays: number;
+    requestMessage: string;
+    approveNotificationMessage: string;
 }
 export interface BotSwitchConfig {
     enabled: boolean;
@@ -45,10 +66,11 @@ export interface PermissionConfig {
     protectedCommands: string[];
 }
 export interface Config {
+    permission: PermissionConfig;
     basic: GroupConfig;
-    frequency: FrequencyConfig;
     invite: GroupInviteConfig;
+    friend: FriendConfig;
+    frequency: FrequencyConfig;
     botSwitch: BotSwitchConfig;
-    permission: PermissionConfig;
 }
 export declare const Config: Schema<Config>;

package/lib/database.d.ts

@@ -13,6 +13,8 @@ export interface CommandFrequencyRecord {
     warningSent: boolean;
     blockExpiryTime: number;
     firstWarningTime: number;
+    blockCount: number;
+    lastBlockNotifyTime: number;
 }
 export interface GroupBotStatus {
     platform: string;
@@ -32,6 +34,14 @@ export interface PendingInvite {
     time: number;
     flag: string;
 }
+export interface PendingFriendRequest {
+    platform: string;
+    userId: string;
+    nickname: string;
+    comment: string;
+    flag: string;
+    time: number;
+}
 declare module 'koishi' {
     interface Tables {
         blacklisted_guild: BlacklistedGuild;
@@ -39,6 +49,7 @@ declare module 'koishi' {
         group_bot_status: GroupBotStatus;
         small_group_whitelist: SmallGroupWhitelist;
         pending_invite: PendingInvite;
+        pending_friend_request: PendingFriendRequest;
     }
 }
 export declare const name = "group-control-database";
@@ -62,3 +73,8 @@ export declare function addPendingInvite(ctx: Context, inviteUser: Omit<PendingI
 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>;
+export declare function getPendingFriendRequest(ctx: Context, platform: string, userId: string): Promise<PendingFriendRequest>;
+export declare function addPendingFriendRequest(ctx: Context, platform: string, data: Omit<PendingFriendRequest, 'platform'>): Promise<void>;
+export declare function removePendingFriendRequest(ctx: Context, platform: string, userId: string): Promise<void>;
+export declare function getAllPendingFriendRequests(ctx: Context, platform: string): Promise<PendingFriendRequest[]>;
+export declare function clearExpiredPendingFriendRequests(ctx: Context, platform: string, expireTimeMs: number): Promise<number>;

package/lib/index.js

@@ -4,8 +4,8 @@ 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 name8 in all)
-    __defProp(target, name8, { get: all[name8], enumerable: true });
+  for (var name9 in all)
+    __defProp(target, name9, { get: all[name9], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -21,8 +21,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   Config: () => Config,
-  apply: () => apply7,
-  name: () => name7
+  apply: () => apply8,
+  name: () => name8
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -30,23 +30,28 @@ module.exports = __toCommonJS(src_exports);
 var database_exports = {};
 __export(database_exports, {
   BLACKLIST_PLATFORM: () => BLACKLIST_PLATFORM,
+  addPendingFriendRequest: () => addPendingFriendRequest,
   addPendingInvite: () => addPendingInvite,
   addToSmallGroupWhitelist: () => addToSmallGroupWhitelist,
   apply: () => apply,
   clearBlacklistedGuilds: () => clearBlacklistedGuilds,
+  clearExpiredPendingFriendRequests: () => clearExpiredPendingFriendRequests,
   clearExpiredPendingInvites: () => clearExpiredPendingInvites,
   createBlacklistedGuild: () => createBlacklistedGuild,
   getAllBlacklistedGuilds: () => getAllBlacklistedGuilds,
+  getAllPendingFriendRequests: () => getAllPendingFriendRequests,
   getAllPendingInvites: () => getAllPendingInvites,
   getAllSmallGroupWhitelist: () => getAllSmallGroupWhitelist,
   getBlacklistedGuild: () => getBlacklistedGuild,
   getCommandFrequencyRecord: () => getCommandFrequencyRecord,
   getGroupBotStatus: () => getGroupBotStatus,
+  getPendingFriendRequest: () => getPendingFriendRequest,
   getPendingInvite: () => getPendingInvite,
   isInSmallGroupWhitelist: () => isInSmallGroupWhitelist,
   name: () => name,
   removeBlacklistedGuild: () => removeBlacklistedGuild,
   removeFromSmallGroupWhitelist: () => removeFromSmallGroupWhitelist,
+  removePendingFriendRequest: () => removePendingFriendRequest,
   removePendingInvite: () => removePendingInvite,
   setGroupBotStatus: () => setGroupBotStatus,
   updateCommandFrequencyRecord: () => updateCommandFrequencyRecord
@@ -66,7 +71,9 @@ function apply(ctx) {
     lastCommandTime: "integer",
     warningSent: "boolean",
     blockExpiryTime: "integer",
-    firstWarningTime: "integer"
+    firstWarningTime: "integer",
+    blockCount: "integer",
+    lastBlockNotifyTime: "integer"
   }, { primary: ["platform", "guildId"] });
   ctx.model.extend("group_bot_status", {
     platform: "string",
@@ -86,6 +93,14 @@ function apply(ctx) {
     time: "integer",
     flag: "string"
   }, { primary: ["platform", "groupId"] });
+  ctx.model.extend("pending_friend_request", {
+    platform: "string",
+    userId: "string",
+    nickname: "string",
+    comment: "string",
+    flag: "string",
+    time: "integer"
+  }, { primary: ["platform", "userId"] });
 }
 __name(apply, "apply");
 var BLACKLIST_PLATFORM = "onebot";
@@ -180,6 +195,33 @@ async function clearExpiredPendingInvites(ctx, expireTimeMs) {
   return expired.length;
 }
 __name(clearExpiredPendingInvites, "clearExpiredPendingInvites");
+async function getPendingFriendRequest(ctx, platform, userId) {
+  const records = await ctx.model.get("pending_friend_request", { platform, userId });
+  return records.length > 0 ? records[0] : null;
+}
+__name(getPendingFriendRequest, "getPendingFriendRequest");
+async function addPendingFriendRequest(ctx, platform, data) {
+  await ctx.model.upsert("pending_friend_request", [{ platform, ...data }]);
+}
+__name(addPendingFriendRequest, "addPendingFriendRequest");
+async function removePendingFriendRequest(ctx, platform, userId) {
+  await ctx.model.remove("pending_friend_request", { platform, userId });
+}
+__name(removePendingFriendRequest, "removePendingFriendRequest");
+async function getAllPendingFriendRequests(ctx, platform) {
+  return await ctx.model.get("pending_friend_request", { platform });
+}
+__name(getAllPendingFriendRequests, "getAllPendingFriendRequests");
+async function clearExpiredPendingFriendRequests(ctx, platform, expireTimeMs) {
+  const cutoff = Date.now() - expireTimeMs;
+  const all = await ctx.model.get("pending_friend_request", { platform });
+  const expired = all.filter((r) => r.time < cutoff);
+  for (const record of expired) {
+    await ctx.model.remove("pending_friend_request", { platform, userId: record.userId });
+  }
+  return expired.length;
+}
+__name(clearExpiredPendingFriendRequests, "clearExpiredPendingFriendRequests");
 
 // src/modules/basic.ts
 var basic_exports = {};
@@ -398,6 +440,11 @@ function apply2(ctx, config) {
                 console.error(`小群自动退群失败 (群号: ${guildId}):`, e);
                 quittingGuilds.delete(`${platform}:${guildId}`);
               }
+            } else if (memberCount > config.basic.smallGroupThreshold) {
+              if (config.basic.smallGroupQualifiedNotifyAdmin) {
+                const qualifiedMsg = config.basic.smallGroupQualifiedMessage.replaceAll("{groupName}", groupName).replaceAll("{groupId}", guildId).replaceAll("{memberCount}", memberCount.toString()).replaceAll("{threshold}", config.basic.smallGroupThreshold.toString());
+                await notifyAdmins(session.bot, config, qualifiedMsg);
+              }
             }
           } catch (error) {
             console.error(`小群自动退群检测失败 (群号: ${guildId}):`, error);
@@ -436,6 +483,18 @@ function apply2(ctx, config) {
       await notifyAdmins(session.bot, config, kickMsg);
     }
   });
+  if (config.basic.notifyAdminOnMute) {
+    ctx.on("guild-member-mute", async (session) => {
+      if (session.userId !== session.bot?.userId) return;
+      if (!session.duration) return;
+      const { guildId, platform } = session;
+      const operatorId = session.operatorId || "未知";
+      const duration = session.duration ?? 0;
+      const groupName = await getGroupName(session.bot, guildId);
+      const msg = config.basic.muteNotificationMessage.replaceAll("{groupId}", guildId).replaceAll("{groupName}", groupName).replaceAll("{operatorId}", operatorId).replaceAll("{duration}", duration.toString());
+      await notifyAdmins(session.bot, config, msg);
+    });
+  }
   if (config.basic.quitCommandEnabled) {
     const cmdOpts = {};
     if (config.permission.mode === "koishi") {
@@ -651,70 +710,191 @@ __export(frequency_exports, {
   name: () => name4
 });
 var name4 = "group-control-frequency";
-function isCurrentlyBlocked(record) {
+var PRIVATE_GUILD_PREFIX = "__private__:";
+function isBlocked(record) {
   if (!record || !record.blockExpiryTime) return false;
   return Date.now() < record.blockExpiryTime * 1e3;
 }
-__name(isCurrentlyBlocked, "isCurrentlyBlocked");
-function apply4(ctx, config) {
-  if (!config.frequency.enabled) return;
-  ctx.on("command/before-execute", async (argv) => {
-    const session = argv.session;
-    if (!session.guildId || !config.frequency.enabled) return;
-    const { guildId, platform } = session;
-    if (config.frequency.whitelist && config.frequency.whitelist.includes(guildId)) return;
-    let record = await getCommandFrequencyRecord(ctx, platform, guildId);
-    const now = Math.floor(Date.now() / 1e3);
-    const windowStart = now - config.frequency.window;
-    if (record && record.lastCommandTime < windowStart) {
-      if (record.warningSent && record.firstWarningTime > 0 && now - record.firstWarningTime <= config.frequency.warnDelay) {
-        record.commandCount = 1;
-        record.lastCommandTime = now;
-      } else if (isCurrentlyBlocked(record) && Date.now() < record.blockExpiryTime * 1e3) {
-      } else {
-        record = { platform, guildId, commandCount: 1, lastCommandTime: now, warningSent: false, blockExpiryTime: 0, firstWarningTime: 0 };
-      }
-    } else if (!record) {
-      record = { platform, guildId, commandCount: 1, lastCommandTime: now, warningSent: false, blockExpiryTime: 0, firstWarningTime: 0 };
+__name(isBlocked, "isBlocked");
+function calcBlockDur(baseDur, expBase, blockCount) {
+  if (expBase <= 1) return baseDur;
+  return Math.round(baseDur * Math.pow(expBase, blockCount - 1));
+}
+__name(calcBlockDur, "calcBlockDur");
+function makeEmptyRecord(platform, guildId, now) {
+  return { platform, guildId, commandCount: 1, lastCommandTime: now, warningSent: false, blockExpiryTime: 0, firstWarningTime: 0, blockCount: 0, lastBlockNotifyTime: 0 };
+}
+__name(makeEmptyRecord, "makeEmptyRecord");
+async function handleTrigger(ctx, platform, guildId, limit, window, warnDelay, baseDur, expBase, expWindow, notifyCooldown) {
+  let record = await getCommandFrequencyRecord(ctx, platform, guildId);
+  const now = Math.floor(Date.now() / 1e3);
+  const windowStart = now - window;
+  if (!record) {
+    record = makeEmptyRecord(platform, guildId, now);
+  } else if (record.lastCommandTime < windowStart) {
+    if (isBlocked(record)) {
     } else {
-      record.commandCount += 1;
+      const blockExpired = record.blockExpiryTime > 0 && now - record.blockExpiryTime > expWindow;
+      record.commandCount = 1;
       record.lastCommandTime = now;
+      record.warningSent = false;
+      record.firstWarningTime = 0;
+      if (blockExpired) record.blockCount = 0;
     }
-    if (isCurrentlyBlocked(record)) {
-      try {
-        const remainingTime = Math.ceil((record.blockExpiryTime * 1e3 - Date.now()) / 1e3);
-        await session.bot.sendMessage(guildId, config.frequency.blockedMsg.replace("{time}", remainingTime.toString()), platform);
-      } catch (e) {
-      }
-      throw new Error("Blocked");
+  } else {
+    record.commandCount += 1;
+    record.lastCommandTime = now;
+  }
+  if (isBlocked(record)) {
+    const remaining = Math.ceil((record.blockExpiryTime * 1e3 - Date.now()) / 1e3);
+    const lastNotify = record.lastBlockNotifyTime || 0;
+    if (now - lastNotify >= notifyCooldown) {
+      record.lastBlockNotifyTime = now;
+      await updateCommandFrequencyRecord(ctx, platform, guildId, record);
+      return { result: "blocked", remaining };
+    } else {
+      await updateCommandFrequencyRecord(ctx, platform, guildId, record);
+      return { result: "blocked-silent" };
+    }
+  }
+  if (record.commandCount > limit) {
+    if (!record.warningSent) {
+      record.warningSent = true;
+      record.commandCount = 1;
+      record.lastCommandTime = now;
+      record.firstWarningTime = now;
+      await updateCommandFrequencyRecord(ctx, platform, guildId, record);
+      return { result: "warn" };
+    } else {
+      record.blockCount = (record.blockCount || 0) + 1;
+      const dur = calcBlockDur(baseDur, expBase, record.blockCount);
+      record.blockExpiryTime = now + dur;
+      record.warningSent = false;
+      record.commandCount = 0;
+      record.firstWarningTime = 0;
+      record.lastBlockNotifyTime = now;
+      await updateCommandFrequencyRecord(ctx, platform, guildId, record);
+      return { result: "new-blocked", dur };
     }
-    if (record.commandCount > config.frequency.limit) {
-      if (!record.warningSent) {
+  }
+  await updateCommandFrequencyRecord(ctx, platform, guildId, record);
+  return { result: "ok" };
+}
+__name(handleTrigger, "handleTrigger");
+function isSystemSession(session) {
+  if (!session.userId) return true;
+  if (session.userId === session.bot?.userId) return true;
+  return false;
+}
+__name(isSystemSession, "isSystemSession");
+function isUserInitiatedNonCommand(session) {
+  if (!session.content) return false;
+  const mentioned = session.elements?.some((e) => e.type === "at" && e.attrs?.id === session.bot?.userId);
+  if (mentioned) return true;
+  if (!session.guildId) return true;
+  return false;
+}
+__name(isUserInitiatedNonCommand, "isUserInitiatedNonCommand");
+function apply4(ctx, config) {
+  const freq = config.frequency;
+  if (!freq.enabled && !freq.privateEnabled) return;
+  async function checkFrequency(session, isCommand) {
+    const isPrivate = !session.guildId;
+    const platform = session.platform;
+    if (isPrivate) {
+      if (!freq.privateEnabled) return true;
+      if (freq.privateWhitelist?.includes(session.userId)) return true;
+      const guildId = PRIVATE_GUILD_PREFIX + session.userId;
+      const r = await handleTrigger(
+        ctx,
+        platform,
+        guildId,
+        freq.privateLimit,
+        freq.privateWindow,
+        freq.privateWarnDelay,
+        freq.privateBlockDur,
+        freq.blockExpBase,
+        freq.blockExpWindow,
+        freq.blockNotifyCooldown
+      );
+      if (r.result === "ok") return true;
+      if (r.result === "warn") {
         try {
-          await session.bot.sendMessage(guildId, config.frequency.warnMsg, platform);
+          await session.send(freq.warnMsg);
         } catch (e) {
         }
-        record.warningSent = true;
-        record.commandCount = 1;
-        record.lastCommandTime = now;
-        record.firstWarningTime = now;
-        await updateCommandFrequencyRecord(ctx, platform, guildId, record);
-        throw new Error("Warning");
-      } else {
-        record.blockExpiryTime = now + config.frequency.blockDur;
-        record.warningSent = false;
-        record.commandCount = 0;
-        record.firstWarningTime = 0;
-        await updateCommandFrequencyRecord(ctx, platform, guildId, record);
+        return false;
+      }
+      if (r.result === "new-blocked") {
+        try {
+          await session.send(freq.blockMsg.replace("{duration}", r.dur.toString()));
+        } catch (e) {
+        }
+        return false;
+      }
+      if (r.result === "blocked") {
+        try {
+          await session.send(freq.blockedMsg.replace("{time}", r.remaining.toString()));
+        } catch (e) {
+        }
+        return false;
+      }
+      return false;
+    } else {
+      if (!freq.enabled) return true;
+      if (freq.whitelist?.includes(session.guildId)) return true;
+      const { guildId } = session;
+      const r = await handleTrigger(
+        ctx,
+        platform,
+        guildId,
+        freq.limit,
+        freq.window,
+        freq.warnDelay,
+        freq.blockDur,
+        freq.blockExpBase,
+        freq.blockExpWindow,
+        freq.blockNotifyCooldown
+      );
+      if (r.result === "ok") return true;
+      if (r.result === "warn") {
+        try {
+          await session.bot.sendMessage(guildId, freq.warnMsg, platform);
+        } catch (e) {
+        }
+        return false;
+      }
+      if (r.result === "new-blocked") {
         try {
-          await session.bot.sendMessage(guildId, config.frequency.blockMsg.replace("{duration}", config.frequency.blockDur.toString()), platform);
+          await session.bot.sendMessage(guildId, freq.blockMsg.replace("{duration}", r.dur.toString()), platform);
         } catch (e) {
         }
-        throw new Error("Blocked");
+        return false;
       }
+      if (r.result === "blocked") {
+        try {
+          await session.bot.sendMessage(guildId, freq.blockedMsg.replace("{time}", r.remaining.toString()), platform);
+        } catch (e) {
+        }
+        return false;
+      }
+      return false;
     }
-    await updateCommandFrequencyRecord(ctx, platform, guildId, record);
+  }
+  __name(checkFrequency, "checkFrequency");
+  ctx.on("command/before-execute", async (argv) => {
+    const session = argv.session;
+    if (isSystemSession(session)) return;
+    const allowed = await checkFrequency(session, true);
+    if (!allowed) throw new Error("Blocked");
   });
+  ctx.middleware(async (session, next) => {
+    if (isSystemSession(session)) return next();
+    if (!isUserInitiatedNonCommand(session)) return next();
+    const allowed = await checkFrequency(session, false);
+    if (!allowed) return;
+    return next();
+  }, true);
 }
 __name(apply4, "apply");
 
@@ -881,6 +1061,93 @@ function apply6(ctx, config) {
 }
 __name(apply6, "apply");
 
+// src/modules/friend.ts
+var friend_exports = {};
+__export(friend_exports, {
+  apply: () => apply7,
+  name: () => name7
+});
+var name7 = "group-control-friend";
+function apply7(ctx, config) {
+  if (!config.friend.enabled) return;
+  setInterval(async () => {
+    const expireMs = config.friend.requestExpireDays * 24 * 60 * 60 * 1e3;
+    try {
+      for (const bot of ctx.bots) {
+        await clearExpiredPendingFriendRequests(ctx, bot.platform, expireMs);
+      }
+    } catch (e) {
+    }
+  }, 60 * 60 * 1e3);
+  ctx.on("friend-request", async (session) => {
+    const raw = session.original || session.raw || session.event?._data || {};
+    const flag = raw.flag || session.flag || session.messageId;
+    const userId = raw.user_id ? String(raw.user_id) : session.userId;
+    const comment = raw.comment || session.comment || "";
+    const { platform } = session;
+    let nickname = userId;
+    try {
+      const info = await session.bot.internal?.getStrangerInfo?.(parseInt(userId));
+      nickname = info?.nickname || nickname;
+    } catch (e) {
+    }
+    if (config.friend.autoApprove) {
+      try {
+        await session.bot.internal?.setFriendAddRequest?.(flag, true, "");
+        if (config.friend.notifyAdminOnApprove) {
+          const msg2 = config.friend.approveNotificationMessage.replaceAll("{userId}", userId).replaceAll("{nickname}", nickname).replaceAll("{comment}", comment);
+          await notifyAdmins(session.bot, config, msg2);
+        }
+      } catch (e) {
+        ctx.logger("group-control-friend").warn("自动通过好友申请失败", e);
+      }
+      return;
+    }
+    await addPendingFriendRequest(ctx, platform, { userId, nickname, comment, flag, time: Date.now() });
+    const msg = config.friend.requestMessage.replaceAll("{userId}", userId).replaceAll("{nickname}", nickname).replaceAll("{comment}", comment);
+    await notifyAdmins(session.bot, config, msg);
+  });
+  ctx.command("friend-pending", "查看待处理的好友申请").action(async ({ session }) => {
+    if (!config.invite.adminQQs.includes(session.userId)) return "权限不足。";
+    const all = await getAllPendingFriendRequests(ctx, session.platform);
+    if (all.length === 0) return "当前没有待处理的好友申请。";
+    const lines = ["待处理好友申请列表："];
+    for (const r of all) {
+      const elapsed = Math.floor((Date.now() - r.time) / 1e3 / 60);
+      lines.push(`- ${r.nickname}（${r.userId}）附言：${r.comment || "无"} · ${elapsed} 分钟前`);
+      lines.push(`  同意：friend-approve ${r.userId} | 拒绝：friend-reject ${r.userId}`);
+    }
+    return lines.join("\n");
+  });
+  ctx.command("friend-approve <userId:string>", "同意好友申请").action(async ({ session }, userId) => {
+    if (!config.invite.adminQQs.includes(session.userId)) return "权限不足。";
+    if (!userId) return "请指定QQ号。用法：friend-approve <QQ号>";
+    const record = await getPendingFriendRequest(ctx, session.platform, userId);
+    if (!record) return `未找到来自 ${userId} 的待处理好友申请。`;
+    try {
+      await session.bot.internal?.setFriendAddRequest?.(record.flag, true, "");
+      await removePendingFriendRequest(ctx, session.platform, userId);
+      return `已同意 ${record.nickname}（${userId}）的好友申请。`;
+    } catch (e) {
+      return `处理失败：${e.message}`;
+    }
+  });
+  ctx.command("friend-reject <userId:string>", "拒绝好友申请").action(async ({ session }, userId) => {
+    if (!config.invite.adminQQs.includes(session.userId)) return "权限不足。";
+    if (!userId) return "请指定QQ号。用法：friend-reject <QQ号>";
+    const record = await getPendingFriendRequest(ctx, session.platform, userId);
+    if (!record) return `未找到来自 ${userId} 的待处理好友申请。`;
+    try {
+      await session.bot.internal?.setFriendAddRequest?.(record.flag, false, "");
+      await removePendingFriendRequest(ctx, session.platform, userId);
+      return `已拒绝 ${record.nickname}（${userId}）的好友申请。`;
+    } catch (e) {
+      return `处理失败：${e.message}`;
+    }
+  });
+}
+__name(apply7, "apply");
+
 // src/config.ts
 var import_koishi = require("koishi");
 var Config = import_koishi.Schema.intersect([
@@ -890,71 +1157,95 @@ var Config = import_koishi.Schema.intersect([
         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("需要群管理员权限才能使用的自定义指令名列表（如来自其他插件的指令）")
+      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群名称：{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}, {groupName}, {groupId}"),
+      welcomeMessage: import_koishi.Schema.string().default("你好，我是机器人。").description("加入群聊时发送的欢迎消息"),
+      quitCommandEnabled: import_koishi.Schema.boolean().default(true).description("启用 quit 指令"),
+      quitMessage: import_koishi.Schema.string().default("收到来自{userId}的指令，即将退出群聊。").description("quit 指令触发后的群内提示，支持变量 {userId}"),
+      enableBlacklist: import_koishi.Schema.boolean().default(true).description("启用被踢出自动拉黑"),
+      blacklistMessage: import_koishi.Schema.string().default("此群聊已被拉黑，机器人将自动退出，请联系管理员移出黑名单。").description("被拉入黑名单群后的提示"),
+      notifyAdminOnKick: import_koishi.Schema.boolean().default(true).description("被踢出群时通知管理员"),
+      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("小群人数阈值（低于等于此值时自动退群）"),
+      smallGroupCheckDelay: import_koishi.Schema.number().default(3e3).description("加入后延迟检测时间（毫秒）"),
+      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("小群检测延迟（毫秒），加入群聊后等待一段时间再获取群信息以确保数据准确")
+      smallGroupQualifiedNotifyAdmin: import_koishi.Schema.boolean().default(true).description("未经审核被拉入人数达标的群时通知管理员"),
+      smallGroupQualifiedMessage: import_koishi.Schema.string().default("机器人被未经审核地拉入群聊\n群名称：{groupName}\n群号：{groupId}\n当前人数：{memberCount}人（阈值：{threshold}人）\n请确认是否保留。").description("合格小群通知模板，支持变量 {groupName}, {groupId}, {memberCount}, {threshold}"),
+      notifyAdminOnMute: import_koishi.Schema.boolean().default(false).description("机器人被禁言时通知管理员"),
+      muteNotificationMessage: import_koishi.Schema.string().default("机器人在群聊中被禁言\n群名称：{groupName}\n群号：{groupId}\n操作者：{operatorId}\n禁言时长：{duration}秒").description("被禁言通知模板，支持变量 {groupId}, {groupName}, {operatorId}, {duration}")
     }).description("基础群组管理")
   }),
-  import_koishi.Schema.object({
-    frequency: import_koishi.Schema.object({
-      enabled: import_koishi.Schema.boolean().default(false).description("启用频率控制（对所有指令生效）"),
-      limit: import_koishi.Schema.number().default(5).description("时间窗口内允许的最大指令次数"),
-      window: import_koishi.Schema.number().default(60).description("频率检测时间窗口（秒）"),
-      warnDelay: import_koishi.Schema.number().default(30).description("发出警告后，再次触发的时间阈值（秒），在此时间内再次触发则进入屏蔽状态"),
-      blockDur: import_koishi.Schema.number().default(300).description("触发频率限制后屏蔽的时长（秒）"),
-      warnMsg: import_koishi.Schema.string().default("指令频率过高，请慢一点~").description("频率过高时发送的警告消息"),
-      blockMsg: import_koishi.Schema.string().default("指令频率过高，本群指令已被禁用 {duration} 秒。").description("触发频率限制后发送的屏蔽通知消息，支持变量{duration}"),
-      blockedMsg: import_koishi.Schema.string().default("指令暂时被禁用，还有 {time} 秒解禁。").description("屏蔽期间接收到指令时的提示消息，支持变量{time}"),
-      whitelist: import_koishi.Schema.array(String).default([]).description("频率控制白名单群号列表，白名单内的群聊不受频率限制")
-    }).description("指令频率控制")
-  }),
   import_koishi.Schema.object({
     invite: import_koishi.Schema.object({
-      enabled: import_koishi.Schema.boolean().default(false).description("启用群聊邀请审核功能"),
-      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请管理员使用指令 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("是否显示详细日志"),
-      inviteExpireDays: import_koishi.Schema.number().default(3).description("邀请记录过期时间（天），超过此时间未处理的邀请将被自动清理")
+      enabled: import_koishi.Schema.boolean().default(false).description("启用群聊邀请审核"),
+      adminQQs: import_koishi.Schema.array(String).default([]).description("管理员QQ号列表（权限验证及通知）"),
+      notificationGroupId: import_koishi.Schema.string().description("通知群号（填写后发到此群，否则私聊管理员）"),
+      autoApprove: import_koishi.Schema.boolean().default(false).description("自动同意邀请（仅在未指定管理员时生效）"),
+      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}"),
+      inviteExpireDays: import_koishi.Schema.number().default(3).description("邀请记录过期天数"),
+      showDetailedLog: import_koishi.Schema.boolean().default(false).description("显示详细日志")
     }).description("群聊邀请审核")
   }),
+  import_koishi.Schema.object({
+    friend: import_koishi.Schema.object({
+      enabled: import_koishi.Schema.boolean().default(false).description("启用好友申请管理"),
+      autoApprove: import_koishi.Schema.boolean().default(false).description("自动通过好友申请（否则通知管理员手动处理）"),
+      notifyAdminOnApprove: import_koishi.Schema.boolean().default(true).description("自动通过时是否仍通知管理员"),
+      requestExpireDays: import_koishi.Schema.number().default(7).description("待处理申请的过期天数"),
+      requestMessage: import_koishi.Schema.string().default("收到新的好友申请\nQQ：{userId}\n昵称：{nickname}\n附言：{comment}\n\n使用 friend-approve {userId} 同意或 friend-reject {userId} 拒绝。").description("通知管理员的消息模板，支持变量 {userId}, {nickname}, {comment}"),
+      approveNotificationMessage: import_koishi.Schema.string().default("已自动通过好友申请\nQQ：{userId}\n昵称：{nickname}\n附言：{comment}").description("自动通过时的通知模板，支持变量 {userId}, {nickname}, {comment}")
+    }).description("好友申请管理")
+  }),
+  import_koishi.Schema.object({
+    frequency: import_koishi.Schema.object({
+      enabled: import_koishi.Schema.boolean().default(false).description("启用群聊频率控制（指令及 @ 对话均受限）"),
+      limit: import_koishi.Schema.number().default(5).description("群聊：时间窗口内允许的最大触发次数"),
+      window: import_koishi.Schema.number().default(60).description("群聊：时间窗口（秒）"),
+      warnDelay: import_koishi.Schema.number().default(30).description("群聊：警告后再次触发的时间阈值（秒），超出则进入屏蔽"),
+      blockDur: import_koishi.Schema.number().default(300).description("群聊：首次屏蔽的基础时长（秒）"),
+      whitelist: import_koishi.Schema.array(String).default([]).description("群聊：不受频率限制的群号列表"),
+      privateEnabled: import_koishi.Schema.boolean().default(false).description("启用私聊频率控制"),
+      privateLimit: import_koishi.Schema.number().default(10).description("私聊：时间窗口内允许的最大触发次数"),
+      privateWindow: import_koishi.Schema.number().default(60).description("私聊：时间窗口（秒）"),
+      privateWarnDelay: import_koishi.Schema.number().default(30).description("私聊：警告后再次触发的时间阈值（秒）"),
+      privateBlockDur: import_koishi.Schema.number().default(300).description("私聊：首次屏蔽的基础时长（秒）"),
+      privateWhitelist: import_koishi.Schema.array(String).default([]).description("私聊：不受频率限制的用户ID列表"),
+      blockExpBase: import_koishi.Schema.number().default(2).description("屏蔽时长指数增长底数（时长 = blockDur × base^(次数-1)），设为 1 禁用"),
+      blockExpWindow: import_koishi.Schema.number().default(3600).description("指数增长重置窗口（秒），从最后一次屏蔽结束计算，超出则重置次数"),
+      blockNotifyCooldown: import_koishi.Schema.number().default(60).description("屏蔽期间提示消息的冷却时间（秒），避免刷屏"),
+      warnMsg: import_koishi.Schema.string().default("发言频率过高，请慢一点~").description("首次超限警告消息"),
+      blockMsg: import_koishi.Schema.string().default("发言频率过高，已被禁用 {duration} 秒。").description("进入屏蔽时的通知，支持变量 {duration}"),
+      blockedMsg: import_koishi.Schema.string().default("暂时被禁用，还有 {time} 秒解禁。").description("屏蔽期间再次触发时的提示，支持变量 {time}")
+    }).description("频率控制")
+  }),
   import_koishi.Schema.object({
     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("机器人在关闭状态下被@时的提示消息")
+      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("关闭状态下被 @ 时的提示")
     }).description("机器人开关控制")
   })
 ]);
 
 // src/index.ts
-var name7 = "group-control";
-function apply7(ctx, config) {
+var name8 = "group-control";
+function apply8(ctx, config) {
   ctx.plugin(database_exports);
   ctx.plugin(basic_exports, config);
   ctx.plugin(invite_exports, config);
   ctx.plugin(frequency_exports, config);
   ctx.plugin(commands_exports, config);
   ctx.plugin(switch_exports, config);
+  ctx.plugin(friend_exports, config);
 }
-__name(apply7, "apply");
+__name(apply8, "apply");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Config,

package/lib/modules/friend.d.ts

@@ -0,0 +1,4 @@
+import { Context } from 'koishi';
+import { Config } from '../config';
+export declare const name = "group-control-friend";
+export declare function apply(ctx: Context, config: Config): void;

package/package.json

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

package/readme.md

@@ -0,0 +1,208 @@
+# koishi-plugin-group-control
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-group-control?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-group-control)
+
+Koishi 插件，多功能群聊自管理工具。仅支持 OneBot 适配器。
+
+> 使用 Qwen3-Coder & Gemini-3.1-Pro-Preview & Claude Sonnet 4.6 协助完成
+
+---
+
+## 功能概览
+
+- **黑名单管理**：被踢出群后自动拉黑，下次被邀请时自动退出
+- **小群自动退群**：加入人数不足的群时自动退出并通知管理员
+- **合格小群通知**：未经审核被拉入人数达标的群时，通知管理员确认
+- **群聊邀请审核**：收到邀请时暂缓加入，等待管理员 approve/reject
+- **好友申请管理**：收到好友申请时通知管理员，或自动通过
+- **频率控制**：限制群聊/私聊的指令及对话频率，支持指数增长屏蔽时长
+- **Bot 开关**：按群独立开关 bot，关闭后屏蔽所有响应
+- **被禁言通知**：bot 被禁言时可选通知管理员
+- **权限管理**：支持 Koishi authority 或内置群管理员两种权限模式
+
+---
+
+## 配置说明
+
+### 权限管理
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| `mode` | `builtin` | `builtin`：使用群管理员/群主权限；`koishi`：使用 Koishi authority |
+| `koishiAuthority` | `3` | Koishi 模式下管理指令所需的最低权限等级 |
+| `protectedCommands` | `[]` | 需要群管理员权限才能使用的自定义指令名列表 |
+
+### 基础群组管理
+
+**欢迎 & 退群**
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| `welcomeMessage` | `你好，我是机器人。` | 加入群聊时发送的欢迎消息 |
+| `quitMessage` | `收到来自{userId}的指令，即将退出群聊。` | quit 指令触发后的群内提示，支持 `{userId}` |
+| `quitCommandEnabled` | `true` | 是否启用 quit 指令 |
+
+**黑名单**
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| `enableBlacklist` | `true` | 启用被踢出自动拉黑 |
+| `blacklistMessage` | *(见配置)* | 被拉入黑名单群后的提示 |
+
+**踢出通知**
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| `notifyAdminOnKick` | `true` | 被踢出时通知管理员 |
+| `kickNotificationMessage` | *(见配置)* | 通知消息模板，支持 `{groupId}`, `{groupName}` |
+
+**小群自动退群**
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| `smallGroupAutoQuit` | `false` | 启用小群自动退群 |
+| `smallGroupThreshold` | `30` | 人数阈值，低于等于此值时自动退出 |
+| `smallGroupQuitMessage` | *(见配置)* | 退群提示，支持 `{memberCount}`, `{threshold}`, `{groupName}`, `{groupId}` |
+| `smallGroupNotifyAdmin` | `true` | 自动退群时通知管理员 |
+| `smallGroupCheckDelay` | `3000` | 加入后延迟检测的时间（毫秒） |
+
+**合格小群通知**
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| `smallGroupQualifiedNotifyAdmin` | `true` | 未经审核被拉入人数达标的群时通知管理员 |
+| `smallGroupQualifiedMessage` | *(见配置)* | 通知消息模板，支持 `{groupName}`, `{groupId}`, `{memberCount}`, `{threshold}` |
+
+**被禁言通知**
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| `notifyAdminOnMute` | `false` | bot 被禁言时通知管理员 |
+| `muteNotificationMessage` | *(见配置)* | 通知消息模板，支持 `{groupId}`, `{groupName}`, `{operatorId}`, `{duration}` |
+
+### 频率控制
+
+**群聊**
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| `enabled` | `false` | 启用群聊频率控制（指令及 @ 对话均受限） |
+| `limit` | `5` | 时间窗口内允许的最大触发次数 |
+| `window` | `60` | 时间窗口（秒） |
+| `warnDelay` | `30` | 警告后再次触发的时间阈值（秒），超出则进入屏蔽 |
+| `blockDur` | `300` | 首次屏蔽的基础时长（秒） |
+| `whitelist` | `[]` | 不受频率限制的群号列表 |
+
+**私聊**
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| `privateEnabled` | `false` | 启用私聊频率控制 |
+| `privateLimit` | `10` | 私聊时间窗口内允许的最大触发次数 |
+| `privateWindow` | `60` | 私聊时间窗口（秒） |
+| `privateWarnDelay` | `30` | 私聊警告后再次触发的时间阈值（秒） |
+| `privateBlockDur` | `300` | 私聊首次屏蔽的基础时长（秒） |
+| `privateWhitelist` | `[]` | 不受私聊频率限制的用户ID列表 |
+
+**指数增长（群聊和私聊共用）**
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| `blockExpBase` | `2` | 指数增长底数，每次屏蔽时长 = `blockDur × base^(次数-1)`，设为 `1` 禁用 |
+| `blockExpWindow` | `3600` | 指数增长重置窗口（秒），从最后一次屏蔽结束计算，超出则重置屏蔽次数 |
+
+**提示消息**
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| `blockNotifyCooldown` | `60` | 屏蔽期间重复触发时提示消息的冷却时间（秒），避免刷屏 |
+| `warnMsg` | `发言频率过高，请慢一点~` | 首次超限警告消息 |
+| `blockMsg` | `发言频率过高，已被禁用 {duration} 秒。` | 进入屏蔽时的通知，支持 `{duration}` |
+| `blockedMsg` | `暂时被禁用，还有 {time} 秒解禁。` | 屏蔽期间再次触发时的提示，支持 `{time}` |
+
+### 好友申请管理
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| `enabled` | `false` | 启用好友申请管理 |
+| `autoApprove` | `false` | 自动通过好友申请，否则通知管理员手动处理 |
+| `notifyAdminOnApprove` | `true` | 自动通过时是否仍通知管理员 |
+| `requestExpireDays` | `7` | 待处理申请的过期天数 |
+| `requestMessage` | *(见配置)* | 通知管理员的消息模板，支持 `{userId}`, `{nickname}`, `{comment}` |
+| `approveNotificationMessage` | *(见配置)* | 自动通过时的通知消息模板，支持 `{userId}`, `{nickname}`, `{comment}` |
+| `approvedUserMessage` | `你的好友申请已通过审核。` | 同意申请后发给对方的消息 |
+
+### 群聊邀请审核
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| `enabled` | `false` | 启用邀请审核 |
+| `adminQQs` | `[]` | 管理员QQ号列表，用于权限验证及私聊通知 |
+| `notificationGroupId` | *(空)* | 通知群号，填写后邀请请求发到此群，否则私聊管理员 |
+| `inviteWaitMessage` | *(见配置)* | 发给邀请者的等待提示 |
+| `inviteRequestMessage` | *(见配置)* | 发给管理员的请求消息，支持 `{groupName}`, `{groupId}`, `{userName}`, `{userId}` |
+| `autoApprove` | `false` | 未配置管理员时自动同意邀请 |
+| `showDetailedLog` | `false` | 显示详细日志 |
+| `inviteExpireDays` | `3` | 邀请记录过期天数 |
+
+### 机器人开关
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| `enabled` | `true` | 启用群聊 bot 开关功能 |
+| `defaultState` | `true` | 默认开启状态 |
+| `disabledMessage` | *(见配置)* | 关闭状态下被 @ 时的提示 |
+
+---
+
+## 指令列表
+
+### 黑名单管理（需全局管理员）
+
+| 指令 | 说明 |
+|------|------|
+| `banlist` | 查看黑名单列表 |
+| `ban <群号>` | 手动添加群到黑名单 |
+| `unban <群号>` | 从黑名单移除群 |
+| `clearban` | 清空黑名单 |
+
+### 小群白名单（需全局管理员）
+
+| 指令 | 说明 |
+|------|------|
+| `sg-add <群号>` | 将群加入小群白名单，不受人数限制 |
+| `sg-rm <群号>` | 从小群白名单移除群 |
+| `sg-list` | 查看小群白名单 |
+
+### 好友申请管理（需在 adminQQs 中）
+
+| 指令 | 说明 |
+|------|------|
+| `friend-pending` | 查看待处理的好友申请列表 |
+| `friend-approve <QQ号>` | 同意指定用户的好友申请 |
+| `friend-reject <QQ号>` | 拒绝指定用户的好友申请 |
+
+### 邀请审核（需在 adminQQs 中）
+
+| 指令 | 说明 |
+|------|------|
+| `pending` | 查看待处理的邀请列表 |
+| `approve <群号>` | 同意加入指定群 |
+| `reject <群号>` | 拒绝加入指定群 |
+
+### 群聊管理
+
+| 指令 | 说明 | 权限 |
+|------|------|------|
+| `quit` | 让 bot 退出当前群聊 | 群管理员 |
+| `bot-on` | 开启当前群的 bot | 群管理员 |
+| `bot-off` | 关闭当前群的 bot | 群管理员 |
+
+---
+
+## 注意事项
+
+- 本插件仅支持 **OneBot 适配器**（如 go-cqhttp、LLOneBot 等）
+- 管理员通知依赖 `invite.adminQQs` 或 `invite.notificationGroupId` 的配置，未配置则无法收到通知
+- 频率控制的非指令拦截（@ 对话、私聊）不影响入群欢迎等系统事件
+- 小群合格通知仅在启用了 `smallGroupAutoQuit` 且未经 `approve` 审核通过的情况下触发

package/README.md

@@ -1,9 +0,0 @@
-# koishi-plugin-group-control
-
-[![npm](https://img.shields.io/npm/v/koishi-plugin-group-control?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-group-control)
-
-Koishi 插件，一个多功能的群聊自管理工具。支持被踢出自动拉黑、刷屏自动屏蔽、开关控制等功能。(仅支持 OneBot 适配器)
-
-#### 仅支持 OneBot 协议
-
-> 使用 Qwen3-Coder & Gemini-3.1-Pro-Preview 协助完成