koishi-plugin-bind-bot 2.1.8 → 2.2.1

package/lib/handlers/whitelist.handler.js

@@ -4,6 +4,7 @@ exports.WhitelistHandler = void 0;
 const koishi_1 = require("koishi");
 const base_handler_1 = require("./base.handler");
 const helpers_1 = require("../utils/helpers");
+const bind_status_1 = require("../utils/bind-status");
 /**
  * 白名单命令处理器
  * 处理所有 mcid.whitelist 子命令
@@ -105,7 +106,7 @@ class WhitelistHandler extends base_handler_1.BaseHandler {
                 })
                     .join('\n\n'); // 使用双换行分隔不同服务器，增强可读性
                 this.logger.info('白名单', `成功: QQ(${normalizedUserId})获取了服务器列表，共${enabledServers.length}个服务器`);
-                const displayUsername = userBind.mcUsername && !userBind.mcUsername.startsWith('_temp_')
+                const displayUsername = bind_status_1.BindStatus.hasValidMcBind(userBind)
                     ? userBind.mcUsername
                     : '未绑定MC账号';
                 return this.deps.sendMessage(session, [
@@ -157,10 +158,7 @@ class WhitelistHandler extends base_handler_1.BaseHandler {
                         const targetValue = targets[0];
                         // 首先检查是否存在该标签名
                         const allBinds = await this.repos.mcidbind.findAll();
-                        const usersWithTag = allBinds.filter(bind => bind.tags &&
-                            bind.tags.includes(targetValue) &&
-                            bind.mcUsername &&
-                            !bind.mcUsername.startsWith('_temp_'));
+                        const usersWithTag = allBinds.filter(bind => bind.tags && bind.tags.includes(targetValue) && bind_status_1.BindStatus.hasValidMcBind(bind));
                         if (usersWithTag.length > 0) {
                             // 作为标签处理
                             const tagName = targetValue;
@@ -363,10 +361,7 @@ class WhitelistHandler extends base_handler_1.BaseHandler {
                         const targetValue = targets[0];
                         // 首先检查是否存在该标签名
                         const allBinds = await this.repos.mcidbind.findAll();
-                        const usersWithTag = allBinds.filter(bind => bind.tags &&
-                            bind.tags.includes(targetValue) &&
-                            bind.mcUsername &&
-                            !bind.mcUsername.startsWith('_temp_'));
+                        const usersWithTag = allBinds.filter(bind => bind.tags && bind.tags.includes(targetValue) && bind_status_1.BindStatus.hasValidMcBind(bind));
                         if (usersWithTag.length > 0) {
                             // 作为标签处理
                             const tagName = targetValue;
@@ -685,10 +680,7 @@ class WhitelistHandler extends base_handler_1.BaseHandler {
                 // 查询所有已绑定MC账号的用户
                 const allBinds = await this.repos.mcidbind.findAll();
                 // 过滤掉无效的绑定：没有用户名或UUID的记录
-                const validBinds = allBinds.filter(bind => (bind.mcUsername &&
-                    bind.mcUsername.trim() !== '' &&
-                    !bind.mcUsername.startsWith('_temp_')) ||
-                    (bind.mcUuid && bind.mcUuid.trim() !== ''));
+                const validBinds = allBinds.filter(bind => bind_status_1.BindStatus.hasValidMcBind(bind) || (bind.mcUuid && bind.mcUuid.trim() !== ''));
                 // 按绑定时间排序，早绑定的用户优先处理
                 validBinds.sort((a, b) => {
                     const timeA = a.lastModified ? new Date(a.lastModified).getTime() : 0;

package/lib/index.js

@@ -14,6 +14,7 @@ const mcidbind_repository_1 = require("./repositories/mcidbind.repository");
 const schedule_mute_repository_1 = require("./repositories/schedule-mute.repository");
 const handlers_1 = require("./handlers");
 const service_container_1 = require("./services/service-container");
+const bind_status_1 = require("./utils/bind-status");
 exports.name = 'bind-bot';
 // 声明插件依赖
 exports.inject = ['database', 'server'];
@@ -428,7 +429,7 @@ function apply(ctx, config) {
             // 检查用户是否已有绑定记录
             const existingBind = await services.database.getMcBindByQQId(normalizedUserId);
             // 如果用户已完成全部绑定，不需要提醒
-            if (existingBind && existingBind.mcUsername && existingBind.buidUid) {
+            if (bind_status_1.BindStatus.hasCompletedAllBinds(existingBind)) {
                 logger.info(`[新人绑定] 用户QQ(${normalizedUserId})已完成全部绑定，跳过提醒`);
                 return;
             }
@@ -436,7 +437,7 @@ function apply(ctx, config) {
             const inMuteTime = await isInMuteTime(session.channelId);
             // 发送欢迎消息
             let welcomeMessage = `🎉 欢迎新成员 ${koishi_1.h.at(session.userId)} 加入群聊！\n\n`;
-            if (!existingBind || (!existingBind.mcUsername && !existingBind.buidUid)) {
+            if (!existingBind || (!bind_status_1.BindStatus.hasValidMcBind(existingBind) && !bind_status_1.BindStatus.hasValidBuidBind(existingBind))) {
                 // 完全未绑定
                 if (inMuteTime) {
                     // 在禁言时间内，只发送欢迎消息和基本提醒
@@ -457,49 +458,36 @@ function apply(ctx, config) {
                     bindingSession.state = 'waiting_buid';
                 }
             }
-            else if (existingBind.mcUsername && !existingBind.buidUid) {
-                // 只绑定了MC，未绑定B站
-                // 检查是否为有效的MC绑定（非临时用户名）
-                if (existingBind.mcUsername.startsWith('_temp_')) {
-                    // 临时用户名，实际上应该是只绑定了B站但MC是临时的，不应该进入这个分支
-                    // 这种情况应该按照"只绑定了B站"处理
-                    welcomeMessage += '📋 检测到您已绑定B站账号，但尚未绑定MC账号\n';
-                    welcomeMessage += `🎮 可使用 ${formatCommand('mcid bind <MC用户名>')} 绑定MC账号`;
+            else if (bind_status_1.BindStatus.hasValidMcBind(existingBind) && !existingBind.buidUid) {
+                // 只绑定了MC（非临时用户名），未绑定B站
+                const displayUsername = existingBind.mcUsername;
+                welcomeMessage += `🎮 已绑定MC: ${displayUsername}\n`;
+                if (inMuteTime) {
+                    // 在禁言时间内，只发送状态信息
+                    welcomeMessage += `📋 请在非禁言时间段使用 ${formatCommand('buid bind <B站UID>')} 绑定B站账号`;
                     await session.bot.sendMessage(session.channelId, welcomeMessage);
-                    logger.info(`[新人绑定] 新成员QQ(${normalizedUserId})实际只绑定了B站（MC为临时用户名），已发送绑定提醒`);
+                    logger.info(`[新人绑定] 新成员QQ(${normalizedUserId})在禁言时间内，仅发送绑定状态提醒`);
                 }
                 else {
-                    // 真正绑定了MC账号
-                    const displayUsername = existingBind.mcUsername;
-                    welcomeMessage += `🎮 已绑定MC: ${displayUsername}\n`;
-                    if (inMuteTime) {
-                        // 在禁言时间内，只发送状态信息
-                        welcomeMessage += `📋 请在非禁言时间段使用 ${formatCommand('buid bind <B站UID>')} 绑定B站账号`;
-                        await session.bot.sendMessage(session.channelId, welcomeMessage);
-                        logger.info(`[新人绑定] 新成员QQ(${normalizedUserId})在禁言时间内，仅发送绑定状态提醒`);
-                    }
-                    else {
-                        // 不在禁言时间，自动启动B站绑定
-                        welcomeMessage += '📋 请发送您的B站UID进行绑定';
-                        await session.bot.sendMessage(session.channelId, welcomeMessage);
-                        logger.info(`[新人绑定] 为新成员QQ(${normalizedUserId})自动启动B站绑定流程`);
-                        // 创建绑定会话，直接进入B站绑定步骤
-                        createBindingSession(session.userId, session.channelId);
-                        const bindingSession = getBindingSession(session.userId, session.channelId);
-                        bindingSession.state = 'waiting_buid';
-                        bindingSession.mcUsername = existingBind.mcUsername;
-                    }
+                    // 不在禁言时间，自动启动B站绑定
+                    welcomeMessage += '📋 请发送您的B站UID进行绑定';
+                    await session.bot.sendMessage(session.channelId, welcomeMessage);
+                    logger.info(`[新人绑定] 为新成员QQ(${normalizedUserId})自动启动B站绑定流程`);
+                    // 创建绑定会话，直接进入B站绑定步骤
+                    createBindingSession(session.userId, session.channelId);
+                    const bindingSession = getBindingSession(session.userId, session.channelId);
+                    bindingSession.state = 'waiting_buid';
+                    bindingSession.mcUsername = existingBind.mcUsername;
                 }
             }
-            else if (!existingBind.mcUsername && existingBind.buidUid) {
+            else if (!bind_status_1.BindStatus.hasValidMcBind(existingBind) && bind_status_1.BindStatus.hasValidBuidBind(existingBind)) {
                 // 只绑定了B站，未绑定MC - 仅发送提醒
                 welcomeMessage += '📋 检测到您已绑定B站账号，但尚未绑定MC账号\n';
                 welcomeMessage += `🎮 可使用 ${formatCommand('mcid bind <MC用户名>')} 绑定MC账号`;
                 await session.bot.sendMessage(session.channelId, welcomeMessage);
                 logger.info(`[新人绑定] 新成员QQ(${normalizedUserId})已绑定B站但未绑定MC，已发送绑定提醒`);
             }
-            else if (existingBind.mcUsername &&
-                existingBind.mcUsername.startsWith('_temp_') &&
+            else if (!bind_status_1.BindStatus.hasValidMcBind(existingBind) &&
                 existingBind.buidUid) {
                 // MC是临时用户名但已绑定B站 - 也按照"只绑定了B站"处理
                 welcomeMessage += '📋 检测到您已绑定B站账号，但尚未绑定MC账号\n';
@@ -664,6 +652,15 @@ function apply(ctx, config) {
         usernameCheckFailCount: {
             type: 'integer',
             initial: 0
+        },
+        // 绑定状态标志字段
+        hasMcBind: {
+            type: 'boolean',
+            initial: false
+        },
+        hasBuidBind: {
+            type: 'boolean',
+            initial: false
         }
     }, {
         // 设置主键为qqId
@@ -673,6 +670,11 @@ function apply(ctx, config) {
         // 添加isAdmin索引，提高查询效率
         indexes: [['isAdmin'], ['buidUid']]
     });
+    // 在插件启动时执行数据迁移
+    ctx.on('ready', async () => {
+        logger.info('[初始化] 开始数据迁移和一致性检查...');
+        await addMissingFields();
+    });
     // 检查表结构是否包含旧字段
     const checkTableStructure = async () => {
         try {
@@ -700,6 +702,7 @@ function apply(ctx, config) {
             for (const record of records) {
                 let needUpdate = false;
                 const updateData = {};
+                const qqId = record.qqId; // 提前提取 qqId，避免类型推断问题
                 // 检查并添加whitelist字段
                 if (!record.whitelist) {
                     updateData.whitelist = [];
@@ -725,9 +728,49 @@ function apply(ctx, config) {
                     updateData.reminderCount = 0;
                     needUpdate = true;
                 }
+                // 检查并修复hasMcBind字段（数据迁移 + 数据一致性检查）
+                const currentHasMcBind = record.hasMcBind;
+                const mcUsername = record.mcUsername;
+                const hasValidMc = !!(mcUsername && !mcUsername.startsWith('_temp_'));
+                // 情况1：字段不存在，需要添加
+                if (currentHasMcBind === undefined || currentHasMcBind === null) {
+                    updateData.hasMcBind = hasValidMc;
+                    needUpdate = true;
+                    logger.debug(`[数据迁移] 添加hasMcBind字段 QQ(${qqId}): ${hasValidMc}`);
+                }
+                // 情况2：字段存在但值不正确，需要修复
+                else if (currentHasMcBind !== hasValidMc) {
+                    updateData.hasMcBind = hasValidMc;
+                    needUpdate = true;
+                    logger.info(`[数据修复] 修正hasMcBind QQ(${qqId}): ${currentHasMcBind} -> ${hasValidMc}`);
+                }
+                // 清理临时用户名（无论hasMcBind字段是否存在）
+                if (!hasValidMc && mcUsername && mcUsername.startsWith('_temp_')) {
+                    updateData.mcUsername = '';
+                    updateData.mcUuid = '';
+                    updateData.whitelist = [];
+                    needUpdate = true;
+                    logger.info(`[数据清理] 清理QQ(${qqId})的临时用户名: ${mcUsername}`);
+                }
+                // 检查并修复hasBuidBind字段（数据迁移 + 数据一致性检查）
+                const currentHasBuidBind = record.hasBuidBind;
+                const buidUid = record.buidUid;
+                const hasValidBuid = !!(buidUid && buidUid.length > 0);
+                // 情况1：字段不存在，需要添加
+                if (currentHasBuidBind === undefined || currentHasBuidBind === null) {
+                    updateData.hasBuidBind = hasValidBuid;
+                    needUpdate = true;
+                    logger.debug(`[数据迁移] 添加hasBuidBind字段 QQ(${qqId}): ${hasValidBuid}`);
+                }
+                // 情况2：字段存在但值不正确，需要修复
+                else if (currentHasBuidBind !== hasValidBuid) {
+                    updateData.hasBuidBind = hasValidBuid;
+                    needUpdate = true;
+                    logger.info(`[数据修复] 修正hasBuidBind QQ(${qqId}): ${currentHasBuidBind} -> ${hasValidBuid}`);
+                }
                 // 如果需要更新，执行更新操作
                 if (needUpdate) {
-                    await mcidbindRepo.update(record.qqId, updateData);
+                    await mcidbindRepo.update(qqId, updateData);
                     updatedCount++;
                 }
             }
@@ -1266,21 +1309,22 @@ function apply(ctx, config) {
                 return next();
             }
             // 情况1：完全未绑定
-            if (!bind || (!bind.mcUsername && !bind.buidUid)) {
+            if (!bind || (!bind_status_1.BindStatus.hasValidMcBind(bind) && !bind_status_1.BindStatus.hasValidBuidBind(bind))) {
                 // 创建新记录或获取提醒次数
                 let reminderCount = 0;
                 if (!bind) {
                     // 创建新记录
-                    const tempUsername = `_temp_${normalizedUserId}`;
                     await mcidbindRepo.create({
                         qqId: normalizedUserId,
-                        mcUsername: tempUsername,
+                        mcUsername: '',
                         mcUuid: '',
                         lastModified: new Date(),
                         isAdmin: false,
                         whitelist: [],
                         tags: [],
-                        reminderCount: 1
+                        reminderCount: 1,
+                        hasMcBind: false,
+                        hasBuidBind: false
                     });
                     reminderCount = 1;
                 }
@@ -1302,7 +1346,7 @@ function apply(ctx, config) {
             // 情况2：只绑定了B站，未绑定MC
             if (bind.buidUid &&
                 bind.buidUsername &&
-                (!bind.mcUsername || bind.mcUsername.startsWith('_temp_'))) {
+                !bind_status_1.BindStatus.hasValidMcBind(bind)) {
                 const mcInfo = null;
                 const isNicknameCorrect = services.nickname.checkNicknameFormat(currentNickname, bind.buidUsername, mcInfo);
                 if (!isNicknameCorrect) {
@@ -1325,8 +1369,7 @@ function apply(ctx, config) {
             // 情况3：都已绑定，但群昵称格式不正确
             if (bind.buidUid &&
                 bind.buidUsername &&
-                bind.mcUsername &&
-                !bind.mcUsername.startsWith('_temp_')) {
+                bind_status_1.BindStatus.hasValidMcBind(bind)) {
                 const isNicknameCorrect = services.nickname.checkNicknameFormat(currentNickname, bind.buidUsername, bind.mcUsername);
                 if (!isNicknameCorrect) {
                     // 更新提醒次数
@@ -1530,20 +1573,17 @@ function apply(ctx, config) {
             else {
                 // 用户未绑定B站账号，需要完成B站绑定
                 logger.info(`[交互绑定] QQ(${normalizedUserId})跳过了MC账号绑定，需要完成B站绑定`);
-                // 为跳过MC绑定的用户创建临时绑定记录
-                const timestamp = Date.now();
-                const tempMcUsername = `_temp_skip_${timestamp}`;
-                // 创建临时MC绑定
-                const tempBindResult = await services.database.createOrUpdateMcBind(session.userId, tempMcUsername, '', false);
+                // 创建绑定记录（不使用临时MC用户名）
+                const tempBindResult = await services.database.createOrUpdateMcBind(session.userId, '', '', false);
                 if (!tempBindResult) {
-                    logger.error(`[交互绑定] QQ(${normalizedUserId})创建临时MC绑定失败`);
-                    await sendMessage(session, [koishi_1.h.text('❌ 创建临时绑定失败，请稍后重试')]);
+                    logger.error(`[交互绑定] QQ(${normalizedUserId})创建MC绑定记录失败`);
+                    await sendMessage(session, [koishi_1.h.text('❌ 创建绑定记录失败，请稍后重试')]);
                     return;
                 }
                 // 跳转到B站绑定流程
                 updateBindingSession(session.userId, session.channelId, {
                     state: 'waiting_buid',
-                    mcUsername: tempMcUsername,
+                    mcUsername: '',
                     mcUuid: ''
                 });
                 await sendMessage(session, [koishi_1.h.text('✅ 已跳过MC绑定\n📋 请发送您的B站UID')]);
@@ -1569,7 +1609,7 @@ function apply(ctx, config) {
         const uuid = profile.id;
         // 检查用户是否已绑定MC账号
         const existingBind = await services.database.getMcBindByQQId(normalizedUserId);
-        if (existingBind && existingBind.mcUsername && !existingBind.mcUsername.startsWith('_temp_')) {
+        if (bind_status_1.BindStatus.hasValidMcBind(existingBind)) {
             // 检查冷却时间
             if (!(await isAdmin(session.userId)) && !checkCooldown(existingBind.lastModified)) {
                 const days = config.cooldownDays;
@@ -1578,9 +1618,7 @@ function apply(ctx, config) {
                 const passedDays = Math.floor(diffTime / (1000 * 60 * 60 * 24));
                 const remainingDays = days - passedDays;
                 removeBindingSession(session.userId, session.channelId);
-                const displayUsername = existingBind.mcUsername && !existingBind.mcUsername.startsWith('_temp_')
-                    ? existingBind.mcUsername
-                    : '未绑定';
+                const displayUsername = bind_status_1.BindStatus.getDisplayMcUsername(existingBind, '未绑定');
                 await sendMessage(session, [
                     koishi_1.h.text(`❌ 您已绑定MC账号: ${displayUsername}\n\n如需修改，请在冷却期结束后(还需${remainingDays}天)使用 ${formatCommand('mcid change')} 命令或联系管理员`)
                 ]);
@@ -1728,9 +1766,7 @@ function apply(ctx, config) {
             logger.error(`[交互绑定] QQ(${normalizedUserId})绑定B站账号失败`);
             removeBindingSession(session.userId, session.channelId);
             // 根据是否有MC绑定提供不同的提示
-            const displayMcName = bindingSession.mcUsername && !bindingSession.mcUsername.startsWith('_temp_')
-                ? bindingSession.mcUsername
-                : null;
+            const displayMcName = bindingSession.mcUsername || null;
             const mcStatus = displayMcName ? `您的MC账号${displayMcName}已成功绑定\n` : '';
             await sendMessage(session, [
                 koishi_1.h.text(`❌ B站账号绑定失败，数据库操作出错\n\n${mcStatus}可稍后使用 ${formatCommand('buid bind <UID>')} 命令单独绑定B站账号`)
@@ -1742,10 +1778,8 @@ function apply(ctx, config) {
         removeBindingSession(session.userId, session.channelId);
         // 自动群昵称设置功能 - 使用新的autoSetGroupNickname函数
         try {
-            // 检查是否有有效的MC用户名（不是临时用户名）
-            const mcName = bindingSession.mcUsername && !bindingSession.mcUsername.startsWith('_temp_')
-                ? bindingSession.mcUsername
-                : null;
+            // 检查是否有有效的MC用户名
+            const mcName = bindingSession.mcUsername || null;
             await services.nickname.autoSetGroupNickname(session, mcName, buidUser.username, String(buidUser.uid));
             logger.info(`[交互绑定] QQ(${normalizedUserId})绑定完成，已设置群昵称`);
         }
@@ -1766,9 +1800,7 @@ function apply(ctx, config) {
             extraInfo += `\n荣耀等级: ${buidUser.wealthMedalLevel}`;
         }
         // 准备完成消息
-        const displayMcName = bindingSession.mcUsername && !bindingSession.mcUsername.startsWith('_temp_')
-            ? bindingSession.mcUsername
-            : null;
+        const displayMcName = bindingSession.mcUsername || null;
         const mcInfo = displayMcName ? `MC: ${displayMcName}` : 'MC: 未绑定';
         let extraTip = '';
         // 如果用户跳过了MC绑定或MC账号是temp，提供后续绑定的指引

package/lib/services/database.service.d.ts

@@ -26,7 +26,7 @@ export declare class DatabaseService {
      */
     createOrUpdateMcBind(userId: string, mcUsername: string, mcUuid: string, isAdmin?: boolean): Promise<boolean>;
     /**
-     * 删除 MC 绑定（同时解绑 MC 和 B 站账号）
+     * 解绑 MC 账号（只清空 MC 字段，保留 B 站绑定）
      */
     deleteMcBind(userId: string): Promise<boolean>;
     /**
@@ -49,6 +49,10 @@ export declare class DatabaseService {
      * 仅更新 B 站信息，不更新绑定时间（用于查询时刷新数据）
      */
     updateBuidInfoOnly(userId: string, buidUser: ZminfoUser): Promise<boolean>;
