koishi-plugin-bind-bot 2.1.2 → 2.1.3

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

@@ -0,0 +1,97 @@
+import { BaseHandler } from './base.handler';
+/**
+ * 入群申请审批处理器
+ *
+ * @remarks
+ * 该处理器实现了通过表情回应审批入群申请的功能：
+ * - 监听指定群的入群申请
+ * - 生成播报消息到管理群
+ * - 自动添加表情选项
+ * - 处理管理员的表情回应
+ * - 执行批准/拒绝操作
+ * - 支持自动绑定和交互式绑定
+ */
+export declare class GroupRequestReviewHandler extends BaseHandler {
+    /** 待审批的申请记录 Map<broadcastMessageId, PendingRequest> */
+    private pendingRequests;
+    /** 拒绝流程状态 Map<askMessageId, RejectFlow> */
+    private rejectFlows;
+    /** 管理员权限缓存 Map<groupId, AdminCache> */
+    private adminCache;
+    /** 用户进群等待列表 Map<userId, resolve> */
+    private userJoinWaiters;
+    /** 配置 */
+    private reviewConfig;
+    /**
+     * 注册事件监听和中间件
+     */
+    register(): void;
+    /**
+     * 处理入群申请事件
+     */
+    private handleRequest;
+    /**
+     * 处理通知事件（包括表情回应）
+     */
+    private handleNotice;
+    /**
+     * 获取申请人信息
+     */
+    private getApplicantInfo;
+    /**
+     * 发送播报消息到管理群
+     */
+    private sendBroadcastMessage;
+    /**
+     * 自动添加表情回应选项
+     */
+    private addReactionOptions;
+    /**
+     * 处理表情回应动作
+     */
+    private handleEmojiReaction;
+    /**
+     * 批准并自动绑定
+     */
+    private approveAndAutoBind;
+    /**
+     * 批准并启动交互式绑定
+     */
+    private approveAndInteractiveBind;
+    /**
+     * 发起拒绝流程
+     */
+    private initRejectFlow;
+    /**
+     * 处理拒绝理由（中间件）
+     */
+    private handleRejectReason;
+    /**
+     * 处理用户成功进群事件
+     */
+    private handleUserJoined;
+    /**
+     * 等待用户进群
+     */
+    private waitForUserJoin;
+    /**
+     * 检查管理员权限
+     */
+    private checkAdminPermission;
+    /**
+     * 解析UID（支持多种格式）
+     */
+    private parseUID;
+    /**
+     * 通知管理员
+     */
+    private notifyAdmin;
+    /**
+     * 执行自动绑定
+     */
+    private performAutoBind;
+    /**
+     * 定时清理过期记录
+     */
+    private cleanupExpiredRecords;
+}

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

