koishi-plugin-minecraft-adapter 1.0.9 → 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,7 +5,7 @@ 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');
 /**
@@ -439,7 +439,7 @@ class MinecraftAdapter extends koishi_1.Adapter {
             });
         }
         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);
@@ -467,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) {

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.9",
+  "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": {