koishi-plugin-group-control 0.2.4 → 0.2.6

package/lib/index.js

@@ -141,31 +141,36 @@ function apply(ctx, config) {
   if (config.invite.enabled) {
     const pendingInvites = /* @__PURE__ */ new Map();
     ctx.on("guild-request", async (session) => {
-      const { guildId, userId, platform } = session;
       const raw = session.original || session.raw || session.event?._data || {};
       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;
+      const { platform } = session;
       if (!flag && config.invite.showDetailedLog) {
         console.warn("Group Control: 未能提取到邀请 flag，可能导致无法处理邀请。Raw event:", JSON.stringify(raw));
       }
-      let userName = userId;
+      if (config.invite.showDetailedLog) {
+        console.log(`收到群邀请事件 - 原始数据: UserID=${raw.user_id}, GroupID=${raw.group_id}, Flag=${flag}`);
+      }
+      let userName = rawUserId;
       try {
-        const userInfo = await session.bot.getUser(userId);
-        userName = userInfo?.nickname || userInfo?.name || userId;
+        const userInfo = await session.bot.getUser(rawUserId);
+        userName = userInfo?.nickname || userInfo?.name || rawUserId;
       } catch (error) {
         console.error("获取用户信息失败:", error);
       }
-      let groupName = guildId;
+      let groupName = rawGroupId;
       try {
-        const guildInfo = await session.bot.getGuild(guildId);
-        groupName = guildInfo?.name || guildInfo?.group_name || guildId;
+        const guildInfo = await session.bot.getGuild(rawGroupId);
+        groupName = guildInfo?.name || guildInfo?.group_name || rawGroupId;
       } catch (error) {
         console.error("获取群信息失败:", error);
       }
       try {
-        const waitMessage = config.invite.inviteWaitMessage.replace("{groupName}", groupName).replace("{groupId}", guildId).replace("{userName}", userName).replace("{userId}", userId);
-        await session.bot.sendPrivateMessage(userId, waitMessage);
+        const waitMessage = config.invite.inviteWaitMessage.replace("{groupName}", groupName).replace("{groupId}", rawGroupId).replace("{userName}", userName).replace("{userId}", rawUserId);
+        await session.bot.sendPrivateMessage(rawUserId, waitMessage);
       } catch (error) {
-        console.error("发送等待审核提示失败:", error);
+        console.error(`发送等待审核提示给 ${rawUserId} 失败:`, error);
       }
       if (!config.invite.adminQQs || config.invite.adminQQs.length === 0) {
         if (config.invite.autoApprove) {
@@ -177,34 +182,30 @@ function apply(ctx, config) {
               reason: ""
             });
             if (config.invite.showDetailedLog) {
-              console.log(`自动同意群聊邀请: 群号 ${guildId}, 邀请者 ${userId}`);
+              console.log(`自动同意群聊邀请: 群号 ${rawGroupId}, 邀请者 ${rawUserId}`);
             }
           } catch (error) {
             console.error("自动同意群聊邀请失败:", error);
           }
-        } else {
-          if (config.invite.showDetailedLog) {
-            console.log(`未配置管理员且未启用自动同意，忽略群聊邀请: 群号 ${guildId}, 邀请者 ${userId}`);
-          }
         }
         return;
       }
-      const inviteId = `${guildId}_${userId}_${Date.now()}`;
+      const inviteId = `${rawGroupId}_${rawUserId}_${Date.now()}`;
       pendingInvites.set(inviteId, {
-        groupId: guildId,
-        userId,
+        groupId: rawGroupId,
+        userId: rawUserId,
         userName,
         time: Date.now(),
         flag
       });
-      const requestMessage = config.invite.inviteRequestMessage.replace("{groupName}", groupName).replace("{groupId}", guildId).replace("{userName}", userName).replace("{userId}", userId);
+      const requestMessage = config.invite.inviteRequestMessage.replace("{groupName}", groupName).replace("{groupId}", rawGroupId).replace("{userName}", userName).replace("{userId}", rawUserId);
       let requestSent = false;
       if (config.invite.notificationGroupId) {
         try {
           await session.bot.sendMessage(config.invite.notificationGroupId, requestMessage);
           requestSent = true;
           if (config.invite.showDetailedLog) {
-            console.log(`发送群聊邀请请求到通知群 ${config.invite.notificationGroupId}`);
+            console.log(`发送邀请请求到通知群 ${config.invite.notificationGroupId}`);
           }
         } catch (error) {
           console.error(`发送邀请请求到通知群 ${config.invite.notificationGroupId} 失败:`, error);
@@ -216,7 +217,7 @@ function apply(ctx, config) {
             await session.bot.sendPrivateMessage(adminQQ, requestMessage);
             requestSent = true;
             if (config.invite.showDetailedLog) {
-              console.log(`发送群聊邀请请求给管理员 ${adminQQ}: 群号 ${guildId}, 邀请者 ${userId}`);
+              console.log(`发送邀请请求给管理员 ${adminQQ}`);
             }
           } catch (error) {
             console.error(`发送邀请请求给管理员 ${adminQQ} 失败:`, error);
@@ -224,32 +225,22 @@ function apply(ctx, config) {
         }
       }
       if (!requestSent && config.invite.showDetailedLog) {
-        console.warn("群邀请请求未发送给任何目标（未配置通知群且私聊发送失败或未配置管理员）");
+        console.warn("群邀请请求发送失败：未配置通知群且管理员私聊发送失败");
       }
     });
     ctx.on("message", async (session) => {
-      const { userId, content, platform, guildId } = session;
-      if (!config.invite.adminQQs.includes(userId)) {
-        return;
-      }
+      const { userId, content, guildId } = session;
+      if (!config.invite.adminQQs.includes(userId)) return;
       const isNotificationGroup = config.invite.notificationGroupId && guildId === config.invite.notificationGroupId;
       const isPrivate = !guildId;
-      if (!isNotificationGroup && !isPrivate && config.invite.notificationGroupId) {
-        return;
-      }
+      if (!isNotificationGroup && !isPrivate && config.invite.notificationGroupId) return;
       const hasQuote = session.elements.some((element) => element.type === "quote");
-      if (!hasQuote) {
-        return;
-      }
+      if (!hasQuote) return;
       const trimmedContent = content.trim();
-      if (trimmedContent !== "同意" && trimmedContent !== "拒绝" && trimmedContent !== "accept" && trimmedContent !== "reject") {
-        return;
-      }
+      if (!["同意", "拒绝", "accept", "reject"].includes(trimmedContent)) return;
       const quoteElement = session.elements.find((element) => element.type === "quote");
-      if (!quoteElement) {
-        return;
-      }
-      const quoteMessageContent = quoteElement.attrs.content || quoteElement.attrs.text || "";
+      if (!quoteElement) return;
+      const quoteMessageContent = session.quote?.content || quoteElement.attrs.content || quoteElement.attrs.text || "";
       const groupIdMatch = quoteMessageContent.match(/群号：(\d+)/i);
       const userIdMatch = quoteMessageContent.match(/QQ:\s*(\d+)/i);
       if (groupIdMatch && userIdMatch) {
@@ -273,20 +264,17 @@ function apply(ctx, config) {
                   approve: true,
                   reason: ""
                 });
-                if (config.invite.showDetailedLog) {
-                  console.log(`管理员 ${userId} 同意群聊邀请: 群号 ${inviteData.groupId}, 邀请者 ${inviteData.userId}`);
-                }
                 await session.send(`已同意加入群 ${inviteData.groupId}`);
                 try {
                   await session.bot.sendPrivateMessage(inviteData.userId, `您的群聊邀请已通过管理员审核，机器人已加入群聊。`);
                 } catch (error) {
-                  console.error("通知邀请者审核结果失败:", error);
+                  console.error("通知邀请者失败:", error);
                 }
               } catch (error) {
                 console.error("处理同意邀请失败:", error);
                 await session.send(`处理同意邀请失败: ${error.message}`);
               }
-            } else if (trimmedContent === "拒绝" || trimmedContent === "reject") {
+            } else {
               try {
                 await session.bot.internal.setGroupAddRequest({
                   flag: inviteData.flag,
@@ -294,14 +282,11 @@ function apply(ctx, config) {
                   approve: false,
                   reason: "已拒绝"
                 });
-                if (config.invite.showDetailedLog) {
-                  console.log(`管理员 ${userId} 拒绝群聊邀请: 群号 ${inviteData.groupId}, 邀请者 ${inviteData.userId}`);
-                }
                 await session.send(`已拒绝加入群 ${inviteData.groupId}`);
                 try {
                   await session.bot.sendPrivateMessage(inviteData.userId, `您的群聊邀请未通过管理员审核，机器人将不会加入该群聊。`);
                 } catch (error) {
-                  console.error("通知邀请者审核结果失败:", error);
+                  console.error("通知邀请者失败:", error);
                 }
               } catch (error) {
                 console.error("处理拒绝邀请失败:", error);
@@ -320,8 +305,7 @@ function apply(ctx, config) {
       if (config.basic.welcomeMessage) {
         try {
           await session.bot.sendMessage(guildId, config.basic.welcomeMessage, platform);
-        } catch (error) {
-          console.error("发送欢迎消息失败:", error);
+        } catch (e) {
         }
       }
       return;
@@ -330,29 +314,24 @@ function apply(ctx, config) {
     if (blacklisted) {
       try {
         await session.bot.sendMessage(guildId, config.basic.blacklistMessage, platform);
-      } catch (error) {
-        console.error("发送黑名单提示失败:", error);
+      } catch (e) {
       }
       try {
         await session.bot.internal.setGroupLeave(parseInt(guildId));
-      } catch (error) {
-        console.error("退出黑名单群聊失败:", error);
+      } catch (e) {
       }
       return;
     }
     if (config.basic.welcomeMessage) {
       try {
         await session.bot.sendMessage(guildId, config.basic.welcomeMessage, platform);
-      } catch (error) {
-        console.error("发送欢迎消息失败:", error);
+      } catch (e) {
       }
     }
   });
   ctx.on("guild-removed", async (session) => {
     const { guildId, platform } = session;
-    if (!config.basic.enableBlacklist) {
-      return;
-    }
+    if (!config.basic.enableBlacklist) return;
     const quittingKey = `${platform}:${guildId}`;
     if (quittingGuilds.has(quittingKey)) {
       quittingGuilds.delete(quittingKey);
@@ -372,83 +351,53 @@ function apply(ctx, config) {
       const { guildId, platform } = session;
       if (config.frequency.whitelist && config.frequency.whitelist.includes(guildId)) return;
       let record = await getCommandFrequencyRecord(ctx, platform, guildId);
-      function handleExpiredWindow(currentRecord, platform2, guildId2, now2, windowStart2, warnDelay) {
-        if (currentRecord && currentRecord.lastCommandTime < windowStart2) {
-          if (currentRecord.warningSent && currentRecord.firstWarningTime > 0) {
-            if (now2 - currentRecord.firstWarningTime > warnDelay) {
-              return { platform: platform2, guildId: guildId2, commandCount: 1, lastCommandTime: now2, warningSent: false, blockExpiryTime: 0, firstWarningTime: 0 };
-            } else {
-              currentRecord.commandCount = 1;
-              currentRecord.lastCommandTime = now2;
-              return currentRecord;
-            }
-          } else if (isCurrentlyBlocked(currentRecord) && Date.now() >= currentRecord.blockExpiryTime * 1e3) {
-            return { platform: platform2, guildId: guildId2, commandCount: 1, lastCommandTime: now2, warningSent: false, blockExpiryTime: 0, firstWarningTime: 0 };
-          } else {
-            return { platform: platform2, guildId: guildId2, commandCount: 1, lastCommandTime: now2, warningSent: false, blockExpiryTime: 0, firstWarningTime: 0 };
-          }
+      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 {
-          if (currentRecord) {
-            currentRecord.commandCount += 1;
-            currentRecord.lastCommandTime = now2;
-            return currentRecord;
-          } else {
-            return { platform: platform2, guildId: guildId2, commandCount: 1, lastCommandTime: now2, warningSent: false, blockExpiryTime: 0, firstWarningTime: 0 };
-          }
+          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 };
+      } else {
+        record.commandCount += 1;
+        record.lastCommandTime = now;
       }
-      __name(handleExpiredWindow, "handleExpiredWindow");
-      if (record && isCurrentlyBlocked(record)) {
+      if (isCurrentlyBlocked(record)) {
         try {
           const remainingTime = Math.ceil((record.blockExpiryTime * 1e3 - Date.now()) / 1e3);
-          const blockedMessage = config.frequency.blockedMsg.replace("{time}", remainingTime.toString());
-          await session.bot.sendMessage(guildId, blockedMessage, platform);
-        } catch (error) {
-          console.error("发送屏蔽提示失败:", error);
+          await session.bot.sendMessage(guildId, config.frequency.blockedMsg.replace("{time}", remainingTime.toString()), platform);
+        } catch (e) {
         }
-        throw new Error("Command frequency limit exceeded - currently blocked");
+        throw new Error("Blocked");
       }
-      const now = Math.floor(Date.now() / 1e3);
-      const windowStart = now - config.frequency.window;
-      record = handleExpiredWindow(record, platform, guildId, now, windowStart, config.frequency.warnDelay);
       if (record.commandCount > config.frequency.limit) {
-        if (isCurrentlyBlocked(record)) {
-          const remainingTime = Math.ceil((record.blockExpiryTime * 1e3 - Date.now()) / 1e3);
+        if (!record.warningSent) {
           try {
-            const blockedMessage = config.frequency.blockedMsg.replace("{time}", remainingTime.toString());
-            await session.bot.sendMessage(guildId, blockedMessage, platform);
-          } catch (error) {
-            console.error("发送屏蔽提示失败:", error);
+            await session.bot.sendMessage(guildId, config.frequency.warnMsg, platform);
+          } catch (e) {
           }
-          throw new Error("Command frequency limit exceeded - currently blocked");
+          record.warningSent = true;
+          record.commandCount = 1;
+          record.lastCommandTime = now;
+          record.firstWarningTime = now;
+          await updateCommandFrequencyRecord(ctx, platform, guildId, record);
+          throw new Error("Warning");
         } else {
-          if (!record.warningSent) {
-            try {
-              await session.bot.sendMessage(guildId, config.frequency.warnMsg, platform);
-            } catch (error) {
-              console.error("发送频率警告消息失败:", error);
-            }
-            record.warningSent = true;
-            record.commandCount = 1;
-            record.lastCommandTime = now;
-            record.firstWarningTime = now;
-            await updateCommandFrequencyRecord(ctx, platform, guildId, record);
-            throw new Error("Command frequency limit exceeded - warning issued");
-          } else {
-            const blockExpiryTime = now + config.frequency.blockDur;
-            record.blockExpiryTime = blockExpiryTime;
-            record.warningSent = false;
-            record.commandCount = 0;
-            record.firstWarningTime = 0;
-            await updateCommandFrequencyRecord(ctx, platform, guildId, record);
-            try {
-              const blockMessage = config.frequency.blockMsg.replace("{duration}", config.frequency.blockDur.toString());
-              await session.bot.sendMessage(guildId, blockMessage, platform);
-            } catch (error) {
-              console.error("发送屏蔽通知失败:", error);
-            }
-            throw new Error("Command frequency limit exceeded - blocked");
+          record.blockExpiryTime = now + config.frequency.blockDur;
+          record.warningSent = false;
+          record.commandCount = 0;
+          record.firstWarningTime = 0;
+          await updateCommandFrequencyRecord(ctx, platform, guildId, record);
+          try {
+            await session.bot.sendMessage(guildId, config.frequency.blockMsg.replace("{duration}", config.frequency.blockDur.toString()), platform);
+          } catch (e) {
           }
+          throw new Error("Blocked");
         }
       }
       await updateCommandFrequencyRecord(ctx, platform, guildId, record);
@@ -459,34 +408,25 @@ function apply(ctx, config) {
       if (!session.guildId) return "quit 指令只能在群聊中使用。";
       const { guildId, platform, userId } = session;
       quittingGuilds.add(`${platform}:${guildId}`);
-      const message = config.basic.quitMessage.replace("{userId}", userId);
       try {
-        await session.bot.sendMessage(session.guildId, message, platform);
-      } catch (sendError) {
-        console.error("发送退出提示消息失败:", sendError);
+        await session.bot.sendMessage(session.guildId, config.basic.quitMessage.replace("{userId}", userId), platform);
+      } catch (e) {
       }
       try {
         await session.bot.internal.setGroupLeave(parseInt(guildId));
-      } catch (leaveError) {
+      } catch (e) {
         quittingGuilds.delete(`${platform}:${guildId}`);
-        console.error("退出群聊失败:", leaveError);
-        return `退出失败: ${leaveError.message || "OneBot API 调用失败"}`;
+        return `退出失败: ${e.message}`;
       }
       return "";
     });
   }
-  async function viewBlacklist({ session }) {
+  async function viewBlacklist() {
     const errorMsg = isBlacklistEnabled(config.basic);
     if (errorMsg) return errorMsg;
     const records = await getAllBlacklistedGuilds(ctx);
     if (records.length === 0) return "黑名单为空。";
-    let msg = "黑名单列表：\n";
-    records.forEach((r) => {
-      const time = formatDate(r.timestamp);
-      msg += `- ${r.guildId} (时间: ${time})
-`;
-    });
-    return msg.trim();
+    return "黑名单列表：\n" + records.map((r) => `- ${r.guildId} (时间: ${formatDate(r.timestamp)})`).join("\n");
   }
   __name(viewBlacklist, "viewBlacklist");
   ctx.command("view-blacklist", "查看被拉黑的群聊列表", { authority: 4 }).action(viewBlacklist);
@@ -494,7 +434,7 @@ function apply(ctx, config) {
     const errorMsg = isBlacklistEnabled(config.basic);
     if (errorMsg) return errorMsg;
     const guildId = parseGuildId(input);
-    if (!guildId) return `输入格式错误。请输入纯群号或 onebot:群号 格式。`;
+    if (!guildId) return `输入格式错误。`;
     const removed = await removeBlacklistedGuild(ctx, guildId);
     return removed ? `已移除群聊 ${guildId}` : `群聊 ${guildId} 不在黑名单中。`;
   }
@@ -504,22 +444,21 @@ function apply(ctx, config) {
     const errorMsg = isBlacklistEnabled(config.basic);
     if (errorMsg) return errorMsg;
     const guildId = parseGuildId(input);
-    if (!guildId) return `输入格式错误。请输入纯群号或 onebot:群号 格式。`;
+    if (!guildId) return `输入格式错误。`;
     const existing = await getBlacklistedGuild(ctx, guildId);
     if (existing.length > 0) return `群聊 ${guildId} 已在黑名单中。`;
     await createBlacklistedGuild(ctx, guildId, "manual_add");
     return `已添加群聊 ${guildId} 到黑名单。`;
   }
   __name(addToBlacklist, "addToBlacklist");
-  ctx.command("add-to-blacklist <groupId:text>", "手动添加群聊到黑名单 (输入群号)", { authority: 4 }).action(addToBlacklist);
-  async function clearBlacklist({ session }) {
+  ctx.command("add-to-blacklist <groupId:text>", "手动添加群聊到黑名单", { authority: 4 }).action(addToBlacklist);
+  async function clearBlacklist() {
     const errorMsg = isBlacklistEnabled(config.basic);
     if (errorMsg) return errorMsg;
     const records = await getAllBlacklistedGuilds(ctx);
-    const count = records.length;
-    if (count === 0) return "黑名单已是空的。";
+    if (records.length === 0) return "黑名单已是空的。";
     await clearBlacklistedGuilds(ctx);
-    return `已清空黑名单，共移除 ${count} 个群聊。`;
+    return `已清空黑名单，共移除 ${records.length} 个群聊。`;
   }
   __name(clearBlacklist, "clearBlacklist");
   ctx.command("clear-blacklist", "清空黑名单", { authority: 4 }).action(clearBlacklist);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-group-control",
   "description": "Koishi群聊自管理插件，支持自定义机器人进群消息、被踢出自动拉黑、刷屏自动屏蔽功能和主动退群指令等。(仅支持OneBot适配器)",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -23,4 +23,4 @@
   "peerDependencies": {
     "koishi": "^4.18.7"
   }
-}
+}