koishi-plugin-bind-bot 2.0.0

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

@@ -0,0 +1,61 @@
+import { Context, Session } from 'koishi';
+import { LoggerService } from '../utils/logger';
+import { MCIDBINDRepository } from '../repositories/mcidbind.repository';
+import { ScheduleMuteRepository } from '../repositories/schedule-mute.repository';
+import { RconManager } from '../managers/rcon-manager';
+import { MessageUtils } from '../utils/message-utils';
+import { ForceBinder } from '../force-bind-utils';
+import { GroupExporter } from '../export-utils';
+import type { MCIDBIND } from '../types';
+/**
+ * Repositories 接口 - 聚合所有数据仓储
+ */
+export interface Repositories {
+    mcidbind: MCIDBINDRepository;
+    scheduleMute: ScheduleMuteRepository;
+}
+/**
+ * Handler 依赖项接口
+ * 包含所有 Handler 需要的共享函数和服务
+ */
+export interface HandlerDependencies {
+    normalizeQQId: (userId: string) => string;
+    formatCommand: (cmd: string) => string;
+    formatUuid: (uuid: string) => string;
+    checkCooldown: (lastModified: Date | null, multiplier?: number) => boolean;
+    getCrafatarUrl: (uuid: string) => string;
+    getStarlightSkinUrl: (uuid: string) => string;
+    sendMessage: (session: Session, content: any[], options?: any) => Promise<void>;
+    autoSetGroupNickname: (session: Session, mcUsername: string, buidUsername: string, targetUserId?: string, specifiedGroupId?: string) => Promise<void>;
+    getBindInfo: (qqId: string) => Promise<MCIDBIND | null>;
+    rconManager: RconManager;
+    messageUtils: MessageUtils;
+    forceBinder: ForceBinder;
+    groupExporter: GroupExporter;
+    getBindingSession: (userId: string, channelId: string) => any;
+    createBindingSession: (userId: string, channelId: string, initialState?: string) => void;
+    updateBindingSession: (userId: string, channelId: string, updates: any) => void;
+    removeBindingSession: (userId: string, channelId: string) => void;
+    avatarCache?: Map<string, {
+        url: string;
+        timestamp: number;
+    }>;
+    bindingSessions: Map<string, any>;
+}
+/**
+ * 命令处理器基类
+ * 提供通用的上下文、配置、日志、数据仓储和共享依赖访问
+ */
+export declare abstract class BaseHandler {
+    protected ctx: Context;
+    protected config: any;
+    protected logger: LoggerService;
+    protected repos: Repositories;
+    protected deps: HandlerDependencies;
+    constructor(ctx: Context, config: any, logger: LoggerService, repos: Repositories, deps: HandlerDependencies);
+    /**
+     * 注册命令
+     * 每个子类实现自己的命令注册逻辑
+     */
+    abstract register(): void;
+}

package/lib/handlers/base.handler.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseHandler = void 0;
+/**
+ * 命令处理器基类
+ * 提供通用的上下文、配置、日志、数据仓储和共享依赖访问
+ */
+class BaseHandler {
+    ctx;
+    config;
+    logger;
+    repos;
+    deps;
+    constructor(ctx, config, logger, repos, deps) {
+        this.ctx = ctx;
+        this.config = config;
+        this.logger = logger;
+        this.repos = repos;
+        this.deps = deps;
+    }
+}
+exports.BaseHandler = BaseHandler;

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

@@ -0,0 +1,45 @@
+import { Context } from 'koishi';
+import { BaseHandler, Repositories, HandlerDependencies } from './base.handler';
+import { LoggerService } from '../utils/logger';
+/**
+ * 交互式绑定命令处理器
+ * 处理 "绑定" 命令，引导用户完成 MC 和 B站双重绑定
+ */
+export declare class BindingHandler extends BaseHandler {
+    private readonly BINDING_SESSION_TIMEOUT;
+    constructor(ctx: Context, config: any, logger: LoggerService, repos: Repositories, deps: HandlerDependencies);
+    /**
+     * 注册交互式绑定命令
+     */
+    register(): void;
+    /**
+     * 检查用户是否为管理员
+     * @param userId 用户ID
+     * @returns 是否为管理员
+     */
+    private isAdmin;
+    /**
+     * 获取用户友好的错误信息
+     * @param error 错误对象
+     * @returns 用户友好的错误消息
+     */
+    private getFriendlyErrorMessage;
+    /**
+     * 提取用户友好的错误信息
+     * @param errorMsg 原始错误消息
+     * @returns 用户友好的错误消息
+     */
+    private getUserFacingErrorMessage;
+    /**
+     * 判断是否为警告级别错误（用户可能输入有误）
+     * @param errorMsg 错误消息
+     * @returns 是否为警告级别错误
+     */
+    private isWarningError;
+    /**
+     * 判断是否为严重错误（系统问题）
+     * @param errorMsg 错误消息
+     * @returns 是否为严重错误
+     */
+    private isCriticalError;
+}

