koishi-plugin-group-control 1.0.3 → 1.0.5

package/lib/config.d.ts

@@ -12,10 +12,16 @@ export interface GroupConfig {
     smallGroupQuitMessage: string;
     smallGroupNotifyAdmin: boolean;
     smallGroupCheckDelay: number;
+    smallGroupExcludeOfficialBots: boolean;
+    smallGroupRealtimeMonitor: boolean;
+    smallGroupRecheckCooldown: number;
     smallGroupQualifiedNotifyAdmin: boolean;
     smallGroupQualifiedMessage: string;
     notifyAdminOnMute: boolean;
     muteNotificationMessage: string;
+    muteAutoQuit: boolean;
+    muteAutoQuitThreshold: number;
+    muteQuitNotificationMessage: string;
 }
 export interface AdminConfig {
     adminQQs: string[];

package/lib/database.d.ts

@@ -25,6 +25,11 @@ export interface SmallGroupWhitelist {
     platform: string;
     guildId: string;
 }
+export interface ApprovedGuild {
+    platform: string;
+    guildId: string;
+    timestamp: number;
+}
 export interface SelfLeftGuild {
     platform: string;
     guildId: string;
@@ -54,6 +59,7 @@ declare module 'koishi' {
         group_bot_status: GroupBotStatus;
         small_group_whitelist: SmallGroupWhitelist;
         self_left_guild: SelfLeftGuild;
+        approved_guild: ApprovedGuild;
         pending_invite: PendingInvite;
         pending_friend_request: PendingFriendRequest;
     }
@@ -75,7 +81,7 @@ export declare function consumeSelfLeft(ctx: Context, guildId: string, maxAgeSec
 /** 清理标记（退群失败时回滚，或 unban 时清理）*/
 export declare function clearSelfLeft(ctx: Context, guildId: string): Promise<void>;
 /** 定期清理过期的主动退群标记（超过 maxAgeSec 秒未消费的）*/
-export declare function clearExpiredSelfLeft(ctx: Context, maxAgeSec?: number): Promise<number>;
+export declare function clearExpiredSelfLeft(ctx: Context, maxAgeSec?: number): Promise<void>;
 export declare function getCommandFrequencyRecord(ctx: Context, platform: string, guildId: string): Promise<CommandFrequencyRecord>;
 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>;
@@ -84,13 +90,16 @@ export declare function isInSmallGroupWhitelist(ctx: Context, guildId: string):
 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 markApprovedGuild(ctx: Context, guildId: string): Promise<void>;
+export declare function isApprovedGuild(ctx: Context, guildId: string): Promise<boolean>;
+export declare function clearApprovedGuild(ctx: Context, guildId: string): Promise<void>;
 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>;
+export declare function clearExpiredPendingInvites(ctx: Context, expireTimeMs: number): Promise<void>;
 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>;
+export declare function clearExpiredPendingFriendRequests(ctx: Context, platform: string, expireTimeMs: number): Promise<void>;

package/lib/index.d.ts

@@ -2,4 +2,5 @@ import { Context } from 'koishi';
 import { Config } from './config';
 export * from './config';
 export declare const name = "group-control";
+export declare const inject: string[];
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -22,6 +22,7 @@ var src_exports = {};
 __export(src_exports, {
   Config: () => Config,
   apply: () => apply8,
+  inject: () => inject,
   name: () => name8
 });
 module.exports = __toCommonJS(src_exports);
@@ -35,6 +36,7 @@ __export(database_exports, {
   addToSmallGroupWhitelist: () => addToSmallGroupWhitelist,
   apply: () => apply,
   blacklistKicked: () => blacklistKicked,
+  clearApprovedGuild: () => clearApprovedGuild,
   clearBlacklistedGuilds: () => clearBlacklistedGuilds,
   clearExpiredPendingFriendRequests: () => clearExpiredPendingFriendRequests,
   clearExpiredPendingInvites: () => clearExpiredPendingInvites,
@@ -51,7 +53,9 @@ __export(database_exports, {
   getGroupBotStatus: () => getGroupBotStatus,
   getPendingFriendRequest: () => getPendingFriendRequest,
   getPendingInvite: () => getPendingInvite,
+  isApprovedGuild: () => isApprovedGuild,
   isInSmallGroupWhitelist: () => isInSmallGroupWhitelist,
+  markApprovedGuild: () => markApprovedGuild,
   markSelfLeft: () => markSelfLeft,
   name: () => name,
   removeBlacklistedGuild: () => removeBlacklistedGuild,
@@ -94,6 +98,11 @@ function apply(ctx) {
     guildId: "string",
     timestamp: "integer"
   }, { primary: ["platform", "guildId"] });
+  ctx.model.extend("approved_guild", {
+    platform: "string",
+    guildId: "string",
+    timestamp: "integer"
+  }, { primary: ["platform", "guildId"] });
   ctx.model.extend("pending_invite", {
     platform: "string",
     groupId: "string",
@@ -115,15 +124,15 @@ function apply(ctx) {
 __name(apply, "apply");
 var BLACKLIST_PLATFORM = "onebot";
 async function getBlacklistedGuild(ctx, guildId) {
-  return await ctx.model.get("blacklisted_guild", { platform: BLACKLIST_PLATFORM, guildId });
+  return await ctx.database.get("blacklisted_guild", { platform: BLACKLIST_PLATFORM, guildId });
 }
 __name(getBlacklistedGuild, "getBlacklistedGuild");
 async function removeBlacklistedGuild(ctx, guildId) {
-  return await ctx.model.remove("blacklisted_guild", { platform: BLACKLIST_PLATFORM, guildId });
+  return await ctx.database.remove("blacklisted_guild", { platform: BLACKLIST_PLATFORM, guildId });
 }
 __name(removeBlacklistedGuild, "removeBlacklistedGuild");
 async function createBlacklistedGuild(ctx, guildId, reason) {
-  return await ctx.model.upsert("blacklisted_guild", [{
+  return await ctx.database.upsert("blacklisted_guild", [{
     platform: BLACKLIST_PLATFORM,
     guildId,
     timestamp: Math.floor(Date.now() / 1e3),
@@ -132,15 +141,15 @@ async function createBlacklistedGuild(ctx, guildId, reason) {
 }
 __name(createBlacklistedGuild, "createBlacklistedGuild");
 async function getAllBlacklistedGuilds(ctx) {
-  return await ctx.model.get("blacklisted_guild", { platform: BLACKLIST_PLATFORM });
+  return await ctx.database.get("blacklisted_guild", { platform: BLACKLIST_PLATFORM });
 }
 __name(getAllBlacklistedGuilds, "getAllBlacklistedGuilds");
 async function clearBlacklistedGuilds(ctx) {
-  return await ctx.model.remove("blacklisted_guild", { platform: BLACKLIST_PLATFORM });
+  return await ctx.database.remove("blacklisted_guild", { platform: BLACKLIST_PLATFORM });
 }
 __name(clearBlacklistedGuilds, "clearBlacklistedGuilds");
 async function blacklistKicked(ctx, guildId) {
-  return await ctx.model.upsert("blacklisted_guild", [{
+  return await ctx.database.upsert("blacklisted_guild", [{
     platform: BLACKLIST_PLATFORM,
     guildId,
     timestamp: Math.floor(Date.now() / 1e3),
@@ -149,7 +158,7 @@ async function blacklistKicked(ctx, guildId) {
 }
 __name(blacklistKicked, "blacklistKicked");
 async function markSelfLeft(ctx, guildId) {
-  await ctx.model.upsert("self_left_guild", [{
+  await ctx.database.upsert("self_left_guild", [{
     platform: BLACKLIST_PLATFORM,
     guildId,
     timestamp: Math.floor(Date.now() / 1e3)
@@ -157,33 +166,28 @@ async function markSelfLeft(ctx, guildId) {
 }
 __name(markSelfLeft, "markSelfLeft");
 async function consumeSelfLeft(ctx, guildId, maxAgeSec = 120) {
-  const [row] = await ctx.model.get("self_left_guild", { platform: BLACKLIST_PLATFORM, guildId });
+  const [row] = await ctx.database.get("self_left_guild", { platform: BLACKLIST_PLATFORM, guildId });
   if (!row) return false;
-  await ctx.model.remove("self_left_guild", { platform: BLACKLIST_PLATFORM, guildId });
+  await ctx.database.remove("self_left_guild", { platform: BLACKLIST_PLATFORM, guildId });
   return Math.floor(Date.now() / 1e3) - row.timestamp <= maxAgeSec;
 }
 __name(consumeSelfLeft, "consumeSelfLeft");
 async function clearSelfLeft(ctx, guildId) {
-  await ctx.model.remove("self_left_guild", { platform: BLACKLIST_PLATFORM, guildId });
+  await ctx.database.remove("self_left_guild", { platform: BLACKLIST_PLATFORM, guildId });
 }
 __name(clearSelfLeft, "clearSelfLeft");
 async function clearExpiredSelfLeft(ctx, maxAgeSec = 300) {
   const cutoff = Math.floor(Date.now() / 1e3) - maxAgeSec;
-  const all = await ctx.model.get("self_left_guild", { platform: BLACKLIST_PLATFORM });
-  const expired = all.filter((r) => r.timestamp < cutoff);
-  for (const record of expired) {
-    await ctx.model.remove("self_left_guild", { platform: BLACKLIST_PLATFORM, guildId: record.guildId });
-  }
-  return expired.length;
+  await ctx.database.remove("self_left_guild", { platform: BLACKLIST_PLATFORM, timestamp: { $lt: cutoff } });
 }
 __name(clearExpiredSelfLeft, "clearExpiredSelfLeft");
 async function getCommandFrequencyRecord(ctx, platform, guildId) {
-  const records = await ctx.model.get("command_frequency_record", { platform, guildId });
+  const records = await ctx.database.get("command_frequency_record", { platform, guildId });
   return records.length > 0 ? records[0] : null;
 }
 __name(getCommandFrequencyRecord, "getCommandFrequencyRecord");
 async function updateCommandFrequencyRecord(ctx, platform, guildId, data) {
-  await ctx.model.upsert("command_frequency_record", [{
+  await ctx.database.upsert("command_frequency_record", [{
     platform,
     guildId,
     ...data
@@ -195,86 +199,93 @@ var groupBotStatusCacheKey = /* @__PURE__ */ __name((platform, guildId) => `${pl
 async function getGroupBotStatus(ctx, platform, guildId) {
   const key = groupBotStatusCacheKey(platform, guildId);
   if (groupBotStatusCache.has(key)) return groupBotStatusCache.get(key);
-  const records = await ctx.model.get("group_bot_status", { platform, guildId });
+  const records = await ctx.database.get("group_bot_status", { platform, guildId });
   const status = records.length > 0 ? records[0] : null;
   groupBotStatusCache.set(key, status);
   return status;
 }
 __name(getGroupBotStatus, "getGroupBotStatus");
 async function setGroupBotStatus(ctx, platform, guildId, botEnabled) {
-  await ctx.model.upsert("group_bot_status", [{ platform, guildId, botEnabled }]);
+  await ctx.database.upsert("group_bot_status", [{ platform, guildId, botEnabled }]);
   groupBotStatusCache.set(groupBotStatusCacheKey(platform, guildId), { platform, guildId, botEnabled });
 }
 __name(setGroupBotStatus, "setGroupBotStatus");
 async function isInSmallGroupWhitelist(ctx, guildId) {
-  const records = await ctx.model.get("small_group_whitelist", { platform: BLACKLIST_PLATFORM, guildId });
+  const records = await ctx.database.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 }]);
+  await ctx.database.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 });
+  await ctx.database.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 });
+  return await ctx.database.get("small_group_whitelist", { platform: BLACKLIST_PLATFORM });
 }
 __name(getAllSmallGroupWhitelist, "getAllSmallGroupWhitelist");
+async function markApprovedGuild(ctx, guildId) {
+  await ctx.database.upsert("approved_guild", [{
+    platform: BLACKLIST_PLATFORM,
+    guildId,
+    timestamp: Math.floor(Date.now() / 1e3)
+  }]);
+}
+__name(markApprovedGuild, "markApprovedGuild");
+async function isApprovedGuild(ctx, guildId) {
+  const records = await ctx.database.get("approved_guild", { platform: BLACKLIST_PLATFORM, guildId });
+  return records.length > 0;
+}
+__name(isApprovedGuild, "isApprovedGuild");
+async function clearApprovedGuild(ctx, guildId) {
+  await ctx.database.remove("approved_guild", { platform: BLACKLIST_PLATFORM, guildId });
+}
+__name(clearApprovedGuild, "clearApprovedGuild");
 async function getPendingInvite(ctx, groupId) {
-  const records = await ctx.model.get("pending_invite", { platform: BLACKLIST_PLATFORM, groupId });
+  const records = await ctx.database.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 }]);
+  await ctx.database.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 });
+  await ctx.database.remove("pending_invite", { platform: BLACKLIST_PLATFORM, groupId });
 }
 __name(removePendingInvite, "removePendingInvite");
 async function getAllPendingInvites(ctx) {
-  return await ctx.model.get("pending_invite", { platform: BLACKLIST_PLATFORM });
+  return await ctx.database.get("pending_invite", { platform: BLACKLIST_PLATFORM });
 }
 __name(getAllPendingInvites, "getAllPendingInvites");
 async function clearExpiredPendingInvites(ctx, expireTimeMs) {
   const cutoff = Math.floor((Date.now() - expireTimeMs) / 1e3);
-  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;
+  await ctx.database.remove("pending_invite", { platform: BLACKLIST_PLATFORM, time: { $lt: cutoff } });
 }
 __name(clearExpiredPendingInvites, "clearExpiredPendingInvites");
 async function getPendingFriendRequest(ctx, platform, userId) {
-  const records = await ctx.model.get("pending_friend_request", { platform, userId });
+  const records = await ctx.database.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 }]);
+  await ctx.database.upsert("pending_friend_request", [{ platform, ...data }]);
 }
 __name(addPendingFriendRequest, "addPendingFriendRequest");
 async function removePendingFriendRequest(ctx, platform, userId) {
-  await ctx.model.remove("pending_friend_request", { platform, userId });
+  await ctx.database.remove("pending_friend_request", { platform, userId });
 }
 __name(removePendingFriendRequest, "removePendingFriendRequest");
 async function getAllPendingFriendRequests(ctx, platform) {
-  return await ctx.model.get("pending_friend_request", { platform });
+  return await ctx.database.get("pending_friend_request", { platform });
 }
 __name(getAllPendingFriendRequests, "getAllPendingFriendRequests");
 async function clearExpiredPendingFriendRequests(ctx, platform, expireTimeMs) {
   const cutoff = Math.floor((Date.now() - expireTimeMs) / 1e3);
-  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;
+  await ctx.database.remove("pending_friend_request", { platform, time: { $lt: cutoff } });
 }
 __name(clearExpiredPendingFriendRequests, "clearExpiredPendingFriendRequests");
 
@@ -292,6 +303,7 @@ function isBlacklistEnabled(config) {
 }
 __name(isBlacklistEnabled, "isBlacklistEnabled");
 function parseGuildId(input) {
+  if (!input) return null;
   const match = input.trim().match(/^onebot:(\d+)$/);
   return match ? match[1] : /^\d+$/.test(input.trim()) ? input.trim() : null;
 }
@@ -376,20 +388,22 @@ var ADMIN_COMMANDS = /* @__PURE__ */ new Set([
   "gc.sg-add",
   "gc.sg-rm",
   "gc.sg-list",
+  "gc.friends",
+  "gc.delfriend",
+  "gc.groups",
+  "gc.leave",
   "gc.fp",
   "gc.fa",
   "gc.fr"
 ]);
 
-// src/state.ts
-var approvedGroups = /* @__PURE__ */ new Set();
-
 // src/modules/basic.ts
 var name2 = "group-control-basic";
 async function getGroupName(bot, guildId) {
   try {
     const info = await bot.internal?.getGroupInfo?.(parseInt(guildId));
-    if (info?.group_name) return info.group_name;
+    const data = info?.data ?? info;
+    if (data?.group_name) return data.group_name;
   } catch {
   }
   try {
@@ -404,8 +418,12 @@ __name(getGroupName, "getGroupName");
 function apply2(ctx, config) {
   const quittingGuilds = /* @__PURE__ */ new Map();
   const processedKicks = /* @__PURE__ */ new Map();
+  const processedAdds = /* @__PURE__ */ new Map();
+  const realtimeLastCheck = /* @__PURE__ */ new Map();
   const QUITTING_EXPIRE_MS = 60 * 1e3;
   const KICK_DEDUP_MS = 60 * 1e3;
+  const ADD_DEDUP_MS = 10 * 1e3;
+  const REALTIME_DEBOUNCE_MS = 1500;
   setInterval(() => {
     const now = Date.now();
     for (const [key, time] of quittingGuilds) {
@@ -414,6 +432,12 @@ function apply2(ctx, config) {
     for (const [key, time] of processedKicks) {
       if (now - time > KICK_DEDUP_MS) processedKicks.delete(key);
     }
+    for (const [key, time] of processedAdds) {
+      if (now - time > ADD_DEDUP_MS) processedAdds.delete(key);
+    }
+    for (const [key, time] of realtimeLastCheck) {
+      if (now - time > 5 * 60 * 1e3) realtimeLastCheck.delete(key);
+    }
   }, 30 * 1e3);
   setInterval(async () => {
     try {
@@ -421,11 +445,101 @@ function apply2(ctx, config) {
     } catch {
     }
   }, 5 * 60 * 1e3);
+  async function evaluateSmallGroup(bot, guildId) {
+    const threshold = config.basic.smallGroupThreshold;
+    const exclude = config.basic.smallGroupExcludeOfficialBots;
+    const maxBots = 20;
+    let total = 0;
+    let groupName = "未知";
+    try {
+      const info = await bot.internal?.getGroupInfo?.(parseInt(guildId));
+      const data = info?.data ?? info;
+      total = Number(data?.member_count) || 0;
+      if (data?.group_name) groupName = data.group_name;
+    } catch {
+    }
+    if (total === 0) {
+      try {
+        const guildInfo = await bot.getGuild(guildId);
+        total = Number(guildInfo?.member_count ?? guildInfo?.memberCount) || 0;
+        if (guildInfo?.name) groupName = guildInfo.name;
+      } catch {
+      }
+    }
+    if (total > 0 && total <= threshold) {
+      return { decision: "quit", count: total, groupName };
+    }
+    if (!exclude) {
+      if (total > 0) return { decision: total <= threshold ? "quit" : "keep", count: total, groupName };
+    } else if (total > threshold + maxBots) {
+      return { decision: "keep", count: total, groupName };
+    }
+    let list = [];
+    try {
+      const raw = await bot.internal?.getGroupMemberList?.(parseInt(guildId));
+      list = Array.isArray(raw) ? raw : Array.isArray(raw?.data) ? raw.data : [];
+    } catch {
+    }
+    if (list.length === 0) {
+      if (total > 0) return { decision: total <= threshold ? "quit" : "keep", count: total, groupName };
+      return { decision: "unknown", count: 0, groupName };
+    }
+    const N = list.length;
+    if (!exclude) return { decision: N <= threshold ? "quit" : "keep", count: N, groupName };
+    if (N <= threshold) return { decision: "quit", count: N, groupName };
+    const selfId = String(bot.selfId ?? "");
+    const botsNeeded = N - threshold;
+    let bots = 0;
+    for (const m of list) {
+      const uid = String(m?.user_id ?? m?.userId ?? "");
+      if (m?.is_robot === true || selfId && uid === selfId) {
+        bots++;
+        if (bots >= botsNeeded) {
+          return { decision: "quit", count: N - bots, groupName };
+        }
+      }
+    }
+    const real = N - bots;
+    return { decision: real <= threshold ? "quit" : "keep", count: real, groupName };
+  }
+  __name(evaluateSmallGroup, "evaluateSmallGroup");
+  async function performSmallGroupQuit(bot, platform, guildId, groupName, memberCount) {
+    const threshold = config.basic.smallGroupThreshold;
+    const quitMsg = config.basic.smallGroupQuitMessage.replaceAll("{memberCount}", memberCount.toString()).replaceAll("{threshold}", threshold.toString()).replaceAll("{groupName}", groupName).replaceAll("{groupId}", guildId);
+    try {
+      await bot.sendMessage(guildId, quitMsg, platform);
+    } catch (e) {
+    }
+    if (config.basic.smallGroupNotifyAdmin) {
+      const adminMsg = `小群自动退群
+群名称：${groupName}
+群号：${guildId}
+群成员数：${memberCount}人（阈值：${threshold}人）
+机器人已自动退出该群。`;
+      await notifyAdmins(bot, config, adminMsg);
+    }
+    quittingGuilds.set(`${BLACKLIST_PLATFORM}:${guildId}`, Date.now());
+    await markSelfLeft(ctx, guildId);
+    try {
+      await bot.internal.setGroupLeave(parseInt(guildId));
+    } catch (e) {
+      console.error(`小群自动退群失败 (群号: ${guildId}):`, e);
+      quittingGuilds.delete(`${BLACKLIST_PLATFORM}:${guildId}`);
+      await clearSelfLeft(ctx, guildId);
+    }
+  }
+  __name(performSmallGroupQuit, "performSmallGroupQuit");
   ctx.on("guild-added", async (session) => {
     const { guildId, platform } = session;
     ctx.logger("group-control-basic").info(`[guild-added] 触发！guildId=${guildId}, platform=${platform}`);
+    const addKey = `${BLACKLIST_PLATFORM}:${guildId}`;
+    if (processedAdds.has(addKey)) {
+      ctx.logger("group-control-basic").info(`[guild-added] 忽略重复事件 guildId=${guildId}`);
+      return;
+    }
+    processedAdds.set(addKey, Date.now());
     if (config.basic.enableBlacklist) {
-      const [blacklisted] = await ctx.model.get("blacklisted_guild", { platform: BLACKLIST_PLATFORM, guildId });
+      const [blacklisted] = await ctx.database.get("blacklisted_guild", { platform: BLACKLIST_PLATFORM, guildId });
       if (blacklisted) {
         try {
           await session.bot.sendMessage(guildId, config.basic.blacklistMessage, platform);
@@ -442,8 +556,7 @@ function apply2(ctx, config) {
     }
     if (config.basic.smallGroupAutoQuit) {
       const inWhitelist = await isInSmallGroupWhitelist(ctx, guildId);
-      const wasApproved = approvedGroups.has(guildId);
-      if (wasApproved) approvedGroups.delete(guildId);
+      const wasApproved = await isApprovedGuild(ctx, guildId);
       const pendingInvite = await getPendingInvite(ctx, guildId);
       const hadPendingInvite = !!pendingInvite;
       if (hadPendingInvite) await removePendingInvite(ctx, guildId);
@@ -452,58 +565,14 @@ function apply2(ctx, config) {
         const delay = config.basic.smallGroupCheckDelay || 3e3;
         setTimeout(async () => {
           try {
-            let memberCount = 0;
-            let groupName = "未知";
-            try {
-              const groupInfo = await session.bot.internal?.getGroupInfo?.(parseInt(guildId));
-              memberCount = groupInfo?.member_count || 0;
-              if (groupInfo?.group_name) groupName = groupInfo.group_name;
-            } catch {
-            }
-            if (memberCount === 0) {
-              try {
-                const guildInfo = await session.bot.getGuild(guildId);
-                memberCount = guildInfo?.member_count || guildInfo?.memberCount || 0;
-                if (guildInfo?.name) groupName = guildInfo.name;
-              } catch {
-              }
-            }
-            if (memberCount === 0) {
-              try {
-                const memberList = await session.bot.getGuildMemberList(guildId);
-                memberCount = memberList?.data?.length || 0;
-              } catch {
-              }
-            }
-            if (groupName === "未知") {
-              groupName = await getGroupName(session.bot, guildId);
-            }
-            if (memberCount > 0 && memberCount <= config.basic.smallGroupThreshold) {
-              const quitMsg = config.basic.smallGroupQuitMessage.replaceAll("{memberCount}", memberCount.toString()).replaceAll("{threshold}", config.basic.smallGroupThreshold.toString()).replaceAll("{groupName}", groupName).replaceAll("{groupId}", guildId);
-              try {
-                await session.bot.sendMessage(guildId, quitMsg, platform);
-              } catch (e) {
-              }
-              if (config.basic.smallGroupNotifyAdmin) {
-                const adminMsg = `小群自动退群
-群名称：${groupName}
-群号：${guildId}
-群成员数：${memberCount}人（阈值：${config.basic.smallGroupThreshold}人）
-机器人已自动退出该群。`;
-                await notifyAdmins(session.bot, config, adminMsg);
-              }
-              quittingGuilds.set(`${BLACKLIST_PLATFORM}:${guildId}`, Date.now());
-              await markSelfLeft(ctx, guildId);
-              try {
-                await session.bot.internal.setGroupLeave(parseInt(guildId));
-              } catch (e) {
-                console.error(`小群自动退群失败 (群号: ${guildId}):`, e);
-                quittingGuilds.delete(`${BLACKLIST_PLATFORM}:${guildId}`);
-                await clearSelfLeft(ctx, guildId);
-              }
-            } else if (memberCount > config.basic.smallGroupThreshold) {
+            const res = await evaluateSmallGroup(session.bot, guildId);
+            let groupName = res.groupName;
+            if (groupName === "未知") groupName = await getGroupName(session.bot, guildId);
+            if (res.decision === "quit") {
+              await performSmallGroupQuit(session.bot, platform, guildId, groupName, res.count);
+            } else if (res.decision === "keep") {
               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());
+                const qualifiedMsg = config.basic.smallGroupQualifiedMessage.replaceAll("{groupName}", groupName).replaceAll("{groupId}", guildId).replaceAll("{memberCount}", res.count.toString()).replaceAll("{threshold}", config.basic.smallGroupThreshold.toString());
                 await notifyAdmins(session.bot, config, qualifiedMsg);
               }
             }
@@ -520,10 +589,41 @@ function apply2(ctx, config) {
       }
     }
   });
+  if (config.basic.smallGroupAutoQuit && config.basic.smallGroupRealtimeMonitor) {
+    ctx.on("guild-member-removed", async (session) => {
+      const { guildId, platform } = session;
+      if (!guildId) return;
+      if (String(session.userId) === String(session.bot.selfId)) return;
+      if (quittingGuilds.has(`${BLACKLIST_PLATFORM}:${guildId}`)) return;
+      const cooldown = (config.basic.smallGroupRecheckCooldown || 60) * 1e3;
+      const now = Date.now();
+      if (now - (realtimeLastCheck.get(guildId) || 0) < cooldown) return;
+      realtimeLastCheck.set(guildId, now);
+      if (await isInSmallGroupWhitelist(ctx, guildId)) return;
+      if (await isApprovedGuild(ctx, guildId)) return;
+      setTimeout(async () => {
+        try {
+          if (quittingGuilds.has(`${BLACKLIST_PLATFORM}:${guildId}`)) return;
+          const res = await evaluateSmallGroup(session.bot, guildId);
+          if (res.decision === "quit") {
+            let groupName = res.groupName;
+            if (groupName === "未知") groupName = await getGroupName(session.bot, guildId);
+            await performSmallGroupQuit(session.bot, platform, guildId, groupName, res.count);
+          }
+        } catch (error) {
+          console.error(`实时小群检测失败 (群号: ${guildId}):`, error);
+        }
+      }, REALTIME_DEBOUNCE_MS);
+    });
+  }
   ctx.on("guild-removed", async (session) => {
     const { guildId } = session;
     const platform = BLACKLIST_PLATFORM;
     const dedupKey = `${platform}:${guildId}`;
+    try {
+      await clearApprovedGuild(ctx, guildId);
+    } catch {
+    }
     if (quittingGuilds.has(dedupKey)) {
       try {
         await clearSelfLeft(ctx, guildId);
@@ -542,7 +642,7 @@ function apply2(ctx, config) {
     if (processedKicks.has(dedupKey)) return;
     processedKicks.set(dedupKey, Date.now());
     if (config.basic.enableBlacklist || config.basic.notifyAdminOnKick) {
-      const [existing] = await ctx.model.get("blacklisted_guild", { platform, guildId });
+      const [existing] = await ctx.database.get("blacklisted_guild", { platform, guildId });
       if (existing && existing.reason === "kicked") {
         return;
       }
@@ -556,7 +656,7 @@ function apply2(ctx, config) {
       await notifyAdmins(session.bot, config, kickMsg);
     }
   });
-  if (config.basic.notifyAdminOnMute) {
+  if (config.basic.notifyAdminOnMute || config.basic.muteAutoQuit) {
     ctx.on("guild-member-mute", async (session) => {
       if (session.userId !== session.bot?.userId) return;
       if (!session.duration) return;
@@ -564,8 +664,28 @@ function apply2(ctx, config) {
       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.muteAutoQuit && duration >= config.basic.muteAutoQuitThreshold) {
+        const quitMsg = config.basic.muteQuitNotificationMessage.replaceAll("{groupId}", guildId).replaceAll("{groupName}", groupName).replaceAll("{operatorId}", operatorId).replaceAll("{duration}", duration.toString());
+        await notifyAdmins(session.bot, config, quitMsg);
+        try {
+          await createBlacklistedGuild(ctx, guildId, "muted");
+        } catch (e) {
+        }
+        quittingGuilds.set(`${BLACKLIST_PLATFORM}:${guildId}`, Date.now());
+        await markSelfLeft(ctx, guildId);
+        try {
+          await session.bot.internal.setGroupLeave(parseInt(guildId));
+        } catch (e) {
+          console.error(`被禁言自动退群失败 (群号: ${guildId}):`, e);
+          quittingGuilds.delete(`${BLACKLIST_PLATFORM}:${guildId}`);
+          await clearSelfLeft(ctx, guildId);
+        }
+        return;
+      }
+      if (config.basic.notifyAdminOnMute) {
+        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) {
@@ -588,7 +708,7 @@ function apply2(ctx, config) {
       quittingGuilds.set(`${BLACKLIST_PLATFORM}:${guildId}`, Date.now());
       await markSelfLeft(ctx, guildId);
       try {
-        await session.bot.sendMessage(session.guildId, config.basic.quitMessage.replace("{userId}", userId), platform);
+        await session.bot.sendMessage(session.guildId, config.basic.quitMessage.replaceAll("{userId}", userId), platform);
       } catch (e) {
       }
       try {
@@ -616,9 +736,9 @@ function apply3(ctx, config) {
   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} 个过期邀请`);
+      await clearExpiredPendingInvites(ctx, expireMs);
+      if (config.invite.showDetailedLog) {
+        console.log("已执行过期邀请清理");
       }
     } catch (error) {
       console.error("清理过期邀请失败:", error);
@@ -629,6 +749,8 @@ function apply3(ctx, config) {
     ctx.logger("group-control-invite").info(`[guild-request] 触发！userId=${session.userId}, guildId=${session.guildId}, messageId=${session.messageId}, type=${session.type}, subtype=${session.subtype}`);
     ctx.logger("group-control-invite").info(`[guild-request] event 对象: ${JSON.stringify(session.event, null, 2)}`);
     const raw = session.original || session.raw || session.event?._data || {};
+    const subType = String(raw.sub_type ?? session.subtype ?? "");
+    if (subType && subType !== "invite") return;
     const flag = raw.flag || session.flag || session.messageId;
     const rawUserId = raw.user_id ? String(raw.user_id) : session.userId;
     const rawGroupId = raw.group_id ? String(raw.group_id) : session.guildId;
@@ -683,7 +805,7 @@ function apply3(ctx, config) {
     if (config.invite.autoApprove) {
       try {
         await session.bot.internal.setGroupAddRequest(flag, "invite", true, "");
-        approvedGroups.add(rawGroupId);
+        await markApprovedGuild(ctx, rawGroupId);
         if (config.invite.showDetailedLog) {
           console.log(`自动同意群聊邀请: 群号 ${rawGroupId}, 邀请者 ${rawUserId}`);
         }
@@ -766,7 +888,7 @@ function apply3(ctx, config) {
     }
     try {
       await session.bot.internal.setGroupAddRequest(inviteData.flag, "invite", true, "");
-      approvedGroups.add(groupId);
+      await markApprovedGuild(ctx, groupId);
       try {
         await session.bot.sendPrivateMessage(inviteData.userId, `您的群聊邀请已通过管理员审核，机器人已加入群聊。`);
       } catch (error) {
@@ -802,7 +924,7 @@ function apply3(ctx, config) {
     }
   });
   ctx.command("gc.pending", "查看待处理的群聊邀请").action(async ({ session }) => {
-    if (!config.admin.adminQQs.includes(session.userId)) {
+    if (!hasGlobalPermission(session, config)) {
       return "权限不足，只有管理员可以查看待处理邀请。";
     }
     const allInvites = await getAllPendingInvites(ctx);
@@ -917,6 +1039,7 @@ __name(isUserInitiatedNonCommand, "isUserInitiatedNonCommand");
 function apply4(ctx, config) {
   const freq = config.frequency;
   if (!freq.enabled && !freq.privateEnabled) return;
+  const countedSessions = /* @__PURE__ */ new WeakSet();
   async function checkFrequency(session, isCommand) {
     const isPrivate = !session.guildId;
     const platform = session.platform;
@@ -1004,12 +1127,14 @@ function apply4(ctx, config) {
   ctx.on("command/before-execute", async (argv) => {
     const session = argv.session;
     if (isSystemSession(session)) return;
+    if (countedSessions.has(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();
+    countedSessions.add(session);
     const allowed = await checkFrequency(session, false);
     if (!allowed) return;
     return next();
@@ -1024,6 +1149,51 @@ __export(commands_exports, {
   name: () => name5
 });
 var name5 = "group-control-commands";
+function chunk(arr, size) {
+  const out = [];
+  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
+  return out;
+}
+__name(chunk, "chunk");
+async function sendAsForward(session, title, lines) {
+  const groups = chunk(lines, 80);
+  const botId = String(session.bot?.selfId || "10000");
+  const nodes = groups.map((g) => ({
+    type: "node",
+    data: { user_id: botId, nickname: title, content: g.join("\n") }
+  }));
+  try {
+    const internal = session.bot.internal;
+    if (session.guildId) {
+      if (typeof internal.sendGroupForwardMsg !== "function") throw new Error("no forward api");
+      await internal.sendGroupForwardMsg(parseInt(session.guildId), nodes);
+    } else {
+      if (typeof internal.sendPrivateForwardMsg !== "function") throw new Error("no forward api");
+      await internal.sendPrivateForwardMsg(parseInt(session.userId), nodes);
+    }
+  } catch {
+    for (const g of groups) {
+      try {
+        await session.send(g.join("\n"));
+      } catch {
+      }
+    }
+  }
+}
+__name(sendAsForward, "sendAsForward");
+async function deleteFriendCompat(bot, userId) {
+  const internal = bot.internal;
+  if (typeof internal?.deleteFriend !== "function") {
+    throw new Error("当前适配器不支持 delete_friend 接口");
+  }
+  const n = parseInt(userId);
+  try {
+    await internal.deleteFriend(n);
+  } catch (e) {
+    await internal.deleteFriend({ user_id: n, friend_id: n, temp_block: false, both_del: false });
+  }
+}
+__name(deleteFriendCompat, "deleteFriendCompat");
 function apply5(ctx, config) {
   ctx.command("gc", "群控管理员指令");
   ctx.command("gc.ban <groupId:text>", "添加群聊到黑名单").action(async ({ session }, input) => {
@@ -1088,6 +1258,69 @@ function apply5(ctx, config) {
     if (records.length === 0) return "小群白名单为空。";
     return "小群白名单列表（以下群不受小群人数限制）：\n" + records.map((r) => `- ${r.guildId}`).join("\n");
   });
+  ctx.command("gc.friends", "列出机器人的好友（合并转发）").action(async ({ session }) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    let list = [];
+    try {
+      const raw = await session.bot.internal.getFriendList();
+      list = Array.isArray(raw) ? raw : Array.isArray(raw?.data) ? raw.data : [];
+    } catch (e) {
+      return `获取好友列表失败：${e.message}`;
+    }
+    if (list.length === 0) return "好友列表为空。";
+    const lines = list.map((f, i) => {
+      const uid = f.user_id ?? f.userId ?? "";
+      const name9 = f.remark || f.nickname || f.nick || String(uid);
+      return `${i + 1}. ${name9} (${uid})`;
+    });
+    await sendAsForward(session, `好友列表（共 ${list.length} 个）`, lines);
+    return "";
+  });
+  ctx.command("gc.delfriend <userId:text>", "删除指定好友").action(async ({ session }, input) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    const userId = (input || "").trim();
+    if (!/^\d+$/.test(userId)) return "输入格式错误，请输入要删除的好友 QQ 号。";
+    try {
+      await deleteFriendCompat(session.bot, userId);
+      return `已删除好友 ${userId}。`;
+    } catch (e) {
+      return `删除好友失败：${e.message}`;
+    }
+  });
+  ctx.command("gc.groups", "列出机器人所在的群（合并转发）").action(async ({ session }) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    let list = [];
+    try {
+      const raw = await session.bot.internal.getGroupList();
+      list = Array.isArray(raw) ? raw : Array.isArray(raw?.data) ? raw.data : [];
+    } catch (e) {
+      return `获取群列表失败：${e.message}`;
+    }
+    if (list.length === 0) return "机器人尚未加入任何群。";
+    const lines = list.map((g, i) => {
+      const gid = g.group_id ?? g.groupId ?? "";
+      const gname = g.group_name ?? g.groupName ?? String(gid);
+      const count = g.member_count ?? g.memberCount;
+      const max = g.max_member_count ?? g.maxMemberCount;
+      const sizeInfo = count != null ? `（${count}${max != null ? `/${max}` : ""}人）` : "";
+      return `${i + 1}. ${gname} (${gid})${sizeInfo}`;
+    });
+    await sendAsForward(session, `群列表（共 ${list.length} 个）`, lines);
+    return "";
+  });
+  ctx.command("gc.leave <groupId:text>", "让机器人退出指定群").action(async ({ session }, input) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    const guildId = parseGuildId(input);
+    if (!guildId) return "输入格式错误，请输入要退出的群号。";
+    await markSelfLeft(ctx, guildId);
+    try {
+      await session.bot.internal.setGroupLeave(parseInt(guildId));
+      return `已退出群 ${guildId}。`;
+    } catch (e) {
+      await clearSelfLeft(ctx, guildId);
+      return `退出群 ${guildId} 失败：${e.message}`;
+    }
+  });
 }
 __name(apply5, "apply");
 
@@ -1281,7 +1514,7 @@ 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 模式下管理指令所需的最低权限等级"),
+      koishiAuthority: import_koishi.Schema.natural().default(3).description("Koishi 模式下管理指令所需的最低权限等级"),
       protectedCommands: import_koishi.Schema.array(String).default([]).description("需要群管理员权限才能使用的自定义指令名列表")
     }).description("权限管理")
   }),
@@ -1291,18 +1524,24 @@ var Config = import_koishi.Schema.intersect([
       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("被拉入黑名单群后的提示"),
+      blacklistMessage: import_koishi.Schema.string().role("textarea").default("此群聊已被拉黑，机器人将自动退出，请联系管理员移出黑名单。").description("被拉入黑名单群后的提示"),
       notifyAdminOnKick: import_koishi.Schema.boolean().default(true).description("被踢出群时通知管理员"),
-      kickNotificationMessage: import_koishi.Schema.string().default("机器人已被踢出群聊\n群名称：{groupName}\n群号：{groupId}\n该群已被自动加入黑名单。").description("被踢出群通知模板，支持变量 {groupId}, {groupName}"),
+      kickNotificationMessage: import_koishi.Schema.string().role("textarea").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}"),
+      smallGroupThreshold: import_koishi.Schema.natural().default(30).description("小群人数阈值（低于等于此值时自动退群）"),
+      smallGroupCheckDelay: import_koishi.Schema.natural().default(3e3).description("加入后延迟检测时间（毫秒）"),
+      smallGroupExcludeOfficialBots: import_koishi.Schema.boolean().default(true).description("统计群人数时排除 QQ 官方机器人（is_robot）及机器人自身，仅统计真人成员"),
+      smallGroupRealtimeMonitor: import_koishi.Schema.boolean().default(true).description("实时监控群人数（监听成员退群事件，群缩小到阈值以下时自动退群）"),
+      smallGroupRecheckCooldown: import_koishi.Schema.natural().default(60).description("实时监控：同一群两次复检的最小间隔（秒），避免成员批量退群时频繁调用接口"),
+      smallGroupQuitMessage: import_koishi.Schema.string().role("textarea").default("该群人数过少（{memberCount}人），不满足最低人数要求（{threshold}人），机器人将自动退出。").description("小群退群提示，支持变量 {memberCount}, {threshold}, {groupName}, {groupId}"),
       smallGroupNotifyAdmin: import_koishi.Schema.boolean().default(true).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}"),
+      smallGroupQualifiedMessage: import_koishi.Schema.string().role("textarea").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}")
+      muteNotificationMessage: import_koishi.Schema.string().role("textarea").default("机器人在群聊中被禁言\n群名称：{groupName}\n群号：{groupId}\n操作者：{operatorId}\n禁言时长：{duration}秒").description("被禁言通知模板，支持变量 {groupId}, {groupName}, {operatorId}, {duration}"),
+      muteAutoQuit: import_koishi.Schema.boolean().default(false).description("机器人被禁言达到阈值时自动退群并拉黑"),
+      muteAutoQuitThreshold: import_koishi.Schema.natural().default(600).description("触发自动退群的禁言时长阈值（秒），被禁言时长 ≥ 此值即退群并拉黑"),
+      muteQuitNotificationMessage: import_koishi.Schema.string().role("textarea").default("机器人被长时间禁言，已自动退群并拉黑\n群名称：{groupName}\n群号：{groupId}\n操作者：{operatorId}\n禁言时长：{duration}秒").description("被禁言自动退群时发给管理员的通知模板，支持变量 {groupId}, {groupName}, {operatorId}, {duration}")
     }).description("基础群组管理")
   }),
   import_koishi.Schema.object({
@@ -1310,11 +1549,11 @@ var Config = import_koishi.Schema.intersect([
       enabled: import_koishi.Schema.boolean().default(false).description("启用群聊邀请审核"),
       autoApprove: import_koishi.Schema.boolean().default(false).description("自动同意邀请"),
       notifyAdminOnApprove: import_koishi.Schema.boolean().default(true).description("自动同意时是否仍通知管理员"),
-      inviteWaitMessage: import_koishi.Schema.string().default("已收到您的群聊邀请，正在等待管理员审核，请耐心等待。").description("发给邀请者的等待提示"),
-      inviteApproveMessage: import_koishi.Schema.string().default("已自动通过您的群聊邀请，机器人正在加入群聊。").description("自动同意时发给邀请者的提示，支持变量 {groupName}, {groupId}, {userName}, {userId}"),
-      inviteRequestMessage: import_koishi.Schema.string().default("收到新的群聊邀请请求：\n群名称：{groupName}\n群号：{groupId}\n邀请者：{userName} (QQ: {userId})\n\n请使用指令 gc.approve {groupId} 同意或 gc.reject {groupId} 拒绝。").description("发给管理员的请求消息模板，支持变量 {groupName}, {groupId}, {userName}, {userId}"),
-      inviteApproveNotificationMessage: import_koishi.Schema.string().default("已自动通过群聊邀请\n群名称：{groupName}\n群号：{groupId}\n邀请者：{userName} (QQ: {userId})").description("自动同意时发给管理员的通知模板，支持变量 {groupName}, {groupId}, {userName}, {userId}"),
-      inviteExpireDays: import_koishi.Schema.number().default(3).description("邀请记录过期天数"),
+      inviteWaitMessage: import_koishi.Schema.string().role("textarea").default("已收到您的群聊邀请，正在等待管理员审核，请耐心等待。").description("发给邀请者的等待提示"),
+      inviteApproveMessage: import_koishi.Schema.string().role("textarea").default("已自动通过您的群聊邀请，机器人正在加入群聊。").description("自动同意时发给邀请者的提示，支持变量 {groupName}, {groupId}, {userName}, {userId}"),
+      inviteRequestMessage: import_koishi.Schema.string().role("textarea").default("收到新的群聊邀请请求：\n群名称：{groupName}\n群号：{groupId}\n邀请者：{userName} (QQ: {userId})\n\n请使用指令 gc.approve {groupId} 同意或 gc.reject {groupId} 拒绝。").description("发给管理员的请求消息模板，支持变量 {groupName}, {groupId}, {userName}, {userId}"),
+      inviteApproveNotificationMessage: import_koishi.Schema.string().role("textarea").default("已自动通过群聊邀请\n群名称：{groupName}\n群号：{groupId}\n邀请者：{userName} (QQ: {userId})").description("自动同意时发给管理员的通知模板，支持变量 {groupName}, {groupId}, {userName}, {userId}"),
+      inviteExpireDays: import_koishi.Schema.natural().default(3).description("邀请记录过期天数"),
       showDetailedLog: import_koishi.Schema.boolean().default(false).description("显示详细日志")
     }).description("群聊邀请审核")
   }),
@@ -1323,28 +1562,28 @@ var Config = import_koishi.Schema.intersect([
       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使用 gc.fa {userId} 同意或 gc.fr {userId} 拒绝。").description("通知管理员的消息模板，支持变量 {userId}, {nickname}, {comment}"),
-      approveNotificationMessage: import_koishi.Schema.string().default("已自动通过好友申请\nQQ：{userId}\n昵称：{nickname}\n附言：{comment}").description("自动通过时的通知模板，支持变量 {userId}, {nickname}, {comment}")
+      requestExpireDays: import_koishi.Schema.natural().default(7).description("待处理申请的过期天数"),
+      requestMessage: import_koishi.Schema.string().role("textarea").default("收到新的好友申请\nQQ：{userId}\n昵称：{nickname}\n附言：{comment}\n\n使用 gc.fa {userId} 同意或 gc.fr {userId} 拒绝。").description("通知管理员的消息模板，支持变量 {userId}, {nickname}, {comment}"),
+      approveNotificationMessage: import_koishi.Schema.string().role("textarea").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("群聊：首次屏蔽的基础时长（秒）"),
+      limit: import_koishi.Schema.natural().default(5).description("群聊：时间窗口内允许的最大触发次数"),
+      window: import_koishi.Schema.natural().default(60).description("群聊：时间窗口（秒）"),
+      warnDelay: import_koishi.Schema.natural().default(30).description("群聊：警告后再次触发的时间阈值（秒），超出则进入屏蔽"),
+      blockDur: import_koishi.Schema.natural().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("私聊：首次屏蔽的基础时长（秒）"),
+      privateLimit: import_koishi.Schema.natural().default(10).description("私聊：时间窗口内允许的最大触发次数"),
+      privateWindow: import_koishi.Schema.natural().default(60).description("私聊：时间窗口（秒）"),
+      privateWarnDelay: import_koishi.Schema.natural().default(30).description("私聊：警告后再次触发的时间阈值（秒）"),
+      privateBlockDur: import_koishi.Schema.natural().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("屏蔽期间提示消息的冷却时间（秒），避免刷屏"),
+      blockExpBase: import_koishi.Schema.natural().min(1).default(2).description("屏蔽时长指数增长底数（时长 = blockDur × base^(次数-1)），设为 1 禁用"),
+      blockExpWindow: import_koishi.Schema.natural().default(3600).description("指数增长重置窗口（秒），从最后一次屏蔽结束计算，超出则重置次数"),
+      blockNotifyCooldown: import_koishi.Schema.natural().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}")
@@ -1354,13 +1593,14 @@ 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("关闭状态下被 @ 时的提示")
+      disabledMessage: import_koishi.Schema.string().role("textarea").default("机器人当前在此群处于关闭状态，请使用 bot-on 开启。").description("关闭状态下被 @ 时的提示")
     }).description("机器人开关控制")
   })
 ]);
 
 // src/index.ts
 var name8 = "group-control";
+var inject = ["database"];
 function apply8(ctx, config) {
   ctx.plugin(database_exports);
   ctx.plugin(basic_exports, config);
@@ -1375,5 +1615,6 @@ __name(apply8, "apply");
 0 && (module.exports = {
   Config,
   apply,
+  inject,
   name
 });

package/lib/utils.d.ts

@@ -1,7 +1,7 @@
 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 parseGuildId(input: string | undefined | null): string | null;
 export declare function formatDate(timestamp: number): string;
 export declare function notifyAdmins(bot: any, config: Config, message: string): Promise<void>;
 /** 是否为全局管理员（填在 adminQQs 里的） */

package/package.json

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

package/readme.md

@@ -11,13 +11,15 @@ Koishi 插件，多功能群聊自管理工具。仅支持 OneBot 适配器。
 ## 功能概览
 
 - **黑名单管理**：被踢出群后自动拉黑，下次被邀请时自动退出
-- **小群自动退群**：加入人数不足的群时自动退出并通知管理员
+- **小群自动退群**：加入人数不足的群时自动退出并通知管理员，统计人数时自动排除 QQ 官方机器人（仅计真人）
+- **实时小群监控**：监听成员退群事件，群缩水到阈值以下时自动退出（仅针对未经审核拉入的群）
 - **合格小群通知**：未经审核被拉入人数达标的群时，通知管理员确认
 - **群聊邀请审核**：收到邀请时暂缓加入，等待管理员审核
 - **好友申请管理**：收到好友申请时通知管理员，或自动通过
 - **频率控制**：限制群聊/私聊的指令及对话频率，支持指数增长屏蔽时长
 - **Bot 开关**：按群独立开关 bot，关闭后屏蔽所有响应
-- **被禁言通知**：bot 被禁言时可选通知管理员
+- **好友/群管理**：指令列出好友（合并转发）、删除好友、列出所在群、远程退出指定群
+- **被禁言通知**：bot 被禁言时可选通知管理员；被禁言时长达到阈值时可自动退群并拉黑
 - **权限管理**：支持 Koishi authority 或内置群管理员两种权限模式
 
 ---
@@ -69,6 +71,9 @@ Koishi 插件，多功能群聊自管理工具。仅支持 OneBot 适配器。
 |--------|--------|------|
 | `smallGroupAutoQuit` | `false` | 启用小群自动退群 |
 | `smallGroupThreshold` | `30` | 人数阈值，低于等于此值时自动退出 |
+| `smallGroupExcludeOfficialBots` | `true` | 统计群人数时排除 QQ 官方机器人（`is_robot`）及机器人自身，仅统计真人成员 |
+| `smallGroupRealtimeMonitor` | `true` | 实时监控群人数：监听成员退群事件，群缩小到阈值以下时自动退群（仅监控未经审核拉入的群） |
+| `smallGroupRecheckCooldown` | `60` | 实时监控时同一群两次复检的最小间隔（秒），避免成员批量退群时频繁调用接口 |
 | `smallGroupQuitMessage` | *(见配置)* | 退群提示，支持 `{memberCount}`, `{threshold}`, `{groupName}`, `{groupId}` |
 | `smallGroupNotifyAdmin` | `true` | 自动退群时通知管理员 |
 | `smallGroupCheckDelay` | `3000` | 加入后延迟检测的时间（毫秒） |
@@ -86,6 +91,9 @@ Koishi 插件，多功能群聊自管理工具。仅支持 OneBot 适配器。
 |--------|--------|------|
 | `notifyAdminOnMute` | `false` | bot 被禁言时通知管理员 |
 | `muteNotificationMessage` | *(见配置)* | 通知消息模板，支持 `{groupId}`, `{groupName}`, `{operatorId}`, `{duration}` |
+| `muteAutoQuit` | `false` | bot 被禁言达到阈值时自动退群并拉黑 |
+| `muteAutoQuitThreshold` | `600` | 触发自动退群的禁言时长阈值（秒），被禁言时长 ≥ 此值即退群并拉黑 |
+| `muteQuitNotificationMessage` | *(见配置)* | 自动退群时发给管理员的通知模板，支持 `{groupId}`, `{groupName}`, `{operatorId}`, `{duration}` |
 
 ### 频率控制
 
@@ -174,6 +182,10 @@ Koishi 插件，多功能群聊自管理工具。仅支持 OneBot 适配器。
 | `gc.sg-add <群号>` | 将群加入小群白名单，不受人数限制 |
 | `gc.sg-rm <群号>` | 从小群白名单移除群 |
 | `gc.sg-list` | 查看小群白名单 |
+| `gc.friends` | 列出机器人的好友（合并转发形式发送） |
+| `gc.delfriend <QQ号>` | 删除指定好友 |
+| `gc.groups` | 列出机器人所在的群（合并转发形式发送） |
+| `gc.leave <群号>` | 让机器人退出指定群 |
 | `gc.approve <群号>` | 同意加入指定群 |
 | `gc.reject <群号>` | 拒绝加入指定群 |
 | `gc.pending` | 查看待处理的群聊邀请列表 |
@@ -197,3 +209,5 @@ Koishi 插件，多功能群聊自管理工具。仅支持 OneBot 适配器。
 - 管理员通知依赖 `admin.adminQQs` 或 `admin.notificationGroupId` 的配置，未配置则无法收到通知
 - 频率控制的非指令拦截（@ 对话、私聊）不影响入群欢迎等系统事件
 - 小群合格通知仅在启用了 `smallGroupAutoQuit` 且未经 `gc.approve` 审核通过的情况下触发
+- **小群人数统计**：开启 `smallGroupExcludeOfficialBots` 后只计真人成员（排除 `is_robot` 机器人与自身）。检测做了分级短路以减少接口调用——原始人数 ≤ 阈值直接退群、原始人数 > 阈值 + 20（单群机器人上限）直接保留，仅当人数处于中间区间时才拉取一次成员列表，且统计到足够机器人即提前结束遍历
+- **实时小群监控**：纯事件驱动（仅监听成员退群），不做轮询，配合 per-群冷却限流，几乎不增加接口压力。**经 `gc.approve` 审核通过或在小群白名单中的群永久豁免**，仅监控未经审核被拉入的群；机器人退出某群后其审核标记自动清除，若日后被未经审核地重新拉入会重新接受检测

package/lib/state.d.ts

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