koishi-plugin-bind-bot 2.0.0 → 2.0.2

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

@@ -56,10 +56,6 @@ export declare class WhitelistHandler extends BaseHandler {
      * 私有辅助方法：计算两个字符串的相似度
      */
     private similarityScore;
-    /**
-     * 私有辅助方法：计算Levenshtein距离
-     */
-    private levenshteinDistance;
     /**
      * 私有辅助方法：检查用户是否在特定服务器的白名单中
      */

package/lib/handlers/whitelist.handler.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WhitelistHandler = void 0;
 const koishi_1 = require("koishi");
 const base_handler_1 = require("./base.handler");
+const helpers_1 = require("../utils/helpers");
 /**
  * 白名单命令处理器
  * 处理所有 mcid.whitelist 子命令
@@ -756,38 +757,8 @@ class WhitelistHandler extends base_handler_1.BaseHandler {
         if (b.includes(a)) {
             return a.length / b.length;
         }
-        // 否则计算Levenshtein距离的相似度
-        const maxLength = Math.max(a.length, b.length);
-        const editDistance = this.levenshteinDistance(a, b);
-        return 1 - (editDistance / maxLength);
-    }
-    /**
-     * 私有辅助方法：计算Levenshtein距离
-     */
-    levenshteinDistance(a, b) {
-        const matrix = [];
-        // 初始化矩阵
-        for (let i = 0; i <= b.length; i++) {
-            matrix[i] = [i];
-        }
-        for (let j = 0; j <= a.length; j++) {
-            matrix[0][j] = j;
-        }
-        // 填充矩阵
-        for (let i = 1; i <= b.length; i++) {
-            for (let j = 1; j <= a.length; j++) {
-                if (b.charAt(i - 1) === a.charAt(j - 1)) {
-                    matrix[i][j] = matrix[i - 1][j - 1];
-                }
-                else {
-                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // 替换
-                    matrix[i][j - 1] + 1, // 插入
-                    matrix[i - 1][j] + 1 // 删除
-                    );
-                }
-            }
-        }
-        return matrix[b.length][a.length];
+        // 否则使用工具函数计算Levenshtein距离的相似度
+        return (0, helpers_1.calculateSimilarity)(a, b);
     }
     /**
      * 私有辅助方法：检查用户是否在特定服务器的白名单中

package/lib/index.js

@@ -12,6 +12,8 @@ const export_utils_1 = require("./export-utils");
 const logger_1 = require("./utils/logger");
 const rcon_manager_1 = require("./managers/rcon-manager");
 const rate_limiter_1 = require("./utils/rate-limiter");
+const helpers_1 = require("./utils/helpers");
+const error_utils_1 = require("./utils/error-utils");
 const mcidbind_repository_1 = require("./repositories/mcidbind.repository");
 const schedule_mute_repository_1 = require("./repositories/schedule-mute.repository");
 const handlers_1 = require("./handlers");
@@ -911,88 +913,6 @@ function apply(ctx, config) {
         return extractedId;
     };
     // 获取用户友好的错误信息
-    const getFriendlyErrorMessage = (error) => {
-        const errorMsg = error instanceof Error ? error.message : error;
-        // 拆分错误信息
-        const userError = getUserFacingErrorMessage(errorMsg);
-        // 将警告级别错误标记出来
-        if (isWarningError(userError)) {
-            return `⚠️ ${userError}`;
-        }
-        // 将严重错误标记出来
-        if (isCriticalError(userError)) {
-            return `❌ ${userError}`;
-        }
-        return userError;
-    };
-    // 提取用户友好的错误信息
-    const 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 '操作失败，请稍后再试';
-    };
-    // 判断是否为警告级别错误（用户可能输入有误）
-    const isWarningError = (errorMsg) => {
-        const warningPatterns = [
-            '用户名不存在',
-            '格式不正确',
-            '已被其他用户绑定',
-            '已在白名单中',
-            '不在白名单中',
-            '未绑定MC账号',
-            '冷却期内'
-        ];
-        return warningPatterns.some(pattern => errorMsg.includes(pattern));
-    };
-    // 判断是否为严重错误（系统问题）
-    const isCriticalError = (errorMsg) => {
-        const criticalPatterns = [
-            '无法连接',
-            'RCON认证失败',
-            '服务器通信失败',
-            '数据库操作出错'
-        ];
-        return criticalPatterns.some(pattern => errorMsg.includes(pattern));
-    };
     // 封装发送消息的函数，处理私聊和群聊的不同格式
     const sendMessage = async (session, content, options) => {
         try {
@@ -1773,41 +1693,11 @@ function apply(ctx, config) {
             const lowerServerName = serverName.toLowerCase().trim();
             // 最小相似度阈值，低于此值的匹配结果将被忽略
             const MIN_SIMILARITY = 0.6; // 60%的相似度
-            // 计算Levenshtein距离的函数
-            const levenshteinDistance = (str1, str2) => {
-                const matrix = [];
-                for (let i = 0; i <= str2.length; i++) {
-                    matrix[i] = [i];
-                }
-                for (let j = 0; j <= str1.length; j++) {
-                    matrix[0][j] = j;
-                }
-                for (let i = 1; i <= str2.length; i++) {
-                    for (let j = 1; j <= str1.length; j++) {
-                        if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
-                            matrix[i][j] = matrix[i - 1][j - 1];
-                        }
-                        else {
-                            matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // 替换
-                            matrix[i][j - 1] + 1, // 插入
-                            matrix[i - 1][j] + 1 // 删除
-                            );
-                        }
-                    }
-                }
-                return matrix[str2.length][str1.length];
-            };
-            // 计算相似度（0到1之间，1表示完全相同）
-            const calculateSimilarity = (str1, str2) => {
-                const distance = levenshteinDistance(str1, str2);
-                const maxLength = Math.max(str1.length, str2.length);
-                return 1 - distance / maxLength;
-            };
             // 查找最相似的服务器名称
             let bestMatch = null;
             let bestSimilarity = 0;
             for (const s of enabledServers) {
-                const similarity = calculateSimilarity(lowerServerName, s.name.toLowerCase().trim());
+                const similarity = (0, helpers_1.calculateSimilarity)(lowerServerName, s.name.toLowerCase().trim());
                 if (similarity > bestSimilarity && similarity >= MIN_SIMILARITY) {
                     bestSimilarity = similarity;
                     bestMatch = s;
@@ -1861,10 +1751,29 @@ function apply(ctx, config) {
         checkCooldown,
         getCrafatarUrl,
         getStarlightSkinUrl,
+        // Database operations (for McidCommandHandler)
+        getMcBindByQQId,
+        getMcBindByUsername,
+        createOrUpdateMcBind,
+        deleteMcBind,
+        checkUsernameExists,
+        checkAndUpdateUsername,
+        // API operations
+        validateUsername,
+        validateBUID,
+        updateBuidInfoOnly,
+        // Permission check functions
+        isAdmin,
+        isMaster,
         // Business functions
         sendMessage,
         autoSetGroupNickname,
+        checkNicknameFormat,
         getBindInfo: getMcBindByQQId,
+        // Config operations
+        getServerConfigById,
+        // Error handling
+        getFriendlyErrorMessage: error_utils_1.getFriendlyErrorMessage,
         // Service instances
         rconManager,
         messageUtils,
@@ -1889,49 +1798,9 @@ function apply(ctx, config) {
     tagHandler.register();
     whitelistHandler.register();
     buidHandler.register();
-    // =========== MC命令组 ===========
-    const cmd = ctx.command('mcid', 'Minecraft 账号绑定管理');
-    // 创建McidHandler的依赖对象
-    const mcidHandlerDeps = {
-        config,
-        logger: loggerService,
-        mcidbindRepo,
-        groupExporter,
-        // 辅助函数依赖
-        normalizeQQId,
-        formatCommand,
-        formatUuid,
-        checkCooldown,
-        getCrafatarUrl,
-        getStarlightSkinUrl,
-        // 数据库操作
-        getMcBindByQQId,
-        getMcBindByUsername,
-        createOrUpdateMcBind,
-        deleteMcBind,
-        checkUsernameExists,
-        checkAndUpdateUsername,
-        // API操作
-        validateUsername,
-        validateBUID,
-        updateBuidInfoOnly,
-        // 权限检查
-        isAdmin,
-        isMaster,
-        // 消息操作
-        sendMessage,
-        autoSetGroupNickname,
-        checkNicknameFormat,
-        // 会话管理
-        removeBindingSession,
-        // 服务器配置
-        getServerConfigById,
-        // 工具函数
-        getFriendlyErrorMessage
-    };
     // 实例化McidCommandHandler并注册命令
-    const mcidHandler = new handlers_1.McidCommandHandler(ctx, mcidHandlerDeps);
-    mcidHandler.registerCommands(cmd);
+    const mcidHandler = new handlers_1.McidCommandHandler(ctx, config, loggerService, repositories, handlerDependencies);
+    mcidHandler.register();
     // 自定义文本前缀匹配
     if (config.allowTextPrefix && config.botNickname) {
         // 创建一个前缀匹配器

package/lib/utils/error-utils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 错误处理工具函数集合
+ * 提供统一的错误信息格式化和分类功能
+ */
+/**
+ * 获取用户友好的错误信息
+ * 将技术性错误转换为用户可理解的提示
+ * @param error 错误对象或错误消息字符串
+ * @returns 格式化后的用户友好错误信息
+ */
+export declare function getFriendlyErrorMessage(error: Error | string): string;
+/**
+ * 提取用户友好的错误信息
+ * 根据错误消息内容返回对应的用户提示
+ * @param errorMsg 原始错误消息
+ * @returns 用户可理解的错误提示
+ */
+export declare function getUserFacingErrorMessage(errorMsg: string): string;
+/**
+ * 判断是否为警告级别错误（用户可能输入有误）
+ * @param errorMsg 错误消息
+ * @returns 是否为警告级别错误
+ */
+export declare function isWarningError(errorMsg: string): boolean;
+/**
+ * 判断是否为严重错误（系统问题）
+ * @param errorMsg 错误消息
+ * @returns 是否为严重错误
+ */
+export declare function isCriticalError(errorMsg: string): boolean;

