koishi-plugin-bind-bot 2.0.4 → 2.1.0

package/lib/services/nickname.service.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NicknameService = void 0;
+const helpers_1 = require("../utils/helpers");
+/**
+ * 群昵称管理服务
+ * 负责自动设置和验证群昵称
+ */
+class NicknameService {
+    logger;
+    config;
+    normalizeQQId;
+    validateBUID;
+    getBilibiliOfficialUserInfo;
+    updateBuidInfoOnly;
+    constructor(logger, config, normalizeQQId, validateBUID, getBilibiliOfficialUserInfo, updateBuidInfoOnly) {
+        this.logger = logger;
+        this.config = config;
+        this.normalizeQQId = normalizeQQId;
+        this.validateBUID = validateBUID;
+        this.getBilibiliOfficialUserInfo = getBilibiliOfficialUserInfo;
+        this.updateBuidInfoOnly = updateBuidInfoOnly;
+    }
+    /**
+     * 检查群昵称格式是否正确
+     */
+    checkNicknameFormat(nickname, buidUsername, mcUsername) {
+        if (!nickname || !buidUsername)
+            return false;
+        // 期望格式：B站名称（ID:MC用户名）或 B站名称（ID:未绑定）
+        const mcInfo = mcUsername && !mcUsername.startsWith('_temp_') ? mcUsername : "未绑定";
+        const expectedFormat = `${buidUsername}（ID:${mcInfo}）`;
+        return nickname === expectedFormat;
+    }
+    /**
+     * 使用四层判断逻辑获取最准确的B站用户名
+     * 优先级：官方API > ZMINFO > 数据库
+     */
+    async getLatestBuidUsername(buidUid, currentDbUsername) {
+        // 1. 尝试获取B站官方API的用户信息（最权威）
+        let officialUsername = null;
+        try {
+            this.logger.debug('群昵称设置', `正在查询B站官方API...`);
+            const officialInfo = await this.getBilibiliOfficialUserInfo(buidUid);
+            if (officialInfo && officialInfo.name) {
+                officialUsername = officialInfo.name;
+                this.logger.info('群昵称设置', `[层1-官方API] ✅ "${officialUsername}"`, true);
+            }
+            else {
+                this.logger.warn('群昵称设置', `[层1-官方API] ❌ 查询失败`);
+            }
+        }
+        catch (officialError) {
+            this.logger.warn('群昵称设置', `[层1-官方API] ❌ 查询出错: ${officialError.message}`);
+        }
+        // 2. 尝试获取ZMINFO API的用户信息（可能有缓存）
+        let zminfoUserData = null;
+        try {
+            this.logger.debug('群昵称设置', `正在查询ZMINFO API...`);
+            zminfoUserData = await this.validateBUID(buidUid);
+            if (zminfoUserData && zminfoUserData.username) {
+                this.logger.debug('群昵称设置', `[层2-ZMINFO] "${zminfoUserData.username}"`);
+            }
+            else {
+                this.logger.warn('群昵称设置', `[层2-ZMINFO] 查询失败`);
+            }
+        }
+        catch (zminfoError) {
+            this.logger.warn('群昵称设置', `[层2-ZMINFO] 查询出错: ${zminfoError.message}`);
+        }
+        // 3. 根据优先级返回结果
+        if (officialUsername) {
+            this.logger.info('群昵称设置', `🎯 采用官方API结果: "${officialUsername}"`, true);
+            return {
+                username: officialUsername,
+                source: 'official',
+                zminfoData: zminfoUserData || undefined
+            };
+        }
+        else if (zminfoUserData && zminfoUserData.username) {
+            this.logger.info('群昵称设置', `⚠️ 官方API不可用，降级使用ZMINFO: "${zminfoUserData.username}"`, true);
+            return {
+                username: zminfoUserData.username,
+                source: 'zminfo',
+                zminfoData: zminfoUserData
+            };
+        }
+        else {
+            this.logger.warn('群昵称设置', `⚠️ 官方API和ZMINFO都不可用，使用数据库名称: "${currentDbUsername}"`);
+            return {
+                username: currentDbUsername,
+                source: 'database'
+            };
+        }
+    }
+    /**
+     * 同步数据库中的B站用户信息
+     */
+    async syncDatabaseIfNeeded(normalizedUserId, latestUsername, currentDbUsername, zminfoData) {
+        if (latestUsername === currentDbUsername) {
+            return; // 无需更新
+        }
+        if (!zminfoData) {
+            this.logger.debug('群昵称设置', `无ZMINFO数据，跳过数据库同步`);
+            return;
+        }
+        try {
+            const updatedData = { ...zminfoData, username: latestUsername };
+            await this.updateBuidInfoOnly(normalizedUserId, updatedData);
+            this.logger.info('群昵称设置', `已同步数据库: "${currentDbUsername}" → "${latestUsername}"`, true);
+        }
+        catch (updateError) {
+            this.logger.warn('群昵称设置', `数据库同步失败: ${updateError.message}`);
+        }
+    }
+    /**
+     * 设置群昵称并验证
+     */
+    async setAndVerifyNickname(session, targetGroupId, normalizedUserId, nickname, currentNickname) {
+        try {
+            await session.bot.internal.setGroupCard(targetGroupId, normalizedUserId, nickname);
+            if (currentNickname) {
+                this.logger.info('群昵称设置', `成功在群${targetGroupId}中将QQ(${normalizedUserId})群昵称从"${currentNickname}"修改为"${nickname}"`, true);
+            }
+            else {
+                this.logger.info('群昵称设置', `成功在群${targetGroupId}中将QQ(${normalizedUserId})群昵称设置为: ${nickname}`, true);
+            }
+            // 验证设置是否生效
+            try {
+                await new Promise(resolve => setTimeout(resolve, 1000)); // 等待1秒
+                const verifyGroupInfo = await session.bot.internal.getGroupMemberInfo(targetGroupId, normalizedUserId);
+                const verifyNickname = verifyGroupInfo.card || verifyGroupInfo.nickname || '';
+                if (verifyNickname === nickname) {
+                    this.logger.info('群昵称设置', `✅ 验证成功，群昵称已生效: "${verifyNickname}"`, true);
+                }
+                else {
+                    this.logger.warn('群昵称设置', `⚠️ 验证失败，期望"${nickname}"，实际"${verifyNickname}"，可能是权限不足或API延迟`);
+                    if (!currentNickname) {
+                        this.logger.warn('群昵称设置', `建议检查: 1.机器人是否为群管理员 2.群设置是否允许管理员修改昵称 3.OneBot实现是否支持该功能`);
+                    }
+                }
+            }
+            catch (verifyError) {
+                this.logger.warn('群昵称设置', `无法验证群昵称设置结果: ${verifyError.message}`);
+            }
+        }
+        catch (setCardError) {
+            this.logger.error('群昵称设置', `设置群昵称失败: ${setCardError.message}`);
+            this.logger.error('群昵称设置', `错误详情: ${JSON.stringify(setCardError)}`);
+            throw setCardError;
+        }
+    }
+    /**
+     * 自动群昵称设置功能（重构版）
+     */
+    async autoSetGroupNickname(session, mcUsername, buidUsername, buidUid, targetUserId, specifiedGroupId) {
+        try {
+            // 准备基本参数
+            const actualUserId = targetUserId || session.userId;
+            const normalizedUserId = this.normalizeQQId(actualUserId);
+            const targetGroupId = specifiedGroupId || this.config.autoNicknameGroupId;
+            const mcInfo = (mcUsername && !mcUsername.startsWith('_temp_')) ? mcUsername : "未绑定";
+            this.logger.debug('群昵称设置', `开始处理QQ(${normalizedUserId})的群昵称设置，目标群: ${targetGroupId}`);
+            // 检查前置条件
+            if (!session.bot.internal) {
+                this.logger.debug('群昵称设置', `QQ(${normalizedUserId})bot不支持OneBot内部API，跳过自动群昵称设置`);
+                return;
+            }
+            if (!targetGroupId) {
+                this.logger.debug('群昵称设置', `QQ(${normalizedUserId})未配置自动群昵称设置目标群，跳过群昵称设置`);
+                return;
+            }
+            // 获取最新的B站用户名
+            let latestBuidUsername = buidUsername;
+            if (buidUid) {
+                this.logger.debug('群昵称设置', `开始四层判断获取最新B站用户名...`);
+                this.logger.debug('群昵称设置', `[层3-数据库] "${buidUsername}"`);
+                const result = await this.getLatestBuidUsername(buidUid, buidUsername);
+                latestBuidUsername = result.username;
+                // 尝试同步数据库
+                await this.syncDatabaseIfNeeded(normalizedUserId, latestBuidUsername, buidUsername, result.zminfoData);
+            }
+            // 生成目标昵称
+            const targetNickname = `${latestBuidUsername}（ID:${mcInfo}）`;
+            this.logger.debug('群昵称设置', `目标昵称: "${targetNickname}"`);
+            // 尝试获取当前昵称并比对
+            try {
+                this.logger.debug('群昵称设置', `正在获取QQ(${normalizedUserId})在群${targetGroupId}的当前昵称...`);
+                const currentGroupInfo = await session.bot.internal.getGroupMemberInfo(targetGroupId, normalizedUserId);
+                const currentNickname = currentGroupInfo.card || currentGroupInfo.nickname || '';
+                this.logger.debug('群昵称设置', `当前昵称: "${currentNickname}"`);
+                // 智能判断：如果当前昵称已包含最新用户名，跳过修改
+                if (buidUid && currentNickname) {
+                    const currentNicknameUsername = (0, helpers_1.extractBuidUsernameFromNickname)(currentNickname);
+                    this.logger.debug('群昵称设置', `[层4-群昵称] "${currentNicknameUsername || '(无法提取)'}"`);
+                    if (currentNicknameUsername && currentNicknameUsername === latestBuidUsername) {
+                        this.logger.info('群昵称设置', `✅ 群昵称已包含最新名称"${latestBuidUsername}"，跳过修改`, true);
+                        return;
+                    }
+                }
+                // 如果昵称完全一致，也跳过
+                if (currentNickname === targetNickname) {
+                    this.logger.info('群昵称设置', `QQ(${normalizedUserId})群昵称已经是"${targetNickname}"，跳过修改`, true);
+                    return;
+                }
+                // 昵称需要更新
+                this.logger.debug('群昵称设置', `昵称不一致，正在修改群昵称为: "${targetNickname}"`);
+                await this.setAndVerifyNickname(session, targetGroupId, normalizedUserId, targetNickname, currentNickname);
+            }
+            catch (getInfoError) {
+                // 无法获取当前昵称，直接设置新昵称
+                this.logger.warn('群昵称设置', `获取QQ(${normalizedUserId})当前群昵称失败: ${getInfoError.message}`);
+                this.logger.debug('群昵称设置', `将直接尝试设置新昵称...`);
+                await this.setAndVerifyNickname(session, targetGroupId, normalizedUserId, targetNickname);
+            }
+        }
+        catch (error) {
+            const actualUserId = targetUserId || session.userId;
+            const normalizedUserId = this.normalizeQQId(actualUserId);
+            this.logger.error('群昵称设置', `QQ(${normalizedUserId})自动群昵称设置失败: ${error.message}`);
+            this.logger.error('群昵称设置', `完整错误信息: ${JSON.stringify(error)}`);
+        }
+    }
+}
+exports.NicknameService = NicknameService;

