koishi-plugin-group-verification 1.0.34 → 1.0.36

package/lib/index.d.ts

@@ -47,7 +47,7 @@ export interface PendingVerification {
 export interface Config {
     defaultReminderMessage?: string;
     enableStrictGroupCheck?: boolean;
-    logLevel?: 'debug' | 'info' | 'warn' | 'error';
+    logLevel?: 'debug' | 'info' | 'warn';
     permissionDeniedMessage?: string;
     invalidGroupMessage?: string;
     parameterConflictMessage?: string;

package/lib/index.js

@@ -44,10 +44,27 @@ module.exports = __toCommonJS(src_exports);
 var import_koishi = require("koishi");
 var name = "group-verification";
 var logger = console;
+var pluginLogLevel = "中等";
+function clog(lvl, mediumMsg, verboseMsg) {
+  if (pluginLogLevel === "简洁") {
+    if (lvl === "warn" || lvl === "error") logger[lvl](mediumMsg);
+  } else if (pluginLogLevel === "详细") {
+    logger[lvl](verboseMsg ?? mediumMsg);
+  } else {
+    const outputLvl = lvl === "debug" ? "info" : lvl;
+    logger[outputLvl](mediumMsg);
+  }
+}
+__name(clog, "clog");
+function clogV(msg, ...args) {
+  if (pluginLogLevel === "详细") logger.debug(msg, ...args);
+}
+__name(clogV, "clogV");
 var Config = import_koishi.Schema.object({
-  defaultReminderMessage: import_koishi.Schema.string().description("默认提醒消息模板（使用 \\n 表示换行，可包含下方变量）").default("{user}({id}) 申请加入群 {gname}({group})\n申请理由: {question}\n匹配情况: {answer}/{threshold}\n使用 gva 同意或 gvr 拒绝申请"),
+  defaultReminderMessage: import_koishi.Schema.string().description("默认提醒消息模板（使用 \\n 表示换行，可包含下方变量）").default("{user}({id}) 申请入群\\n申请理由: {question}\\n匹配情况: {answer}/{threshold}\\n使用 gva 同意或 gvr 拒绝申请"),
   enableStrictGroupCheck: import_koishi.Schema.boolean().description("是否启用严格的群号检查（检查群号长度）").default(false),
-  logLevel: import_koishi.Schema.union(["debug", "info", "warn", "error"]).description("日志级别").default("info"),
+  logLevel: import_koishi.Schema.union(["debug", "info", "warn"]).description("日志详细程度").default("info"),
+  // debug=详细, info=中等, warn=简洁
   permissionDeniedMessage: import_koishi.Schema.string().description("权限不足时返回给调用者的提示").default("权限不足: 需要群主/管理员权限或koishi三级以上权限"),
   invalidGroupMessage: import_koishi.Schema.string().description("无效群号或机器人未在该群时的提示").default("群号 {group} 格式不合法或机器人不在该群中"),
   parameterConflictMessage: import_koishi.Schema.string().description("参数冲突时提示").default("参数冲突: -? 或 -r 不能与其他参数或关键词一起使用（仅可搭配 -i）"),
@@ -194,22 +211,22 @@ function usageString() {
 __name(usageString, "usageString");
 function mergeReminder(existingConfig, cleanedOptions, hasRealMessageParam, hasRealEnableMessageParam, hasRealDisableMessageParam, logger2, defaultMessage) {
   let reminderEnabled = true;
-  let reminderMessage = defaultMessage || "{user}({id}) 申请加入群 {gname}({group})\n申请理由: {question}\n匹配情况: {answer}/{threshold}";
+  let reminderMessage = defaultMessage || "{user}({id}) 申请入群\\n申请理由: {question}\\n匹配情况: {answer}/{threshold}\\n使用 gva 同意或 gvr 拒绝申请";
   if (existingConfig) {
     reminderEnabled = existingConfig.reminderEnabled;
     reminderMessage = existingConfig.reminderMessage || reminderMessage;
   }
   if (hasRealDisableMessageParam) {
     reminderEnabled = false;
-    logger2.debug("禁用提醒消息功能 (保留现有内容)");
+    clog("debug", "禁用提醒消息功能 (保留现有内容)");
   } else if (hasRealEnableMessageParam) {
     reminderEnabled = true;
-    logger2.debug(`启用提醒消息（保留原消息）: ${reminderMessage.substring(0, 50)}...`);
+    clog("debug", `启用提醒消息（保留原消息）: ${reminderMessage.substring(0, 50)}...`);
   } else if (hasRealMessageParam) {
     reminderEnabled = true;
     if (cleanedOptions.message !== void 0) {
-      reminderMessage = cleanedOptions.message.replace(/\\n/g, "\n");
-      logger2.debug(`设置自定义提醒消息: ${reminderMessage.substring(0, 50)}...`);
+      reminderMessage = cleanedOptions.message;
+      clog("debug", `设置自定义提醒消息: ${reminderMessage.substring(0, 50)}...`);
     }
   }
   return { reminderEnabled, reminderMessage };
@@ -233,7 +250,7 @@ async function syncTotalStats(ctx) {
         totalJoined,
         lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
       });
-      logger.debug(`总计统计已同步: 自动批准${totalAutoApproved}, 手动批准${totalManuallyApproved}, 拒绝${totalRejected}, 入群${totalJoined}`);
+      clog("debug", `总计统计已同步: 自动批准${totalAutoApproved}, 手动批准${totalManuallyApproved}, 拒绝${totalRejected}, 入群${totalJoined}`);
     }
   } catch (error) {
     logger.error("同步总计统计时出错:", error);
@@ -330,46 +347,49 @@ async function checkPermission(session, targetGroupId) {
   if (!groupId) {
     return [false, "请在群聊中使用此命令或使用 -i 参数指定群号"];
   }
-  logger.debug(`权限检查 - 用户ID: ${session.userId}, 群号: ${groupId}`);
   const koishiAuthority = session.author?.authority || session.user?.authority;
-  logger.debug(`权限检查 - Koishi权限等级: ${koishiAuthority || "未获取到"}`);
+  clogV(`权限检查 - 用户ID: ${session.userId}, 群号: ${groupId}`);
+  clogV(`权限检查 - Koishi权限等级: ${koishiAuthority || "未获取到"}`);
   if (!session.author) {
-    logger.debug(`权限检查 - session中可能的权限字段:`, {
+    clogV(`权限检查 - session中可能的权限字段:`, {
       authority: session.authority,
       permission: session.permission,
       role: session.role
     });
   } else {
-    logger.debug(`权限检查 - author对象中的字段:`, {
+    clogV(`权限检查 - author对象中的字段:`, {
       permission: session.author.permission,
       role: session.author.role,
       permissions: session.author.permissions
     });
   }
   if (session.user) {
-    logger.debug(`权限检查 - user对象中的权限信息:`, {
+    clogV(`权限检查 - user对象中的权限信息:`, {
       authority: session.user.authority,
       permission: session.user.permission,
       role: session.user.role
     });
   }
   if (koishiAuthority && koishiAuthority >= 3) {
-    logger.debug(`权限检查 - 通过koishi权限检查: ${koishiAuthority}`);
+    clogV(`权限检查 - 通过koishi权限检查: ${koishiAuthority}`);
+    clog("debug", `权限通过(koishi): uid=${session.userId} authority=${koishiAuthority}`);
     return [true];
   }
   try {
     const member = await session.bot.getGuildMember(groupId, session.userId);
-    logger.info(`权限检查 - 获取到成员信息:`, {
+    clogV(`权限检查 - 获取到成员信息:`, {
       roles: member?.roles,
       permissions: member?.permissions
     });
     if (member) {
       if (member.permissions?.includes("OWNER") || member.roles?.includes("owner")) {
-        logger.info(`权限检查 - 用户是群主`);
+        clogV(`权限检查 - 用户是群主`);
+        clog("debug", `权限通过(群主): uid=${session.userId}`);
         return [true];
       }
       if (member.roles?.includes("admin") || member.permissions?.includes("ADMINISTRATOR")) {
-        logger.info(`权限检查 - 用户是管理员`);
+        clogV(`权限检查 - 用户是管理员`);
+        clog("debug", `权限通过(管理员): uid=${session.userId}`);
         return [true];
       }
     }
@@ -380,9 +400,10 @@ async function checkPermission(session, targetGroupId) {
 }
 __name(checkPermission, "checkPermission");
 async function handleGuildMemberRequestEvent(ctx, session) {
-  logger.debug("guild-member-request event", session);
+  clogV("guild-member-request event", session);
   let guildId = (session.guildId || session.channelId || "").toString().trim();
   const userId = session.userId;
+  clog("debug", `guild-member-request: guild=${guildId} user=${userId}`);
   const message = session.content || "";
   if (!guildId) {
     logger.warn("guild-member-request 没有 guildId，跳过处理");
@@ -393,7 +414,7 @@ async function handleGuildMemberRequestEvent(ctx, session) {
   if (!groupConfig || groupConfig.length === 0) return;
   const config = groupConfig[0];
   if (config.reviewMethod === 3) {
-    logger.info(`配置要求全部拒绝，自动拒绝用户 ${userId}`);
+    clog("info", `配置要求全部拒绝，自动拒绝用户 ${userId}`);
     if (requestId) {
       try {
         await session.bot.handleGuildMemberRequest(requestId, false);
@@ -407,7 +428,7 @@ async function handleGuildMemberRequestEvent(ctx, session) {
   try {
     const blacklisted = await isUserBlacklisted(ctx, guildId, userId);
     if (blacklisted) {
-      logger.info(`用户 ${userId} 在群 ${guildId} 或全局黑名单中，自动拒绝申请`);
+      clog("info", `用户 ${userId} 在群 ${guildId} 或全局黑名单中，自动拒绝申请`);
       if (requestId) {
         try {
           await session.bot.handleGuildMemberRequest(requestId, false);
@@ -422,12 +443,13 @@ async function handleGuildMemberRequestEvent(ctx, session) {
     logger.warn("黑名单检查失败", e);
   }
   const { isValid, matchedCount, requiredThreshold } = await verifyApplication(config, message, session);
-  logger.debug(`验证结果 guild=${guildId} user=${userId} msg="${message}" matched=${matchedCount} threshold=${requiredThreshold} valid=${isValid}`);
+  clogV(`验证结果 guild=${guildId} user=${userId} msg="${message}" matched=${matchedCount} threshold=${requiredThreshold} valid=${isValid}`);
   if (isValid) {
     if (requestId) {
       try {
         await session.bot.handleGuildMemberRequest(requestId, true);
-        logger.debug(`自动同意 requestId=${requestId}`);
+        clogV(`自动同意 requestId=${requestId}`);
+        await updateStats(ctx, guildId, "autoApproved");
         if (!autoQueue.has(guildId)) autoQueue.set(guildId, /* @__PURE__ */ new Set());
         autoQueue.get(guildId).add(userId);
       } catch (e) {
@@ -461,7 +483,7 @@ function parseConfigArgs(raw) {
     }
   }
   tokens = tokens.map(
-    (t) => t.replace(new RegExp(ESC_QUOTE, "g"), '"').replace(new RegExp(ESC_BACKSLASH, "g"), "\\")
+    (t) => t.replace(new RegExp(ESC_QUOTE, "g"), '"').replace(new RegExp(ESC_BACKSLASH, "g"), "\\\\")
   );
   for (let i = 0; i < tokens.length; i++) {
     const tok = tokens[i];
@@ -567,7 +589,11 @@ async function verifyApplication(config, message, session) {
       isValid = false;
       requiredThreshold = "null";
   }
-  logger.debug(`verifyApplication msg="${message}" keywords=${JSON.stringify(config.keywords)} matched=${matchedCount} threshold=${requiredThreshold} valid=${isValid}`);
+  clog(
+    "debug",
+    `verify: matched=${matchedCount}/${requiredThreshold} valid=${isValid}`,
+    `verifyApplication msg="${message}" keywords=${JSON.stringify(config.keywords)} matched=${matchedCount} threshold=${requiredThreshold} valid=${isValid}`
+  );
   return { isValid, matchedCount, requiredThreshold };
 }
 __name(verifyApplication, "verifyApplication");
@@ -580,7 +606,11 @@ async function handleFailedVerification(ctx, session, config, matchedCount, requ
   }
   const username = session.username || "未知用户";
   const message = session.content || "";
-  logger.debug(`处理失败验证 guild=${guildId} user=${userId} msg="${message}" matched=${matchedCount} threshold=${requiredThreshold}`);
+  clog(
+    "debug",
+    `待审核: guild=${guildId} user=${userId} matched=${matchedCount}/${requiredThreshold}`,
+    `处理失败验证 guild=${guildId} user=${userId} msg="${session.content || ""}" matched=${matchedCount} threshold=${requiredThreshold}`
+  );
   if (matchedCount === void 0 || requiredThreshold === void 0) {
     const result = await verifyApplication(config, message, session);
     matchedCount = result.matchedCount;
@@ -603,31 +633,31 @@ async function handleFailedVerification(ctx, session, config, matchedCount, requ
     applyTime: (/* @__PURE__ */ new Date()).toISOString()
   });
   if (!config.reminderEnabled || !config.reminderMessage || config.reminderMessage === "") {
-    logger.debug(`群 ${guildId} 的提醒消息已被禁用，跳过发送`);
+    clog("debug", `群 ${guildId} 的提醒消息已被禁用，跳过发送`);
     return;
   }
-  let reminderMsg = config.reminderMessage;
+  let reminderMsg = config.reminderMessage.replace(/\\\\n/g, "
").replace(/\\n/g, "\n").replace(/\x01/g, "\\n");
   reminderMsg = reminderMsg.replace(/{user}/g, username).replace(/{id}/g, userId).replace(/{group}/g, guildId).replace(/{gname}/g, groupName).replace(/{question}/g, message).replace(/{answer}/g, matchedCount.toString()).replace(/{threshold}/g, requiredThreshold);
   const rawChannel = (session.channelId || "").toString().trim();
   const channel = rawChannel || guildId;
   const target = rawChannel ? [channel, guildId] : guildId;
-  logger.debug("broadcast target", { channel, guildId, target });
+  clog("debug", `broadcast target: channel=${channel} guild=${guildId}`);
   if (session.bot && typeof session.bot.broadcast === "function") {
     try {
       await session.bot.broadcast([target], reminderMsg);
     } catch (err) {
-      logger.warn("bot.broadcast failed, fallback to ctx.broadcast", err);
+      logger.warn("bot.broadcast 失败，回退到 ctx.broadcast", err);
       if (typeof ctx.broadcast === "function") {
         await ctx.broadcast([target], reminderMsg);
       } else {
-        logger.info("ctx.broadcast 不可用，跳过发送");
+        clog("info", "ctx.broadcast 不可用，跳过发送");
       }
     }
   } else {
     if (typeof ctx.broadcast === "function") {
       await ctx.broadcast([target], reminderMsg);
     } else {
-      logger.info("ctx.broadcast 不可用，跳过发送");
+      clog("info", "ctx.broadcast 不可用，跳过发送");
     }
   }
 }
@@ -711,7 +741,7 @@ async function processBlacklistCommand(ctx, session, rawArgs, config) {
     if (session.bot && typeof session.bot.kickGuildMember === "function") {
       try {
         await session.bot.kickGuildMember(group, targetUser);
-        logger.info(`已将黑名单用户 ${targetUser} 从群 ${group} 踢出`);
+        clog("info", `已将黑名单用户 ${targetUser} 从群 ${group} 踢出`);
       } catch (e) {
         logger.warn(`踢出用户 ${targetUser} 失败`, e);
       }
@@ -863,11 +893,12 @@ function apply(ctx, config) {
     autoInc: true
   });
   logger = ctx.logger("group-verification");
-  if (config.logLevel) logger.level = config.logLevel;
-  logger.info("群组验证插件已启动");
-  logger.info(`默认提醒消息: ${config.defaultReminderMessage}`);
-  logger.info(`严格群号检查: ${config.enableStrictGroupCheck ? "启用" : "禁用"}`);
-  logger.info(`日志级别: ${config.logLevel}`);
+  pluginLogLevel = { debug: "详细", info: "中等", warn: "简洁" }[config?.logLevel ?? "info"] ?? "中等";
+  if (pluginLogLevel === "详细") logger.level = 3;
+  clog("info", "群组验证插件已启动");
+  clog("info", `默认提醒消息: ${config.defaultReminderMessage}`);
+  clog("info", `严格群号检查: ${config.enableStrictGroupCheck ? "启用" : "禁用"}`);
+  clog("info", `日志详细度: ${config.logLevel ?? "中等"}`);
   ctx.model.extend("group_verification_stats", {
     id: "unsigned",
     groupId: "string",
@@ -875,8 +906,8 @@ function apply(ctx, config) {
     manuallyApproved: "integer",
     rejected: "integer",
     totalJoined: "integer",
-    // store as string (ISO timestamp) to preserve full date+time;
-    // Koishi `date` type truncates to day which leads to 00:00:00.
+    // 以字符串（ISO 时间戳）格式存储，保留完整日期+时间；
+    // Koishi 的 date 类型会截断到天，导致时间显示为 00:00:00。
     lastUpdated: "string"
   }, {
     primary: "id",
@@ -890,7 +921,7 @@ function apply(ctx, config) {
     requestMessage: "string",
     // 保存 OneBot 事件提供的原始 requestId；用于同意/拒绝操作
     requestId: "string",
-    // record full timestamp as string to keep time component
+    // 以字符串格式记录完整时间戳，保留时间分量
     applyTime: "string"
   }, {
     primary: "id",
@@ -906,54 +937,36 @@ function apply(ctx, config) {
     indexes: [["groupId"]]
   });
   ctx.on("guild-member-request", async (session) => {
-    logger.info("收到 guild-member-request 事件，转发给处理函数");
+    clog("debug", "收到 guild-member-request 事件，转发给处理函数");
     await handleGuildMemberRequestEvent(ctx, session);
   });
   ctx.on("guild-member-added", async (session) => {
     const groupId = session.guildId || "";
     const userId = session.userId || "";
-    if (!groupId || !userId) {
-      return;
-    }
+    if (!groupId || !userId) return;
     await incrementTotal(ctx, groupId);
-    const set = autoQueue.get(groupId);
-    if (set && set.has(userId)) {
-      await updateStats(ctx, groupId, "autoApproved");
-      set.delete(userId);
-      logger.info(`用户 ${userId} 通过机器人审批加入群 ${groupId}（autoQueue），统计已更新`);
-      return;
-    }
-    const pendingRecords = await ctx.database.get("group_verification_pending", {
-      groupId,
-      userId
-    });
-    if (pendingRecords.length > 0) {
-      await updateStats(ctx, groupId, "autoApproved");
-      for (const rec of pendingRecords) {
-        await ctx.database.remove("group_verification_pending", { id: rec.id });
-      }
-      logger.info(`用户 ${userId} 通过验证加入群 ${groupId}，已清理 ${pendingRecords.length} 条待审核记录，统计已更新`);
-    } else {
-      await updateStats(ctx, groupId, "manuallyApproved");
-      logger.info(`用户 ${userId} 被手动邀请加入群 ${groupId}，手动批准统计已更新`);
+    const autoSet = autoQueue.get(groupId);
+    if (autoSet && autoSet.has(userId)) {
+      autoSet.delete(userId);
     }
+    await ctx.database.remove("group_verification_pending", { groupId, userId });
   });
   async function checkPermission2(session, targetGroupId) {
     const groupId = targetGroupId || session.guildId;
     if (!groupId) {
       return [false, config.invalidGroupMessage || "请在群聊中使用此命令或使用 -i 参数指定群号"];
     }
-    logger.debug(`权限检查 - 用户ID: ${session.userId}, 群号: ${groupId}`);
     const koishiAuthority = session.author?.authority || session.user?.authority;
-    logger.debug(`权限检查 - Koishi权限等级: ${koishiAuthority || "未获取到"}`);
+    clogV(`权限检查 - 用户ID: ${session.userId}, 群号: ${groupId}`);
+    clogV(`权限检查 - Koishi权限等级: ${koishiAuthority || "未获取到"}`);
     if (!session.author) {
-      logger.debug(`权限检查 - session中可能的权限字段:`, {
+      clogV(`权限检查 - session中可能的权限字段:`, {
         authority: session.authority,
         permission: session.permission,
         role: session.role
       });
     } else {
-      logger.debug(`权限检查 - author对象中的字段:`, {
+      clogV(`权限检查 - author对象中的字段:`, {
         authority: session.author.authority,
         permission: session.author.permission,
         role: session.author.role,
@@ -961,29 +974,32 @@ function apply(ctx, config) {
       });
     }
     if (session.user) {
-      logger.debug(`权限检查 - user对象中的权限信息:`, {
+      clogV(`权限检查 - user对象中的权限信息:`, {
         authority: session.user.authority,
         permission: session.user.permission,
         role: session.user.role
       });
     }
     if (koishiAuthority && koishiAuthority >= 3) {
-      logger.debug(`权限检查 - 通过koishi权限检查: ${koishiAuthority}`);
+      clogV(`权限检查 - 通过koishi权限检查: ${koishiAuthority}`);
+      clog("debug", `权限通过(koishi): uid=${session.userId} authority=${koishiAuthority}`);
       return [true];
     }
     try {
       const member = await session.bot.getGuildMember(groupId, session.userId);
-      logger.debug(`权限检查 - 获取到成员信息:`, {
+      clogV(`权限检查 - 获取到成员信息:`, {
         roles: member?.roles,
         permissions: member?.permissions
       });
       if (member) {
         if (member.permissions?.includes("OWNER") || member.roles?.includes("owner")) {
-          logger.info(`权限检查 - 用户是群主`);
+          clogV(`权限检查 - 用户是群主`);
+          clog("debug", `权限通过(群主): uid=${session.userId}`);
           return [true];
         }
         if (member.roles?.includes("admin") || member.permissions?.includes("ADMINISTRATOR")) {
-          logger.debug(`权限检查 - 用户是管理员`);
+          clogV(`权限检查 - 用户是管理员`);
+          clog("debug", `权限通过(管理员): uid=${session.userId}`);
           return [true];
         }
       }
@@ -991,10 +1007,8 @@ function apply(ctx, config) {
       logger.warn(`权限检查 - 获取群成员信息失败:`, error);
       return [false, `无法获取群 ${groupId} 的成员信息，请确认机器人已在该群中`];
     }
-    logger.debug(`权限检查 - 权限不足`);
-    const debugInfo = `调试信息 - 用户ID:${session.userId}, 群号:${groupId}, 权限等级:${koishiAuthority || "未知"}`;
-    return [false, (config.permissionDeniedMessage || "权限不足: 需要群主/管理员权限或koishi三级以上权限") + `
-${debugInfo}`];
+    clogV(`权限检查 - 权限不足`);
+    return [false, config.permissionDeniedMessage || "权限不足: 需要群主/管理员权限或koishi三级以上权限"];
   }
   __name(checkPermission2, "checkPermission");
   const groupVerify = ctx.command("group-verify", "群组验证管理命令").alias("gv", "gverify");
@@ -1007,16 +1021,17 @@ ${debugInfo}`];
     "group-verify.配置",
     "gvc"
   ).option("groupId", "-i <groupId> 指定群号").option("method", "-m <method> 审核方式 (0-3)").option("threshold", "-t <threshold> 阈值参数").option("message", "-msg [message] 自定义提醒消息").option("disableMessage", "-nomsg 禁用提醒消息").option("query", "-? 查询当前配置").option("remove", "-r 删除配置").action(async ({ session, options }, keywords) => {
-    logger.info(`=== 命令解析调试 ===`);
-    logger.info(`session内容: guildId=${session.guildId}, userId=${session.userId}`);
+    clogV(`=== 命令解析调试 ===`);
+    clogV(`session内容: guildId=${session.guildId}, userId=${session.userId}`);
     const rawInput = session.content.split(/\s+/).slice(1).join(" ");
-    logger.info(`原始命令参数: "${rawInput}"`);
+    clogV(`原始命令参数: "${rawInput}"`);
+    if (pluginLogLevel !== "详细") clog("debug", `gvc: uid=${session.userId} guild=${session.guildId} args="${rawInput}"`);
     const parsed = parseConfigArgs(rawInput);
     const { keywords: parsedKeywords, flags, error: parseError } = parsed;
     if (parseError) {
       return parseError;
     }
-    logger.info(`解析结果 flags=${JSON.stringify(flags)}, keywords=[${parsedKeywords.join(", ")}]`);
+    clog("debug", `解析结果 flags=${JSON.stringify(flags)}, keywords=[${parsedKeywords.join(", ")}]`);
     const cleanedOptions = {
       groupId: flags.groupId || options.groupId,
       method: flags.method || (options.method === "" ? void 0 : options.method),
@@ -1028,7 +1043,8 @@ ${debugInfo}`];
       query: flags.query || options.query,
       remove: flags.remove || options.remove
     };
-    logger.info(`合并后options: ${JSON.stringify(cleanedOptions, null, 2)}`);
+    clogV(`合并后options: ${JSON.stringify(cleanedOptions, null, 2)}
+`);
     if ((cleanedOptions.query || cleanedOptions.remove) && (parsedKeywords.length > 0 || cleanedOptions.method !== void 0 || cleanedOptions.threshold !== void 0 || cleanedOptions.message !== void 0 || cleanedOptions.enableMessage || cleanedOptions.disableMessage)) {
       return config.parameterConflictMessage || "参数冲突: -? 或 -r 不能与其他参数或关键词一起使用（仅可搭配 -i）";
     }
@@ -1077,7 +1093,7 @@ ${debugInfo}`];
       const existingConfig2 = await ctx.database.get("group_verification_config", { groupId: targetGroupId });
       if (existingConfig2.length > 0) {
         await ctx.database.remove("group_verification_config", { id: existingConfig2[0].id });
-        logger.info(`配置删除 - 用户ID:${session.userId}, 群号:${targetGroupId}`);
+        clog("info", `配置删除 - 用户ID:${session.userId}, 群号:${targetGroupId}`);
         return `已删除群 ${targetGroupId} 的验证配置`;
       } else {
         return `群 ${targetGroupId} 无验证配置`;
@@ -1113,13 +1129,14 @@ ${debugInfo}`];
         const createTime = new Date(config2.createdAt).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" });
         const updateTime = new Date(config2.updatedAt).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" });
         const reminderStatus = config2.reminderEnabled ? "启用" : "禁用";
+        const displayMsg = (config2.reminderMessage || "无").replace(/\\\\n/g, "
").replace(/\\n/g, "\n").replace(/\x01/g, "\\n");
         return `群 ${targetGroupId} 配置: 
 关键词: ${decodedKeywords2.join(", ")}
 审核方式: ${methodDesc}
 阈值: ${thresholdInfo}
 提醒消息: ${reminderStatus}
 自定义消息:
-${config2.reminderMessage || "无"}
+${displayMsg}
 创建时间: ${createTime}
 更新时间: ${updateTime}
 创建者: ${config2.createdBy}
@@ -1129,7 +1146,7 @@ ${config2.reminderMessage || "无"}
       }
     }
     let keywordList = parsedKeywords.slice();
-    logger.info(`关键词解析结果: [${keywordList.join(", ")}] - 原始输入: "${rawInput}"`);
+    clogV(`关键词解析结果: [${keywordList.join(", ")}] - 原始输入: "${rawInput}"`);
     if (keywordList.length === 0 && !cleanedOptions.query && !cleanedOptions.remove) {
       const hasConfigParams = cleanedOptions.method !== void 0 || cleanedOptions.threshold !== void 0 || hasRealMessageParam || hasRealEnableMessageParam || hasRealDisableMessageParam;
       if (!hasConfigParams) {
@@ -1162,7 +1179,7 @@ ${config2.reminderMessage || "无"}
       reviewMethod = existingConfig.reviewMethod;
       if (existingConfig.reviewParameters === void 0 || existingConfig.reviewParameters === null || isNaN(existingConfig.reviewParameters)) {
         reviewParameters = 0;
-        logger.info(`检测到老版本数据或无效值，使用默认阈值: 0`);
+        clog("debug", `检测到老版本数据或无效值，使用默认阈值: 0`);
       } else {
         reviewParameters = existingConfig.reviewParameters;
       }
@@ -1174,10 +1191,10 @@ ${config2.reminderMessage || "无"}
       }
       const oldMethod = reviewMethod;
       reviewMethod = methodNum;
-      logger.debug(`审核方式明确指定为: ${reviewMethod}`);
+      clog("debug", `审核方式明确指定为: ${reviewMethod}`);
       var methodChanged = oldMethod !== reviewMethod;
     } else {
-      logger.debug(`未指定审核方式，保持原有值: ${reviewMethod}`);
+      clog("debug", `未指定审核方式，保持原有值: ${reviewMethod}`);
       var methodChanged = false;
     }
     const thresholdResult = resolveThreshold(
@@ -1197,7 +1214,7 @@ ${config2.reminderMessage || "无"}
         updatedBy: session.username || session.userId,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-      logger.debug(`自动调整并更新数据库阈值为: ${reviewParameters}`);
+      clog("debug", `自动调整并更新数据库阈值为: ${reviewParameters}`);
     }
     let autoAdjustNote = "";
     if (thresholdResult.autoInfo === "methodChange") {
@@ -1215,7 +1232,6 @@ ${config2.reminderMessage || "无"}
     const encodedKeywords = keywordList.map((keyword) => {
       return keyword.replace(/,/g, "[[COMMA]]");
     });
-    logger.info(`编码后准备存储的关键词: ${JSON.stringify(encodedKeywords)}`);
     const dbData = {
       keywords: encodedKeywords,
       reviewMethod,
@@ -1231,7 +1247,7 @@ ${config2.reminderMessage || "无"}
         ...dbData,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-      logger.info(`更新配置成功 - 审核方式: ${reviewMethod}, 阈值: ${reviewParameters}`);
+      clog("info", `更新配置成功 - 审核方式: ${reviewMethod}, 阈值: ${reviewParameters}`);
     } else {
       await ctx.database.create("group_verification_config", {
         groupId: targetGroupId,
@@ -1239,7 +1255,7 @@ ${config2.reminderMessage || "无"}
         createdBy: session.username || session.userId,
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-      logger.info(`创建配置成功 - 审核方式: ${reviewMethod}, 阈值: ${reviewParameters}`);
+      clog("info", `创建配置成功 - 审核方式: ${reviewMethod}, 阈值: ${reviewParameters}`);
     }
     const decodedKeywords = keywordList;
     let feedbackMessage = `群 ${targetGroupId} 配置已更新:
@@ -1259,25 +1275,12 @@ ${config2.reminderMessage || "无"}
     feedbackMessage += `提醒状态: ${reminderEnabled ? "启用" : "禁用"}
 `;
     if (reminderMessage && reminderEnabled) {
+      const displayReminder = reminderMessage.replace(/\\\\n/g, "
").replace(/\\n/g, "\n").replace(/\x01/g, "\\n");
       feedbackMessage += `提醒消息:
-${reminderMessage}
+${displayReminder}
 `;
     }
-    logger.info(`准备存储到数据库的关键词: ${JSON.stringify(encodedKeywords)}`);
-    logger.info(`=== 配置处理详情 ===`);
-    logger.info(`原始输入: ${keywords || "无关键词"}`);
-    logger.info(`审核方式: ${reviewMethod} (${["全部同意", "按数量", "按比例", "全部拒绝"][reviewMethod]})`);
-    logger.info(`阈值参数: ${JSON.stringify(reviewParameters)}`);
-    logger.info(`关键词列表: [${keywordList.map((k) => `"${k}"`).join(", ")}]`);
-    logger.info(`现有配置: ${existingConfig ? "存在" : "不存在"}`);
-    if (existingConfig) {
-      logger.info(`原审核方式: ${existingConfig.reviewMethod}`);
-      logger.info(`原阈值: ${JSON.stringify(existingConfig.reviewParameters)}`);
-      logger.info(`原关键词数: ${existingConfig.keywords.length}`);
-      logger.info(`新关键词数: ${keywordList.length}`);
-    }
-    logger.info(`==================`);
-    logger.info(feedbackMessage.replace(/\n/g, "; "));
+    clog("info", feedbackMessage.replace(/\n/g, "; "));
     return feedbackMessage;
   });
   groupVerify.subcommand(".approve [userId]", "同意加群申请").alias(
@@ -1313,6 +1316,7 @@ ${reminderMessage}
           if (request2.requestId) {
             try {
               await session.bot.handleGuildMemberRequest(request2.requestId, true);
+              await updateStats(ctx, groupId, "manuallyApproved");
               approvedCount++;
             } catch (error) {
               logger.warn(`处理申请 ${request2.id} 时出错:`, error);
@@ -1340,6 +1344,7 @@ ${reminderMessage}
           const reply = `已同意用户 ${displayName} 的加群申请`;
           session.bot.handleGuildMemberRequest(request2.requestId, true).catch((e) => logger.warn("自动同意失败", e));
           await ctx.database.remove("group_verification_pending", { groupId, userId: request2.userId });
+          await updateStats(ctx, groupId, "manuallyApproved");
           return reply;
         } catch (error) {
           return `处理申请时出错: ${error.message}`;
@@ -1362,6 +1367,7 @@ ${reminderMessage}
       const reply = `已同意用户 ${displayName} 的加群申请`;
       session.bot.handleGuildMemberRequest(request.requestId, true).catch((e) => logger.warn("自动同意失败", e));
       await ctx.database.remove("group_verification_pending", { groupId, userId });
+      await updateStats(ctx, groupId, "manuallyApproved");
       return reply;
     } catch (error) {
       return `处理申请时出错: ${error.message}`;
@@ -1629,7 +1635,7 @@ ${reminderMessage}
           await ctx.database.set("group_verification_pending", { id: p.id }, updates);
         }
       }
-      logger.info("旧版日期字段迁移完成");
+      clog("info", "旧版日期字段迁移完成");
     } catch (e) {
       logger.warn("迁移旧日期字段时出错", e);
     }
@@ -1642,9 +1648,9 @@ ${reminderMessage}
         rejected: 0,
         lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
       });
-      logger.info("已创建总计统计行");
+      clog("info", "已创建总计统计行");
     } else {
-      logger.info("总计统计行已存在");
+      clog("info", "总计统计行已存在");
     }
     await syncTotalStats(ctx);
   });

package/package.json

@@ -8,7 +8,7 @@
   "bugs": {
     "url": "https://github.com/LHDyx/koishi-plugin-group-verification/issues"
   },
-  "version": "1.0.34",
+  "version": "1.0.36",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -44,7 +44,7 @@
     "koishi": "^4.15.0"
   },
   "devDependencies": {
-    "typescript": "^4.9.0",
-    "@types/node": "^16.0.0"
+    "@types/node": "^16.0.0",
+    "typescript": "^4.9.0"
   }
 }

package/readme.md

@@ -138,11 +138,11 @@ group-verify.blacklist i <用户ID> [群号|all]
 
 插件启动时会输出运行状态，并根据 `logLevel` 调整输出量。
 - `debug`：打印所有调试细节，包括权限检查、命令解析等。
-- `info`：默认值，记录关键事件（插件启动、配置修改、自动拒绝、黑名单踢人等）。
+- `info`：默认值，记录关键事件（插件启动、配置修改、自动拒绝、黑名单踢人等），包括成功踢人日志。
 - `warn`：记录可恢复的异常，例如尝试踢出用户失败、数据库操作问题。
 - `error`：仅在遇到严重错误时输出。
 
-添加黑名单时会尝试在对应群踢出该用户，成功记为 `info`，失败记为 `warn`。
+添加黑名单时会尝试在对应群踢出该用户，成功记为 `info`，失败记为 `warn`。权限检查的详细过程则只会在 `debug` 级别输出。
 
 ### 严格群号检查