package/lib/utils/error-utils.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * 错误处理工具函数集合
+ * 提供统一的错误信息格式化和分类功能
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFriendlyErrorMessage = getFriendlyErrorMessage;
+exports.getUserFacingErrorMessage = getUserFacingErrorMessage;
+exports.isWarningError = isWarningError;
+exports.isCriticalError = isCriticalError;
+/**
+ * 获取用户友好的错误信息
+ * 将技术性错误转换为用户可理解的提示
+ * @param error 错误对象或错误消息字符串
+ * @returns 格式化后的用户友好错误信息
+ */
+function getFriendlyErrorMessage(error) {
+    const errorMsg = error instanceof Error ? error.message : error;
+    // 拆分错误信息
+    const userError = getUserFacingErrorMessage(errorMsg);
+    // 将警告级别错误标记出来
+    if (isWarningError(userError)) {
+        return `⚠️ ${userError}`;
+    }
+    // 将严重错误标记出来
+    if (isCriticalError(userError)) {
+        return `❌ ${userError}`;
+    }
+    return userError;
+}
+/**
+ * 提取用户友好的错误信息
+ * 根据错误消息内容返回对应的用户提示
+ * @param errorMsg 原始错误消息
+ * @returns 用户可理解的错误提示
+ */
+function 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 是否为警告级别错误
+ */
+function isWarningError(errorMsg) {
+    const warningPatterns = [
+        '用户名不存在',
+        '格式不正确',
+        '已被其他用户绑定',
+        '已在白名单中',
+        '不在白名单中',
+        '未绑定MC账号',
+        '冷却期内'
+    ];
+    return warningPatterns.some(pattern => errorMsg.includes(pattern));
+}
+/**
+ * 判断是否为严重错误（系统问题）
+ * @param errorMsg 错误消息
+ * @returns 是否为严重错误
+ */
+function isCriticalError(errorMsg) {
+    const criticalPatterns = [
+        '无法连接',
+        'RCON认证失败',
+        '服务器通信失败',
+        '数据库操作出错'
+    ];
+    return criticalPatterns.some(pattern => errorMsg.includes(pattern));
+}

