koishi-plugin-group-verification 1.0.9 → 1.0.11

package/lib/index.d.ts

@@ -42,4 +42,5 @@ export interface Config {
     logLevel?: 'debug' | 'info' | 'warn' | 'error';
 }
 export declare const Config: Schema<Config>;
+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: () => apply,
+  inject: () => inject,
   name: () => name
 });
 module.exports = __toCommonJS(src_exports);
@@ -37,6 +38,7 @@ var Config = import_koishi.Schema.object({
   ).description("默认提醒消息模板"),
   logLevel: import_koishi.Schema.union(["debug", "info", "warn", "error"]).default("info").description("日志级别")
 }).description("群组验证插件配置");
+var inject = ["database"];
 function apply(ctx, config) {
   ctx.model.extend("group_verification_config", {
     id: "unsigned",
@@ -97,6 +99,22 @@ function apply(ctx, config) {
       await handleFailedVerification(ctx, session, config2);
     }
   });
+  ctx.on("guild-member-added", async (session) => {
+    const groupId = session.guildId;
+    const userId = session.userId;
+    const pendingRecords = await ctx.database.get("group_verification_pending", {
+      groupId,
+      userId
+    });
+    if (pendingRecords.length > 0) {
+      await updateStats(groupId, "autoApproved");
+      await ctx.database.remove("group_verification_pending", { id: pendingRecords[0].id });
+      logger.info(`用户 ${userId} 通过验证加入群 ${groupId}，统计已更新`);
+    } else {
+      await updateStats(groupId, "manuallyApproved");
+      logger.info(`用户 ${userId} 被手动邀请加入群 ${groupId}，手动批准统计已更新`);
+    }
+  });
   async function handleFailedVerification(ctx2, session, config2) {
     const guildId = session.guildId;
     const userId = session.userId;
@@ -153,39 +171,24 @@ function apply(ctx, config) {
     return { isValid, matchedCount, requiredThreshold };
   }
   __name(verifyApplication, "verifyApplication");
-  async function updateStats(groupId, statType) {
-    const groupStats = await ctx.database.get("group_verification_stats", { groupId });
-    if (groupStats.length > 0) {
-      const stats = groupStats[0];
+  async function updateStats(groupId, action) {
+    const existingStats = await ctx.database.get("group_verification_stats", { groupId });
+    if (existingStats.length > 0) {
+      const stats = existingStats[0];
       await ctx.database.set("group_verification_stats", { id: stats.id }, {
-        [statType]: stats[statType] + 1,
+        [action]: stats[action] + 1,
         lastUpdated: /* @__PURE__ */ new Date()
       });
     } else {
       await ctx.database.create("group_verification_stats", {
         groupId,
-        autoApproved: statType === "autoApproved" ? 1 : 0,
-        manuallyApproved: statType === "manuallyApproved" ? 1 : 0,
-        rejected: statType === "rejected" ? 1 : 0,
-        lastUpdated: /* @__PURE__ */ new Date()
-      });
-    }
-    const totalStats = await ctx.database.get("group_verification_stats", { groupId: "all" });
-    if (totalStats.length > 0) {
-      const stats = totalStats[0];
-      await ctx.database.set("group_verification_stats", { id: stats.id }, {
-        [statType]: stats[statType] + 1,
-        lastUpdated: /* @__PURE__ */ new Date()
-      });
-    } else {
-      await ctx.database.create("group_verification_stats", {
-        groupId: "all",
-        autoApproved: statType === "autoApproved" ? 1 : 0,
-        manuallyApproved: statType === "manuallyApproved" ? 1 : 0,
-        rejected: statType === "rejected" ? 1 : 0,
+        autoApproved: action === "autoApproved" ? 1 : 0,
+        manuallyApproved: action === "manuallyApproved" ? 1 : 0,
+        rejected: action === "rejected" ? 1 : 0,
         lastUpdated: /* @__PURE__ */ new Date()
       });
     }
+    await syncTotalStats(ctx);
   }
   __name(updateStats, "updateStats");
   async function checkPermission(session, targetGroupId) {
@@ -370,68 +373,149 @@ ${debugInfo}`];
       return `已为群 ${targetGroupId} 创建验证配置`;
     }
   });
-  groupVerify.subcommand(".approve <userId>", "同意用户加群申请").alias("accept", "同意", "appr", "通过").action(async ({ session }, userId) => {
-    if (!await checkPermission(session)) {
-      return "权限不足";
+  groupVerify.subcommand(".approve [userId]", "同意加群申请").alias("accept", "同意", "通过", "gva").action(async ({ session }, userId) => {
+    const [hasPermission, errorMsg] = await checkPermission(session);
+    if (!hasPermission) {
+      return errorMsg || "权限不足";
     }
-    if (!session.guildId) {
+    const groupId = session.guildId;
+    if (!groupId) {
       return "请在群聊中使用此命令";
     }
-    if (!userId) {
-      return "请提供用户ID";
+    if (!userId || userId.toLowerCase() === "all") {
+      if (userId?.toLowerCase() === "all") {
+        const pendingRequests2 = await ctx.database.get("group_verification_pending", { groupId });
+        if (pendingRequests2.length === 0) {
+          return "当前无待审核的加群申请";
+        }
+        let approvedCount = 0;
+        for (const request2 of pendingRequests2) {
+          try {
+            await ctx.database.remove("group_verification_pending", { id: request2.id });
+            await updateStats(groupId, "manuallyApproved");
+            approvedCount++;
+          } catch (error) {
+            logger.warn(`处理申请 ${request2.id} 时出错:`, error);
+          }
+        }
+        return `已处理 ${approvedCount} 个加群申请`;
+      } else {
+        const recentRequest = await ctx.database.get("group_verification_pending", { groupId }, ["id", "userId", "userName"]);
+        if (recentRequest.length === 0) {
+          return "当前无待审核的加群申请";
+        }
+        const request2 = recentRequest[0];
+        try {
+          await session.bot.handleGuildMemberRequest(request2.userId, true);
+          await ctx.database.remove("group_verification_pending", { id: request2.id });
+          await updateStats(groupId, "manuallyApproved");
+          return `已同意用户 ${request2.userName}(${request2.userId}) 的加群申请`;
+        } catch (error) {
+          return `处理申请时出错: ${error.message}`;
+        }
+      }
     }
-    const pendingApplications = await ctx.database.get("group_verification_pending", {
-      groupId: session.guildId,
+    const pendingRequests = await ctx.database.get("group_verification_pending", {
+      groupId,
       userId
     });
-    if (pendingApplications.length === 0) {
+    if (pendingRequests.length === 0) {
       return `未找到用户 ${userId} 的待审核申请`;
     }
-    const application = pendingApplications[0];
-    await ctx.database.remove("group_verification_pending", { id: application.id });
-    await updateStats(session.guildId, "manuallyApproved");
-    return `已同意用户 ${application.userName}(${userId}) 的加群申请`;
+    const request = pendingRequests[0];
+    try {
+      await session.bot.handleGuildMemberRequest(request.userId, true);
+      await ctx.database.remove("group_verification_pending", { id: request.id });
+      await updateStats(groupId, "manuallyApproved");
+      return `已同意用户 ${request.userName}(${userId}) 的加群申请`;
+    } catch (error) {
+      return `处理申请时出错: ${error.message}`;
+    }
   });
-  groupVerify.subcommand(".reject <userId>", "拒绝用户加群申请").alias("拒绝", "rej", "拒绝").action(async ({ session }, userId) => {
-    if (!await checkPermission(session)) {
-      return "权限不足";
+  groupVerify.subcommand(".reject [userId]", "拒绝加群申请").alias("拒绝", "rej", "gvr").action(async ({ session }, userId) => {
+    const [hasPermission, errorMsg] = await checkPermission(session);
+    if (!hasPermission) {
+      return errorMsg || "权限不足";
     }
-    if (!session.guildId) {
+    const groupId = session.guildId;
+    if (!groupId) {
       return "请在群聊中使用此命令";
     }
-    if (!userId) {
-      return "请提供用户ID";
+    if (!userId || userId.toLowerCase() === "all") {
+      if (userId?.toLowerCase() === "all") {
+        const pendingRequests2 = await ctx.database.get("group_verification_pending", { groupId });
+        if (pendingRequests2.length === 0) {
+          return "当前无待审核的加群申请";
+        }
+        let rejectedCount = 0;
+        for (const request2 of pendingRequests2) {
+          try {
+            await ctx.database.remove("group_verification_pending", { id: request2.id });
+            await updateStats(groupId, "rejected");
+            rejectedCount++;
+          } catch (error) {
+            logger.warn(`处理申请 ${request2.id} 时出错:`, error);
+          }
+        }
+        return `已拒绝 ${rejectedCount} 个加群申请`;
+      } else {
+        const recentRequest = await ctx.database.get("group_verification_pending", { groupId }, ["id", "userId", "userName"]);
+        if (recentRequest.length === 0) {
+          return "当前无待审核的加群申请";
+        }
+        const request2 = recentRequest[0];
+        try {
+          await ctx.database.remove("group_verification_pending", { id: request2.id });
+          await updateStats(groupId, "rejected");
+          return `已拒绝用户 ${request2.userName}(${request2.userId}) 的加群申请`;
+        } catch (error) {
+          return `处理申请时出错: ${error.message}`;
+        }
+      }
     }
-    const pendingApplications = await ctx.database.get("group_verification_pending", {
-      groupId: session.guildId,
+    const pendingRequests = await ctx.database.get("group_verification_pending", {
+      groupId,
       userId
     });
-    if (pendingApplications.length === 0) {
+    if (pendingRequests.length === 0) {
       return `未找到用户 ${userId} 的待审核申请`;
     }
-    const application = pendingApplications[0];
-    await ctx.database.remove("group_verification_pending", { id: application.id });
-    await updateStats(session.guildId, "rejected");
-    return `已拒绝用户 ${application.userName}(${userId}) 的加群申请`;
+    const request = pendingRequests[0];
+    try {
+      await ctx.database.remove("group_verification_pending", { id: request.id });
+      await updateStats(groupId, "rejected");
+      return `已拒绝用户 ${request.userName}(${userId}) 的加群申请`;
+    } catch (error) {
+      return `处理申请时出错: ${error.message}`;
+    }
   });
-  groupVerify.subcommand(".stats [groupId]", "查看验证统计信息").alias("statistics", "统计", "stat", "统计信息").action(async ({ session }, groupId) => {
-    const targetGroupId = groupId || session.guildId || "all";
-    const stats = await ctx.database.get("group_verification_stats", { groupId: targetGroupId });
-    if (stats.length === 0) {
-      return targetGroupId === "all" ? "暂无统计信息" : `群 ${targetGroupId} 暂无统计信息`;
+  groupVerify.subcommand(".stats [target]", "查看群组验证统计信息").alias("统计", "stat", "statistics").action(async ({ session }, target) => {
+    const validTargets = ["all", "total"];
+    const isGroupId = target && /^\d+$/.test(target);
+    const isSpecialTarget = target && validTargets.includes(target.toLowerCase());
+    if (target && !isGroupId && !isSpecialTarget) {
+      return "参数错误：只能指定群号、all、total或留空";
     }
-    const stat = stats[0];
-    if (targetGroupId === "all") {
-      return `总体统计：
-自动通过：${stat.autoApproved}
-手动通过：${stat.manuallyApproved}
-拒绝：${stat.rejected}`;
-    } else {
-      return `群 ${targetGroupId} 统计：
-自动通过：${stat.autoApproved}
-手动通过：${stat.manuallyApproved}
-拒绝：${stat.rejected}`;
+    if (target?.toLowerCase() === "total" || target?.toLowerCase() === "all") {
+      const koishiAuthority = session.author?.authority || session.user?.authority;
+      if (!(koishiAuthority && koishiAuthority >= 3)) {
+        return "查看总计统计需要koishi 3级以上权限";
+      }
+    }
+    const groupId = session.guildId;
+    if (!target) {
+      if (!groupId) {
+        return "请在群聊中使用此命令或指定群号";
+      }
+      return await getGroupStats(groupId);
     }
+    if (target.toLowerCase() === "all" || target.toLowerCase() === "total") {
+      return await getTotalStats();
+    }
+    if (isGroupId) {
+      return await getGroupStats(target);
+    }
+    return "参数错误";
   });
   groupVerify.subcommand(".pending", "查看待审核加群申请").alias("list", "待审", "pend", "待处理").action(async ({ session }) => {
     if (!session.guildId) {
@@ -488,15 +572,82 @@ ${debugInfo}`];
 
 其他命令：
   .approve <用户ID> - 同意加群申请
-  .reject <用户ID> - 拒绝加群申请  
+  .reject <用户ID> - 拒绝加群申请
   .pending - 查看待审核列表
   .stats [群号] - 查看统计信息`;
   });
+  ctx.on("ready", async () => {
+    const totalStats = await ctx.database.get("group_verification_stats", { groupId: "TOTAL" });
+    if (totalStats.length === 0) {
+      await ctx.database.create("group_verification_stats", {
+        groupId: "TOTAL",
+        autoApproved: 0,
+        manuallyApproved: 0,
+        rejected: 0,
+        lastUpdated: /* @__PURE__ */ new Date()
+      });
+      logger.info("已创建总计统计行");
+    } else {
+      logger.info("总计统计行已存在");
+    }
+    await syncTotalStats(ctx);
+  });
+  async function getGroupStats(groupId) {
+    const stats = await ctx.database.get("group_verification_stats", { groupId });
+    if (stats.length === 0) {
+      return `群 ${groupId} 暂无验证统计信息`;
+    }
+    const stat = stats[0];
+    const lastUpdated = new Date(stat.lastUpdated).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" });
+    return `群 ${groupId} 验证统计：
+自动批准: ${stat.autoApproved}
+手动批准: ${stat.manuallyApproved}
+拒绝: ${stat.rejected}
+最后更新: ${lastUpdated}`;
+  }
+  __name(getGroupStats, "getGroupStats");
+  async function getTotalStats() {
+    const stats = await ctx.database.get("group_verification_stats", { groupId: "TOTAL" });
+    if (stats.length === 0) {
+      return "暂无统计信息";
+    }
+    const stat = stats[0];
+    const lastUpdated = new Date(stat.lastUpdated).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" });
+    return `总计验证统计：
+自动批准: ${stat.autoApproved}
+手动批准: ${stat.manuallyApproved}
+拒绝: ${stat.rejected}
+最后更新: ${lastUpdated}`;
+  }
+  __name(getTotalStats, "getTotalStats");
+  async function syncTotalStats(ctx2) {
+    try {
+      const allStats = await ctx2.database.get("group_verification_stats", {
+        groupId: { $ne: "TOTAL" }
+      });
+      if (allStats.length > 0) {
+        const totalAutoApproved = allStats.reduce((sum, stat) => sum + (stat.autoApproved || 0), 0);
+        const totalManuallyApproved = allStats.reduce((sum, stat) => sum + (stat.manuallyApproved || 0), 0);
+        const totalRejected = allStats.reduce((sum, stat) => sum + (stat.rejected || 0), 0);
+        await ctx2.database.set("group_verification_stats", { groupId: "TOTAL" }, {
+          autoApproved: totalAutoApproved,
+          manuallyApproved: totalManuallyApproved,
+          rejected: totalRejected,
+          lastUpdated: /* @__PURE__ */ new Date()
+        });
+        logger.info(`总计统计已同步: 自动批准${totalAutoApproved}, 手动批准${totalManuallyApproved}, 拒绝${totalRejected}`);
+      }
+    } catch (error) {
+      logger.error("同步总计统计时出错:", error);
+    }
+  }
+  __name(syncTotalStats, "syncTotalStats");
 }
 __name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Config,
   apply,
+  inject,
   name
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-group-verification",
   "description": "Koishi 群组加群验证插件，支持多关键词匹配审核、多种审核方式和详细统计功能",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/src/index.ts

@@ -67,6 +67,8 @@ export const Config: Schema<Config> = Schema.object({
     .description('日志级别')
 }).description('群组验证插件配置')
 
+export const inject = ['database']
+
 export function apply(ctx: Context, config: Config) {
   // 创建数据库表
   ctx.model.extend('group_verification_config', {
@@ -155,6 +157,30 @@ export function apply(ctx: Context, config: Config) {
     }
   })
 
+  // 监听群成员增加事件（包括手动邀请入群）
+  ctx.on('guild-member-added', async (session) => {
+    const groupId = session.guildId
+    const userId = session.userId
+    
+    // 检查是否有待审核记录
+    const pendingRecords = await ctx.database.get('group_verification_pending', {
+      groupId: groupId,
+      userId: userId
+    })
+    
+    if (pendingRecords.length > 0) {
+      // 通过验证的用户入群，更新统计
+      await updateStats(groupId, 'autoApproved')
+      // 清除待审核记录
+      await ctx.database.remove('group_verification_pending', { id: pendingRecords[0].id })
+      logger.info(`用户 ${userId} 通过验证加入群 ${groupId}，统计已更新`)
+    } else {
+      // 手动邀请入群，记录到手动批准统计
+      await updateStats(groupId, 'manuallyApproved')
+      logger.info(`用户 ${userId} 被手动邀请加入群 ${groupId}，手动批准统计已更新`)
+    }
+  })
+
   // 处理验证失败的情况
   async function handleFailedVerification(ctx: Context, session: any, config: GroupVerificationConfig) {
     const guildId = session.guildId
@@ -236,44 +262,28 @@ export function apply(ctx: Context, config: Config) {
   }
 
   // 更新统计信息
-  async function updateStats(groupId: string, statType: 'autoApproved' | 'manuallyApproved' | 'rejected') {
+  async function updateStats(groupId: string, action: 'autoApproved' | 'manuallyApproved' | 'rejected') {
     // 更新群组统计
-    const groupStats = await ctx.database.get('group_verification_stats', { groupId })
+    const existingStats = await ctx.database.get('group_verification_stats', { groupId })
     
-    if (groupStats.length > 0) {
-      const stats = groupStats[0]
+    if (existingStats.length > 0) {
+      const stats = existingStats[0]
       await ctx.database.set('group_verification_stats', { id: stats.id }, {
-        [statType]: stats[statType] + 1,
+        [action]: stats[action] + 1,
         lastUpdated: new Date()
       })
     } else {
-      // 创建新的统计记录
       await ctx.database.create('group_verification_stats', {
         groupId,
-        autoApproved: statType === 'autoApproved' ? 1 : 0,
-        manuallyApproved: statType === 'manuallyApproved' ? 1 : 0,
-        rejected: statType === 'rejected' ? 1 : 0,
+        autoApproved: action === 'autoApproved' ? 1 : 0,
+        manuallyApproved: action === 'manuallyApproved' ? 1 : 0,
+        rejected: action === 'rejected' ? 1 : 0,
         lastUpdated: new Date()
       })
     }
     
-    // 更新总统计（groupId为'all'）
-    const totalStats = await ctx.database.get('group_verification_stats', { groupId: 'all' })
-    if (totalStats.length > 0) {
-      const stats = totalStats[0]
-      await ctx.database.set('group_verification_stats', { id: stats.id }, {
-        [statType]: stats[statType] + 1,
-        lastUpdated: new Date()
-      })
-    } else {
-      await ctx.database.create('group_verification_stats', {
-        groupId: 'all',
-        autoApproved: statType === 'autoApproved' ? 1 : 0,
-        manuallyApproved: statType === 'manuallyApproved' ? 1 : 0,
-        rejected: statType === 'rejected' ? 1 : 0,
-        lastUpdated: new Date()
-      })
-    }
+    // 同步更新总计统计
+    await syncTotalStats(ctx)
   }
 
   // 权限检查函数
@@ -526,97 +536,211 @@ export function apply(ctx: Context, config: Config) {
 
   // Subcommand: approve join request
   groupVerify
-    .subcommand('.approve <userId>', '同意用户加群申请')
-    .alias('accept', '同意', 'appr', '通过')
+    .subcommand('.approve [userId]', '同意加群申请')
+    .alias('accept', '同意', '通过', 'gva')
     .action(async ({ session }, userId) => {
       // 权限检查
-      if (!(await checkPermission(session))) {
-        return '权限不足'
+      const [hasPermission, errorMsg] = await checkPermission(session)
+      if (!hasPermission) {
+        return errorMsg || '权限不足'
       }
 
-      if (!session.guildId) {
+      const groupId = session.guildId
+      if (!groupId) {
         return '请在群聊中使用此命令'
       }
-      
-      if (!userId) {
-        return '请提供用户ID'
+
+      // 处理默认情况和all情况
+      if (!userId || userId.toLowerCase() === 'all') {
+        if (userId?.toLowerCase() === 'all') {
+          // 处理所有待审核申请
+          const pendingRequests = await ctx.database.get('group_verification_pending', { groupId })
+          if (pendingRequests.length === 0) {
+            return '当前无待审核的加群申请'
+          }
+          
+          let approvedCount = 0
+          for (const request of pendingRequests) {
+            try {
+              // TODO: 需要获取实际的requestId来进行审批
+              // await session.bot.handleGuildMemberRequest(request.requestId, true)
+              await ctx.database.remove('group_verification_pending', { id: request.id })
+              await updateStats(groupId, 'manuallyApproved')
+              approvedCount++
+            } catch (error) {
+              logger.warn(`处理申请 ${request.id} 时出错:`, error)
+            }
+          }
+          
+          return `已处理 ${approvedCount} 个加群申请`
+        } else {
+          // 处理最近的一个申请
+          const recentRequest = await ctx.database.get('group_verification_pending', { groupId }, ['id', 'userId', 'userName'])
+          if (recentRequest.length === 0) {
+            return '当前无待审核的加群申请'
+          }
+          
+          const request = recentRequest[0]
+          try {
+            // 这里需要获取实际的requestId，暂时用userId作为示例
+            await session.bot.handleGuildMemberRequest(request.userId, true)
+            await ctx.database.remove('group_verification_pending', { id: request.id })
+            await updateStats(groupId, 'manuallyApproved')
+            return `已同意用户 ${request.userName}(${request.userId}) 的加群申请`
+          } catch (error) {
+            return `处理申请时出错: ${error.message}`
+          }
+        }
       }
-      
-      // Find pending applications
-      const pendingApplications = await ctx.database.get('group_verification_pending', {
-        groupId: session.guildId,
-        userId: userId
+
+      // 处理指定用户ID的情况
+      const pendingRequests = await ctx.database.get('group_verification_pending', { 
+        groupId, 
+        userId: userId 
       })
-      
-      if (pendingApplications.length === 0) {
+
+      if (pendingRequests.length === 0) {
         return `未找到用户 ${userId} 的待审核申请`
       }
-      
-      const application = pendingApplications[0]
-      
-      // Remove pending record
-      await ctx.database.remove('group_verification_pending', { id: application.id })
-      await updateStats(session.guildId, 'manuallyApproved')
-      
-      return `已同意用户 ${application.userName}(${userId}) 的加群申请`
+
+      const request = pendingRequests[0]
+      try {
+        // 这里需要获取实际的requestId来进行审批
+        await session.bot.handleGuildMemberRequest(request.userId, true)
+        await ctx.database.remove('group_verification_pending', { id: request.id })
+        await updateStats(groupId, 'manuallyApproved')
+        return `已同意用户 ${request.userName}(${userId}) 的加群申请`
+      } catch (error) {
+        return `处理申请时出错: ${error.message}`
+      }
     })
 
   // Subcommand: reject join request
   groupVerify
-    .subcommand('.reject <userId>', '拒绝用户加群申请')
-    .alias('拒绝', 'rej', '拒绝')
+    .subcommand('.reject [userId]', '拒绝加群申请')
+    .alias('拒绝', 'rej', 'gvr')
     .action(async ({ session }, userId) => {
       // 权限检查
-      if (!(await checkPermission(session))) {
-        return '权限不足'
+      const [hasPermission, errorMsg] = await checkPermission(session)
+      if (!hasPermission) {
+        return errorMsg || '权限不足'
       }
 
-      if (!session.guildId) {
+      const groupId = session.guildId
+      if (!groupId) {
         return '请在群聊中使用此命令'
       }
-      
-      if (!userId) {
-        return '请提供用户ID'
+
+      // 处理默认情况和all情况
+      if (!userId || userId.toLowerCase() === 'all') {
+        if (userId?.toLowerCase() === 'all') {
+          // 拒绝所有待审核申请
+          const pendingRequests = await ctx.database.get('group_verification_pending', { groupId })
+          if (pendingRequests.length === 0) {
+            return '当前无待审核的加群申请'
+          }
+          
+          let rejectedCount = 0
+          for (const request of pendingRequests) {
+            try {
+              // TODO: 需要获取实际的requestId来进行拒绝
+              // await session.bot.handleGuildMemberRequest(request.requestId, false)
+              await ctx.database.remove('group_verification_pending', { id: request.id })
+              await updateStats(groupId, 'rejected')
+              rejectedCount++
+            } catch (error) {
+              logger.warn(`处理申请 ${request.id} 时出错:`, error)
+            }
+          }
+          
+          return `已拒绝 ${rejectedCount} 个加群申请`
+        } else {
+          // 拒绝最近的一个申请
+          const recentRequest = await ctx.database.get('group_verification_pending', { groupId }, ['id', 'userId', 'userName'])
+          if (recentRequest.length === 0) {
+            return '当前无待审核的加群申请'
+          }
+          
+          const request = recentRequest[0]
+          try {
+            // TODO: 需要获取实际的requestId来进行拒绝
+            // await session.bot.handleGuildMemberRequest(request.requestId, false)
+            await ctx.database.remove('group_verification_pending', { id: request.id })
+            await updateStats(groupId, 'rejected')
+            return `已拒绝用户 ${request.userName}(${request.userId}) 的加群申请`
+          } catch (error) {
+            return `处理申请时出错: ${error.message}`
+          }
+        }
       }
-      
-      // Find pending applications
-      const pendingApplications = await ctx.database.get('group_verification_pending', {
-        groupId: session.guildId,
-        userId: userId
+
+      // 处理指定用户ID的情况
+      const pendingRequests = await ctx.database.get('group_verification_pending', { 
+        groupId, 
+        userId: userId 
       })
-      
-      if (pendingApplications.length === 0) {
+
+      if (pendingRequests.length === 0) {
         return `未找到用户 ${userId} 的待审核申请`
       }
-      
-      const application = pendingApplications[0]
-      
-      // Remove pending record
-      await ctx.database.remove('group_verification_pending', { id: application.id })
-      await updateStats(session.guildId, 'rejected')
-      
-      return `已拒绝用户 ${application.userName}(${userId}) 的加群申请`
+
+      const request = pendingRequests[0]
+      try {
+        // TODO: 需要获取实际的requestId来进行拒绝
+        // await session.bot.handleGuildMemberRequest(request.requestId, false)
+        await ctx.database.remove('group_verification_pending', { id: request.id })
+        await updateStats(groupId, 'rejected')
+        return `已拒绝用户 ${request.userName}(${userId}) 的加群申请`
+      } catch (error) {
+        return `处理申请时出错: ${error.message}`
+      }
     })
 
   // Subcommand: view statistics
   groupVerify
-    .subcommand('.stats [groupId]', '查看验证统计信息')
-    .alias('statistics', '统计', 'stat', '统计信息')
-    .action(async ({ session }, groupId) => {
-      const targetGroupId = groupId || session.guildId || 'all'
+    .subcommand('.stats [target]', '查看群组验证统计信息')
+    .alias('统计', 'stat', 'statistics')
+    .action(async ({ session }, target) => {
+      // 参数验证：只能是群号、all、total或空
+      const validTargets = ['all', 'total']
+      const isGroupId = target && /^\d+$/.test(target)
+      const isSpecialTarget = target && validTargets.includes(target.toLowerCase())
+      
+      if (target && !isGroupId && !isSpecialTarget) {
+        return '参数错误：只能指定群号、all、total或留空'
+      }
+      
+      // 权限检查：总计统计需要3级以上权限
+      if (target?.toLowerCase() === 'total' || target?.toLowerCase() === 'all') {
+        // 检查是否为koishi 3级以上权限
+        const koishiAuthority = (session as any).author?.authority || (session as any).user?.authority
+        if (!(koishiAuthority && koishiAuthority >= 3)) {
+          return '查看总计统计需要koishi 3级以上权限'
+        }
+      }
       
-      const stats = await ctx.database.get('group_verification_stats', { groupId: targetGroupId })
+      const groupId = session.guildId
       
-      if (stats.length === 0) {
-        return targetGroupId === 'all' ? '暂无统计信息' : `群 ${targetGroupId} 暂无统计信息`
+      // 处理不同参数情况
+      if (!target) {
+        // 无参数：显示当前群统计
+        if (!groupId) {
+          return '请在群聊中使用此命令或指定群号'
+        }
+        return await getGroupStats(groupId)
       }
       
-      const stat = stats[0]
-      if (targetGroupId === 'all') {
-        return `总体统计：\n自动通过：${stat.autoApproved}\n手动通过：${stat.manuallyApproved}\n拒绝：${stat.rejected}`
-      } else {
-        return `群 ${targetGroupId} 统计：\n自动通过：${stat.autoApproved}\n手动通过：${stat.manuallyApproved}\n拒绝：${stat.rejected}`
+      if (target.toLowerCase() === 'all' || target.toLowerCase() === 'total') {
+        // 显示总计统计
+        return await getTotalStats()
+      }
+      
+      if (isGroupId) {
+        // 显示指定群统计
+        return await getGroupStats(target)
       }
+      
+      return '参数错误'
     })
 
   // Subcommand: view pending requests
@@ -687,8 +811,96 @@ export function apply(ctx: Context, config: Config) {
 
 其他命令：
   .approve <用户ID> - 同意加群申请
-  .reject <用户ID> - 拒绝加群申请  
+  .reject <用户ID> - 拒绝加群申请
   .pending - 查看待审核列表
   .stats [群号] - 查看统计信息`
     })
+
+  // 插件初始化时确保总计统计行存在
+  ctx.on('ready', async () => {
+    // 检查是否已存在总计行（groupId为'TOTAL'）
+    const totalStats = await ctx.database.get('group_verification_stats', { groupId: 'TOTAL' })
+    
+    if (totalStats.length === 0) {
+      // 创建总计统计行
+      await ctx.database.create('group_verification_stats', {
+        groupId: 'TOTAL',
+        autoApproved: 0,
+        manuallyApproved: 0,
+        rejected: 0,
+        lastUpdated: new Date()
+      })
+      logger.info('已创建总计统计行')
+    } else {
+      logger.info('总计统计行已存在')
+    }
+    
+    // 同步现有统计数据到总计行
+    await syncTotalStats(ctx)
+  })
+  
+  // 辅助函数：获取群组统计
+  async function getGroupStats(groupId: string): Promise<string> {
+    const stats = await ctx.database.get('group_verification_stats', { groupId })
+    
+    if (stats.length === 0) {
+      return `群 ${groupId} 暂无验证统计信息`
+    }
+    
+    const stat = stats[0]
+    const lastUpdated = new Date(stat.lastUpdated).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' })
+    
+    return `群 ${groupId} 验证统计：
+自动批准: ${stat.autoApproved}
+手动批准: ${stat.manuallyApproved}
+拒绝: ${stat.rejected}
+最后更新: ${lastUpdated}`
+  }
+  
+  // 辅助函数：获取总计统计
+  async function getTotalStats(): Promise<string> {
+    const stats = await ctx.database.get('group_verification_stats', { groupId: 'TOTAL' })
+    
+    if (stats.length === 0) {
+      return '暂无统计信息'
+    }
+    
+    const stat = stats[0]
+    const lastUpdated = new Date(stat.lastUpdated).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' })
+    
+    return `总计验证统计：
+自动批准: ${stat.autoApproved}
+手动批准: ${stat.manuallyApproved}
+拒绝: ${stat.rejected}
+最后更新: ${lastUpdated}`
+  }
+  
+  // 同步统计数据到总计行的函数
+  async function syncTotalStats(ctx: Context) {
+    try {
+      // 获取所有群组统计（排除TOTAL行）
+      const allStats = await ctx.database.get('group_verification_stats', {
+        groupId: { $ne: 'TOTAL' }
+      })
+      
+      if (allStats.length > 0) {
+        // 计算总计
+        const totalAutoApproved = allStats.reduce((sum, stat) => sum + (stat.autoApproved || 0), 0)
+        const totalManuallyApproved = allStats.reduce((sum, stat) => sum + (stat.manuallyApproved || 0), 0)
+        const totalRejected = allStats.reduce((sum, stat) => sum + (stat.rejected || 0), 0)
+        
+        // 更新总计行
+        await ctx.database.set('group_verification_stats', { groupId: 'TOTAL' }, {
+          autoApproved: totalAutoApproved,
+          manuallyApproved: totalManuallyApproved,
+          rejected: totalRejected,
+          lastUpdated: new Date()
+        })
+        
+        logger.info(`总计统计已同步: 自动批准${totalAutoApproved}, 手动批准${totalManuallyApproved}, 拒绝${totalRejected}`)
+      }
+    } catch (error) {
+      logger.error('同步总计统计时出错:', error)
+    }
+  }
 }