+    /**
+     * 解绑 B 站账号（只清空 B 站字段，保留 MC 绑定）
+     */
+    deleteBuidBind(userId: string): Promise<boolean>;
     /**
      * 检查并更新用户名（如果与当前数据库中的不同）
      */

package/lib/services/database.service.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseService = void 0;
 const helpers_1 = require("../utils/helpers");
+const bind_status_1 = require("../utils/bind-status");
 /**
  * 数据库服务层
  * 统一管理数据库操作，包括 MC 绑定和 BUID 绑定的 CRUD
@@ -77,7 +78,8 @@ class DatabaseService {
                 const updateData = {
                     mcUsername,
                     mcUuid,
-                    lastModified: new Date()
+                    lastModified: new Date(),
+                    hasMcBind: true
                 };
                 // 仅当指定了isAdmin参数时更新管理员状态
                 if (typeof isAdmin !== 'undefined') {
@@ -95,7 +97,9 @@ class DatabaseService {
                         mcUsername,
                         mcUuid,
                         lastModified: new Date(),
-                        isAdmin: isAdmin || false
+                        isAdmin: isAdmin || false,
+                        hasMcBind: true,
+                        hasBuidBind: false
                     });
                     this.logger.info('MCIDBIND', `创建绑定: QQ=${normalizedQQId}, MC用户名=${mcUsername}, UUID=${mcUuid}`, true);
                     return true;
@@ -112,45 +116,59 @@ class DatabaseService {
         }
     }
     /**
-     * 删除 MC 绑定（同时解绑 MC 和 B 站账号）
+     * 解绑 MC 账号（只清空 MC 字段，保留 B 站绑定）
      */
     async deleteMcBind(userId) {
         try {
             // 验证输入参数
             if (!userId) {
-                this.logger.error('MCIDBIND', '删除绑定失败: 无效的用户ID');
+                this.logger.error('MCIDBIND', '解绑MC失败: 无效的用户ID');
                 return false;
             }
             const normalizedQQId = this.normalizeQQId(userId);
             if (!normalizedQQId) {
-                this.logger.error('MCIDBIND', '删除绑定失败: 无法提取有效的QQ号');
+                this.logger.error('MCIDBIND', '解绑MC失败: 无法提取有效的QQ号');
                 return false;
             }
             // 查询是否存在绑定记录
             const bind = await this.getMcBindByQQId(normalizedQQId);
-            if (bind) {
-                // 删除整个绑定记录，包括MC和B站账号
+            if (!bind) {
+                this.logger.warn('MCIDBIND', `解绑MC失败: QQ=${normalizedQQId}不存在绑定记录`);
+                return false;
+            }
+            // 如果没有MC绑定，返回失败
+            if (!bind_status_1.BindStatus.hasValidMcBind(bind)) {
+                this.logger.warn('MCIDBIND', `解绑MC失败: QQ=${normalizedQQId}未绑定MC账号`);
+                return false;
+            }
+            const oldUsername = bind.mcUsername;
+            // 检查是否有B站绑定
+            if (bind_status_1.BindStatus.hasValidBuidBind(bind)) {
+                // 如果有B站绑定，只清空MC字段，保留记录
+                await this.mcidbindRepo.update(normalizedQQId, {
+                    mcUsername: '',
+                    mcUuid: '',
+                    hasMcBind: false,
+                    whitelist: [],
+                    lastModified: new Date()
+                });
+                this.logger.info('MCIDBIND', `解绑MC: QQ=${normalizedQQId}, MC用户名=${oldUsername}, 保留B站绑定`, true);
+            }
+            else {
+                // 如果没有B站绑定，删除整条记录
                 const removedCount = await this.mcidbindRepo.delete(normalizedQQId);
-                // 检查是否真正删除成功
                 if (removedCount > 0) {
-                    let logMessage = `删除绑定: QQ=${normalizedQQId}`;
-                    if (bind.mcUsername)
-                        logMessage += `, MC用户名=${bind.mcUsername}`;
-                    if (bind.buidUid)
-                        logMessage += `, B站UID=${bind.buidUid}(${bind.buidUsername})`;
-                    this.logger.info('MCIDBIND', logMessage, true);
-                    return true;
+                    this.logger.info('MCIDBIND', `解绑MC并删除记录: QQ=${normalizedQQId}, MC用户名=${oldUsername}`, true);
                 }
                 else {
-                    this.logger.warn('MCIDBIND', `删除绑定异常: QQ=${normalizedQQId}, 可能未实际删除`);
+                    this.logger.warn('MCIDBIND', `解绑MC异常: QQ=${normalizedQQId}, 可能未实际删除`);
                     return false;
                 }
             }
-            this.logger.warn('MCIDBIND', `删除绑定失败: QQ=${normalizedQQId}不存在绑定记录`);
-            return false;
+            return true;
         }
         catch (error) {
-            this.logger.error('MCIDBIND', `删除绑定失败: 错误=${error.message}`);
+            this.logger.error('MCIDBIND', `解绑MC失败: 错误=${error.message}`);
             return false;
         }
     }
@@ -164,17 +182,13 @@ class DatabaseService {
                 this.logger.warn('绑定检查', '尝试检查空MC用户名');
                 return false;
             }
-            // 跳过临时用户名的检查
-            if (username.startsWith('_temp_')) {
-                return false;
-            }
             // 使用不区分大小写的查询
             const bind = await this.mcidbindRepo.findByUsernameIgnoreCase(username);
             // 如果没有绑定，返回false
             if (!bind)
                 return false;
             // 如果绑定的用户名是临时用户名，视为未绑定
-            if (bind.mcUsername && bind.mcUsername.startsWith('_temp_')) {
+            if (!bind_status_1.BindStatus.hasValidMcBind(bind)) {
                 return false;
             }
             // 如果提供了 UUID，检查是否为同一个 MC 账号（用户改名场景）
@@ -272,23 +286,26 @@ class DatabaseService {
                 lastModified: new Date()
             };
             if (bind) {
+                // 添加 hasBuidBind 标志
+                updateData.hasBuidBind = true;
                 await this.mcidbindRepo.update(normalizedQQId, updateData);
                 this.logger.info('B站账号绑定', `更新绑定: QQ=${normalizedQQId}, B站UID=${buidUser.uid}, 用户名=${buidUser.username}`, true);
             }
             else {
-                // 为跳过MC绑定的用户生成唯一的临时用户名，避免UNIQUE constraint冲突
-                const tempMcUsername = `_temp_skip_${normalizedQQId}_${Date.now()}`;
+                // 创建新绑定记录（不使用临时用户名）
                 const newBind = {
                     qqId: normalizedQQId,
-                    mcUsername: tempMcUsername,
+                    mcUsername: '',
                     mcUuid: '',
                     isAdmin: false,
                     whitelist: [],
                     tags: [],
+                    hasMcBind: false,
+                    hasBuidBind: true,
                     ...updateData
                 };
                 await this.mcidbindRepo.create(newBind);
-                this.logger.info('B站账号绑定', `创建绑定(跳过MC): QQ=${normalizedQQId}, B站UID=${buidUser.uid}, 用户名=${buidUser.username}, 临时MC用户名=${tempMcUsername}`, true);
+                this.logger.info('B站账号绑定', `创建绑定(跳过MC): QQ=${normalizedQQId}, B站UID=${buidUser.uid}, 用户名=${buidUser.username}`, true);
             }
             return true;
         }
@@ -334,6 +351,71 @@ class DatabaseService {
             return false;
         }
     }