package/lib/utils/helpers.d.ts

@@ -74,3 +74,18 @@ export declare function escapeRegExp(string: string): string;
  * @returns 清理后的输入内容
  */
 export declare function cleanUserInput(content: string, session: Session, botNickname: string, logger?: Logger): string;
+/**
+ * 计算两个字符串之间的Levenshtein距离
+ * Levenshtein距离是指将一个字符串转换成另一个字符串所需的最少编辑操作次数
+ * @param str1 第一个字符串
+ * @param str2 第二个字符串
+ * @returns 两个字符串之间的编辑距离
+ */
+export declare function levenshteinDistance(str1: string, str2: string): number;
+/**
+ * 计算两个字符串的相似度（基于Levenshtein距离）
+ * @param str1 第一个字符串
+ * @param str2 第二个字符串
+ * @returns 相似度值（0到1之间，1表示完全相同）
+ */
+export declare function calculateSimilarity(str1: string, str2: string): number;

package/lib/utils/helpers.js

@@ -9,6 +9,8 @@ exports.getStarlightSkinUrl = getStarlightSkinUrl;
 exports.checkIrrelevantInput = checkIrrelevantInput;
 exports.escapeRegExp = escapeRegExp;
 exports.cleanUserInput = cleanUserInput;
+exports.levenshteinDistance = levenshteinDistance;
+exports.calculateSimilarity = calculateSimilarity;
 /**
  * 通用工具函数集合
  */