@@ -0,0 +1,582 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupRequestReviewHandler = void 0;
+const koishi_1 = require("koishi");
+const base_handler_1 = require("./base.handler");
+/**
+ * 入群申请审批处理器
+ *
+ * @remarks
+ * 该处理器实现了通过表情回应审批入群申请的功能：
+ * - 监听指定群的入群申请
+ * - 生成播报消息到管理群
+ * - 自动添加表情选项
+ * - 处理管理员的表情回应
+ * - 执行批准/拒绝操作
+ * - 支持自动绑定和交互式绑定
+ */
+class GroupRequestReviewHandler extends base_handler_1.BaseHandler {
+    /** 待审批的申请记录 Map<broadcastMessageId, PendingRequest> */
+    pendingRequests = new Map();
+    /** 拒绝流程状态 Map<askMessageId, RejectFlow> */
+    rejectFlows = new Map();
+    /** 管理员权限缓存 Map<groupId, AdminCache> */
+    adminCache = new Map();
+    /** 用户进群等待列表 Map<userId, resolve> */
+    userJoinWaiters = new Map();
+    /** 配置 */
+    reviewConfig;
+    /**
+     * 注册事件监听和中间件
+     */
+    register() {
+        // 检查功能是否启用
+        if (!this.config.groupRequestReview?.enabled) {
+            this.logger.info('入群审批', '功能未启用');
+            return;
+        }
+        this.reviewConfig = this.config.groupRequestReview;
+        this.logger.info('入群审批', '功能已启用');
+        this.logger.info('入群审批', `目标群: ${this.reviewConfig.targetGroupId}, 管理群: ${this.reviewConfig.reviewGroupId}`);
+        // 监听入群申请
+        this.ctx.on('guild-member-request', this.handleRequest.bind(this));
+        // 监听用户成功进群
+        this.ctx.on('guild-member-added', this.handleUserJoined.bind(this));
+        // 监听表情回应（NapCat扩展事件）
+        // 使用通用 'message' 事件监听，在 handleNotice 中过滤
+        this.ctx.on('message', this.handleNotice.bind(this));
+        // 中间件：处理拒绝理由
+        this.ctx.middleware(this.handleRejectReason.bind(this));
+        // 定时清理过期记录
+        this.ctx.setInterval(() => {
+            this.cleanupExpiredRecords();
+        }, 60 * 60 * 1000); // 每小时清理一次
+        this.logger.info('入群审批', '已注册所有事件监听器', true);
+    }
+    /**
+     * 处理入群申请事件
+     */
+    async handleRequest(session) {
+        try {
+            // 只处理目标群的申请
+            if (session.guildId !== this.reviewConfig.targetGroupId) {
+                return;
+            }
+            const normalizedUserId = this.deps.normalizeQQId(session.userId);
+            this.logger.info('入群审批', `收到申请 - QQ: ${normalizedUserId}, 群: ${session.guildId}`);
+            // 获取申请人信息
+            const applicantInfo = await this.getApplicantInfo(session);
+            // 生成播报消息并发送到管理群
+            const broadcastMsgId = await this.sendBroadcastMessage(applicantInfo, session);
+            if (!broadcastMsgId) {
+                this.logger.error('入群审批', '播报消息发送失败');
+                return;
+            }
+            // 保存待审批记录
+            const pendingReq = {
+                broadcastMessageId: broadcastMsgId,
+                requestFlag: session.messageId, // OneBot的请求标识
+                applicantQQ: normalizedUserId,
+                applicantNickname: applicantInfo.nickname,
+                applicantAvatar: applicantInfo.avatar,
+                targetGroupId: session.guildId,
+                answer: session.content || '',
+                timestamp: Date.now(),
+                status: 'pending'
+            };
+            this.pendingRequests.set(broadcastMsgId, pendingReq);
+            this.logger.info('入群审批', `已保存待审批记录 - 申请人: ${normalizedUserId}, 播报消息ID: ${broadcastMsgId}`, true);
+            // 自动添加表情回应选项
+            await this.addReactionOptions(broadcastMsgId, session.bot);
+        }
+        catch (error) {
+            this.logger.error('入群审批', `处理入群申请失败: ${error.message}`, error);
+        }
+    }
+    /**
+     * 处理通知事件（包括表情回应）
+     */
+    async handleNotice(session) {
+        try {
+            // 只处理群表情回应事件
+            if (session.subtype !== 'group-msg-emoji-like') {
+                return;
+            }
+            // 只处理管理群的表情
+            if (session.guildId !== this.reviewConfig.reviewGroupId) {
+                return;
+            }
+            // 获取原始事件数据（使用类型断言访问 onebot 扩展属性）
+            const sessionAny = session;
+            if (!sessionAny.onebot || !sessionAny.onebot.likes) {
+                return;
+            }
+            const emojiData = sessionAny.onebot.likes;
+            const msgId = session.messageId;
+            const operatorId = this.deps.normalizeQQId(session.userId);
+            this.logger.debug('入群审批', `收到表情回应 - 消息: ${msgId}, 操作者: ${operatorId}, 表情数: ${emojiData.length}`);
+            // 检查是否是待审批的消息
+            const pendingReq = this.pendingRequests.get(msgId);
+            if (!pendingReq) {
+                return;
+            }
+            // 检查是否已处理
+            if (pendingReq.status !== 'pending') {
+                this.logger.info('入群审批', `申请已处理，状态: ${pendingReq.status}`);
+                return;
+            }
+            // 检查操作者是否有管理权限
+            const hasPermission = await this.checkAdminPermission(operatorId, session.guildId, session.bot);
+            if (!hasPermission) {
+                this.logger.warn('入群审批', `权限不足 - 操作者: ${operatorId} 不是管理员`);
+                await this.deps.sendMessage(session, [koishi_1.h.text('⚠️ 只有管理员才能审批入群申请')]);
+                return;
+            }
+            // 标记为处理中，防止重复操作
+            pendingReq.status = 'processing';
+            // 处理表情回应
+            await this.handleEmojiReaction(emojiData, pendingReq, operatorId, session);
+        }
+        catch (error) {
+            this.logger.error('入群审批', `处理表情回应失败: ${error.message}`, error);
+        }
+    }
+    /**
+     * 获取申请人信息
+     */
+    async getApplicantInfo(session) {
+        const qq = this.deps.normalizeQQId(session.userId);
+        const answer = session.content || '（未填写）';
+        // 尝试获取用户信息
+        let nickname = qq;
+        let avatar = `http://q.qlogo.cn/headimg_dl?dst_uin=${qq}&spec=640`;
+        try {
+            // 使用 bot.getUser 获取用户信息（如果可用）
+            if (session.bot.getUser) {
+                const userInfo = await session.bot.getUser(qq);
+                if (userInfo.username) {
+                    nickname = userInfo.username;
+                }
+                if (userInfo.avatar) {
+                    avatar = userInfo.avatar;
+                }
+            }
+        }
+        catch (error) {
+            this.logger.warn('入群审批', `获取用户信息失败，使用默认值: ${error.message}`);
+        }
+        return { qq, nickname, avatar, answer };
+    }
+    /**
+     * 发送播报消息到管理群
+     */
+    async sendBroadcastMessage(applicantInfo, session) {
+        const { qq, nickname, avatar, answer } = applicantInfo;
+        const elements = [
+            koishi_1.h.text('📢 收到新的入群申请\n\n'),
+            koishi_1.h.image(avatar),
+            koishi_1.h.text(`\n👤 昵称：${nickname}\n`),
+            koishi_1.h.text(`🆔 QQ号：${qq}\n`),
+            koishi_1.h.text(`💬 回答：${answer}\n\n`),
+            koishi_1.h.text('━━━━━━━━━━━━━━━\n'),
+            koishi_1.h.text('请管理员点击表情回应：\n'),
+            koishi_1.h.text('👍 /太赞了 - 通过并自动绑定\n'),
+            koishi_1.h.text('😊 /偷感 - 通过并交互式绑定\n'),
+            koishi_1.h.text('❌ /NO - 拒绝申请')
+        ];
+        try {
+            const result = await session.bot.sendMessage(this.reviewConfig.reviewGroupId, elements);
+            // result 通常是数组，第一个元素是消息ID
+            if (Array.isArray(result) && result.length > 0) {
+                return result[0];
+            }
+            return null;
+        }
+        catch (error) {
+            this.logger.error('入群审批', `发送播报消息失败: ${error.message}`, error);
+            return null;
+        }
+    }
+    /**
+     * 自动添加表情回应选项
+     */
+    async addReactionOptions(messageId, bot) {
+        const emojis = [
+            this.reviewConfig.approveAutoBindEmoji,
+            this.reviewConfig.approveInteractiveBindEmoji,
+            this.reviewConfig.rejectEmoji
+        ];
+        for (const emojiId of emojis) {
+            try {
+                await bot.internal.setMsgEmojiLike(messageId, emojiId);
+                this.logger.debug('入群审批', `已添加表情: ${emojiId}`);
+                // 避免频繁调用
+                await new Promise(resolve => setTimeout(resolve, 200));
+            }
+            catch (error) {
+                this.logger.error('入群审批', `添加表情失败 - ID: ${emojiId}, 错误: ${error.message}`);
+            }
+        }
+    }
+    /**
+     * 处理表情回应动作
+     */
+    async handleEmojiReaction(emojiData, pendingReq, operatorId, session) {
+        for (const emoji of emojiData) {
+            const emojiId = emoji.emoji_id;
+            if (emojiId === this.reviewConfig.approveAutoBindEmoji) {
+                // /太赞了 - 自动绑定
+                this.logger.info('入群审批', `执行自动绑定 - 申请人: ${pendingReq.applicantQQ}`);
+                await this.approveAndAutoBind(pendingReq, operatorId, session);
+                break;
+            }
+            else if (emojiId === this.reviewConfig.approveInteractiveBindEmoji) {
+                // /偷感 - 交互式绑定
+                this.logger.info('入群审批', `执行交互式绑定 - 申请人: ${pendingReq.applicantQQ}`);
+                await this.approveAndInteractiveBind(pendingReq, operatorId, session);
+                break;
+            }
+            else if (emojiId === this.reviewConfig.rejectEmoji) {
+                // /NO - 拒绝
+                this.logger.info('入群审批', `发起拒绝流程 - 申请人: ${pendingReq.applicantQQ}`);
+                await this.initRejectFlow(pendingReq, operatorId, session);
+                break;
+            }
+        }
+    }
+    /**
+     * 批准并自动绑定
+     */
+    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
+            const uid = this.parseUID(pendingReq.answer);
+            if (!uid) {
+                await this.notifyAdmin(operatorId, session, `⚠️ 无法解析UID"${pendingReq.answer}"，请手动处理\n申请人: ${pendingReq.applicantQQ}`);
+                pendingReq.status = 'approved';
+                return;
+            }
+            this.logger.info('入群审批', `开始自动绑定 - QQ: ${pendingReq.applicantQQ}, UID: ${uid}`);
+            // 4. 调用 BuidHandler 的绑定逻辑（需要从 handlers 获取）
+            // 注意：这里需要访问其他 handler，可能需要调整架构
+            // 暂时先记录日志，稍后实现具体绑定逻辑
+            await this.performAutoBind(pendingReq.applicantQQ, uid, session.bot);
+            // 5. 通知管理员
+            await this.notifyAdmin(operatorId, session, `✅ 已批准 ${pendingReq.applicantQQ} 入群并完成自动绑定\nUID: ${uid}`);
+            pendingReq.status = 'approved';
+        }
+        catch (error) {
+            this.logger.error('入群审批', `自动绑定失败: ${error.message}`, error);
+            await this.notifyAdmin(operatorId, session, `❌ 操作失败：${error.message}`);
+            pendingReq.status = 'pending'; // 恢复状态
+        }
+    }
+    /**
+     * 批准并启动交互式绑定
+     */
+    async approveAndInteractiveBind(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) {
+                // 3. 用户进群后会自动触发 guild-member-added 事件
+                // 现有的入群欢迎流程会自动启动交互式绑定
+                await this.notifyAdmin(operatorId, session, `✅ 已批准 ${pendingReq.applicantQQ} 入群，交互式绑定已启动`);
+            }
+            else {
+                await this.notifyAdmin(operatorId, session, `⚠️ 已批准但用户 ${pendingReq.applicantQQ} 未在10秒内进群`);
+            }
+            pendingReq.status = 'approved';
+        }
+        catch (error) {
+            this.logger.error('入群审批', `交互式绑定失败: ${error.message}`, error);
+            await this.notifyAdmin(operatorId, session, `❌ 操作失败：${error.message}`);
+            pendingReq.status = 'pending';
+        }
+    }
+    /**
+     * 发起拒绝流程
+     */
+    async initRejectFlow(pendingReq, operatorId, session) {
+        try {
+            // 发送询问消息
+            const askElements = [
+                koishi_1.h.text(`❓ 请回复拒绝理由（引用此消息回复）\n`),
+                koishi_1.h.text(`申请人：${pendingReq.applicantNickname}（${pendingReq.applicantQQ}）`)
+            ];
+            const askResult = await session.bot.sendMessage(session.channelId, askElements);
+            const askMsgId = Array.isArray(askResult) ? askResult[0] : null;
+            if (!askMsgId) {
+                throw new Error('发送询问消息失败');
+            }
+            // 保存拒绝流程状态
+            const rejectFlow = {
+                pendingRequest: pendingReq,
+                operatorId,
+                askMessageId: askMsgId,
+                timeout: Date.now() + 5 * 60 * 1000 // 5分钟超时
+            };
+            this.rejectFlows.set(askMsgId, rejectFlow);
+            this.logger.info('入群审批', `已发起拒绝流程 - 询问消息ID: ${askMsgId}`);
+        }
+        catch (error) {
+            this.logger.error('入群审批', `发起拒绝流程失败: ${error.message}`, error);
+            await this.notifyAdmin(operatorId, session, `❌ 发起拒绝流程失败：${error.message}`);
+            pendingReq.status = 'pending';
+        }
+    }
+    /**
+     * 处理拒绝理由（中间件）
+     */
+    async handleRejectReason(session, next) {
+        // 检查是否是引用消息
+        if (!session.quote) {
+            return next();
+        }
+        const rejectFlow = this.rejectFlows.get(session.quote.id);
+        if (!rejectFlow) {
+            return next();
+        }
+        // 检查是否是同一个管理员
+        const operatorId = this.deps.normalizeQQId(session.userId);
+        if (operatorId !== rejectFlow.operatorId) {
+            return '⚠️ 只有发起拒绝的管理员可以提供理由';
+        }
+        // 检查是否超时
+        if (Date.now() > rejectFlow.timeout) {
+            this.rejectFlows.delete(session.quote.id);
+            rejectFlow.pendingRequest.status = 'pending';
+            return '❌ 拒绝流程已超时，请重新操作';
+        }
+        // 执行拒绝
+        const reason = session.content;
+        const { pendingRequest } = rejectFlow;
+        try {
+            await session.bot.handleGuildMemberRequest(pendingRequest.requestFlag, false, reason);
+            this.logger.info('入群审批', `已拒绝入群 - QQ: ${pendingRequest.applicantQQ}, 理由: ${reason}`, true);
+            pendingRequest.status = 'rejected';
+            this.rejectFlows.delete(session.quote.id);
+            return `✅ 已拒绝 ${pendingRequest.applicantQQ} 的入群申请\n拒绝理由：${reason}`;
+        }
+        catch (error) {
+            this.logger.error('入群审批', `拒绝入群失败: ${error.message}`, error);
+            pendingRequest.status = 'pending';
+            return `❌ 拒绝失败：${error.message}`;
+        }
+    }
+    /**
+     * 处理用户成功进群事件
+     */
+    handleUserJoined(session) {
+        const userId = this.deps.normalizeQQId(session.userId);
+        const waiter = this.userJoinWaiters.get(userId);
+        if (waiter) {
+            this.logger.debug('入群审批', `用户已进群 - QQ: ${userId}`);
+            waiter(true);
+            this.userJoinWaiters.delete(userId);
+        }
+    }
+    /**
+     * 等待用户进群
+     */
+    waitForUserJoin(userId, groupId, timeout) {
+        return new Promise(resolve => {
+            const timer = setTimeout(() => {
+                this.userJoinWaiters.delete(userId);
+                resolve(false);
+            }, timeout);
+            this.userJoinWaiters.set(userId, (joined) => {
+                clearTimeout(timer);
+                resolve(joined);
+            });
+        });
+    }
+    /**
+     * 检查管理员权限
+     */
+    async checkAdminPermission(userId, groupId, bot) {
+        // 检查是否是 masterId
+        if (userId === this.config.masterId) {
+            return true;
+        }
+        // 先检查缓存
+        const cache = this.adminCache.get(groupId);
+        if (cache && Date.now() - cache.lastUpdate < 5 * 60 * 1000) {
+            return cache.admins.includes(userId);
+        }
+        // 调用 NapCat 扩展 API 获取群信息
+        try {
+            const groupInfo = await bot.internal.getGroupInfoEx(groupId);
+            const admins = (groupInfo.admins || []).map(String);
+            // 更新缓存
+            this.adminCache.set(groupId, {
+                admins,
+                lastUpdate: Date.now()
+            });
+            return admins.includes(userId);
+        }
+        catch (error) {
+            this.logger.error('入群审批', `获取管理员列表失败: ${error.message}`);
+            // 降级方案：只允许 masterId
+            return userId === this.config.masterId;
+        }
+    }
+    /**
+     * 解析UID（支持多种格式）
+     */
+    parseUID(input) {
+        if (!input)
+            return null;
+        input = input.trim();
+        // 格式1: 纯数字
+        if (/^\d+$/.test(input)) {
+            return input;
+        }
+        // 格式2: UID:123456789
+        const uidMatch = input.match(/^UID:(\d+)$/i);
+        if (uidMatch) {
+            return uidMatch[1];
+        }
+        // 格式3: https://space.bilibili.com/123456789
+        const urlMatch = input.match(/space\.bilibili\.com\/(\d+)/);
+        if (urlMatch) {
+            return urlMatch[1];
+        }
+        return null;
+    }
+    /**
+     * 通知管理员
+     */
+    async notifyAdmin(operatorId, session, message) {
+        try {
+            const elements = [koishi_1.h.at(operatorId), koishi_1.h.text(' '), koishi_1.h.text(message)];
+            await session.bot.sendMessage(session.channelId, elements);
+        }
+        catch (error) {
+            this.logger.error('入群审批', `通知管理员失败: ${error.message}`);
+        }
+    }
+    /**
+     * 执行自动绑定
+     */
+    async performAutoBind(qq, uid, bot) {
+        const axios = require('axios');
+        try {
+            // 1. 验证 UID
+            this.logger.debug('入群审批', `验证 B站 UID: ${uid}`);
+            const response = await axios.get(`${this.config.zminfoApiUrl}/api/user/${uid}`, {
+                timeout: 10000,
+                headers: {
+                    'User-Agent': 'Koishi-MCID-Bot/1.0'
+                }
+            });
+            if (response.status !== 200 || !response.data || !response.data.uid) {
+                throw new Error(`无法验证B站UID: ${uid}`);
+            }
+            const buidUser = response.data;
+            // 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用户名）
+                const tempMcUsername = `_temp_${Date.now()}`;
+                bind = await this.repos.mcidbind.create({
+                    qqId: qq,
+                    mcUsername: tempMcUsername,
+                    mcUuid: '',
+                    buidUid: buidUser.uid,
+                    buidUsername: buidUser.username,
+                    guardLevel: buidUser.guard_level || 0,
+                    guardLevelText: buidUser.guard_level_text || '',
+                    maxGuardLevel: buidUser.guard_level || 0,
+                    maxGuardLevelText: buidUser.guard_level_text || '',
+                    medalName: buidUser.medal?.name || '',
+                    medalLevel: buidUser.medal?.level || 0,
+                    wealthMedalLevel: buidUser.wealth_medal_level || 0,
+                    lastActiveTime: new Date(),
+                    lastModified: new Date()
+                });
+                this.logger.info('入群审批', `已创建新绑定 - QQ: ${qq}, UID: ${uid}`, true);
+            }
+            else {
+                // 更新现有绑定
+                await this.repos.mcidbind.update(qq, {
+                    buidUid: buidUser.uid,
+                    buidUsername: buidUser.username,
+                    guardLevel: buidUser.guard_level || 0,
+                    guardLevelText: buidUser.guard_level_text || '',
+                    maxGuardLevel: Math.max(bind.maxGuardLevel || 0, buidUser.guard_level || 0),
+                    maxGuardLevelText: buidUser.guard_level > (bind.maxGuardLevel || 0)
+                        ? buidUser.guard_level_text
+                        : bind.maxGuardLevelText,
+                    medalName: buidUser.medal?.name || '',
+                    medalLevel: buidUser.medal?.level || 0,
+                    wealthMedalLevel: buidUser.wealth_medal_level || 0,
+                    lastActiveTime: new Date(),
+                    lastModified: new Date()
+                });
+                this.logger.info('入群审批', `已更新绑定 - QQ: ${qq}, UID: ${uid}`, true);
+            }
+            // 4. 更新群昵称
+            try {
+                const groupId = this.reviewConfig.targetGroupId;
+                const nickname = `${buidUser.username}_${bind.mcUsername || 'MCID'}`;
+                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}, 用户名: ${buidUser.username}`, true);
+        }
+        catch (error) {
+            this.logger.error('入群审批', `自动绑定失败: ${error.message}`, error);
+            throw error;
+        }
+    }
+    /**
+     * 定时清理过期记录
+     */
+    cleanupExpiredRecords() {
+        const now = Date.now();
+        const cleanupThreshold = this.reviewConfig.autoCleanupHours * 60 * 60 * 1000;
+        // 清理过期的待审批记录
+        let cleanedPending = 0;
+        for (const [msgId, req] of this.pendingRequests.entries()) {
+            if (now - req.timestamp > cleanupThreshold) {
+                this.pendingRequests.delete(msgId);
+                cleanedPending++;
+            }
+        }
+        // 清理过期的拒绝流程
+        let cleanedReject = 0;
+        for (const [askMsgId, flow] of this.rejectFlows.entries()) {
+            if (now > flow.timeout) {
+                this.rejectFlows.delete(askMsgId);
+                cleanedReject++;
+            }
+        }
+        if (cleanedPending > 0 || cleanedReject > 0) {
+            this.logger.info('入群审批', `清理过期记录 - 待审批: ${cleanedPending}, 拒绝流程: ${cleanedReject}`);
+        }
+    }
+}
+exports.GroupRequestReviewHandler = GroupRequestReviewHandler;

package/lib/handlers/index.d.ts

@@ -5,3 +5,4 @@ export * from './whitelist.handler';
 export * from './buid.handler';
 export * from './mcid.handler';
 export * from './lottery.handler';
+export * from './group-request-review.handler';

package/lib/handlers/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./whitelist.handler"), exports);
 __exportStar(require("./buid.handler"), exports);
 __exportStar(require("./mcid.handler"), exports);
 __exportStar(require("./lottery.handler"), exports);
+__exportStar(require("./group-request-review.handler"), exports);

package/lib/index.js

@@ -52,6 +52,25 @@ exports.Config = koishi_1.Schema.object({
     forceBindTargetUpUid: koishi_1.Schema.number().description('强制绑定目标UP主UID').default(686127),
     forceBindTargetRoomId: koishi_1.Schema.number().description('强制绑定目标房间号').default(544853),
     forceBindTargetMedalName: koishi_1.Schema.string().description('强制绑定目标粉丝牌名称').default('生态'),
+    groupRequestReview: koishi_1.Schema.object({
+        enabled: koishi_1.Schema.boolean().description('是否启用入群申请审批功能').default(false),
+        targetGroupId: koishi_1.Schema.string()
+            .description('需要审批的目标群ID（入群申请来源群）')
+            .default('931805503'),
+        reviewGroupId: koishi_1.Schema.string()
+            .description('管理员审批操作所在的群ID（播报群）')
+            .default('290238092'),
+        approveAutoBindEmoji: koishi_1.Schema.string()
+            .description('批准并自动绑定的表情ID（/太赞了）')
+            .default('389'),
+        approveInteractiveBindEmoji: koishi_1.Schema.string()
+            .description('批准并交互式绑定的表情ID（/偷感）')
+            .default('427'),
+        rejectEmoji: koishi_1.Schema.string().description('拒绝申请的表情ID（/NO）').default('123'),
+        autoCleanupHours: koishi_1.Schema.number()
+            .description('待审批记录自动清理时间（小时）')
+            .default(24)
+    }).description('入群申请审批功能配置'),
     servers: koishi_1.Schema.array(koishi_1.Schema.object({
         id: koishi_1.Schema.string().description('服务器唯一ID（不允许重复）').required(),
         name: koishi_1.Schema.string().description('服务器名称（用于指令显示）').required(),
@@ -1131,6 +1150,9 @@ function apply(ctx, config) {
     // 实例化McidCommandHandler并注册命令
     const mcidHandler = new handlers_1.McidCommandHandler(ctx, config, loggerService, repositories, handlerDependencies);
     mcidHandler.register();
+    // 实例化并注册入群申请审批Handler
+    const groupRequestReviewHandler = new handlers_1.GroupRequestReviewHandler(ctx, config, loggerService, repositories, handlerDependencies);
+    groupRequestReviewHandler.register();
     // 自定义文本前缀匹配
     if (config.allowTextPrefix && config.botNickname) {
         // 创建一个前缀匹配器

package/lib/services/nickname.service.js

@@ -189,16 +189,12 @@ class NicknameService {
                 const currentGroupInfo = await session.bot.internal.getGroupMemberInfo(targetGroupId, normalizedUserId);
                 const currentNickname = currentGroupInfo.card || currentGroupInfo.nickname || '';
                 this.logger.debug('群昵称设置', `当前昵称: "${currentNickname}"`);
-                // 智能判断：如果当前昵称已包含最新用户名，跳过修改
+                // 【调试信息】提取当前昵称中的BUID用户名（仅用于日志）
                 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;

package/lib/types/common.d.ts

@@ -38,3 +38,48 @@ export interface LotteryResult {
     host_uid: number;
     host_username: string;
 }
+/**
+ * 待审批的入群申请信息
+ */
+export interface PendingRequest {
+    /** 播报消息的ID（用于监听表情回应） */
+    broadcastMessageId: string;
+    /** OneBot的请求标识（用于批准/拒绝） */
+    requestFlag: string;
+    /** 申请人QQ号 */
+    applicantQQ: string;
+    /** 申请人昵称 */
+    applicantNickname: string;
+    /** 申请人头像URL */
+    applicantAvatar: string;
+    /** 目标群号 */
+    targetGroupId: string;
+    /** 申请人回答的内容（UID） */
+    answer: string;
+    /** 申请时间戳 */
+    timestamp: number;
+    /** 审批状态 */
+    status: 'pending' | 'approved' | 'rejected' | 'processing';
+}
+/**
+ * 拒绝流程状态
+ */
+export interface RejectFlow {
+    /** 对应的待审批申请 */
+    pendingRequest: PendingRequest;
+    /** 发起拒绝的管理员QQ号 */
+    operatorId: string;
+    /** 询问消息ID */
+    askMessageId: string;
+    /** 超时时间戳 */
+    timeout: number;
+}
+/**
+ * 管理员权限缓存
+ */
+export interface AdminCache {
+    /** 管理员QQ号列表 */
+    admins: string[];
+    /** 最后更新时间戳 */
+    lastUpdate: number;
+}

package/lib/types/config.d.ts

@@ -53,6 +53,8 @@ export interface Config {
     forceBindTargetRoomId: number;
     /** 强制绑定目标粉丝牌名称 */
     forceBindTargetMedalName: string;
+    /** 入群申请审批功能配置 */
+    groupRequestReview?: GroupRequestReviewConfig;
 }
 /**
  * 服务器配置接口
@@ -116,3 +118,28 @@ export interface ForceBindConfig {
     targetMedalName: string;
     debugMode: boolean;
 }
+/**
+ * 入群申请审批功能配置接口
+ *
+ * @remarks
+ * 该功能允许通过表情回应来审批入群申请
+ * - 支持自动绑定 B站 UID
+ * - 支持交互式绑定流程
+ * - 支持拒绝申请并回传理由
+ */
+export interface GroupRequestReviewConfig {
+    /** 是否启用入群申请审批功能 */
+    enabled: boolean;
+    /** 需要审批的目标群ID */
+    targetGroupId: string;
+    /** 管理员审批操作所在的群ID（播报群） */
+    reviewGroupId: string;
+    /** 批准并自动绑定的表情ID（默认：389 /太赞了） */
+    approveAutoBindEmoji: string;
+    /** 批准并交互式绑定的表情ID（默认：427 /偷感） */
+    approveInteractiveBindEmoji: string;
+    /** 拒绝申请的表情ID（默认：123 /NO） */
+    rejectEmoji: string;
+    /** 待审批记录自动清理时间（小时） */
+    autoCleanupHours: number;
+}

package/package.json

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