koishi-plugin-bind-bot 2.2.8 → 2.2.9

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

@@ -8,6 +8,34 @@ import { LoggerService } from '../utils/logger';
 export declare class BindingHandler extends BaseHandler {
     private readonly BINDING_SESSION_TIMEOUT;
     constructor(ctx: Context, config: any, logger: LoggerService, repos: Repositories, deps: HandlerDependencies);
+    /**
+     * 格式化绑定信息
+     * @param bind 绑定记录
+     * @param prefix 前缀文本
+     * @returns 格式化后的绑定信息
+     */
+    private formatBindInfo;
+    /**
+     * 处理已完成全部绑定的场景
+     */
+    private handleCompletedBinds;
+    /**
+     * 处理只绑定MC未绑定B站的场景
+     */
+    private handleMcOnlyBind;
+    /**
+     * 处理只绑定B站未绑定MC的场景
+     */
+    private handleBuidOnlyBind;
+    /**
+     * 处理都未绑定的场景
+     */
+    private handleNoBind;
+    /**
+     * 处理绑定流程
+     * @param ctx 绑定流程上下文
+     */
+    private handleBindingFlow;
     /**
      * 注册交互式绑定命令
      */

package/lib/handlers/binding.handler.js

@@ -15,6 +15,156 @@ class BindingHandler extends base_handler_1.BaseHandler {
         // 从配置中获取会话超时时间，默认3分钟
         this.BINDING_SESSION_TIMEOUT = 3 * 60 * 1000;
     }
+    /**
+     * 格式化绑定信息
+     * @param bind 绑定记录
+     * @param prefix 前缀文本
+     * @returns 格式化后的绑定信息
+     */
+    formatBindInfo(bind, prefix = '') {
+        const displayUsername = bind_status_1.BindStatus.getDisplayMcUsername(bind, '未绑定');
+        let bindInfo = `${prefix}\n✅ MC账号: ${displayUsername}\n✅ B站账号: ${bind.buidUsername} (UID: ${bind.buidUid})`;
+        if (bind.guardLevel > 0) {
+            bindInfo += `\n舰长等级: ${bind.guardLevelText}`;
+        }
+        if (bind.medalName) {
+            bindInfo += `\n粉丝牌: ${bind.medalName} Lv.${bind.medalLevel}`;
+        }
+        return bindInfo;
+    }
+    /**
+     * 处理已完成全部绑定的场景
+     */
+    async handleCompletedBinds(ctx, bind) {
+        const { session, userId, isAdminAction } = ctx;
+        this.logger.info('交互绑定', `QQ(${userId})已完成全部绑定`, true);
+        const prefix = isAdminAction
+            ? `用户 ${userId} 已完成全部账号绑定：`
+            : '您已完成全部账号绑定：';
+        let bindInfo = this.formatBindInfo(bind, prefix);
+        // 用户自己绑定时显示修改提示
+        if (!isAdminAction) {
+            bindInfo += `\n\n如需修改绑定信息，请使用：\n- ${this.deps.formatCommand('mcid change <新用户名>')} 修改MC账号\n- ${this.deps.formatCommand('buid bind <新UID>')} 修改B站账号`;
+        }
+        await this.deps.sendMessage(session, [koishi_1.h.text(bindInfo)]);
+    }
+    /**
+     * 处理只绑定MC未绑定B站的场景
+     */
+    async handleMcOnlyBind(ctx, bind) {
+        const { session, userId, rawUserId, channelId, isAdminAction } = ctx;
+        this.logger.info('交互绑定', `QQ(${userId})已绑定MC，进入B站绑定流程`, true);
+        const displayUsername = bind_status_1.BindStatus.getDisplayMcUsername(bind, '未绑定');
+        if (isAdminAction) {
+            // 管理员操作：更新会话状态并@目标用户
+            this.deps.updateBindingSession(rawUserId, channelId, {
+                state: 'waiting_buid',
+                mcUsername: bind.mcUsername,
+                mcUuid: bind.mcUuid
+            });
+            await this.deps.sendMessage(session, [
+                koishi_1.h.at(userId),
+                koishi_1.h.text(` 管理员为您启动了B站绑定流程\n🎮 已绑定MC: ${displayUsername}\n🔗 请发送您的B站UID`)
+            ]);
+        }
+        else {
+            // 用户自己操作：创建带超时的会话
+            const timeout = setTimeout(() => {
+                this.deps.bindingSessions.delete(`${userId}_${channelId}`);
+                this.ctx.bots.forEach(bot => {
+                    bot
+                        .sendMessage(channelId, [
+                        koishi_1.h.at(userId),
+                        koishi_1.h.text(' 绑定会话已超时，请重新开始绑定流程\n\n⚠️ 温馨提醒：若在管理员多次提醒后仍不配合绑定账号信息，将按群规进行相应处理。')
+                    ])
+                        .catch(() => { });
+                });
+                this.logger.info('交互绑定', `QQ(${userId})的绑定会话因超时被清理`, true);
+            }, this.BINDING_SESSION_TIMEOUT);
+            const sessionData = {
+                userId: rawUserId,
+                channelId: channelId,
+                state: 'waiting_buid',
+                startTime: Date.now(),
+                timeout: timeout,
+                mcUsername: bind.mcUsername,
+                mcUuid: bind.mcUuid
+            };
+            this.deps.bindingSessions.set(`${userId}_${channelId}`, sessionData);
+            await this.deps.sendMessage(session, [
+                koishi_1.h.text(`🎮 已绑定MC: ${displayUsername}\n🔗 请发送您的B站UID`)
+            ]);
+        }
+    }
+    /**
+     * 处理只绑定B站未绑定MC的场景
+     */
+    async handleBuidOnlyBind(ctx, bind) {
+        const { session, userId, rawUserId, channelId, isAdminAction } = ctx;
+        this.logger.info('交互绑定', `QQ(${userId})${isAdminAction ? '已' : '只'}绑定${isAdminAction ? 'B站' : '了B站'}，进入MC绑定流程`, true);
+        if (isAdminAction) {
+            // 管理员操作：更新会话状态并@目标用户
+            this.deps.updateBindingSession(rawUserId, channelId, {
+                state: 'waiting_mc_username',
+                buidUid: bind.buidUid,
+                buidUsername: bind.buidUsername
+            });
+            await this.deps.sendMessage(session, [
+                koishi_1.h.at(userId),
+                koishi_1.h.text(` 管理员为您启动了MC绑定流程\n✅ 已绑定B站: ${bind.buidUsername}\n🎮 请发送您的MC用户名，或发送"跳过"保持当前状态`)
+            ]);
+        }
+        else {
+            // 用户自己操作：创建会话并更新状态
+            this.deps.createBindingSession(rawUserId, channelId, 'waiting_mc_username');
+            const bindingSession = this.deps.getBindingSession(rawUserId, channelId);
+            bindingSession.state = 'waiting_mc_username';
+            await this.deps.sendMessage(session, [
+                koishi_1.h.text(`✅ 已绑定B站: ${bind.buidUsername}\n🎮 请发送您的MC用户名，或发送"跳过"保持当前状态`)
+            ]);
+        }
+    }
+    /**
+     * 处理都未绑定的场景
+     */
+    async handleNoBind(ctx) {
+        const { session, userId, isAdminAction } = ctx;
+        const messageElements = isAdminAction
+            ? [
+                koishi_1.h.at(userId),
+                koishi_1.h.text(' 管理员为您启动了账号绑定流程\n📋 请选择绑定方式：\n1. 发送您的B站UID进行B站绑定\n2. 发送"跳过"仅绑定MC账号')
+            ]
+            : [koishi_1.h.text('📋 请选择绑定方式：\n1. 发送您的B站UID进行B站绑定\n2. 发送"跳过"仅绑定MC账号')];
+        await this.deps.sendMessage(session, messageElements);
+    }
+    /**
+     * 处理绑定流程
+     * @param ctx 绑定流程上下文
+     */
+    async handleBindingFlow(ctx) {
+        const { userId, rawUserId, channelId, bind, isAdminAction } = ctx;
+        // 场景1: 已完成全部绑定
+        if (bind_status_1.BindStatus.hasCompletedAllBinds(bind)) {
+            return this.handleCompletedBinds(ctx, bind);
+        }
+        // 创建绑定会话（用户自己绑定时在后续场景中创建）
+        if (isAdminAction) {
+            this.deps.createBindingSession(rawUserId, channelId, 'waiting_buid');
+        }
+        // 场景2: 只绑定MC → 进入B站绑定流程
+        if (bind_status_1.BindStatus.hasOnlyMcBind(bind)) {
+            return this.handleMcOnlyBind(ctx, bind);
+        }
+        // 场景3: 只绑定B站 → 进入MC绑定流程
+        if (bind_status_1.BindStatus.hasOnlyBuidBind(bind)) {
+            return this.handleBuidOnlyBind(ctx, bind);
+        }
+        // 场景4: 都未绑定 → 显示选择菜单
+        if (!isAdminAction) {
+            this.deps.createBindingSession(rawUserId, channelId, 'waiting_buid');
+        }
+        return this.handleNoBind(ctx);
+    }
     /**
      * 注册交互式绑定命令
      */
@@ -58,48 +208,16 @@ class BindingHandler extends base_handler_1.BaseHandler {
                             koishi_1.h.text(`用户 ${normalizedTargetId} 已有进行中的绑定会话`)
                         ]);
                     }