package/lib/services/service-container.d.ts

@@ -0,0 +1,17 @@
+import { Context } from 'koishi';
+import { LoggerService } from '../utils/logger';
+import { MCIDBINDRepository } from '../repositories/mcidbind.repository';
+import { ApiService } from './api.service';
+import { DatabaseService } from './database.service';
+import { NicknameService } from './nickname.service';
+import { Config } from '../types/config';
+/**
+ * 服务容器类
+ * 统一管理所有服务的实例化，解决服务初始化分散的问题
+ */
+export declare class ServiceContainer {
+    readonly api: ApiService;
+    readonly database: DatabaseService;
+    readonly nickname: NicknameService;
+    constructor(ctx: Context, config: Config, logger: LoggerService, mcidbindRepo: MCIDBINDRepository, normalizeQQId: (userId: string) => string);
+}

package/lib/services/service-container.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceContainer = void 0;
+const api_service_1 = require("./api.service");
+const database_service_1 = require("./database.service");
+const nickname_service_1 = require("./nickname.service");
+/**
+ * 服务容器类
+ * 统一管理所有服务的实例化，解决服务初始化分散的问题
+ */
+class ServiceContainer {
+    api;
+    database;
+    nickname;
+    constructor(ctx, config, logger, mcidbindRepo, normalizeQQId) {
+        // 1. 实例化 API 服务（无依赖）
+        this.api = new api_service_1.ApiService(logger.createChild('API服务'), { zminfoApiUrl: config.zminfoApiUrl });
+        // 2. 实例化数据库服务（依赖 API 服务）
+        this.database = new database_service_1.DatabaseService(ctx, logger.createChild('数据库服务'), mcidbindRepo, normalizeQQId, (uuid) => this.api.getUsernameByUuid(uuid));
+        // 3. 实例化群昵称服务（依赖 API 和数据库服务）
+        this.nickname = new nickname_service_1.NicknameService(logger.createChild('群昵称服务'), { autoNicknameGroupId: config.autoNicknameGroupId }, normalizeQQId, (buid) => this.api.validateBUID(buid), (uid) => this.api.getBilibiliOfficialUserInfo(uid), (userId, buidUser) => this.database.updateBuidInfoOnly(userId, buidUser));
+    }
+}
+exports.ServiceContainer = ServiceContainer;