@@ -273,3 +275,47 @@ function cleanUserInput(content, session, botNickname, logger) {
     }
     return cleanedContent;
 }
+/**
+ * 计算两个字符串之间的Levenshtein距离
+ * Levenshtein距离是指将一个字符串转换成另一个字符串所需的最少编辑操作次数
+ * @param str1 第一个字符串
+ * @param str2 第二个字符串
+ * @returns 两个字符串之间的编辑距离
+ */
+function levenshteinDistance(str1, str2) {
+    const matrix = [];
+    // 初始化第一列
+    for (let i = 0; i <= str2.length; i++) {
+        matrix[i] = [i];
+    }
+    // 初始化第一行
+    for (let j = 0; j <= str1.length; j++) {
+        matrix[0][j] = j;
+    }
+    // 填充矩阵
+    for (let i = 1; i <= str2.length; i++) {
+        for (let j = 1; j <= str1.length; j++) {
+            if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            }
+            else {
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // 替换
+                matrix[i][j - 1] + 1, // 插入
+                matrix[i - 1][j] + 1 // 删除
+                );
+            }
+        }
+    }
+    return matrix[str2.length][str1.length];
+}
+/**
+ * 计算两个字符串的相似度（基于Levenshtein距离）
+ * @param str1 第一个字符串
+ * @param str2 第二个字符串
+ * @returns 相似度值（0到1之间，1表示完全相同）
+ */
+function calculateSimilarity(str1, str2) {
+    const distance = levenshteinDistance(str1, str2);
+    const maxLength = Math.max(str1.length, str2.length);
+    return 1 - distance / maxLength;
+}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "koishi-plugin-bind-bot",
   "description": "[WittF自用] BIND-BOT - 账号绑定管理机器人，支持Minecraft账号和B站账号绑定与管理。",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
     "lib"
   ],
-  "license": "MIT",
+  "license": "CC-BY-NC-SA-4.0",
   "scripts": {
     "build": "tsc"
   },