-                    // 检查目标用户当前绑定状态
+                    // 检查目标用户当前绑定状态并处理绑定流程
                     const targetBind = await this.deps.databaseService.getMcBindByQQId(normalizedTargetId);
-                    // 如果两个账号都已绑定，不需要进入绑定流程
-                    if (bind_status_1.BindStatus.hasCompletedAllBinds(targetBind)) {
-                        this.logger.info('交互绑定', `QQ(${normalizedTargetId})已完成全部绑定`, true);
-                        // 显示当前绑定信息
-                        const displayUsername = bind_status_1.BindStatus.getDisplayMcUsername(targetBind, '未绑定');
-                        let bindInfo = `用户 ${normalizedTargetId} 已完成全部账号绑定：\n✅ MC账号: ${displayUsername}\n✅ B站账号: ${targetBind.buidUsername} (UID: ${targetBind.buidUid})`;
-                        if (targetBind.guardLevel > 0) {
-                            bindInfo += `\n舰长等级: ${targetBind.guardLevelText}`;
-                        }
-                        if (targetBind.medalName) {
-                            bindInfo += `\n粉丝牌: ${targetBind.medalName} Lv.${targetBind.medalLevel}`;
-                        }
-                        return this.deps.sendMessage(session, [koishi_1.h.text(bindInfo)]);
-                    }
-                    // 为目标用户创建绑定会话
-                    this.deps.createBindingSession(target, channelId, 'waiting_buid');
-                    // 如果已绑定MC但未绑定B站，直接进入B站绑定流程
-                    if (bind_status_1.BindStatus.hasValidMcBind(targetBind) && !bind_status_1.BindStatus.hasValidBuidBind(targetBind)) {
-                        this.logger.info('交互绑定', `QQ(${normalizedTargetId})已绑定MC，进入B站绑定流程`, true);
-                        // 更新会话状态
-                        this.deps.updateBindingSession(target, channelId, {
-                            state: 'waiting_buid',
-                            mcUsername: bind_status_1.BindStatus.hasValidMcBind(targetBind)
-                                ? targetBind.mcUsername
-                                : null,
-                            mcUuid: targetBind.mcUuid
-                        });
-                        // 向目标用户发送提示（@他们）
-                        const displayUsername = bind_status_1.BindStatus.getDisplayMcUsername(targetBind, '未绑定');
-                        await this.deps.sendMessage(session, [
-                            koishi_1.h.at(normalizedTargetId),
-                            koishi_1.h.text(` 管理员为您启动了B站绑定流程\n🎮 已绑定MC: ${displayUsername}\n🔗 请发送您的B站UID`)
-                        ]);
-                        return;
-                    }
-                    // 向目标用户发送提示（@他们）
-                    await this.deps.sendMessage(session, [
-                        koishi_1.h.at(normalizedTargetId),
-                        koishi_1.h.text(' 管理员为您启动了账号绑定流程\n📋 请选择绑定方式：\n1. 发送您的B站UID进行B站绑定\n2. 发送"跳过"仅绑定MC账号')
-                    ]);
+                    await this.handleBindingFlow({
+                        session,
+                        userId: normalizedTargetId,
+                        rawUserId: target,
+                        channelId,
+                        bind: targetBind,
+                        isAdminAction: true
+                    });
                     return;
                 }
                 // 为自己启动绑定流程
