koishi-plugin-bind-bot 2.0.2 → 2.0.3

package/lib/handlers/base.handler.d.ts

@@ -29,8 +29,9 @@ export interface HandlerDependencies {
     getMcBindByUsername: (username: string) => Promise<MCIDBIND | null>;
     createOrUpdateMcBind: (userId: string, username: string, uuid: string, isAdmin?: boolean) => Promise<boolean>;
     deleteMcBind: (userId: string) => Promise<boolean>;
-    checkUsernameExists: (username: string, currentUserId?: string) => Promise<boolean>;
+    checkUsernameExists: (username: string, currentUserId?: string, uuid?: string) => Promise<boolean>;
     checkAndUpdateUsername: (bind: MCIDBIND) => Promise<MCIDBIND>;
+    checkAndUpdateUsernameWithCache: (bind: MCIDBIND) => Promise<MCIDBIND>;
     validateUsername: (username: string) => Promise<any>;
     validateBUID: (uid: string) => Promise<any>;
     updateBuidInfoOnly: (qqId: string, buidUser: any) => Promise<boolean>;

package/lib/handlers/mcid.handler.js

@@ -96,8 +96,8 @@ class McidCommandHandler extends base_handler_1.BaseHandler {
                     }
                     return this.deps.sendMessage(session, [koishi_1.h.text('该用户尚未绑定MC账号')]);
                 }
-                // 显示MC绑定信息
-                const updatedBind = await this.deps.checkAndUpdateUsername(targetBind);
+                // 显示MC绑定信息（使用智能缓存检测，避免频繁API调用）
+                const updatedBind = await this.deps.checkAndUpdateUsernameWithCache(targetBind);
                 return this.buildQueryResponse(session, updatedBind, normalizedTargetId);
             }
             // 查询自己
@@ -136,7 +136,8 @@ class McidCommandHandler extends base_handler_1.BaseHandler {
                 }
                 return this.deps.sendMessage(session, [koishi_1.h.text('您尚未绑定MC账号，请使用 ' + this.deps.formatCommand('mcid bind <用户名>') + ' 进行绑定')]);
             }
