koishi-plugin-bind-bot 2.2.4 → 2.2.6

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

@@ -21,13 +21,9 @@ export declare class BuidHandler extends BaseHandler {
      */
     private handleFindUser;
     /**
-     * 处理 mcid.bindbuid 命令
+     * 处理 buid.unbind 命令
      */
-    private handleBindBuid;
-    /**
-     * 处理 mcid.unbindbuid 命令
-     */
-    private handleUnbindBuid;
+    private handleUnbind;
     /**
      * 解析UID输入（支持多种格式）
      */

package/lib/handlers/buid.handler.js

@@ -37,17 +37,11 @@ class BuidHandler extends base_handler_1.BaseHandler {
             .action(async ({ session }, uid) => {
             return this.handleFindUser(session, uid);
         });
-        // mcid 命令组中的 BUID 相关子命令
-        const mcidCmd = this.ctx.command('mcid');
-        // 绑定B站账号（mcid.bindbuid）
-        mcidCmd
-            .subcommand('.bindbuid <buid:string>', '绑定B站账号')
-            .action(async ({ session }, buid) => {
-            return this.handleBindBuid(session, buid);
-        });
-        // 解绑B站账号（mcid.unbindbuid）
-        mcidCmd.subcommand('.unbindbuid', '解绑B站账号').action(async ({ session }) => {
-            return this.handleUnbindBuid(session);
+        // 解绑BUID
+        buidCmd
+            .subcommand('.unbind', '解绑B站账号')
+            .action(async ({ session }) => {
+            return this.handleUnbind(session);
         });
     }
     /**
@@ -71,12 +65,16 @@ class BuidHandler extends base_handler_1.BaseHandler {
                         : `您尚未绑定B站账号，请使用 ${this.deps.formatCommand('buid bind <UID>')} 进行绑定`)
                 ]);
             }
-            // 每次查询都刷新B站数据
+            // 每次查询都必须从API获取最新数据
             const buidUser = await this.validateBUID(bind.buidUid);
-            if (buidUser) {
-                await this.updateBuidInfoOnly(bind.qqId, buidUser);
-                bind = await this.repos.mcidbind.findByQQId(bind.qqId);
+            if (!buidUser) {
+                return this.deps.sendMessage(session, [
+                    koishi_1.h.text(`无法从API获取B站UID ${bind.buidUid} 的最新数据，该用户可能不存在或API服务暂时不可用`)
+                ]);
             }
+            // 更新本地数据库中的信息
+            await this.updateBuidInfoOnly(bind.qqId, buidUser);
+            bind = await this.repos.mcidbind.findByQQId(bind.qqId);
             const userInfo = `${target ? `用户 ${bind.qqId} 的` : '您的'}B站账号信息：\nB站UID: ${bind.buidUid}\n用户名: ${bind.buidUsername}`;
             let detailInfo = '';
             if (bind.guardLevel > 0) {
@@ -192,68 +190,9 @@ class BuidHandler extends base_handler_1.BaseHandler {
         }
     }
     /**
-     * 处理 mcid.bindbuid 命令
-     */
-    async handleBindBuid(session, buid) {
-        try {
-            const normalizedUserId = this.deps.normalizeQQId(session.userId);
-            this.logger.info('绑定', `QQ(${normalizedUserId})尝试绑定B站UID(${buid})`);
-            // 验证格式
-            if (!buid || !/^\d+$/.test(buid)) {
-                this.logger.warn('绑定', `QQ(${normalizedUserId})尝试绑定无效的B站UID格式: ${buid}`);
-                return this.deps.sendMessage(session, [koishi_1.h.text('无效的B站UID格式，请输入正确的B站UID')]);
-            }
-            // 检查是否已被他人绑定
-            const existingBind = await this.repos.mcidbind.findByBuidUid(buid);
-            if (existingBind) {
-                const existingQQId = existingBind.qqId;
-                this.logger.warn('绑定', `QQ(${normalizedUserId})尝试绑定已被QQ(${existingQQId})绑定的B站UID(${buid})`);
-                return this.deps.sendMessage(session, [koishi_1.h.text('该B站UID已被其他用户绑定')]);
-            }
-            // 验证B站UID
-            const buidUser = await this.validateBUID(buid);
-            if (!buidUser) {
-                this.logger.warn('绑定', `QQ(${normalizedUserId})尝试绑定不存在的B站UID(${buid})`);
-                return this.deps.sendMessage(session, [koishi_1.h.text('无法验证B站UID，请确认输入正确')]);
-            }
-            // 创建或更新绑定
-            const success = await this.createOrUpdateBuidBind(normalizedUserId, buidUser);
-            if (success) {
-                this.logger.info('绑定', `QQ(${normalizedUserId})成功绑定B站UID(${buid})`);
-                return this.deps.sendMessage(session, [
-                    koishi_1.h.text('成功绑定B站账号！\n'),
-                    koishi_1.h.text(`B站UID: ${buidUser.uid}\n`),
-                    koishi_1.h.text(`用户名: ${buidUser.username}\n`),
-                    buidUser.guard_level > 0
-                        ? koishi_1.h.text(`舰长等级: ${buidUser.guard_level_text} (${buidUser.guard_level})\n`)
-                        : null,
-                    buidUser.medal
-                        ? koishi_1.h.text(`粉丝牌: ${buidUser.medal.name} Lv.${buidUser.medal.level}\n`)
-                        : null,
-                    buidUser.wealthMedalLevel > 0
-                        ? koishi_1.h.text(`荣耀等级: ${buidUser.wealthMedalLevel}\n`)
-                        : null,
-                    ...(this.config?.showAvatar
-                        ? [koishi_1.h.image(`https://workers.vrp.moe/bilibili/avatar/${buidUser.uid}?size=160`)]
-                        : [])
-                ].filter(Boolean));
-            }
-            else {
-                this.logger.error('绑定', normalizedUserId, `QQ(${normalizedUserId})绑定B站UID(${buid})失败`);
-                return this.deps.sendMessage(session, [koishi_1.h.text('绑定失败，请稍后重试')]);
-            }
-        }
-        catch (error) {
-            this.logger.error('绑定', session.userId, error);
-            return this.deps.sendMessage(session, [
-                koishi_1.h.text(`绑定失败：${this.getFriendlyErrorMessage(error)}`)
-            ]);
-        }
-    }
-    /**
-     * 处理 mcid.unbindbuid 命令
+     * 处理 buid.unbind 命令
      */
-    async handleUnbindBuid(session) {
+    async handleUnbind(session) {
         try {
             const normalizedUserId = this.deps.normalizeQQId(session.userId);
             this.logger.info('解绑', `QQ(${normalizedUserId})尝试解绑B站账号`);

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

@@ -175,21 +175,37 @@ class GroupRequestReviewHandler extends base_handler_1.BaseHandler {
         this.logger.debug('入群审批', `[DEBUG] parseUID结果: ${parsedUid ? parsedUid : 'null'}`);
         if (parsedUid) {
             buidUid = parsedUid;
-            // 并行查询官方API和ZMINFO API
-            const [officialInfo, zminfoData] = await Promise.all([
-                this.deps.apiService.getBilibiliOfficialUserInfo(parsedUid).catch(() => null),
-                this.deps.apiService.validateBUID(parsedUid).catch(() => null)
-            ]);
-            // 用户名：优先使用官方API（最准确），降级到ZMINFO
-            if (officialInfo?.name) {
-                buidUsername = officialInfo.name;
-                this.logger.debug('入群审批', `✅ 使用官方API用户名: ${buidUsername}`);
-            }
-            else if (zminfoData?.username) {
-                buidUsername = zminfoData.username;
-                this.logger.debug('入群审批', `⚠️ 官方API失败，使用ZMINFO用户名: ${buidUsername}`);
-            }
-            // 粉丝牌信息：只能从ZMINFO获取（官方API不提供）
+            // 尝试使用强制绑定模式获取完整信息（避免频率限制）
+            let zminfoData = null;
+            if (this.config.forceBindSessdata) {
+                try {
+                    this.logger.debug('入群审批', '使用强制绑定模式获取用户信息...');
+                    const enhancedUser = await this.deps.forceBinder.forceBindUser(parsedUid);
+                    const standardUser = this.deps.forceBinder.convertToZminfoUser(enhancedUser);
+                    buidUsername = standardUser.username;
+                    zminfoData = standardUser;
+                    this.logger.debug('入群审批', `✅ 强制绑定模式获取成功: ${buidUsername}`);
+                }
+                catch (error) {
+                    this.logger.warn('入群审批', `强制绑定获取用户信息失败: ${error.message}，降级到ZMINFO`);
+                    // 降级：使用ZMINFO
+                    zminfoData = await this.deps.apiService.validateBUID(parsedUid).catch(() => null);
+                    if (zminfoData) {
+                        buidUsername = zminfoData.username;
+                        this.logger.debug('入群审批', `⚠️ 降级到ZMINFO用户名: ${buidUsername}`);
+                    }
+                }
+            }
+            else {
+                // 未配置Cookie，直接使用ZMINFO
+                this.logger.debug('入群审批', '未配置强制绑定Cookie，使用ZMINFO获取用户信息...');
+                zminfoData = await this.deps.apiService.validateBUID(parsedUid).catch(() => null);
+                if (zminfoData) {
+                    buidUsername = zminfoData.username;
+                    this.logger.debug('入群审批', `✅ ZMINFO用户名: ${buidUsername}`);
+                }
+            }
+            // 粉丝牌信息：从ZMINFO或强制绑定结果获取
             if (zminfoData) {
                 const medalLevel = zminfoData.medal?.level || 0;
                 const medalName = zminfoData.medal?.name || '';
@@ -204,7 +220,7 @@ class GroupRequestReviewHandler extends base_handler_1.BaseHandler {
                 }
             }
             else {
-                this.logger.warn('入群审批', 'ZMINFO API查询失败，无法获取粉丝牌信息');
+                this.logger.warn('入群审批', 'B站用户信息查询失败，无法获取粉丝牌信息');
             }
             // 绑定状态：查询数据库
             if (buidUsername) {
@@ -222,7 +238,7 @@ class GroupRequestReviewHandler extends base_handler_1.BaseHandler {
                 }
             }
             else {
-                bindStatus = '❌ UID 查询失败（官方API和ZMINFO均失败）';
+                bindStatus = '❌ UID 查询失败';
             }
         }
         return { qq, nickname, avatar, answer, buidUid, buidUsername, medalInfo, bindStatus };
@@ -319,17 +335,7 @@ class GroupRequestReviewHandler extends base_handler_1.BaseHandler {
      */
     async approveAndAutoBind(pendingReq, operatorId, session) {
         try {
-            // 1. 批准入群
-            await session.bot.handleGuildMemberRequest(pendingReq.requestFlag, true, '欢迎加入！');
-            this.logger.info('入群审批', `已批准入群 - QQ: ${pendingReq.applicantQQ}`, true);
-            // 2. 等待用户进群
-            const joined = await this.waitForUserJoin(pendingReq.applicantQQ, pendingReq.targetGroupId, 10000);
-            if (!joined) {
-                await this.notifyAdmin(operatorId, session, `⚠️ 已批准 ${pendingReq.applicantQQ} 入群，但用户未在10秒内进群`);
-                pendingReq.status = 'approved';
-                return;
-            }
-            // 3. 解析UID
+            // 1. 解析UID（在批准入群前先检查）
             const uid = this.parseUID(pendingReq.answer);
             if (!uid) {
                 await this.notifyAdmin(operatorId, session, `⚠️ 无法解析UID"${pendingReq.answer}"，请手动处理\n申请人: ${pendingReq.applicantQQ}`);
@@ -337,10 +343,19 @@ class GroupRequestReviewHandler extends base_handler_1.BaseHandler {
                 return;
             }
             this.logger.info('入群审批', `开始自动绑定 - QQ: ${pendingReq.applicantQQ}, UID: ${uid}`);
-            // 4. 调用 BuidHandler 的绑定逻辑（需要从 handlers 获取）
-            // 注意：这里需要访问其他 handler，可能需要调整架构
-            // 暂时先记录日志，稍后实现具体绑定逻辑
+            // 2. 先执行绑定（在批准入群前）
             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;
+            }
             // 5. 通知管理员
             await this.notifyAdmin(operatorId, session, `✅ 已批准 ${pendingReq.applicantQQ} 入群并完成自动绑定\nUID: ${uid}`);
             pendingReq.status = 'approved';
@@ -582,34 +597,16 @@ class GroupRequestReviewHandler extends base_handler_1.BaseHandler {
      */
     async performAutoBind(qq, uid, bot) {
         try {
-            // 1. 使用双API数据源获取最新用户信息（优先B站官方API）
+            // 1. 使用强制绑定模式获取最新用户信息（避免频率限制）
             this.logger.debug('入群审批', `开始获取 B站 UID ${uid} 的信息`);
-            // 尝试获取B站官方API的用户信息（最权威）
-            let officialUsername = null;
-            try {
-                this.logger.debug('入群审批', '正在查询B站官方API...');
-                const officialInfo = await this.deps.apiService.getBilibiliOfficialUserInfo(uid);
-                if (officialInfo && officialInfo.name) {
-                    officialUsername = officialInfo.name;
-                    this.logger.info('入群审批', `[官方API] ✅ 获取到用户名: "${officialUsername}"`, true);
-                }
-                else {
-                    this.logger.warn('入群审批', '[官方API] ❌ 查询失败');
-                }
-            }
-            catch (officialError) {
-                this.logger.warn('入群审批', `[官方API] ❌ 查询出错: ${officialError.message}`);
-            }
-            // 获取ZMINFO API的完整用户信息（包含粉丝牌、大航海等数据）
-            this.logger.debug('入群审批', '正在查询ZMINFO API...');
-            const zminfoUser = await this.deps.apiService.validateBUID(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.debug('入群审批', `[ZMINFO] 获取到用户名: "${zminfoUser.username}"`);
-            // 使用官方API的用户名（如果可用），否则使用ZMINFO的
-            const finalUsername = officialUsername || zminfoUser.username;
-            this.logger.info('入群审批', `🎯 最终采用用户名: "${finalUsername}"`, true);
+            this.logger.info('入群审批', `✅ 获取到用户名: "${zminfoUser.username}"`, true);
             // 2. 检查是否已被其他人绑定
             const existingBind = await this.repos.mcidbind.findByBuidUid(uid);
             if (existingBind && existingBind.qqId !== qq) {
@@ -624,7 +621,7 @@ class GroupRequestReviewHandler extends base_handler_1.BaseHandler {
                     mcUsername: null,
                     mcUuid: null,
                     buidUid: zminfoUser.uid,
-                    buidUsername: finalUsername,
+                    buidUsername: zminfoUser.username,
                     guardLevel: zminfoUser.guard_level || 0,
                     guardLevelText: zminfoUser.guard_level_text || '',
                     maxGuardLevel: zminfoUser.guard_level || 0,
@@ -643,7 +640,7 @@ class GroupRequestReviewHandler extends base_handler_1.BaseHandler {
                 // 更新现有绑定
                 await this.repos.mcidbind.update(qq, {
                     buidUid: zminfoUser.uid,
-                    buidUsername: finalUsername,
+                    buidUsername: zminfoUser.username,
                     guardLevel: zminfoUser.guard_level || 0,
                     guardLevelText: zminfoUser.guard_level_text || '',
                     maxGuardLevel: Math.max(bind.maxGuardLevel || 0, zminfoUser.guard_level || 0),
@@ -663,7 +660,7 @@ class GroupRequestReviewHandler extends base_handler_1.BaseHandler {
             try {
                 const groupId = this.reviewConfig.targetGroupId;
                 const mcInfo = bind_status_1.BindStatus.getDisplayMcUsername(bind, '未绑定');
-                const nickname = `${finalUsername}（ID:${mcInfo}）`;
+                const nickname = `${zminfoUser.username}（ID:${mcInfo}）`;
                 await bot.internal.setGroupCard(groupId, qq, nickname);
                 this.logger.info('入群审批', `已更新群昵称 - QQ: ${qq}, 昵称: ${nickname}`);
             }
@@ -671,7 +668,7 @@ class GroupRequestReviewHandler extends base_handler_1.BaseHandler {
                 this.logger.warn('入群审批', `更新群昵称失败: ${error.message}`);
                 // 昵称更新失败不影响绑定
             }
-            this.logger.info('入群审批', `自动绑定完成 - QQ: ${qq}, UID: ${uid}, 用户名: ${finalUsername}`, true);
+            this.logger.info('入群审批', `自动绑定完成 - QQ: ${qq}, UID: ${uid}, 用户名: ${zminfoUser.username}`, true);
         }
         catch (error) {
             this.logger.error('入群审批', `自动绑定失败: ${error.message}`, error);

package/lib/index.js

@@ -428,6 +428,18 @@ function apply(ctx, config) {
             logger.info(`[新人绑定] 用户QQ(${normalizedUserId})加入群聊，准备发送绑定提醒`);
             // 检查用户是否已有绑定记录
             const existingBind = await services.database.getMcBindByQQId(normalizedUserId);
+            // 检查是否刚刚通过入群审批的自动绑定完成（lastModified 在最近 15 秒内且已绑定 B 站）
+            const isRecentAutoBind = existingBind &&
+                existingBind.lastModified &&
+                Date.now() - new Date(existingBind.lastModified).getTime() < 15000 &&
+                bind_status_1.BindStatus.hasValidBuidBind(existingBind);
+            if (isRecentAutoBind) {
+                // 刚刚完成自动绑定，只发送欢迎消息，不启动交互式绑定
+                logger.info(`[新人绑定] 用户QQ(${normalizedUserId})刚刚通过入群审批完成自动绑定，仅发送欢迎消息`);
+                const welcomeMessage = `🎉 欢迎 ${koishi_1.h.at(session.userId)} 加入群聊！\n\n✅ 您的B站账号已自动绑定完成\nB站: ${existingBind.buidUsername}\n\n💡 使用 ${formatCommand('mcid bind <用户名>')} 可绑定MC账号`;
+                await session.bot.sendMessage(session.channelId, welcomeMessage);
+                return;
+            }
             // 如果用户已完成全部绑定，不需要提醒
             if (bind_status_1.BindStatus.hasCompletedAllBinds(existingBind)) {
                 logger.info(`[新人绑定] 用户QQ(${normalizedUserId})已完成全部绑定，跳过提醒`);

package/package.json

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