@@ -112,73 +230,16 @@ class BindingHandler extends base_handler_1.BaseHandler {
                         koishi_1.h.text('您已有进行中的绑定会话，请先完成当前绑定或等待会话超时')
                     ]);
                 }
-                // 检查用户当前绑定状态
+                // 检查用户当前绑定状态并处理绑定流程
                 const existingBind = await this.deps.databaseService.getMcBindByQQId(normalizedUserId);
-                // 如果两个账号都已绑定（且MC不是temp用户名），不需要进入绑定流程
-                if (existingBind && bind_status_1.BindStatus.hasValidMcBind(existingBind) && existingBind.buidUid) {
-                    this.logger.info('交互绑定', `QQ(${normalizedUserId})已完成全部绑定`, true);
-                    // 显示当前绑定信息
-                    const displayUsername = existingBind.mcUsername;
-                    let bindInfo = `您已完成全部账号绑定：\n✅ MC账号: ${displayUsername}\n✅ B站账号: ${existingBind.buidUsername} (UID: ${existingBind.buidUid})`;
-                    if (existingBind.guardLevel > 0) {
-                        bindInfo += `\n舰长等级: ${existingBind.guardLevelText}`;
-                    }
-                    if (existingBind.medalName) {
-                        bindInfo += `\n粉丝牌: ${existingBind.medalName} Lv.${existingBind.medalLevel}`;
-                    }
-                    bindInfo += `\n\n如需修改绑定信息，请使用：\n- ${this.deps.formatCommand('mcid change <新用户名>')} 修改MC账号\n- ${this.deps.formatCommand('buid bind <新UID>')} 修改B站账号`;
-                    return this.deps.sendMessage(session, [koishi_1.h.text(bindInfo)]);
-                }
-                // 如果已绑定MC（且不是temp用户名）但未绑定B站，直接进入B站绑定流程
-                if (existingBind && bind_status_1.BindStatus.hasValidMcBind(existingBind) && !existingBind.buidUid) {
-                    this.logger.info('交互绑定', `QQ(${normalizedUserId})已绑定MC，进入B站绑定流程`, true);
-                    // 创建绑定会话，状态直接设为等待B站UID
-                    const timeout = setTimeout(() => {
-                        this.deps.bindingSessions.delete(`${normalizedUserId}_${channelId}`);
-                        this.ctx.bots.forEach(bot => {
-                            bot
-                                .sendMessage(channelId, [
-                                koishi_1.h.at(normalizedUserId),
-                                koishi_1.h.text(' 绑定会话已超时，请重新开始绑定流程\n\n⚠️ 温馨提醒：若在管理员多次提醒后仍不配合绑定账号信息，将按群规进行相应处理。')
-                            ])
-                                .catch(() => { });
-                        });
-                        this.logger.info('交互绑定', `QQ(${normalizedUserId})的绑定会话因超时被清理`, true);
-                    }, this.BINDING_SESSION_TIMEOUT);
-                    const sessionData = {
-                        userId: session.userId,
-                        channelId: channelId,
-                        state: 'waiting_buid',
-                        startTime: Date.now(),
-                        timeout: timeout,
-                        mcUsername: existingBind.mcUsername,
-                        mcUuid: existingBind.mcUuid
-                    };
-                    this.deps.bindingSessions.set(`${normalizedUserId}_${channelId}`, sessionData);
-                    return this.deps.sendMessage(session, [
-                        koishi_1.h.text(`🎮 已绑定MC: ${existingBind.mcUsername}\n🔗 请发送您的B站UID`)
-                    ]);
-                }
-                // 如果只绑定了B站（MC是temp用户名），提醒绑定MC账号
-                if (existingBind &&
-                    existingBind.buidUid &&
-                    existingBind.buidUsername &&
-                    !bind_status_1.BindStatus.hasValidMcBind(existingBind)) {
-                    this.logger.info('交互绑定', `QQ(${normalizedUserId})只绑定了B站，进入MC绑定流程`, true);
-                    // 创建绑定会话，状态设为等待MC用户名
-                    this.deps.createBindingSession(session.userId, channelId, 'waiting_mc_username');
-                    const bindingSession = this.deps.getBindingSession(session.userId, channelId);
-                    bindingSession.state = 'waiting_mc_username';
-                    return this.deps.sendMessage(session, [
-                        koishi_1.h.text(`✅ 已绑定B站: ${existingBind.buidUsername}\n🎮 请发送您的MC用户名，或发送"跳过"保持当前状态`)
-                    ]);
-                }
-                // 如果未绑定账号，让用户选择绑定方式，优先B站绑定
-                this.deps.createBindingSession(session.userId, channelId, 'waiting_buid');
-                // 发送绑定选项提示
-                return this.deps.sendMessage(session, [
-                    koishi_1.h.text('📋 请选择绑定方式：\n1. 发送您的B站UID进行B站绑定\n2. 发送"跳过"仅绑定MC账号')
-                ]);
+                await this.handleBindingFlow({
+                    session,
+                    userId: normalizedUserId,
+                    rawUserId: session.userId,
+                    channelId,
+                    bind: existingBind,
+                    isAdminAction: false
+                });
             }
             catch (error) {
                 const normalizedUserId = this.deps.normalizeQQId(session.userId);

package/lib/handlers/group-request-review.handler.d.ts

@@ -87,9 +87,14 @@ export declare class GroupRequestReviewHandler extends BaseHandler {
      */
     private notifyAdmin;
     /**
-     * 执行自动绑定
+     * 执行自动绑定（仅数据库操作，不设置昵称）
+     * @returns 绑定信息，包含B站用户名和MC用户名
      */
     private performAutoBind;
+    /**
+     * 用户进群后设置群昵称
+     */
+    private setGroupNicknameAfterJoin;
     /**
      * 定时清理过期记录
      */

package/lib/handlers/group-request-review.handler.js

@@ -292,7 +292,7 @@ class GroupRequestReviewHandler extends base_handler_1.BaseHandler {
         else {
             elements.push(koishi_1.h.text(`⚠️ 未提供有效的 B 站 UID\n\n`));
         }
-        elements.push(koishi_1.h.text('请点击表情回应：\n'), koishi_1.h.text('👍 - 通过并自动绑定\n'), koishi_1.h.text('😊 - 通过并交互式绑定\n'), koishi_1.h.text('❌ - 拒绝申请'));
+        elements.push(koishi_1.h.text('请点击表情回应：\n'), koishi_1.h.text('/赞 - 通过并自动绑定\n'), koishi_1.h.text('/OK - 通过并交互式绑定\n'), koishi_1.h.text('/NO - 拒绝申请'));
         try {
             const result = await session.bot.sendMessage(this.reviewConfig.reviewGroupId, elements);
             // result 通常是数组，第一个元素是消息ID
@@ -366,21 +366,23 @@ class GroupRequestReviewHandler extends base_handler_1.BaseHandler {
                 return;
             }
             this.logger.info('入群审批', `开始自动绑定 - QQ: ${pendingReq.applicantQQ}, UID: ${uid}`);
-            // 2. 先执行绑定（在批准入群前）
-            await this.performAutoBind(pendingReq.applicantQQ, uid, session.bot);
+            // 2. 先执行绑定（在批准入群前，仅数据库操作，不设置昵称）
+            const bindResult = await this.performAutoBind(pendingReq.applicantQQ, uid, session.bot);
             this.logger.info('入群审批', `预绑定完成 - QQ: ${pendingReq.applicantQQ}, UID: ${uid}`);
             // 3. 批准入群
             await session.bot.handleGuildMemberRequest(pendingReq.requestFlag, true, '欢迎加入！');
             this.logger.info('入群审批', `已批准入群 - QQ: ${pendingReq.applicantQQ}`, true);
             // 4. 等待用户进群
             const joined = await this.waitForUserJoin(pendingReq.applicantQQ, pendingReq.targetGroupId, 10000);
-            if (!joined) {
-                await this.notifyAdmin(operatorId, session, `⚠️ 已完成绑定并批准 ${pendingReq.applicantQQ} 入群，但用户未在10秒内进群`);
-                pendingReq.status = 'approved';
-                return;
+            if (joined) {
+                // 5. 用户进群后再设置群昵称
+                await this.setGroupNicknameAfterJoin(pendingReq.applicantQQ, bindResult.buidUsername, bindResult.mcUsername, session.bot);
+                // 6. 通知管理员
+                await this.notifyAdmin(operatorId, session, `✅ 已批准 ${pendingReq.applicantQQ} 入群并完成自动绑定\nUID: ${uid}`);
+            }
+            else {
+                await this.notifyAdmin(operatorId, session, `⚠️ 已完成绑定并批准 ${pendingReq.applicantQQ} 入群，但用户未在10秒内进群\n昵称将在用户进群后由系统自动设置`);
             }
-            // 5. 通知管理员
-            await this.notifyAdmin(operatorId, session, `✅ 已批准 ${pendingReq.applicantQQ} 入群并完成自动绑定\nUID: ${uid}`);
             pendingReq.status = 'approved';
         }
         catch (error) {
@@ -605,86 +607,92 @@ class GroupRequestReviewHandler extends base_handler_1.BaseHandler {
         }
     }
     /**
-     * 执行自动绑定
+     * 执行自动绑定（仅数据库操作，不设置昵称）
+     * @returns 绑定信息，包含B站用户名和MC用户名
      */
     async performAutoBind(qq, uid, bot) {
+        // 1. 使用强制绑定模式获取最新用户信息（避免频率限制）
+        this.logger.debug('入群审批', `开始获取 B站 UID ${uid} 的信息`);
+        // 使用强制绑定模式获取完整信息（与 bind -f 保持一致）
+        this.logger.debug('入群审批', '正在使用强制绑定模式获取B站用户信息...');
+        const enhancedUser = await this.deps.forceBinder.forceBindUser(uid);
+        const zminfoUser = this.deps.forceBinder.convertToZminfoUser(enhancedUser);
+        if (!zminfoUser) {
+            throw new Error(`无法验证B站UID: ${uid}`);
+        }
+        this.logger.info('入群审批', `✅ 获取到用户名: "${zminfoUser.username}"`, true);
+        // 2. 检查是否已被其他人绑定
+        const existingBind = await this.repos.mcidbind.findByBuidUid(uid);
+        if (existingBind && existingBind.qqId !== qq) {
+            throw new Error(`UID ${uid} 已被其他用户绑定`);
+        }
+        // 3. 获取或创建绑定记录
+        let bind = await this.repos.mcidbind.findByQQId(qq);
+        let mcUsername = null;
+        if (!bind) {
+            // 创建新绑定（不使用临时MC用户名）
+            bind = await this.repos.mcidbind.create({
+                qqId: qq,
+                mcUsername: null,
+                mcUuid: null,
+                buidUid: zminfoUser.uid,
+                buidUsername: zminfoUser.username,
+                guardLevel: zminfoUser.guard_level || 0,
+                guardLevelText: zminfoUser.guard_level_text || '',
+                maxGuardLevel: zminfoUser.guard_level || 0,
+                maxGuardLevelText: zminfoUser.guard_level_text || '',
+                medalName: zminfoUser.medal?.name || '',
+                medalLevel: zminfoUser.medal?.level || 0,
+                wealthMedalLevel: zminfoUser.wealthMedalLevel || 0,
+                lastActiveTime: new Date(),
+                lastModified: new Date(),
+                hasMcBind: false,
+                hasBuidBind: true
+            });
+            this.logger.info('入群审批', `已创建新绑定 - QQ: ${qq}, UID: ${uid}`, true);
+        }
+        else {
+            // 保存现有的MC用户名
+            mcUsername = bind_status_1.BindStatus.getDisplayMcUsername(bind, null);
+            // 更新现有绑定
+            await this.repos.mcidbind.update(qq, {
+                buidUid: zminfoUser.uid,
+                buidUsername: zminfoUser.username,
+                guardLevel: zminfoUser.guard_level || 0,
+                guardLevelText: zminfoUser.guard_level_text || '',
+                maxGuardLevel: Math.max(bind.maxGuardLevel || 0, zminfoUser.guard_level || 0),
+                maxGuardLevelText: zminfoUser.guard_level > (bind.maxGuardLevel || 0)
+                    ? zminfoUser.guard_level_text
+                    : bind.maxGuardLevelText,
+                medalName: zminfoUser.medal?.name || '',
+                medalLevel: zminfoUser.medal?.level || 0,
+                wealthMedalLevel: zminfoUser.wealthMedalLevel || 0,
+                lastActiveTime: new Date(),
+                lastModified: new Date(),
+                hasBuidBind: true
+            });
+            this.logger.info('入群审批', `已更新绑定 - QQ: ${qq}, UID: ${uid}`, true);
+        }
+        this.logger.info('入群审批', `自动绑定完成 - QQ: ${qq}, UID: ${uid}, 用户名: ${zminfoUser.username}`, true);
+        // 返回绑定信息供后续使用（昵称设置在用户进群后执行）
+        return {
+            buidUsername: zminfoUser.username,
+            mcUsername: mcUsername
+        };
+    }
+    /**
+     * 用户进群后设置群昵称
+     */
+    async setGroupNicknameAfterJoin(qq, buidUsername, mcUsername, bot) {
         try {
-            // 1. 使用强制绑定模式获取最新用户信息（避免频率限制）
-            this.logger.debug('入群审批', `开始获取 B站 UID ${uid} 的信息`);
-            // 使用强制绑定模式获取完整信息（与 bind -f 保持一致）
-            this.logger.debug('入群审批', '正在使用强制绑定模式获取B站用户信息...');
-            const enhancedUser = await this.deps.forceBinder.forceBindUser(uid);
-            const zminfoUser = this.deps.forceBinder.convertToZminfoUser(enhancedUser);
-            if (!zminfoUser) {
-                throw new Error(`无法验证B站UID: ${uid}`);
-            }
-            this.logger.info('入群审批', `✅ 获取到用户名: "${zminfoUser.username}"`, true);
-            // 2. 检查是否已被其他人绑定
-            const existingBind = await this.repos.mcidbind.findByBuidUid(uid);
-            if (existingBind && existingBind.qqId !== qq) {
-                throw new Error(`UID ${uid} 已被其他用户绑定`);
-            }
-            // 3. 获取或创建绑定记录
-            let bind = await this.repos.mcidbind.findByQQId(qq);
-            if (!bind) {
-                // 创建新绑定（不使用临时MC用户名）
-                bind = await this.repos.mcidbind.create({
-                    qqId: qq,
-                    mcUsername: null,
-                    mcUuid: null,
-                    buidUid: zminfoUser.uid,
-                    buidUsername: zminfoUser.username,
-                    guardLevel: zminfoUser.guard_level || 0,
-                    guardLevelText: zminfoUser.guard_level_text || '',
-                    maxGuardLevel: zminfoUser.guard_level || 0,
-                    maxGuardLevelText: zminfoUser.guard_level_text || '',
-                    medalName: zminfoUser.medal?.name || '',
-                    medalLevel: zminfoUser.medal?.level || 0,
-                    wealthMedalLevel: zminfoUser.wealthMedalLevel || 0,
-                    lastActiveTime: new Date(),
-                    lastModified: new Date(),
-                    hasMcBind: false,
-                    hasBuidBind: true
-                });
-                this.logger.info('入群审批', `已创建新绑定 - QQ: ${qq}, UID: ${uid}`, true);
-            }
-            else {
-                // 更新现有绑定
-                await this.repos.mcidbind.update(qq, {
-                    buidUid: zminfoUser.uid,
-                    buidUsername: zminfoUser.username,
-                    guardLevel: zminfoUser.guard_level || 0,
-                    guardLevelText: zminfoUser.guard_level_text || '',
-                    maxGuardLevel: Math.max(bind.maxGuardLevel || 0, zminfoUser.guard_level || 0),
-                    maxGuardLevelText: zminfoUser.guard_level > (bind.maxGuardLevel || 0)
-                        ? zminfoUser.guard_level_text
-                        : bind.maxGuardLevelText,
-                    medalName: zminfoUser.medal?.name || '',
-                    medalLevel: zminfoUser.medal?.level || 0,
-                    wealthMedalLevel: zminfoUser.wealthMedalLevel || 0,
-                    lastActiveTime: new Date(),
-                    lastModified: new Date(),
-                    hasBuidBind: true
-                });
-                this.logger.info('入群审批', `已更新绑定 - QQ: ${qq}, UID: ${uid}`, true);
-            }
-            // 4. 更新群昵称（使用标准格式）
-            try {
-                const groupId = this.reviewConfig.targetGroupId;
-                const mcInfo = bind_status_1.BindStatus.getDisplayMcUsername(bind, '未绑定');
-                const nickname = `${zminfoUser.username}（ID:${mcInfo}）`;
-                await bot.internal.setGroupCard(groupId, qq, nickname);
-                this.logger.info('入群审批', `已更新群昵称 - QQ: ${qq}, 昵称: ${nickname}`);
-            }
-            catch (error) {
-                this.logger.warn('入群审批', `更新群昵称失败: ${error.message}`);
-                // 昵称更新失败不影响绑定
-            }
-            this.logger.info('入群审批', `自动绑定完成 - QQ: ${qq}, UID: ${uid}, 用户名: ${zminfoUser.username}`, true);
+            const groupId = this.reviewConfig.targetGroupId;
+            const mcInfo = mcUsername || '未绑定';
+            const nickname = `${buidUsername}（ID:${mcInfo}）`;
+            await bot.internal.setGroupCard(groupId, qq, nickname);
+            this.logger.info('入群审批', `已更新群昵称 - QQ: ${qq}, 昵称: ${nickname}`);
         }
         catch (error) {
-            this.logger.error('入群审批', `自动绑定失败: ${error.message}`, error);
-            throw error;
+            this.logger.warn('入群审批', `更新群昵称失败: ${error.message}`);
         }
     }
     /**

package/lib/index.js

@@ -60,11 +60,11 @@ exports.Config = koishi_1.Schema.object({
         reviewGroupId: koishi_1.Schema.string()
             .description('管理员审批操作所在的群ID（播报群）'),
         approveAutoBindEmoji: koishi_1.Schema.string()
-            .description('批准并自动绑定的表情ID（/太赞了）')
-            .default('389'),
+            .description('批准并自动绑定的表情ID（/赞）')
+            .default('76'),
         approveInteractiveBindEmoji: koishi_1.Schema.string()
-            .description('批准并交互式绑定的表情ID（/偷感）')
-            .default('427'),
+            .description('批准并交互式绑定的表情ID（/OK）')
+            .default('124'),
         rejectEmoji: koishi_1.Schema.string().description('拒绝申请的表情ID（/NO）').default('123'),
         autoCleanupHours: koishi_1.Schema.number()
             .description('待审批记录自动清理时间（小时）')

package/lib/types/config.d.ts

@@ -134,9 +134,9 @@ export interface GroupRequestReviewConfig {
     targetGroupId: string;
     /** 管理员审批操作所在的群ID（播报群） */
     reviewGroupId: string;
-    /** 批准并自动绑定的表情ID（默认：389 /太赞了） */
+    /** 批准并自动绑定的表情ID（默认：76 /赞） */
     approveAutoBindEmoji: string;
-    /** 批准并交互式绑定的表情ID（默认：427 /偷感） */
+    /** 批准并交互式绑定的表情ID（默认：124 /OK） */
     approveInteractiveBindEmoji: string;
     /** 拒绝申请的表情ID（默认：123 /NO） */
     rejectEmoji: string;

package/lib/utils/bind-status.d.ts

@@ -79,6 +79,20 @@ export declare class BindStatus {
      * ```
      */
     static hasCompletedAllBinds(bind: MCIDBIND | null | undefined): boolean;
+    /**
+     * 检查是否只绑定了MC（未绑定B站）
+     *
+     * @param bind - 绑定记录（可为 null 或 undefined）
+     * @returns true 表示已绑定MC但未绑定B站
+     */
+    static hasOnlyMcBind(bind: MCIDBIND | null | undefined): boolean;
+    /**
+     * 检查是否只绑定了B站（未绑定MC）
+     *
+     * @param bind - 绑定记录（可为 null 或 undefined）
+     * @returns true 表示已绑定B站但未绑定MC
+     */
+    static hasOnlyBuidBind(bind: MCIDBIND | null | undefined): boolean;
     /**
      * 获取绑定状态摘要信息
      *

package/lib/utils/bind-status.js

@@ -111,6 +111,28 @@ class BindStatus {
     static hasCompletedAllBinds(bind) {
         return this.hasValidMcBind(bind) && this.hasValidBuidBind(bind);
     }
+    /**
+     * 检查是否只绑定了MC（未绑定B站）
+     *
+     * @param bind - 绑定记录（可为 null 或 undefined）
+     * @returns true 表示已绑定MC但未绑定B站
+     */
+    static hasOnlyMcBind(bind) {
+        return this.hasValidMcBind(bind) && !this.hasValidBuidBind(bind);
+    }
+    /**
+     * 检查是否只绑定了B站（未绑定MC）
+     *
+     * @param bind - 绑定记录（可为 null 或 undefined）
+     * @returns true 表示已绑定B站但未绑定MC
+     */
+    static hasOnlyBuidBind(bind) {
+        return (bind !== null &&
+            bind !== undefined &&
+            !!bind.buidUid &&
+            !!bind.buidUsername &&
+            !this.hasValidMcBind(bind));
+    }
     /**
      * 获取绑定状态摘要信息
      *

package/package.json

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