-            const updatedBind = await this.deps.checkAndUpdateUsername(selfBind);
+            // 使用智能缓存检测，避免频繁API调用
+            const updatedBind = await this.deps.checkAndUpdateUsernameWithCache(selfBind);
             return this.buildQueryResponse(session, updatedBind, null);
         }
         catch (error) {
@@ -336,8 +337,8 @@ class McidCommandHandler extends base_handler_1.BaseHandler {
             this.logger.warn('绑定', `权限不足: QQ(${operatorId})不是管理员`);
             return this.deps.sendMessage(session, [koishi_1.h.text('只有管理员才能为其他用户绑定MC账号')]);
         }
-        // 检查用户名是否已被占用
-        if (await this.deps.checkUsernameExists(username, target)) {
+        // 检查用户名是否已被占用（支持改名检测）
+        if (await this.deps.checkUsernameExists(username, target, uuid)) {
             this.logger.warn('绑定', `MC用户名"${username}"已被其他QQ号绑定`);
             return this.deps.sendMessage(session, [koishi_1.h.text(`用户名 ${username} 已被其他用户绑定`)]);
         }
@@ -410,8 +411,8 @@ class McidCommandHandler extends base_handler_1.BaseHandler {
                 this.logger.debug('绑定', `QQ(${operatorId})之前绑定的是临时用户名"${selfBind.mcUsername}"，允许直接使用bind命令`);
             }
         }
-        // 检查用户名是否已被占用
-        if (await this.deps.checkUsernameExists(username)) {
+        // 检查用户名是否已被占用（支持改名检测）
+        if (await this.deps.checkUsernameExists(username, session.userId, uuid)) {
             this.logger.warn('绑定', `MC用户名"${username}"已被其他QQ号绑定`);
             return this.deps.sendMessage(session, [koishi_1.h.text(`用户名 ${username} 已被其他用户绑定`)]);
         }
@@ -512,8 +513,8 @@ class McidCommandHandler extends base_handler_1.BaseHandler {
             this.logger.warn('修改', `QQ(${normalizedTargetId})已绑定相同的MC账号"${username}"`);
             return this.deps.sendMessage(session, [koishi_1.h.text(`用户 ${normalizedTargetId} 当前已绑定此用户名: ${username}`)]);
         }
-        // 检查用户名是否已被占用
-        if (await this.deps.checkUsernameExists(username, target)) {
+        // 检查用户名是否已被占用（支持改名检测）
+        if (await this.deps.checkUsernameExists(username, target, uuid)) {
             this.logger.warn('修改', `MC用户名"${username}"已被其他QQ号绑定`);
             return this.deps.sendMessage(session, [koishi_1.h.text(`用户名 ${username} 已被其他用户绑定`)]);
         }
@@ -563,8 +564,8 @@ class McidCommandHandler extends base_handler_1.BaseHandler {
             this.logger.warn('修改', `QQ(${operatorId})在冷却期内，无法修改MC账号`);
             return this.deps.sendMessage(session, [koishi_1.h.text(`您的MC账号绑定在冷却期内，还需${remainingDays}天才能修改。如需立即修改，请联系管理员。`)]);
         }
-        // 检查用户名是否已被占用
-        if (await this.deps.checkUsernameExists(username, session.userId)) {
+        // 检查用户名是否已被占用（支持改名检测）
+        if (await this.deps.checkUsernameExists(username, session.userId, uuid)) {
             this.logger.warn('修改', `MC用户名"${username}"已被其他QQ号绑定`);
             return this.deps.sendMessage(session, [koishi_1.h.text(`用户名 ${username} 已被其他用户绑定`)]);
         }

package/lib/handlers/whitelist.handler.js

@@ -779,11 +779,13 @@ class WhitelistHandler extends base_handler_1.BaseHandler {
                 return false;
             }
             // 重新获取最新的用户绑定信息
-            const freshBind = await this.deps.getBindInfo(mcBind.qqId);
+            let freshBind = await this.deps.getBindInfo(mcBind.qqId);
             if (!freshBind || !freshBind.mcUsername) {
                 this.logger.warn('白名单', `用户QQ(${mcBind.qqId})可能在操作过程中解绑了MC账号`);
                 return false;
             }
+            // 智能检测用户名变更（带缓存，避免频繁API调用）
+            freshBind = await this.deps.checkAndUpdateUsernameWithCache(freshBind);
             // 检查最新状态是否已在白名单中
             if (freshBind.whitelist && freshBind.whitelist.includes(server.id)) {
                 this.logger.info('白名单', `用户QQ(${mcBind.qqId})已在服务器${server.name}的白名单中`);
@@ -860,11 +862,13 @@ class WhitelistHandler extends base_handler_1.BaseHandler {
                 return false;
             }
             // 重新获取最新的用户绑定信息
-            const freshBind = await this.deps.getBindInfo(mcBind.qqId);
+            let freshBind = await this.deps.getBindInfo(mcBind.qqId);
             if (!freshBind || !freshBind.mcUsername) {
                 this.logger.warn('白名单', `用户QQ(${mcBind.qqId})可能在操作过程中解绑了MC账号`);
                 return false;
             }
+            // 智能检测用户名变更（带缓存，避免频繁API调用）
+            freshBind = await this.deps.checkAndUpdateUsernameWithCache(freshBind);
             // 检查最新状态是否在白名单中
             if (!freshBind.whitelist || !freshBind.whitelist.includes(server.id)) {
                 this.logger.info('白名单', `用户QQ(${mcBind.qqId})不在服务器${server.name}的白名单中`);

package/lib/index.js

@@ -1176,8 +1176,8 @@ function apply(ctx, config) {
             return false;
         }
     };
-    // 检查MC用户名是否已被其他QQ号绑定
-    const checkUsernameExists = async (username, currentUserId) => {
+    // 检查MC用户名是否已被其他QQ号绑定（支持不区分大小写和UUID检查）
+    const checkUsernameExists = async (username, currentUserId, uuid) => {
         try {
             // 验证输入参数
             if (!username) {
@@ -1188,8 +1188,8 @@ function apply(ctx, config) {
             if (username.startsWith('_temp_')) {
                 return false;
             }
-            // 查询新表中是否已有此用户名的绑定
-            const bind = await getMcBindByUsername(username);
+            // 使用不区分大小写的查询
+            const bind = await mcidbindRepo.findByUsernameIgnoreCase(username);
             // 如果没有绑定，返回false
             if (!bind)
                 return false;
@@ -1197,6 +1197,16 @@ function apply(ctx, config) {
             if (bind.mcUsername && bind.mcUsername.startsWith('_temp_')) {
                 return false;
             }
+            // 如果提供了 UUID，检查是否为同一个 MC 账号（用户改名场景）
+            if (uuid && bind.mcUuid) {
+                const cleanUuid = uuid.replace(/-/g, '');
+                const bindCleanUuid = bind.mcUuid.replace(/-/g, '');
+                if (cleanUuid === bindCleanUuid) {
+                    // 同一个 UUID，说明是用户改名，允许绑定
+                    logger.info(`[绑定检查] 检测到MC账号改名: UUID=${uuid}, 旧用户名=${bind.mcUsername}, 新用户名=${username}`);
+                    return false;
+                }
+            }
             // 如果提供了当前用户ID，需要排除当前用户
             if (currentUserId) {
                 const normalizedCurrentId = normalizeQQId(currentUserId);
@@ -1647,8 +1657,10 @@ function apply(ctx, config) {
                 logger.warn(`[用户名更新] 无法获取UUID "${bind.mcUuid}" 的最新用户名`);
                 return bind;
             }
-            // 如果用户名与数据库中的不同，更新数据库
-            if (latestUsername !== bind.mcUsername) {
+            // 如果用户名与数据库中的不同，更新数据库（使用规范化比较，不区分大小写）
+            const normalizedLatest = (0, helpers_1.normalizeUsername)(latestUsername);
+            const normalizedCurrent = (0, helpers_1.normalizeUsername)(bind.mcUsername);
+            if (normalizedLatest !== normalizedCurrent) {
                 logger.info(`[用户名更新] 用户 QQ(${bind.qqId}) 的Minecraft用户名已变更: ${bind.mcUsername} -> ${latestUsername}`);
                 // 更新数据库中的用户名
                 await ctx.database.set('mcidbind', { qqId: bind.qqId }, {
@@ -1664,6 +1676,88 @@ function apply(ctx, config) {
             return bind;
         }
     };
+    /**
+     * 智能缓存版本的改名检测函数
+     * 特性：
+     * - 24小时冷却期（失败>=3次时延长到72小时）
+     * - 失败计数追踪
+     * - 成功时重置失败计数
+     * @param bind 绑定记录
+     * @returns 更新后的绑定记录
+     */
+    const checkAndUpdateUsernameWithCache = async (bind) => {
+        try {
+            if (!bind || !bind.mcUuid) {
+                logger.warn(`[改名检测缓存] 无法检查用户名更新: 空绑定或空UUID`);
+                return bind;
+            }
+            const now = new Date();
+            const failCount = bind.usernameCheckFailCount || 0;
+            // 根据失败次数决定冷却期：普通24小时，失败>=3次则72小时
+            const cooldownHours = failCount >= 3 ? 72 : 24;
+            // 检查是否在冷却期内
+            if (bind.usernameLastChecked) {
+                const lastCheck = new Date(bind.usernameLastChecked);
+                const hoursSinceCheck = (now.getTime() - lastCheck.getTime()) / (1000 * 60 * 60);
+                if (hoursSinceCheck < cooldownHours) {
+                    logger.debug(`[改名检测缓存] QQ(${bind.qqId}) 在冷却期内(${hoursSinceCheck.toFixed(1)}h/${cooldownHours}h)，跳过检查`);
+                    return bind;
+                }
+            }
+            logger.debug(`[改名检测缓存] QQ(${bind.qqId}) 开始检查用户名变更（失败计数: ${failCount}）`);
+            // 执行实际的改名检测
+            const oldUsername = bind.mcUsername;
+            const updatedBind = await checkAndUpdateUsername(bind);
+            // 判断检测是否成功
+            const detectionSuccess = updatedBind.mcUsername !== null && updatedBind.mcUsername !== undefined;
+            if (detectionSuccess) {
+                // 检测成功
+                const usernameChanged = (0, helpers_1.normalizeUsername)(updatedBind.mcUsername) !== (0, helpers_1.normalizeUsername)(oldUsername);
+                // 更新检查时间和重置失败计数
+                await mcidbindRepo.update(bind.qqId, {
+                    usernameLastChecked: now,
+                    usernameCheckFailCount: 0
+                });
+                if (usernameChanged) {
+                    logger.info(`[改名检测缓存] QQ(${bind.qqId}) 用户名已变更: ${oldUsername} -> ${updatedBind.mcUsername}`);
+                }
+                else {
+                    logger.debug(`[改名检测缓存] QQ(${bind.qqId}) 用户名无变更: ${updatedBind.mcUsername}`);
+                }
+                // 更新返回对象的缓存字段
+                updatedBind.usernameLastChecked = now;
+                updatedBind.usernameCheckFailCount = 0;
+            }
+            else {
+                // 检测失败��API失败或返回null）
+                const newFailCount = failCount + 1;
+                await mcidbindRepo.update(bind.qqId, {
+                    usernameLastChecked: now,
+                    usernameCheckFailCount: newFailCount
+                });
+                logger.warn(`[改名检测缓存] QQ(${bind.qqId}) 检测失败，失败计数: ${newFailCount}`);
+                // 更新返回对象的缓存字段
+                updatedBind.usernameLastChecked = now;
+                updatedBind.usernameCheckFailCount = newFailCount;
+            }
+            return updatedBind;
+        }
+        catch (error) {
+            logger.error(`[改名检测缓存] 检查和更新用户名失败: ${error.message}`);
+            // 失败时也更新检查时间和递增失败计数
+            try {
+                const failCount = bind.usernameCheckFailCount || 0;
+                await mcidbindRepo.update(bind.qqId, {
+                    usernameLastChecked: new Date(),
+                    usernameCheckFailCount: failCount + 1
+                });
+            }
+            catch (updateError) {
+                logger.error(`[改名检测缓存] 更新失败计数时出错: ${updateError.message}`);
+            }
+            return bind;
+        }
+    };
     // 安全地替换命令模板
     const safeCommandReplace = (template, mcid) => {
         // 过滤可能导致命令注入的字符
@@ -1758,6 +1852,7 @@ function apply(ctx, config) {
         deleteMcBind,
         checkUsernameExists,
         checkAndUpdateUsername,
+        checkAndUpdateUsernameWithCache,
         // API operations
         validateUsername,
         validateBUID,
@@ -2172,7 +2267,7 @@ function apply(ctx, config) {
             }
         }
         // 检查用户名是否已被其他人绑定
-        if (await checkUsernameExists(username, session.userId)) {
+        if (await checkUsernameExists(username, session.userId, uuid)) {
             logger.warn(`[交互绑定] MC用户名"${username}"已被其他用户绑定`);
             await sendMessage(session, [koishi_1.h.text(`❌ 用户名 ${username} 已被其他用户绑定\n\n请输入其他MC用户名或发送"跳过"完成绑定`)]);
             return;

package/lib/repositories/mcidbind.repository.d.ts

@@ -16,11 +16,23 @@ export declare class MCIDBINDRepository {
      */
     findByQQId(qqId: string): Promise<MCIDBIND | null>;
     /**
-     * 根据 MC 用户名查询绑定信息
+     * 根据 MC 用户名查询绑定信息（精确匹配）
      * @param mcUsername MC用户名
      * @returns 绑定信息或 null
      */
     findByMCUsername(mcUsername: string): Promise<MCIDBIND | null>;
+    /**
+     * 根据 MC 用户名查询绑定信息（不区分大小写）
+     * @param mcUsername MC用户名
+     * @returns 绑定信息或 null
+     */
+    findByUsernameIgnoreCase(mcUsername: string): Promise<MCIDBIND | null>;
+    /**
+     * 根据 MC UUID 查询绑定信息
+     * @param mcUuid MC UUID（可带或不带连字符）
+     * @returns 绑定信息或 null
+     */
+    findByUuid(mcUuid: string): Promise<MCIDBIND | null>;
     /**
      * 根据 B站 UID 查询绑定信息
      * @param buidUid B站UID

package/lib/repositories/mcidbind.repository.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MCIDBINDRepository = void 0;
+const helpers_1 = require("../utils/helpers");
 /**
  * MCIDBIND 数据仓储类
  * 封装所有 MCIDBIND 表的数据库操作
@@ -29,7 +30,7 @@ class MCIDBINDRepository {
         }
     }
     /**
-     * 根据 MC 用户名查询绑定信息
+     * 根据 MC 用户名查询绑定信息（精确匹配）
      * @param mcUsername MC用户名
      * @returns 绑定信息或 null
      */
@@ -44,6 +45,54 @@ class MCIDBINDRepository {
             return null;
         }
     }
+    /**
+     * 根据 MC 用户名查询绑定信息（不区分大小写）
+     * @param mcUsername MC用户名
+     * @returns 绑定信息或 null
+     */
+    async findByUsernameIgnoreCase(mcUsername) {
+        try {
+            const normalizedInput = (0, helpers_1.normalizeUsername)(mcUsername, this.logger.getRawLogger());
+            this.logger.debug('数据库', `查询MC用户名(${mcUsername} -> ${normalizedInput})的绑定信息（不区分大小写）`);
+            // 获取所有绑定记录，然后在应用层过滤（因为 Koishi 数据库不支持不区分大小写查询）
+            const allBinds = await this.ctx.database.get('mcidbind', {});
+            const match = allBinds.find(bind => bind.mcUsername && (0, helpers_1.normalizeUsername)(bind.mcUsername) === normalizedInput);
+            return match || null;
+        }
+        catch (error) {
+            this.logger.error('数据库', `查询MC用户名(${mcUsername})绑定信息失败（不区分大小写）: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * 根据 MC UUID 查询绑定信息
+     * @param mcUuid MC UUID（可带或不带连字符）
+     * @returns 绑定信息或 null
+     */
+    async findByUuid(mcUuid) {
+        try {
+            // 规范化 UUID（移除连字符）
+            const cleanUuid = mcUuid.replace(/-/g, '');
+            this.logger.debug('数据库', `查询MC UUID(${cleanUuid})的绑定信息`);
+            // 先尝试精确匹配
+            let binds = await this.ctx.database.get('mcidbind', { mcUuid: cleanUuid });
+            if (binds.length > 0)
+                return binds[0];
+            // 尝试带连字符的格式
+            const formattedUuid = `${cleanUuid.substring(0, 8)}-${cleanUuid.substring(8, 12)}-${cleanUuid.substring(12, 16)}-${cleanUuid.substring(16, 20)}-${cleanUuid.substring(20)}`;
+            binds = await this.ctx.database.get('mcidbind', { mcUuid: formattedUuid });
+            if (binds.length > 0)
+                return binds[0];
+            // 如果都没有，在应用层过滤（去除连字符后比较）
+            const allBinds = await this.ctx.database.get('mcidbind', {});
+            const match = allBinds.find(bind => bind.mcUuid && bind.mcUuid.replace(/-/g, '') === cleanUuid);
+            return match || null;
+        }
+        catch (error) {
+            this.logger.error('数据库', `查询MC UUID(${mcUuid})绑定信息失败: ${error.message}`);
+            return null;
+        }
+    }
     /**
      * 根据 B站 UID 查询绑定信息
      * @param buidUid B站UID

package/lib/types/database.d.ts

@@ -9,6 +9,8 @@ export interface MCIDBIND {
     qqId: string;
     mcUsername: string;
     mcUuid: string;
+    usernameLastChecked?: Date;
+    usernameCheckFailCount?: number;
     lastModified: Date;
     isAdmin: boolean;
     whitelist: string[];

package/lib/utils/helpers.d.ts

@@ -89,3 +89,21 @@ export declare function levenshteinDistance(str1: string, str2: string): number;
  * @returns 相似度值（0到1之间，1表示完全相同）
  */
 export declare function calculateSimilarity(str1: string, str2: string): number;
+/**
+ * 规范化 Minecraft 用户名（统一小写，用于存储和比较）
+ * Minecraft 用户名不区分大小写，但 Mojang 返回的是规范大小写
+ * 为避免 "Notch" 和 "notch" 被视为不同用户，统一转小写存储
+ *
+ * @param username MC 用户名
+ * @param logger Koishi Logger实例（用于日志）
+ * @returns 规范化后的用户名（小写）
+ */
+export declare function normalizeUsername(username: string, logger?: Logger): string;
+/**
+ * 比较两个 Minecraft 用户名是否相同（不区分大小写）
+ *
+ * @param username1 第一个用户名
+ * @param username2 第二个用户名
+ * @returns 是否相同
+ */
+export declare function isSameUsername(username1: string, username2: string): boolean;

package/lib/utils/helpers.js

@@ -11,6 +11,8 @@ exports.escapeRegExp = escapeRegExp;
 exports.cleanUserInput = cleanUserInput;
 exports.levenshteinDistance = levenshteinDistance;
 exports.calculateSimilarity = calculateSimilarity;
+exports.normalizeUsername = normalizeUsername;
+exports.isSameUsername = isSameUsername;
 /**
  * 通用工具函数集合
  */
@@ -319,3 +321,42 @@ function calculateSimilarity(str1, str2) {
     const maxLength = Math.max(str1.length, str2.length);
     return 1 - distance / maxLength;
 }
+/**
+ * 规范化 Minecraft 用户名（统一小写，用于存储和比较）
+ * Minecraft 用户名不区分大小写，但 Mojang 返回的是规范大小写
+ * 为避免 "Notch" 和 "notch" 被视为不同用户，统一转小写存储
+ *
+ * @param username MC 用户名
+ * @param logger Koishi Logger实例（用于日志）
+ * @returns 规范化后的用户名（小写）
+ */
+function normalizeUsername(username, logger) {
+    if (!username) {
+        logger?.warn(`[用户名规范化] 收到空用户名`);
+        return '';
+    }
+    // 移除首尾空格
+    const trimmed = username.trim();
+    // 检查是否为临时用户名，临时用户名不做转换
+    if (trimmed.startsWith('_temp_')) {
+        return trimmed;
+    }
+    // 转小写
+    const normalized = trimmed.toLowerCase();
+    if (normalized !== trimmed) {
+        logger?.debug(`[用户名规范化] "${trimmed}" -> "${normalized}"`);
+    }
+    return normalized;
+}
+/**
+ * 比较两个 Minecraft 用户名是否相同（不区分大小写）
+ *
+ * @param username1 第一个用户名
+ * @param username2 第二个用户名
+ * @returns 是否相同
+ */
+function isSameUsername(username1, username2) {
+    if (!username1 || !username2)
+        return false;
+    return normalizeUsername(username1) === normalizeUsername(username2);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-bind-bot",
   "description": "[WittF自用] BIND-BOT - 账号绑定管理机器人，支持Minecraft账号和B站账号绑定与管理。",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [