koishi-plugin-group-control 1.0.2 → 1.0.3

package/lib/database.d.ts

@@ -25,6 +25,11 @@ export interface SmallGroupWhitelist {
     platform: string;
     guildId: string;
 }
+export interface SelfLeftGuild {
+    platform: string;
+    guildId: string;
+    timestamp: number;
+}
 export interface PendingInvite {
     platform: string;
     groupId: string;
@@ -48,6 +53,7 @@ declare module 'koishi' {
         command_frequency_record: CommandFrequencyRecord;
         group_bot_status: GroupBotStatus;
         small_group_whitelist: SmallGroupWhitelist;
+        self_left_guild: SelfLeftGuild;
         pending_invite: PendingInvite;
         pending_friend_request: PendingFriendRequest;
     }
@@ -60,6 +66,16 @@ export declare function removeBlacklistedGuild(ctx: Context, guildId: string): P
 export declare function createBlacklistedGuild(ctx: Context, guildId: string, reason: string): Promise<import("minato").Driver.WriteResult>;
 export declare function getAllBlacklistedGuilds(ctx: Context): Promise<BlacklistedGuild[]>;
 export declare function clearBlacklistedGuilds(ctx: Context): Promise<import("minato").Driver.WriteResult>;
+/** 统一写入被踢黑名单行，保证 platform = BLACKLIST_PLATFORM */
+export declare function blacklistKicked(ctx: Context, guildId: string): Promise<import("minato").Driver.WriteResult>;
+/** 在主动退群前写入标记，让 guild-removed 能区分「自己退的」和「被踢的」*/
+export declare function markSelfLeft(ctx: Context, guildId: string): Promise<void>;
+/** 消费标记（单次读取后删除），返回是否在 maxAgeSec 内。用于 guild-removed 判断是自己退的 */
+export declare function consumeSelfLeft(ctx: Context, guildId: string, maxAgeSec?: number): Promise<boolean>;
+/** 清理标记（退群失败时回滚，或 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 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>;

package/lib/index.js

@@ -34,9 +34,13 @@ __export(database_exports, {
   addPendingInvite: () => addPendingInvite,
   addToSmallGroupWhitelist: () => addToSmallGroupWhitelist,
   apply: () => apply,
+  blacklistKicked: () => blacklistKicked,
   clearBlacklistedGuilds: () => clearBlacklistedGuilds,
   clearExpiredPendingFriendRequests: () => clearExpiredPendingFriendRequests,
   clearExpiredPendingInvites: () => clearExpiredPendingInvites,
+  clearExpiredSelfLeft: () => clearExpiredSelfLeft,
+  clearSelfLeft: () => clearSelfLeft,
+  consumeSelfLeft: () => consumeSelfLeft,
   createBlacklistedGuild: () => createBlacklistedGuild,
   getAllBlacklistedGuilds: () => getAllBlacklistedGuilds,
   getAllPendingFriendRequests: () => getAllPendingFriendRequests,
@@ -48,6 +52,7 @@ __export(database_exports, {
   getPendingFriendRequest: () => getPendingFriendRequest,
   getPendingInvite: () => getPendingInvite,
   isInSmallGroupWhitelist: () => isInSmallGroupWhitelist,
+  markSelfLeft: () => markSelfLeft,
   name: () => name,
   removeBlacklistedGuild: () => removeBlacklistedGuild,
   removeFromSmallGroupWhitelist: () => removeFromSmallGroupWhitelist,
@@ -84,6 +89,11 @@ function apply(ctx) {
     platform: "string",
     guildId: "string"
   }, { primary: ["platform", "guildId"] });
+  ctx.model.extend("self_left_guild", {
+    platform: "string",
+    guildId: "string",
+    timestamp: "integer"
+  }, { primary: ["platform", "guildId"] });
   ctx.model.extend("pending_invite", {
     platform: "string",
     groupId: "string",
@@ -129,6 +139,44 @@ async function clearBlacklistedGuilds(ctx) {
   return await ctx.model.remove("blacklisted_guild", { platform: BLACKLIST_PLATFORM });
 }
 __name(clearBlacklistedGuilds, "clearBlacklistedGuilds");
+async function blacklistKicked(ctx, guildId) {
+  return await ctx.model.upsert("blacklisted_guild", [{
+    platform: BLACKLIST_PLATFORM,
+    guildId,
+    timestamp: Math.floor(Date.now() / 1e3),
+    reason: "kicked"
+  }]);
+}
+__name(blacklistKicked, "blacklistKicked");
+async function markSelfLeft(ctx, guildId) {
+  await ctx.model.upsert("self_left_guild", [{
+    platform: BLACKLIST_PLATFORM,
+    guildId,
+    timestamp: Math.floor(Date.now() / 1e3)
+  }]);
+}
+__name(markSelfLeft, "markSelfLeft");
+async function consumeSelfLeft(ctx, guildId, maxAgeSec = 120) {
+  const [row] = await ctx.model.get("self_left_guild", { platform: BLACKLIST_PLATFORM, guildId });
+  if (!row) return false;
+  await ctx.model.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 });
+}
+__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;
+}
+__name(clearExpiredSelfLeft, "clearExpiredSelfLeft");
 async function getCommandFrequencyRecord(ctx, platform, guildId) {
   const records = await ctx.model.get("command_frequency_record", { platform, guildId });
   return records.length > 0 ? records[0] : null;
@@ -367,17 +415,24 @@ function apply2(ctx, config) {
       if (now - time > KICK_DEDUP_MS) processedKicks.delete(key);
     }
   }, 30 * 1e3);
+  setInterval(async () => {
+    try {
+      await clearExpiredSelfLeft(ctx);
+    } catch {
+    }
+  }, 5 * 60 * 1e3);
   ctx.on("guild-added", async (session) => {
     const { guildId, platform } = session;
     ctx.logger("group-control-basic").info(`[guild-added] 触发！guildId=${guildId}, platform=${platform}`);
     if (config.basic.enableBlacklist) {
-      const [blacklisted] = await ctx.model.get("blacklisted_guild", { platform, guildId });
+      const [blacklisted] = await ctx.model.get("blacklisted_guild", { platform: BLACKLIST_PLATFORM, guildId });
       if (blacklisted) {
         try {
           await session.bot.sendMessage(guildId, config.basic.blacklistMessage, platform);
         } catch (e) {
         }
-        quittingGuilds.set(`${platform}:${guildId}`, Date.now());
+        quittingGuilds.set(`${BLACKLIST_PLATFORM}:${guildId}`, Date.now());
+        await markSelfLeft(ctx, guildId);
         try {
           await session.bot.internal.setGroupLeave(parseInt(guildId));
         } catch (e) {
@@ -437,12 +492,14 @@ function apply2(ctx, config) {
 机器人已自动退出该群。`;
                 await notifyAdmins(session.bot, config, adminMsg);
               }
-              quittingGuilds.set(`${platform}:${guildId}`, Date.now());
+              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(`${platform}:${guildId}`);
+                quittingGuilds.delete(`${BLACKLIST_PLATFORM}:${guildId}`);
+                await clearSelfLeft(ctx, guildId);
               }
             } else if (memberCount > config.basic.smallGroupThreshold) {
               if (config.basic.smallGroupQualifiedNotifyAdmin) {
@@ -464,25 +521,37 @@ function apply2(ctx, config) {
     }
   });
   ctx.on("guild-removed", async (session) => {
-    const { guildId, platform } = session;
-    const quittingKey = `${platform}:${guildId}`;
-    if (quittingGuilds.has(quittingKey)) {
+    const { guildId } = session;
+    const platform = BLACKLIST_PLATFORM;
+    const dedupKey = `${platform}:${guildId}`;
+    if (quittingGuilds.has(dedupKey)) {
+      try {
+        await clearSelfLeft(ctx, guildId);
+      } catch {
+      }
       return;
     }
-    if (processedKicks.has(quittingKey)) {
-      return;
+    const isSelfLeft = await consumeSelfLeft(ctx, guildId);
+    if (isSelfLeft) return;
+    const raw = session.event?._data || session.original || session.onebot || {};
+    const subType = String(raw.sub_type ?? session.subtype ?? "");
+    const eventTs = typeof raw.time === "number" ? raw.time : Math.floor(Date.now() / 1e3);
+    const ageSec = Math.floor(Date.now() / 1e3) - eventTs;
+    if (subType === "leave") return;
+    if (!subType && ageSec > 60) return;
+    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 });
+      if (existing && existing.reason === "kicked") {
+        return;
+      }
     }
-    processedKicks.set(quittingKey, Date.now());
-    const groupName = await getGroupName(session.bot, guildId);
     if (config.basic.enableBlacklist) {
-      await ctx.model.upsert("blacklisted_guild", [{
-        platform,
-        guildId,
-        timestamp: Math.floor(Date.now() / 1e3),
-        reason: "kicked"
-      }]);
+      await blacklistKicked(ctx, guildId);
     }
     if (config.basic.notifyAdminOnKick) {
+      const groupName = await getGroupName(session.bot, guildId);
       const kickMsg = config.basic.kickNotificationMessage.replaceAll("{groupId}", guildId).replaceAll("{groupName}", groupName);
       await notifyAdmins(session.bot, config, kickMsg);
     }
@@ -516,7 +585,8 @@ function apply2(ctx, config) {
 群名称：${groupName}
 群号：${guildId}`;
       await notifyAdmins(session.bot, config, adminMsg);
-      quittingGuilds.set(`${platform}:${guildId}`, Date.now());
+      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);
       } catch (e) {
@@ -524,7 +594,8 @@ function apply2(ctx, config) {
       try {
         await session.bot.internal.setGroupLeave(parseInt(guildId));
       } catch (e) {
-        quittingGuilds.delete(`${platform}:${guildId}`);
+        quittingGuilds.delete(`${BLACKLIST_PLATFORM}:${guildId}`);
+        await clearSelfLeft(ctx, guildId);
         return `退出失败: ${e.message}`;
       }
       return "";
@@ -562,6 +633,33 @@ function apply3(ctx, config) {
     const rawUserId = raw.user_id ? String(raw.user_id) : session.userId;
     const rawGroupId = raw.group_id ? String(raw.group_id) : session.guildId;
     const { platform } = session;
+    if (config.basic.enableBlacklist && rawGroupId && /^\d+$/.test(String(rawGroupId))) {
+      const bl = await getBlacklistedGuild(ctx, String(rawGroupId));
+      if (bl.length > 0) {
+        try {
+          await session.bot.internal.setGroupAddRequest(flag, "invite", false, "该群已被机器人拉黑");
+        } catch (e) {
+          ctx.logger("group-control-invite").warn("拒绝黑名单群邀请失败 (flag 可能已失效):", e);
+        }
+        const rejectNotify = `已自动拒绝黑名单群邀请
+群号：${rawGroupId}
+邀请者 QQ：${rawUserId}
+如需放行请先执行 gc.unban ${rawGroupId} 再让对方重新邀请。`;
+        try {
+          await notifyAdmins(session.bot, config, rejectNotify);
+        } catch (e) {
+        }
+        try {
+          const rejectMsg = `您邀请加入的群 ${rawGroupId} 已被机器人拉黑，邀请已被自动拒绝。如有疑问请联系机器人管理员。`;
+          await session.bot.sendPrivateMessage(rawUserId, rejectMsg);
+        } catch (e) {
+        }
+        if (config.invite.showDetailedLog) {
+          console.log(`已自动拒绝黑名单群邀请: 群号 ${rawGroupId}, 邀请者 ${rawUserId}`);
+        }
+        return;
+      }
+    }
     if (!flag && config.invite.showDetailedLog) {
       console.warn("未能提取到邀请 flag，可能导致无法处理邀请。Raw event:", JSON.stringify(raw));
     }
@@ -655,6 +753,12 @@ function apply3(ctx, config) {
   ctx.command("gc.approve <groupId:string>", "同意群聊邀请").action(async ({ session }, groupId) => {
     if (!groupId) return "请指定群号。用法：gc.approve <群号>";
     if (!hasGlobalPermission(session, config)) return "权限不足，只有管理员可以审核邀请。";
+    if (config.basic.enableBlacklist) {
+      const bl = await getBlacklistedGuild(ctx, groupId);
+      if (bl.length > 0) {
+        return `群 ${groupId} 在黑名单中，无法通过审核。如需放行请先执行 gc.unban ${groupId}。`;
+      }
+    }
     const inviteData = await getPendingInvite(ctx, groupId);
     if (!inviteData) {
       const allInvites = await getAllPendingInvites(ctx);
@@ -940,6 +1044,7 @@ function apply5(ctx, config) {
     const guildId = parseGuildId(input);
     if (!guildId) return `输入格式错误。`;
     const removed = await removeBlacklistedGuild(ctx, guildId);
+    await clearSelfLeft(ctx, guildId);
     return removed ? `已移除群聊 ${guildId}` : `群聊 ${guildId} 不在黑名单中。`;
   });
   ctx.command("gc.banlist", "查看黑名单").action(async ({ session }) => {

package/package.json

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