koishi-plugin-minecraft-adapter 1.0.8 → 1.0.10

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 import { Adapter, Bot, Context, Schema } from 'koishi';
-import { Rcon } from 'rcon-client';
+import { Rcon } from './rcon';
 import WebSocket from 'ws';
 /**
  * Minecraft 文本组件格式

package/lib/index.js

@@ -5,33 +5,56 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinecraftAdapter = exports.MinecraftBot = void 0;
 const koishi_1 = require("koishi");
-const rcon_client_1 = require("rcon-client");
+const rcon_1 = require("./rcon");
 const ws_1 = __importDefault(require("ws"));
 const logger = new koishi_1.Logger('minecraft');
 /**
- * 将嵌套格式的服务器配置扁平化
+ * 将嵌套格式的服务器配置扁平化。
+ * 每种嵌套对象（websocket / rcon / chatImage）独立处理，
+ * 确保任何混合格式（如扁平 url + 嵌套 rcon）都能正确转换。
  */
 function flattenServerConfig(server) {
-    if (server.websocket && typeof server.websocket === 'object') {
-        // 嵌套格式的 rcon 对象：只要存在且有 host/port/password 任一字段，即视为启用
-        const hasRcon = server.rcon && typeof server.rcon === 'object'
-            && (server.rcon.host || server.rcon.port || server.rcon.password);
-        return {
-            selfId: server.selfId,
-            serverName: server.serverName,
-            url: server.websocket.url,
-            accessToken: server.websocket.accessToken,
-            extraHeaders: server.websocket.extraHeaders,
-            enableRcon: hasRcon ? true : (server.rcon?.enabled ?? false),
-            rconHost: server.rcon?.host,
-            rconPort: server.rcon?.port,
-            rconPassword: server.rcon?.password,
-            rconTimeout: server.rcon?.timeout,
-            enableChatImage: server.chatImage?.enabled ?? !!(server.chatImage && (server.chatImage.defaultImageName)),
-            chatImageDefaultName: server.chatImage?.defaultImageName,
-        };
+    const result = { ...server };
+    // ── websocket 嵌套 → 扁平 ──
+    if (result.websocket && typeof result.websocket === 'object') {
+        const ws = result.websocket;
+        if (ws.url !== undefined)
+            result.url = ws.url;
+        if (ws.accessToken !== undefined)
+            result.accessToken = ws.accessToken;
+        if (ws.extraHeaders !== undefined)
+            result.extraHeaders = ws.extraHeaders;
+        delete result.websocket;
+    }
+    // ── rcon 嵌套 → 扁平 ──
+    if (result.rcon && typeof result.rcon === 'object') {
+        const rcon = result.rcon;
+        const hasRconConfig = rcon.host || rcon.port || rcon.password;
+        if (hasRconConfig || rcon.enabled) {
+            result.enableRcon = true;
+        }
+        // 仅在嵌套值实际存在时覆盖，避免用 undefined 覆盖已有值或阻止 Schema 默认值
+        if (rcon.host !== undefined)
+            result.rconHost = rcon.host;
+        if (rcon.port !== undefined)
+            result.rconPort = rcon.port;
+        if (rcon.password !== undefined)
+            result.rconPassword = rcon.password;
+        if (rcon.timeout !== undefined)
+            result.rconTimeout = rcon.timeout;
+        delete result.rcon;
+    }
+    // ── chatImage 嵌套 → 扁平 ──
+    if (result.chatImage && typeof result.chatImage === 'object') {
+        const ci = result.chatImage;
+        if (ci.enabled !== undefined || ci.defaultImageName) {
+            result.enableChatImage = ci.enabled ?? !!ci.defaultImageName;
+        }
+        if (ci.defaultImageName !== undefined)
+            result.chatImageDefaultName = ci.defaultImageName;
+        delete result.chatImage;
     }
-    return server;
+    return result;
 }
 /**
  * 向后兼容：
@@ -120,8 +143,7 @@ class MinecraftAdapter extends koishi_1.Adapter {
     constructor(ctx, rawConfig) {
         super(ctx);
         try {
-            const resolvedConfig = MinecraftAdapter.Config(rawConfig);
-            const config = migrateConfig(resolvedConfig);
+            const config = migrateConfig(rawConfig);
             this.debug = config.debug ?? false;
             this.detailedLogging = config.detailedLogging ?? false;
             this.tokenizeMode = config.tokenizeMode ?? 'split';
@@ -395,9 +417,17 @@ class MinecraftAdapter extends koishi_1.Adapter {
     async connectRcon(bot) {
         const config = bot.config;
         const selfId = bot.selfId;
-        const rconHost = config.rconHost || '127.0.0.1';
-        const rconPort = config.rconPort || 25575;
-        const rconTimeout = config.rconTimeout || 5000;
+        // rconHost 未配置时，从 WebSocket URL 中提取主机地址作为回退
+        let rconHost = config.rconHost;
+        if (!rconHost && config.url) {
+            try {
+                rconHost = new URL(config.url).hostname;
+            }
+            catch { }
+        }
+        rconHost = rconHost || '127.0.0.1';
+        const rconPort = config.rconPort ?? 25575;
+        const rconTimeout = config.rconTimeout ?? 5000;
         if (this.debug) {
             logger.info(`[DEBUG] RCON config for server ${selfId}:`, {
                 rconHost: config.rconHost,
@@ -405,12 +435,11 @@ class MinecraftAdapter extends koishi_1.Adapter {
                 rconPassword: config.rconPassword ? '***' : undefined,
                 rconTimeout: config.rconTimeout,
                 enableRcon: config.enableRcon,
-                configKeys: Object.keys(config),
+                resolved: `${rconHost}:${rconPort}`,
             });
-            logger.info(`[DEBUG] Connecting RCON for server ${selfId} to ${rconHost}:${rconPort}`);
         }
         try {
-            const rcon = await this.createRconWithTimeout(rconHost, rconPort, config.rconPassword || '', rconTimeout);
+            const rcon = await this.createRconWithTimeout(rconHost, rconPort, String(config.rconPassword ?? ''), rconTimeout);
             this.rconConnections.set(selfId, rcon);
             bot.rcon = rcon;
             this.rconReconnectAttempts.set(selfId, 0);
@@ -438,7 +467,7 @@ class MinecraftAdapter extends koishi_1.Adapter {
             const timer = setTimeout(() => {
                 reject(new Error(`RCON TCP connection timeout after ${timeout}ms to ${host}:${port}`));
             }, timeout);
-            rcon_client_1.Rcon.connect({ host, port, password, timeout }).then((rcon) => { clearTimeout(timer); resolve(rcon); }, (err) => { clearTimeout(timer); reject(err); });
+            rcon_1.Rcon.connect({ host, port, password, timeout }).then((rcon) => { clearTimeout(timer); resolve(rcon); }, (err) => { clearTimeout(timer); reject(err); });
         });
     }
     scheduleRconReconnect(bot) {
@@ -1193,34 +1222,20 @@ MinecraftBot.MessageEncoder = MinecraftMessageEncoder;
 // ============================================================================
 // Koishi Schema 配置
 // ============================================================================
-const serverSchema = koishi_1.Schema.intersect([
-    koishi_1.Schema.object({
-        selfId: koishi_1.Schema.string().description('机器人 ID（唯一标识）').required(),
-        serverName: koishi_1.Schema.string().description('服务器名称（需与鹊桥 config.yml 中的 server_name 一致）'),
-        url: koishi_1.Schema.string().description('WebSocket 地址（如 ws://127.0.0.1:8080）').required(),
-        accessToken: koishi_1.Schema.string().description('访问令牌（需与鹊桥 config.yml 中的 access_token 一致）'),
-        extraHeaders: koishi_1.Schema.dict(koishi_1.Schema.string()).description('额外请求头'),
-        enableRcon: koishi_1.Schema.boolean().description('启用 RCON 远程命令执行').default(false),
-        enableChatImage: koishi_1.Schema.boolean().description('启用 ChatImage CICode 图片发送（需客户端安装 ChatImage Mod）').default(false),
-    }),
-    koishi_1.Schema.union([
-        koishi_1.Schema.object({
-            enableRcon: koishi_1.Schema.const(true).required(),
-            rconHost: koishi_1.Schema.string().description('RCON 主机地址').default('127.0.0.1'),
-            rconPort: koishi_1.Schema.number().description('RCON 端口').default(25575),
-            rconPassword: koishi_1.Schema.string().description('RCON 密码（留空表示无密码）'),
-            rconTimeout: koishi_1.Schema.number().description('RCON 超时时间(ms)').default(5000),
-        }),
-        koishi_1.Schema.object({}),
-    ]),
-    koishi_1.Schema.union([
-        koishi_1.Schema.object({
-            enableChatImage: koishi_1.Schema.const(true).required(),
-            chatImageDefaultName: koishi_1.Schema.string().description('图片在聊天栏中的默认显示名称').default('图片'),
-        }),
-        koishi_1.Schema.object({}),
-    ]),
-]);
+const serverSchema = koishi_1.Schema.object({
+    selfId: koishi_1.Schema.string().description('机器人 ID（唯一标识）').required(),
+    serverName: koishi_1.Schema.string().description('服务器名称（需与鹊桥 config.yml 中的 server_name 一致）'),
+    url: koishi_1.Schema.string().description('WebSocket 地址（如 ws://127.0.0.1:8080）').required(),
+    accessToken: koishi_1.Schema.string().description('访问令牌（需与鹊桥 config.yml 中的 access_token 一致）'),
+    extraHeaders: koishi_1.Schema.dict(koishi_1.Schema.string()).description('额外请求头'),
+    enableRcon: koishi_1.Schema.boolean().description('启用 RCON 远程命令执行').default(false),
+    rconHost: koishi_1.Schema.string().description('RCON 主机地址（留空则自动取 WebSocket 地址中的主机）'),
+    rconPort: koishi_1.Schema.number().description('RCON 端口').default(25575),
+    rconPassword: koishi_1.Schema.string().description('RCON 密码（留空表示无密码）'),
+    rconTimeout: koishi_1.Schema.number().description('RCON 超时时间(ms)').default(5000),
+    enableChatImage: koishi_1.Schema.boolean().description('启用 ChatImage CICode 图片发送（需客户端安装 ChatImage Mod）').default(false),
+    chatImageDefaultName: koishi_1.Schema.string().description('图片在聊天栏中的默认显示名称').default('图片'),
+});
 (function (MinecraftAdapter) {
     MinecraftAdapter.Config = koishi_1.Schema.object({
         debug: koishi_1.Schema.boolean().description('启用调试模式，输出详细日志').default(false),

package/lib/rcon.d.ts

@@ -0,0 +1,61 @@
+export interface RconOptions {
+    host: string;
+    port?: number;
+    password: string;
+    timeout?: number;
+}
+/**
+ * 轻量级 Minecraft RCON 客户端
+ * 替换已停止维护的 rcon-client 库，修复认证兼容性问题
+ *
+ * 主要改进：
+ * - 正确处理 Minecraft 服务端的认证响应（兼容 Vanilla/Paper/Spigot/Fabric）
+ * - 稳健的 TCP 分包/合包缓冲处理
+ * - 独立的 TCP 连接超时和认证超时
+ * - 密码类型安全（防止 YAML 解析为非字符串）
+ */
+export declare class Rcon {
+    private socket;
+    private emitter;
+    private buf;
+    private nextId;
+    private authenticated;
+    private authCb;
+    private pending;
+    private host;
+    private port;
+    private password;
+    private timeout;
+    constructor(options: RconOptions);
+    static connect(options: RconOptions): Promise<Rcon>;
+    on(event: string, listener: (...args: any[]) => void): void;
+    once(event: string, listener: (...args: any[]) => void): void;
+    off(event: string, listener: (...args: any[]) => void): void;
+    connect(): Promise<void>;
+    send(command: string): Promise<string>;
+    end(): void;
+    /**
+     * 编码 RCON 数据包
+     * 格式: [4:size][4:id][4:type][body][0x00][0x00]
+     */
+    private encode;
+    /**
+     * 从缓冲区中提取并处理完整的 RCON 数据包
+     * 正确处理 TCP 分包和合包
+     */
+    private drain;
+    /**
+     * 处理接收到的 RCON 数据包
+     *
+     * 认证阶段：
+     *   Minecraft 服务端对认证请求的响应因实现而异：
+     *   - Vanilla: 仅发送 Auth_Response (type=2, id=请求id 或 -1)
+     *   - 部分实现: 先发送空 Response_Value (type=0) 再发送 Auth_Response
+     *
+     *   处理策略：
+     *   1. 收到 type=2（Auth_Response）→ 立即判断认证结果
+     *   2. 收到 id=-1 → 认证失败（无论 type）
+     *   3. 其他包 → 忽略（可能是前导空响应）
+     */
+    private onPacket;
+}

package/lib/rcon.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rcon = void 0;
+const net_1 = require("net");
+const events_1 = require("events");
+/**
+ * 轻量级 Minecraft RCON 客户端
+ * 替换已停止维护的 rcon-client 库，修复认证兼容性问题
+ *
+ * 主要改进：
+ * - 正确处理 Minecraft 服务端的认证响应（兼容 Vanilla/Paper/Spigot/Fabric）
+ * - 稳健的 TCP 分包/合包缓冲处理
+ * - 独立的 TCP 连接超时和认证超时
+ * - 密码类型安全（防止 YAML 解析为非字符串）
+ */
+class Rcon {
+    socket = null;
+    emitter = new events_1.EventEmitter();
+    buf = Buffer.alloc(0);
+    nextId = 0;
+    authenticated = false;
+    // 认证阶段回调（独立于命令回调，避免 id 冲突）
+    authCb = null;
+    // 命令响应回调
+    pending = new Map();
+    host;
+    port;
+    password;
+    timeout;
+    constructor(options) {
+        this.host = options.host;
+        this.port = options.port ?? 25575;
+        // 关键修复：强制转为字符串，防止 YAML 将纯数字/布尔密码解析为非 string 类型
+        this.password = String(options.password ?? '');
+        this.timeout = options.timeout ?? 5000;
+    }
+    static async connect(options) {
+        const rcon = new Rcon(options);
+        await rcon.connect();
+        return rcon;
+    }
+    on(event, listener) {
+        this.emitter.on(event, listener);
+    }
+    once(event, listener) {
+        this.emitter.once(event, listener);
+    }
+    off(event, listener) {
+        this.emitter.removeListener(event, listener);
+    }
+    async connect() {
+        if (this.socket)
+            throw new Error('Already connected');
+        // ── Phase 1: TCP 连接 ──
+        const socket = (0, net_1.createConnection)({ host: this.host, port: this.port });
+        this.socket = socket;
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                socket.destroy();
+                this.socket = null;
+                reject(new Error(`RCON: TCP connection to ${this.host}:${this.port} timed out (${this.timeout}ms)`));
+            }, this.timeout);
+            const onError = (err) => {
+                clearTimeout(timer);
+                this.socket = null;
+                reject(err);
+            };
+            socket.once('error', onError);
+            socket.once('connect', () => {
+                clearTimeout(timer);
+                socket.removeListener('error', onError);
+                resolve();
+            });
+        });
+        socket.setNoDelay(true);
+        socket.on('data', (chunk) => {
+            this.buf = Buffer.concat([this.buf, chunk]);
+            this.drain();
+        });
+        socket.on('error', (err) => this.emitter.emit('error', err));
+        socket.on('close', () => {
+            this.authenticated = false;
+            this.socket = null;
+            this.buf = Buffer.alloc(0);
+            for (const [, p] of this.pending) {
+                clearTimeout(p.timer);
+                p.reject(new Error('Connection closed'));
+            }
+            this.pending.clear();
+            if (this.authCb) {
+                clearTimeout(this.authCb.timer);
+                this.authCb.reject(new Error('Connection closed during authentication'));
+                this.authCb = null;
+            }
+            this.emitter.emit('end');
+        });
+        // ── Phase 2: RCON 认证 ──
+        const authId = this.nextId++;
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.authCb = null;
+                socket.destroy();
+                this.socket = null;
+                reject(new Error(`RCON: Authentication timed out (${this.timeout}ms)`));
+            }, this.timeout);
+            this.authCb = { id: authId, resolve, reject, timer };
+            // Auth packet: type = 3 (SERVERDATA_AUTH)
+            socket.write(this.encode(authId, 3, this.password));
+        });
+    }
+    async send(command) {
+        if (!this.authenticated || !this.socket) {
+            throw new Error('RCON not connected');
+        }
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`RCON command timed out: ${command}`));
+            }, this.timeout);
+            this.pending.set(id, { resolve, reject, timer });
+            // Command packet: type = 2 (SERVERDATA_EXECCOMMAND)
+            this.socket.write(this.encode(id, 2, command));
+        });
+    }
+    end() {
+        this.socket?.destroy();
+    }
+    // ── RCON 协议编解码 ──
+    /**
+     * 编码 RCON 数据包
+     * 格式: [4:size][4:id][4:type][body][0x00][0x00]
+     */
+    encode(id, type, body) {
+        const payload = Buffer.from(body, 'utf-8');
+        const size = 4 + 4 + payload.length + 2; // id + type + body + 2 null terminators
+        const pkt = Buffer.alloc(4 + size); // 4 for size field
+        pkt.writeInt32LE(size, 0);
+        pkt.writeInt32LE(id, 4);
+        pkt.writeInt32LE(type, 8);
+        payload.copy(pkt, 12);
+        // 末尾 2 字节已由 Buffer.alloc 置 0x00（null terminators）
+        return pkt;
+    }
+    /**
+     * 从缓冲区中提取并处理完整的 RCON 数据包
+     * 正确处理 TCP 分包和合包
+     */
+    drain() {
+        while (this.buf.length >= 4) {
+            const size = this.buf.readInt32LE(0);
+            // 安全校验：size 最小为 10（4 id + 4 type + 2 null），最大为 1MB
+            if (size < 10 || size > 0x100000) {
+                this.buf = Buffer.alloc(0);
+                return;
+            }
+            const total = 4 + size;
+            if (this.buf.length < total)
+                return; // 等待更多数据
+            const raw = this.buf.subarray(0, total);
+            this.buf = this.buf.subarray(total);
+            const id = raw.readInt32LE(4);
+            const type = raw.readInt32LE(8);
+            // body 位于 header(12字节) 之后、末尾 2 字节 null 之前
+            const bodyEnd = Math.max(12, total - 2);
+            const body = raw.subarray(12, bodyEnd).toString('utf-8').replace(/\0+$/, '');
+            this.onPacket(id, type, body);
+        }
+    }
+    /**
+     * 处理接收到的 RCON 数据包
+     *
+     * 认证阶段：
+     *   Minecraft 服务端对认证请求的响应因实现而异：
+     *   - Vanilla: 仅发送 Auth_Response (type=2, id=请求id 或 -1)
+     *   - 部分实现: 先发送空 Response_Value (type=0) 再发送 Auth_Response
+     *
+     *   处理策略：
+     *   1. 收到 type=2（Auth_Response）→ 立即判断认证结果
+     *   2. 收到 id=-1 → 认证失败（无论 type）
+     *   3. 其他包 → 忽略（可能是前导空响应）
+     */
+    onPacket(id, type, body) {
+        if (!this.authenticated && this.authCb) {
+            // Auth_Response (type=2) 或 id=-1 → 最终认证结果
+            if (type === 2 || id === -1) {
+                const cb = this.authCb;
+                this.authCb = null;
+                clearTimeout(cb.timer);
+                if (id === -1) {
+                    cb.reject(new Error('RCON authentication failed: incorrect password'));
+                }
+                else if (id === cb.id) {
+                    this.authenticated = true;
+                    this.emitter.emit('authenticated');
+                    cb.resolve();
+                }
+                else {
+                    cb.reject(new Error(`RCON authentication failed: unexpected response id ${id}`));
+                }
+                return;
+            }
+            // type != 2 且 id != -1 → 前导空响应包，忽略
+            return;
+        }
+        // ── 命令响应 ──
+        const cb = this.pending.get(id);
+        if (cb) {
+            this.pending.delete(id);
+            clearTimeout(cb.timer);
+            cb.resolve(body);
+        }
+    }
+}
+exports.Rcon = Rcon;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-minecraft-adapter",
   "description": "Minecraft adapter for Koishi based on QueQiao V2 protocol",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -22,7 +22,6 @@
     "koishi": "^4.17.9"
   },
   "dependencies": {
-    "rcon-client": "^4.2.5",
     "ws": "^8.18.0"
   },
   "devDependencies": {