package/lib/types/config.d.ts

@@ -18,6 +18,8 @@ export interface Config {
     showMcSkin: boolean;
     zminfoApiUrl: string;
     enableLotteryBroadcast: boolean;
+    lotteryTargetGroupId: string;
+    lotteryTargetPrivateId: string;
     autoNicknameGroupId: string;
     forceBindSessdata: string;
     forceBindTargetUpUid: number;

package/lib/types/index.d.ts

@@ -6,3 +6,4 @@ export * from './config';
 export * from './database';
 export * from './api';
 export * from './common';
+export * from './update-data';

package/lib/types/index.js

@@ -26,3 +26,5 @@ __exportStar(require("./database"), exports);
 __exportStar(require("./api"), exports);
 // 通用类型
 __exportStar(require("./common"), exports);
+// 更新数据类型
+__exportStar(require("./update-data"), exports);

package/lib/types/update-data.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 数据库更新数据类型定义
+ */
+/**
+ * MC绑定更新数据接口
+ */
+export interface UpdateMcBindData {
+    mcUsername?: string;
+    mcUuid?: string;
+    lastModified?: Date;
+    isAdmin?: boolean;
+    usernameLastChecked?: Date;
+    usernameCheckFailCount?: number;
+}
+/**
+ * BUID绑定更新数据接口（完整更新）
+ */
+export interface UpdateBuidBindData {
+    buidUid?: string;
+    buidUsername?: string;
+    guardLevel?: number;
+    guardLevelText?: string;
+    maxGuardLevel?: number;
+    maxGuardLevelText?: string;
+    medalName?: string;
+    medalLevel?: number;
+    wealthMedalLevel?: number;
+    lastActiveTime?: Date;
+    lastModified?: Date;
+}
+/**
+ * BUID信息更新数据接口（仅更新信息，不更新lastModified）
+ */
+export interface UpdateBuidInfoData {
+    buidUsername?: string;
+    guardLevel?: number;
+    guardLevelText?: string;
+    maxGuardLevel?: number;
+    maxGuardLevelText?: string;
+    medalName?: string;
+    medalLevel?: number;
+    wealthMedalLevel?: number;
+    lastActiveTime?: Date;
+}
+/**
+ * 创建新绑定时的完整数据接口
+ */
+export interface CreateBindData {
+    qqId: string;
+    mcUsername: string;
+    mcUuid: string;
+    isAdmin: boolean;
+    whitelist: string[];
+    tags: string[];
+    [key: string]: any;
+}
+/**
+ * 标签更新数据接口
+ */
+export interface UpdateTagsData {
+    tags?: string[];
+}
+/**
+ * 白名单更新数据接口
+ */
+export interface UpdateWhitelistData {
+    whitelist?: string[];
+}

package/lib/types/update-data.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * 数据库更新数据类型定义
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/helpers.d.ts

@@ -107,3 +107,16 @@ export declare function normalizeUsername(username: string, logger?: Logger): st
  * @returns 是否相同
  */
 export declare function isSameUsername(username1: string, username2: string): boolean;
+/**
+ * 从群昵称中提取B站用户名
+ * 用于解析标准格式的群昵称：B站名称（ID:MC名称）
+ *
+ * @param nickname 群昵称字符串
+ * @returns B站用户名，如果格式不匹配返回 null
+ *
+ * @example
+ * extractBuidUsernameFromNickname("张三（ID:Steve）") // => "张三"
+ * extractBuidUsernameFromNickname("李四（ID:未绑定）") // => "李四"
+ * extractBuidUsernameFromNickname("无效格式") // => null
+ */
+export declare function extractBuidUsernameFromNickname(nickname: string): string | null;

package/lib/utils/helpers.js

@@ -13,6 +13,7 @@ exports.levenshteinDistance = levenshteinDistance;
 exports.calculateSimilarity = calculateSimilarity;
 exports.normalizeUsername = normalizeUsername;
 exports.isSameUsername = isSameUsername;
+exports.extractBuidUsernameFromNickname = extractBuidUsernameFromNickname;
 /**
  * 通用工具函数集合
  */
@@ -360,3 +361,23 @@ function isSameUsername(username1, username2) {
         return false;
     return normalizeUsername(username1) === normalizeUsername(username2);
 }
+/**
+ * 从群昵称中提取B站用户名
+ * 用于解析标准格式的群昵称：B站名称（ID:MC名称）
+ *
+ * @param nickname 群昵称字符串
+ * @returns B站用户名，如果格式不匹配返回 null
+ *
+ * @example
+ * extractBuidUsernameFromNickname("张三（ID:Steve）") // => "张三"
+ * extractBuidUsernameFromNickname("李四（ID:未绑定）") // => "李四"
+ * extractBuidUsernameFromNickname("无效格式") // => null
+ */
+function extractBuidUsernameFromNickname(nickname) {
+    if (!nickname)
+        return null;
+    // 匹配格式：任意内容（ID:任意内容）
+    // 使用非贪婪匹配 .+? 确保正确提取第一个括号前的内容
+    const match = nickname.match(/^(.+?)（ID:.+）$/);
+    return match ? match[1].trim() : null;
+}

package/lib/utils/message-utils.d.ts

@@ -18,13 +18,17 @@ export declare class MessageUtils {
     private config;
     private logger;
     private getBindingSessionFn;
+    private validateBUID?;
+    private updateBuidInfoOnly?;
     /**
      * 创建消息工具实例
      * @param config 消息工具配置
      * @param logger 日志服务
      * @param getBindingSessionFn 获取绑定会话的函数
+     * @param validateBUID 验证B站UID的函数（可选）
+     * @param updateBuidInfoOnly 更新B站信息的函数（可选）
      */
-    constructor(config: MessageUtilsConfig, logger: LoggerService, getBindingSessionFn: (userId: string, channelId: string) => BindingSession | null);
+    constructor(config: MessageUtilsConfig, logger: LoggerService, getBindingSessionFn: (userId: string, channelId: string) => BindingSession | null, validateBUID?: (uid: string) => Promise<any>, updateBuidInfoOnly?: (qqId: string, buidUser: any) => Promise<boolean>);
     /**
      * 发送消息并处理自动撤回
      * @param session Koishi Session对象
@@ -39,8 +43,9 @@ export declare class MessageUtils {
      * @param session Koishi Session对象
      * @param mcUsername MC用户名
      * @param buidUsername B站用户名
+     * @param buidUid B站UID（可选，用于实时验证）
      * @param targetUserId 目标用户ID（可选，用于管理员为他人设置）
      * @param specifiedGroupId 指定的群ID（可选，默认使用配置的群ID）
      */
-    autoSetGroupNickname(session: Session, mcUsername: string | null, buidUsername: string, targetUserId?: string, specifiedGroupId?: string): Promise<void>;
+    autoSetGroupNickname(session: Session, mcUsername: string | null, buidUsername: string, buidUid?: string, targetUserId?: string, specifiedGroupId?: string): Promise<void>;
 }

package/lib/utils/message-utils.js

@@ -11,16 +11,22 @@ class MessageUtils {
     config;
     logger;
     getBindingSessionFn;
+    validateBUID;
+    updateBuidInfoOnly;
     /**
      * 创建消息工具实例
      * @param config 消息工具配置
      * @param logger 日志服务
      * @param getBindingSessionFn 获取绑定会话的函数
+     * @param validateBUID 验证B站UID的函数（可选）
+     * @param updateBuidInfoOnly 更新B站信息的函数（可选）
      */
-    constructor(config, logger, getBindingSessionFn) {
+    constructor(config, logger, getBindingSessionFn, validateBUID, updateBuidInfoOnly) {
         this.config = config;
         this.logger = logger;
         this.getBindingSessionFn = getBindingSessionFn;
+        this.validateBUID = validateBUID;
+        this.updateBuidInfoOnly = updateBuidInfoOnly;
     }
     /**
      * 发送消息并处理自动撤回
@@ -135,17 +141,19 @@ class MessageUtils {
      * @param session Koishi Session对象
      * @param mcUsername MC用户名
      * @param buidUsername B站用户名
+     * @param buidUid B站UID（可选，用于实时验证）
      * @param targetUserId 目标用户ID（可选，用于管理员为他人设置）
      * @param specifiedGroupId 指定的群ID（可选，默认使用配置的群ID）
      */
-    async autoSetGroupNickname(session, mcUsername, buidUsername, targetUserId, specifiedGroupId) {
+    async autoSetGroupNickname(session, mcUsername, buidUsername, buidUid, targetUserId, specifiedGroupId) {
         try {
             // 如果指定了目标用户ID，使用目标用户ID，否则使用session的用户ID
             const actualUserId = targetUserId || session.userId;
             const normalizedUserId = (0, helpers_1.normalizeQQId)(actualUserId);
             // 根据MC绑定状态设置不同的格式（临时用户名视为未绑定）
             const mcInfo = (mcUsername && !mcUsername.startsWith('_temp_')) ? mcUsername : "未绑定";
-            const newNickname = `${buidUsername}（ID:${mcInfo}）`;
+            let currentBuidUsername = buidUsername;
+            const newNickname = `${currentBuidUsername}（ID:${mcInfo}）`;
             // 使用指定的群ID，如果没有指定则使用配置的默认群ID
             const targetGroupId = specifiedGroupId || this.config.autoNicknameGroupId;
             this.logger.debug('群昵称设置', `开始处理QQ(${normalizedUserId})的群昵称设置，目标群: ${targetGroupId}`);
@@ -164,20 +172,82 @@ class MessageUtils {
                         this.logger.info('群昵称设置', `QQ(${normalizedUserId})群昵称已经是"${newNickname}"，跳过修改`);
                         return;
                     }
+                    // 昵称不一致，先尝试获取最新的B站用户信息
+                    if (buidUid && this.validateBUID && this.updateBuidInfoOnly) {
+                        this.logger.debug('群昵称设置', `检测到昵称不一致，尝试获取B站UID ${buidUid} 的最新信息...`);
+                        // 1. 提取当前群昵称中的B站用户名
+                        const currentNicknameUsername = (0, helpers_1.extractBuidUsernameFromNickname)(currentNickname);
+                        this.logger.debug('群昵称设置', `从当前群昵称"${currentNickname}"中提取到B站名称: ${currentNicknameUsername || '(无法提取)'}`);
+                        try {
+                            const latestBuidUser = await this.validateBUID(buidUid);
+                            if (latestBuidUser && latestBuidUser.username) {
+                                this.logger.debug('群昵称设置', `API返回B站用户名: "${latestBuidUser.username}"`);
+                                // 2. 智能三层判断
+                                // 情况A: API返回 == 当前群昵称中的名称
+                                if (currentNicknameUsername && latestBuidUser.username === currentNicknameUsername) {
+                                    this.logger.info('群昵称设置', `✅ 当前群昵称"${currentNickname}"已包含正确的B站名称"${currentNicknameUsername}"`);
+                                    // 群昵称已经正确，仅需更新数据库（如果数据库是旧的）
+                                    if (latestBuidUser.username !== buidUsername) {
+                                        this.logger.info('群昵称设置', `数据库中的B站名称需要更新: "${buidUsername}" → "${latestBuidUser.username}"`);
+                                        try {
+                                            await this.updateBuidInfoOnly(normalizedUserId, latestBuidUser);
+                                            this.logger.info('群昵称设置', `已更新数据库中的B站用户名`);
+                                        }
+                                        catch (updateError) {
+                                            this.logger.warn('群昵称设置', `更新数据库失败: ${updateError.message}`);
+                                        }
+                                    }
+                                    else {
+                                        this.logger.debug('群昵称设置', `数据库中的B站名称已是最新，无需更新`);
+                                    }
+                                    // 跳过群昵称修改
+                                    this.logger.info('群昵称设置', `群昵称格式正确且名称最新，跳过修改`);
+                                    return;
+                                }
+                                // 情况B: API返回 == 数据库（都是旧的）
+                                if (latestBuidUser.username === buidUsername) {
+                                    this.logger.warn('群昵称设置', `⚠️ API返回的B站名称"${latestBuidUser.username}"与数据库一致，但与群昵称不符`);
+                                    this.logger.warn('群昵称设置', `可能是API缓存未刷新，采用保守策略：不修改群昵称`);
+                                    return;
+                                }
+                                // 情况C: API返回新数据（!= 群昵称 且 != 数据库）
+                                this.logger.info('群昵称设置', `检测到B站用户名已更新: "${buidUsername}" → "${latestBuidUser.username}"`);
+                                currentBuidUsername = latestBuidUser.username;
+                                // 更新数据库中的B站信息
+                                try {
+                                    await this.updateBuidInfoOnly(normalizedUserId, latestBuidUser);
+                                    this.logger.info('群昵称设置', `已更新数据库中的B站用户名为: ${currentBuidUsername}`);
+                                }
+                                catch (updateError) {
+                                    this.logger.warn('群昵称设置', `更新数据库中的B站用户名失败: ${updateError.message}`);
+                                    // 即使更新数据库失败，也继续使用最新的用户名设置昵称
+                                }
+                            }
+                            else {
+                                this.logger.warn('群昵称设置', `获取最新B站用户信息失败，使用数据库中的用户名: ${currentBuidUsername}`);
+                            }
+                        }
+                        catch (validateError) {
+                            this.logger.warn('群昵称设置', `获取最新B站用户信息时出错: ${validateError.message}，使用数据库中的用户名: ${currentBuidUsername}`);
+                            // API调用失败时降级处理，使用数据库中的旧名称
+                        }
+                    }
+                    // 使用（可能已更新的）用户名重新生成昵称
+                    const finalNickname = `${currentBuidUsername}（ID:${mcInfo}）`;
                     // 昵称不一致，执行修改
-                    this.logger.debug('群昵称设置', `昵称不一致，正在修改群昵称...`);
-                    await session.bot.internal.setGroupCard(targetGroupId, normalizedUserId, newNickname);
-                    this.logger.info('群昵称设置', `成功在群${targetGroupId}中将QQ(${normalizedUserId})群昵称从"${currentNickname}"修改为"${newNickname}"`, true);
+                    this.logger.debug('群昵称设置', `昵称不一致，正在修改群昵称为: "${finalNickname}"`);
+                    await session.bot.internal.setGroupCard(targetGroupId, normalizedUserId, finalNickname);
+                    this.logger.info('群昵称设置', `成功在群${targetGroupId}中将QQ(${normalizedUserId})群昵称从"${currentNickname}"修改为"${finalNickname}"`, true);
                     // 验证设置是否生效 - 再次获取群昵称确认
                     try {
                         await new Promise(resolve => setTimeout(resolve, 1000)); // 等待1秒
                         const verifyGroupInfo = await session.bot.internal.getGroupMemberInfo(targetGroupId, normalizedUserId);
                         const verifyNickname = verifyGroupInfo.card || verifyGroupInfo.nickname || '';
-                        if (verifyNickname === newNickname) {
+                        if (verifyNickname === finalNickname) {
                             this.logger.info('群昵称设置', `✅ 验证成功，群昵称已生效: "${verifyNickname}"`, true);
                         }
                         else {
-                            this.logger.warn('群昵称设置', `⚠️ 验证失败，期望"${newNickname}"，实际"${verifyNickname}"，可能是权限不足或API延迟`);
+                            this.logger.warn('群昵称设置', `⚠️ 验证失败，期望"${finalNickname}"，实际"${verifyNickname}"，可能是权限不足或API延迟`);
                         }
                     }
                     catch (verifyError) {
@@ -189,19 +259,54 @@ class MessageUtils {
                     this.logger.warn('群昵称设置', `获取QQ(${normalizedUserId})当前群昵称失败: ${getInfoError.message}`);
                     this.logger.warn('群昵称设置', `错误详情: ${JSON.stringify(getInfoError)}`);
                     this.logger.debug('群昵称设置', `将直接尝试设置新昵称...`);
+                    // 如果传入了 buidUid，尝试获取最新的B站用户信息
+                    if (buidUid && this.validateBUID && this.updateBuidInfoOnly) {
+                        this.logger.debug('群昵称设置', `尝试获取B站UID ${buidUid} 的最新信息...`);
+                        try {
+                            const latestBuidUser = await this.validateBUID(buidUid);
+                            if (latestBuidUser && latestBuidUser.username) {
+                                this.logger.debug('群昵称设置', `API返回B站用户名: "${latestBuidUser.username}"`);
+                                // 智能判断：API返回 == 数据库（都是旧的）
+                                if (latestBuidUser.username === buidUsername) {
+                                    this.logger.warn('群昵称设置', `⚠️ API返回的B站名称"${latestBuidUser.username}"与数据库一致`);
+                                    this.logger.warn('群昵称设置', `可能是API缓存未刷新，且无法获取当前群昵称，采用保守策略：跳过修改`);
+                                    return;
+                                }
+                                // API返回新数据（!= 数据库）
+                                this.logger.info('群昵称设置', `检测到B站用户名已更新: "${buidUsername}" → "${latestBuidUser.username}"`);
+                                currentBuidUsername = latestBuidUser.username;
+                                // 更新数据库
+                                try {
+                                    await this.updateBuidInfoOnly(normalizedUserId, latestBuidUser);
+                                    this.logger.info('群昵称设置', `已更新数据库中的B站用户名为: ${currentBuidUsername}`);
+                                }
+                                catch (updateError) {
+                                    this.logger.warn('群昵称设置', `更新数据库失败: ${updateError.message}`);
+                                }
+                            }
+                            else {
+                                this.logger.warn('群昵称设置', `获取最新B站用户信息失败`);
+                            }
+                        }
+                        catch (validateError) {
+                            this.logger.warn('群昵称设置', `获取最新B站用户信息失败: ${validateError.message}`);
+                        }
+                    }
                     try {
-                        await session.bot.internal.setGroupCard(targetGroupId, normalizedUserId, newNickname);
-                        this.logger.info('群昵称设置', `成功在群${targetGroupId}中将QQ(${normalizedUserId})群昵称设置为: ${newNickname}`, true);
+                        // 使用（可能已更新的）用户名生成昵称
+                        const nicknameToSet = `${currentBuidUsername}（ID:${mcInfo}）`;
+                        await session.bot.internal.setGroupCard(targetGroupId, normalizedUserId, nicknameToSet);
+                        this.logger.info('群昵称设置', `成功在群${targetGroupId}中将QQ(${normalizedUserId})群昵称设置为: ${nicknameToSet}`, true);
                         // 验证设置是否生效
                         try {
                             await new Promise(resolve => setTimeout(resolve, 1000)); // 等待1秒
                             const verifyGroupInfo = await session.bot.internal.getGroupMemberInfo(targetGroupId, normalizedUserId);
                             const verifyNickname = verifyGroupInfo.card || verifyGroupInfo.nickname || '';
-                            if (verifyNickname === newNickname) {
+                            if (verifyNickname === nicknameToSet) {
                                 this.logger.info('群昵称设置', `✅ 验证成功，群昵称已生效: "${verifyNickname}"`, true);
                             }
                             else {
-                                this.logger.warn('群昵称设置', `⚠️ 验证失败，期望"${newNickname}"，实际"${verifyNickname}"，可能是权限不足`);
+                                this.logger.warn('群昵称设置', `⚠️ 验证失败，期望"${nicknameToSet}"，实际"${verifyNickname}"，可能是权限不足`);
                                 this.logger.warn('群昵称设置', `建议检查: 1.机器人是否为群管理员 2.群设置是否允许管理员修改昵称 3.OneBot实现是否支持该功能`);
                             }
                         }

package/package.json

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