+    /**
+     * 解绑 B 站账号（只清空 B 站字段，保留 MC 绑定）
+     */
+    async deleteBuidBind(userId) {
+        try {
+            // 验证输入参数
+            if (!userId) {
+                this.logger.error('B站账号解绑', '解绑失败: 无效的用户ID');
+                return false;
+            }
+            const normalizedQQId = this.normalizeQQId(userId);
+            if (!normalizedQQId) {
+                this.logger.error('B站账号解绑', '解绑失败: 无法提取有效的QQ号');
+                return false;
+            }
+            // 查询是否存在绑定记录
+            const bind = await this.getMcBindByQQId(normalizedQQId);
+            if (!bind) {
+                this.logger.warn('B站账号解绑', `解绑失败: QQ=${normalizedQQId}不存在绑定记录`);
+                return false;
+            }
+            // 如果没有B站绑定，返回失败
+            if (!bind_status_1.BindStatus.hasValidBuidBind(bind)) {
+                this.logger.warn('B站账号解绑', `解绑失败: QQ=${normalizedQQId}未绑定B站账号`);
+                return false;
+            }
+            const oldBuidUid = bind.buidUid;
+            const oldBuidUsername = bind.buidUsername;
+            // 检查是否有MC绑定
+            if (bind_status_1.BindStatus.hasValidMcBind(bind)) {
+                // 如果有MC绑定，只清空B站字段，保留记录
+                await this.mcidbindRepo.update(normalizedQQId, {
+                    buidUid: '',
+                    buidUsername: '',
+                    guardLevel: 0,
+                    guardLevelText: '',
+                    maxGuardLevel: 0,
+                    maxGuardLevelText: '',
+                    medalName: '',
+                    medalLevel: 0,
+                    wealthMedalLevel: 0,
+                    lastActiveTime: null,
+                    hasBuidBind: false,
+                    lastModified: new Date()
+                });
+                this.logger.info('B站账号解绑', `解绑B站: QQ=${normalizedQQId}, B站UID=${oldBuidUid}, 用户名=${oldBuidUsername}, 保留MC绑定`, true);
+            }
+            else {
+                // 如果没有MC绑定，删除整条记录
+                const removedCount = await this.mcidbindRepo.delete(normalizedQQId);
+                if (removedCount > 0) {
+                    this.logger.info('B站账号解绑', `解绑B站并删除记录: QQ=${normalizedQQId}, B站UID=${oldBuidUid}, 用户名=${oldBuidUsername}`, true);
+                }
+                else {
+                    this.logger.warn('B站账号解绑', `解绑B站异常: QQ=${normalizedQQId}, 可能未实际删除`);
+                    return false;
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            this.logger.error('B站账号解绑', `解绑B站失败: 错误=${error.message}`);
+            return false;
+        }
+    }
     // =========== 用户名更新检查 ===========
     /**
      * 检查并更新用户名（如果与当前数据库中的不同）

package/lib/services/nickname.service.js

@@ -28,7 +28,7 @@ class NicknameService {
         if (!nickname || !buidUsername)
             return false;
         // 期望格式：B站名称（ID:MC用户名）或 B站名称（ID:未绑定）
-        const mcInfo = mcUsername && !mcUsername.startsWith('_temp_') ? mcUsername : '未绑定';
+        const mcInfo = mcUsername || '未绑定';
         const expectedFormat = `${buidUsername}（ID:${mcInfo}）`;
         return nickname === expectedFormat;
     }
@@ -159,7 +159,7 @@ class NicknameService {
             const actualUserId = targetUserId || session.userId;
             const normalizedUserId = this.normalizeQQId(actualUserId);
             const targetGroupId = specifiedGroupId || this.config.autoNicknameGroupId;
-            const mcInfo = mcUsername && !mcUsername.startsWith('_temp_') ? mcUsername : '未绑定';
+            const mcInfo = mcUsername || '未绑定';
             this.logger.debug('群昵称设置', `开始处理QQ(${normalizedUserId})的群昵称设置，目标群: ${targetGroupId}`);
             // 检查前置条件
             if (!session.bot.internal) {

package/lib/types/database.d.ts

@@ -76,6 +76,10 @@ export interface MCIDBIND {
     lastActiveTime: Date;
     /** 随机提醒次数 (用于天选时刻等功能) */
     reminderCount: number;
+    /** 是否已绑定 Minecraft 账号 (true=已绑定有效MC账号, false=未绑定或临时状态) */
+    hasMcBind: boolean;
+    /** 是否已绑定 B站账号 (true=已绑定有效B站账号, false=未绑定) */
+    hasBuidBind: boolean;
 }
 /**
  * SCHEDULE_MUTE_TASKS表结构 - 定时禁言任务配置