package/lib/handlers/binding.handler.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BindingHandler = void 0;
+const koishi_1 = require("koishi");
+const base_handler_1 = require("./base.handler");
+/**
+ * 交互式绑定命令处理器
+ * 处理 "绑定" 命令，引导用户完成 MC 和 B站双重绑定
+ */
+class BindingHandler extends base_handler_1.BaseHandler {
+    BINDING_SESSION_TIMEOUT;
+    constructor(ctx, config, logger, repos, deps) {
+        super(ctx, config, logger, repos, deps);
+        // 从配置中获取会话超时时间，默认3分钟
+        this.BINDING_SESSION_TIMEOUT = 3 * 60 * 1000;
+    }
+    /**
+     * 注册交互式绑定命令
+     */
+    register() {
+        this.ctx.command('绑定 [target:string]', '交互式绑定流程')
+            .alias('bind')
+            .alias('interact')
+            .action(async ({ session }, target) => {
+            try {
+                const normalizedUserId = this.deps.normalizeQQId(session.userId);
+                const channelId = session.channelId;
+                // 如果指定了目标用户（管理员功能）
+                if (target) {
+                    // 检查权限
+                    if (!await this.isAdmin(session.userId)) {
+                        this.logger.warn('交互绑定', `权限不足: QQ(${normalizedUserId})不是管理员，无法为他人启动绑定`);
+                        return this.deps.sendMessage(session, [koishi_1.h.text('只有管理员才能为其他用户启动绑定流程')]);
+                    }
+                    const normalizedTargetId = this.deps.normalizeQQId(target);
+                    // 检查目标用户ID是否有效
+                    if (!normalizedTargetId) {
+                        this.logger.warn('交互绑定', `QQ(${normalizedUserId})提供的目标用户ID"${target}"无效`);
+                        if (target.startsWith('@')) {
+                            return this.deps.sendMessage(session, [koishi_1.h.text('❌ 请使用真正的@功能，而不是手动输入@符号\n正确做法：点击或长按用户头像选择@功能')]);
+                        }
+                        return this.deps.sendMessage(session, [koishi_1.h.text('❌ 目标用户ID无效\n请提供有效的QQ号或使用@功能选择用户')]);
+                    }
+                    this.logger.info('交互绑定', `管理员QQ(${normalizedUserId})为QQ(${normalizedTargetId})启动交互式绑定流程`, true);
+                    // 检查目标用户是否已有进行中的会话
+                    const existingTargetSession = this.deps.getBindingSession(target, channelId);
+                    if (existingTargetSession) {
+                        this.logger.warn('交互绑定', `QQ(${normalizedTargetId})已有进行中的绑定会话`);
+                        return this.deps.sendMessage(session, [koishi_1.h.text(`用户 ${normalizedTargetId} 已有进行中的绑定会话`)]);
+                    }
+                    // 检查目标用户当前绑定状态
+                    const targetBind = await this.deps.getBindInfo(normalizedTargetId);
+                    // 如果两个账号都已绑定，不需要进入绑定流程
+                    if (targetBind && targetBind.mcUsername && targetBind.buidUid) {
+                        this.logger.info('交互绑定', `QQ(${normalizedTargetId})已完成全部绑定`, true);
+                        // 显示当前绑定信息
+                        const displayUsername = targetBind.mcUsername && !targetBind.mcUsername.startsWith('_temp_') ? targetBind.mcUsername : '未绑定';
+                        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 (targetBind && targetBind.mcUsername && !targetBind.buidUid) {
+                        this.logger.info('交互绑定', `QQ(${normalizedTargetId})已绑定MC，进入B站绑定流程`, true);
+                        // 更新会话状态
+                        this.deps.updateBindingSession(target, channelId, {
+                            state: 'waiting_buid',
+                            mcUsername: targetBind.mcUsername && !targetBind.mcUsername.startsWith('_temp_') ? targetBind.mcUsername : null,
+                            mcUuid: targetBind.mcUuid
+                        });
+                        // 向目标用户发送提示（@他们）
+                        const displayUsername = targetBind.mcUsername && !targetBind.mcUsername.startsWith('_temp_') ? targetBind.mcUsername : '未绑定';
+                        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账号`)
+                    ]);
+                    return;
+                }
+                // 为自己启动绑定流程
+                this.logger.info('交互绑定', `QQ(${normalizedUserId})开始交互式绑定流程`, true);
+                // 检查是否已有进行中的会话
+                const existingSession = this.deps.getBindingSession(session.userId, channelId);
+                if (existingSession) {
+                    this.logger.warn('交互绑定', `QQ(${normalizedUserId})已有进行中的绑定会话`);
+                    return this.deps.sendMessage(session, [koishi_1.h.text('您已有进行中的绑定会话，请先完成当前绑定或等待会话超时')]);
+                }
+                // 检查用户当前绑定状态
+                const existingBind = await this.deps.getBindInfo(normalizedUserId);
+                // 如果两个账号都已绑定（且MC不是temp用户名），不需要进入绑定流程
+                if (existingBind && existingBind.mcUsername && !existingBind.mcUsername.startsWith('_temp_') && 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 && existingBind.mcUsername && !existingBind.mcUsername.startsWith('_temp_') && !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 &&
+                    existingBind.mcUsername && existingBind.mcUsername.startsWith('_temp_')) {
+                    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账号`)]);
+            }
+            catch (error) {
+                const normalizedUserId = this.deps.normalizeQQId(session.userId);
+                this.logger.error('交互绑定', `QQ(${normalizedUserId})开始交互式绑定失败: ${error.message}`, error);
+                return this.deps.sendMessage(session, [koishi_1.h.text(this.getFriendlyErrorMessage(error))]);
+            }
+        });
+    }
+    /**
+     * 检查用户是否为管理员
+     * @param userId 用户ID
+     * @returns 是否为管理员
+     */
+    async isAdmin(userId) {
+        try {
+            // 主人始终是管理员
+            const normalizedMasterId = this.deps.normalizeQQId(this.config.masterId);
+            const normalizedQQId = this.deps.normalizeQQId(userId);
+            if (normalizedQQId === normalizedMasterId)
+                return true;
+            // 查询MCIDBIND表中是否是管理员
+            const bind = await this.deps.getBindInfo(normalizedQQId);
+            return bind && bind.isAdmin === true;
+        }
+        catch (error) {
+            const normalizedQQId = this.deps.normalizeQQId(userId);
+            this.logger.error('权限检查', `QQ(${normalizedQQId})的管理员状态查询失败: ${error.message}`, error);
+            return false;
+        }
+    }
+    /**
+     * 获取用户友好的错误信息
+     * @param error 错误对象
+     * @returns 用户友好的错误消息
+     */
+    getFriendlyErrorMessage(error) {
+        const errorMsg = error instanceof Error ? error.message : error;
+        // 拆分错误信息
+        const userError = this.getUserFacingErrorMessage(errorMsg);
+        // 将警告级别错误标记出来
+        if (this.isWarningError(userError)) {
+            return `⚠️ ${userError}`;
+        }
+        // 将严重错误标记出来
+        if (this.isCriticalError(userError)) {
+            return `❌ ${userError}`;
+        }
+        return userError;
+    }
+    /**
+     * 提取用户友好的错误信息
+     * @param errorMsg 原始错误消息
+     * @returns 用户友好的错误消息
+     */
+    getUserFacingErrorMessage(errorMsg) {
+        // Mojang API相关错误
+        if (errorMsg.includes('ECONNABORTED') || errorMsg.includes('timeout')) {
+            return '无法连接到Mojang服务器，请稍后再试';
+        }
+        if (errorMsg.includes('404')) {
+            return '该Minecraft用户名不存在';
+        }
+        if (errorMsg.includes('network') || errorMsg.includes('connect')) {
+            return '网络连接异常，请稍后再试';
+        }
+        // 数据库相关错误
+        if (errorMsg.includes('unique') || errorMsg.includes('duplicate')) {
+            return '该Minecraft用户名已被其他用户绑定';
+        }
+        // RCON相关错误
+        if (errorMsg.includes('RCON') || errorMsg.includes('服务器')) {
+            if (errorMsg.includes('authentication') || errorMsg.includes('auth') || errorMsg.includes('认证')) {
+                return 'RCON认证失败，服务器拒绝访问，请联系管理员检查密码';
+            }
+            if (errorMsg.includes('ECONNREFUSED') || errorMsg.includes('ETIMEDOUT') || errorMsg.includes('无法连接')) {
+                return '无法连接到游戏服务器，请确认服务器是否在线或联系管理员';
+            }
+            if (errorMsg.includes('command') || errorMsg.includes('执行命令')) {
+                return '服务器命令执行失败，请稍后再试';
+            }
+            return '与游戏服务器通信失败，请稍后再试';
+        }
+        // 用户名相关错误
+        if (errorMsg.includes('用户名') || errorMsg.includes('username')) {
+            if (errorMsg.includes('不存在')) {
+                return '该Minecraft用户名不存在，请检查拼写';
+            }
+            if (errorMsg.includes('已被')) {
+                return '该Minecraft用户名已被其他用户绑定，请使用其他用户名';
+            }
+            if (errorMsg.includes('格式')) {
+                return 'Minecraft用户名格式不正确，应为3-16位字母、数字和下划线';
+            }
+            return '用户名验证失败，请检查用户名并重试';
+        }
+        // 默认错误信息
+        return '操作失败，请稍后再试';
+    }
+    /**
+     * 判断是否为警告级别错误（用户可能输入有误）
+     * @param errorMsg 错误消息
+     * @returns 是否为警告级别错误
+     */
+    isWarningError(errorMsg) {
+        const warningPatterns = [
+            '用户名不存在',
+            '格式不正确',
+            '已被其他用户绑定',
+            '已在白名单中',
+            '不在白名单中',
+            '未绑定MC账号',
+            '冷却期内'
+        ];
+        return warningPatterns.some(pattern => errorMsg.includes(pattern));
+    }
+    /**
+     * 判断是否为严重错误（系统问题）
+     * @param errorMsg 错误消息
+     * @returns 是否为严重错误
+     */
+    isCriticalError(errorMsg) {
+        const criticalPatterns = [
+            '无法连接',
+            'RCON认证失败',
+            '服务器通信失败',
+            '数据库操作出错'
+        ];
+        return criticalPatterns.some(pattern => errorMsg.includes(pattern));
+    }
+}
+exports.BindingHandler = BindingHandler;

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

@@ -0,0 +1,71 @@
+import { BaseHandler } from './base.handler';
+/**
+ * BUID 命令处理器
+ * 处理 B站账号相关命令
+ */
+export declare class BuidHandler extends BaseHandler {
+    /**
+     * 注册 BUID 相关命令
+     */
+    register(): void;
+    /**
+     * 处理 BUID 查询命令
+     */
+    private handleQuery;
+    /**
+     * 处理 BUID 绑定命令
+     */
+    private handleBind;
+    /**
+     * 处理查找用户命令（通过BUID反查QQ）
+     */
+    private handleFindUser;
+    /**
+     * 处理 mcid.bindbuid 命令
+     */
+    private handleBindBuid;
+    /**
+     * 处理 mcid.unbindbuid 命令
+     */
+    private handleUnbindBuid;
+    /**
+     * 解析UID输入（支持多种格式）
+     */
+    private parseUidInput;
+    /**
+     * 验证B站UID
+     */
+    private validateBUID;
+    /**
+     * 检查B站UID是否已被其他用户绑定
+     */
+    private checkBuidExists;
+    /**
+     * 创建或更新B站账号绑定
+     */
+    private createOrUpdateBuidBind;
+    /**
+     * 仅更新B站信息，不更新绑定时间
+     */
+    private updateBuidInfoOnly;
+    /**
+     * 检查是否为管理员
+     */
+    private checkIsAdmin;
+    /**
+     * 强制绑定模式处理
+     */
+    private handleForceBindMode;
+    /**
+     * 管理员为他人绑定处理
+     */
+    private handleAdminBindForOthers;
+    /**
+     * 为自己绑定处理
+     */
+    private handleSelfBind;
+    /**
+     * 获取友好的错误消息
+     */
+    private getFriendlyErrorMessage;
+}