koishi-plugin-minecraft-adapter 1.0.9 → 1.0.11

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');
 /**
@@ -415,7 +415,8 @@ class MinecraftAdapter extends koishi_1.Adapter {
         return states[state] || `UNKNOWN(${state})`;
     }
     async connectRcon(bot) {
-        const config = bot.config;
+        // 优先使用 rconConfigs（经 migrateConfig 扁平化后的可靠配置），回退到 bot.config
+        const config = this.rconConfigs.get(bot.selfId) ?? bot.config;
         const selfId = bot.selfId;
         // rconHost 未配置时，从 WebSocket URL 中提取主机地址作为回退
         let rconHost = config.rconHost;
@@ -439,7 +440,8 @@ class MinecraftAdapter extends koishi_1.Adapter {
             });
         }
         try {
-            const rcon = await this.createRconWithTimeout(rconHost, rconPort, config.rconPassword || '', rconTimeout);
+            const rconPassword = String(config.rconPassword ?? '');
+            const rcon = await this.createRconWithTimeout(rconHost, rconPort, rconPassword, rconTimeout);
             this.rconConnections.set(selfId, rcon);
             bot.rcon = rcon;
             this.rconReconnectAttempts.set(selfId, 0);
@@ -463,11 +465,12 @@ class MinecraftAdapter extends koishi_1.Adapter {
         }
     }
     createRconWithTimeout(host, port, password, timeout) {
+        const debug = this.debug;
         return new Promise((resolve, reject) => {
             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, debug }).then((rcon) => { clearTimeout(timer); resolve(rcon); }, (err) => { clearTimeout(timer); reject(err); });
         });
     }
     scheduleRconReconnect(bot) {
@@ -1225,7 +1228,7 @@ MinecraftBot.MessageEncoder = MinecraftMessageEncoder;
 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(),
+    url: koishi_1.Schema.string().description('WebSocket 地址（如 ws://127.0.0.1:8080）'),
     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),
@@ -1235,6 +1238,10 @@ const serverSchema = koishi_1.Schema.object({
     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('图片'),
+    // 接受嵌套配置格式（README 文档中推荐的格式），由 flattenServerConfig 扁平化
+    websocket: koishi_1.Schema.any().hidden(),
+    rcon: koishi_1.Schema.any().hidden(),
+    chatImage: koishi_1.Schema.any().hidden(),
 });
 (function (MinecraftAdapter) {
     MinecraftAdapter.Config = koishi_1.Schema.object({

package/lib/index.ts.backup

@@ -0,0 +1,492 @@
+import { Adapter, Bot, Context, Logger, Schema, Session } from 'koishi'
+import { Rcon } from 'rcon-client'
+import WebSocket from 'ws'
+
+const logger = new Logger('minecraft')
+
+export interface MinecraftBotConfig {
+  selfId: string
+  serverName?: string
+  rcon?: {
+    host: string
+    port: number
+    password: string
+    timeout?: number
+  }
+  websocket?: {
+    url: string
+    accessToken?: string
+    extraHeaders?: Record<string, string>
+  }
+}
+
+export class MinecraftBot<C extends Context = Context> extends Bot<C, MinecraftBotConfig> {
+  public rcon?: Rcon
+  public ws?: WebSocket
+
+  constructor(ctx: C, config: MinecraftBotConfig) {
+    super(ctx, config, 'minecraft')
+    this.selfId = config.selfId
+  }
+
+  async sendMessage(channelId: string, content: string) {
+    if (channelId.startsWith('mc:')) {
+      const player = channelId.slice(3)
+      return await this.sendPrivateMessage(player, content)
+    } else {
+      if (this.adapter instanceof MinecraftAdapter) {
+        await this.adapter.broadcast(content)
+        return []
+      }
+      return []
+    }
+  }
+
+  async sendPrivateMessage(userId: string, content: string): Promise<string[]> {
+    if (this.adapter instanceof MinecraftAdapter) {
+      await this.adapter.sendPrivateMessage(userId, content)
+      return []
+    }
+    return []
+  }
+
+  async executeCommand(command: string): Promise<string> {
+    if (!this.rcon) throw new Error('RCON not connected')
+    return await this.rcon.send(command)
+  }
+}
+
+export interface MinecraftAdapterConfig {
+  bots: MinecraftBotConfig[]
+  debug?: boolean
+  reconnectInterval?: number
+  maxReconnectAttempts?: number
+}
+
+export class MinecraftAdapter<C extends Context = Context> extends Adapter<C, MinecraftBot<C>> {
+  private rconConnections = new Map<string, Rcon>()
+  private wsConnections = new Map<string, WebSocket>()
+  private reconnectAttempts = new Map<string, number>()
+  private debug: boolean
+  private reconnectInterval: number
+  private maxReconnectAttempts: number
+
+  constructor(ctx: C, config: MinecraftAdapterConfig) {
+    super(ctx)
+    this.debug = config.debug ?? false
+    this.reconnectInterval = config.reconnectInterval ?? 5000
+    this.maxReconnectAttempts = config.maxReconnectAttempts ?? 10
+
+    if (this.debug) {
+      logger.info(`[DEBUG] MinecraftAdapter initialized with config:`, {
+        debug: this.debug,
+        reconnectInterval: this.reconnectInterval,
+        maxReconnectAttempts: this.maxReconnectAttempts,
+        botCount: config.bots.length
+      })
+    }
+
+    // 为每个配置创建机器人
+    ctx.on('ready', async () => {
+      if (this.debug) {
+        logger.info(`[DEBUG] Koishi ready event triggered, initializing ${config.bots.length} bots`)
+      }
+
+      for (const botConfig of config.bots) {
+        if (this.debug) {
+          logger.info(`[DEBUG] Initializing bot ${botConfig.selfId}`)
+        }
+
+        const bot = new MinecraftBot(ctx, botConfig)
+        bot.adapter = this
+        this.bots.push(bot)
+
+        // 初始化 RCON 连接
+        if (botConfig.rcon) {
+          try {
+            if (this.debug) {
+              logger.info(`[DEBUG] Connecting RCON for bot ${botConfig.selfId} to ${botConfig.rcon.host}:${botConfig.rcon.port}`)
+            }
+
+            const rcon = await Rcon.connect({
+              host: botConfig.rcon.host,
+              port: botConfig.rcon.port,
+              password: botConfig.rcon.password,
+              timeout: botConfig.rcon.timeout || 5000,
+            })
+            this.rconConnections.set(botConfig.selfId, rcon)
+            bot.rcon = rcon
+            logger.info(`RCON connected for bot ${botConfig.selfId}`)
+          } catch (error) {
+            logger.warn(`Failed to connect RCON for bot ${botConfig.selfId}:`, error)
+            if (this.debug) {
+              logger.info(`[DEBUG] RCON connection error details:`, error.message, error.stack)
+            }
+          }
+        } else {
+          if (this.debug) {
+            logger.info(`[DEBUG] No RCON config for bot ${botConfig.selfId}`)
+          }
+        }
+
+        // 初始化 WebSocket 连接
+        if (botConfig.websocket) {
+          if (this.debug) {
+            logger.info(`[DEBUG] Initializing WebSocket for bot ${botConfig.selfId}`)
+          }
+          await this.connectWebSocket(bot, botConfig.websocket)
+        } else {
+          if (this.debug) {
+            logger.info(`[DEBUG] No WebSocket config for bot ${botConfig.selfId}`)
+          }
+        }
+      }
+    })
+  }
+
+  private getWebSocketCloseCode(code: number): string {
+    const codes: Record<number, string> = {
+      1000: 'Normal Closure',
+      1001: 'Going Away',
+      1002: 'Protocol Error',
+      1003: 'Unsupported Data',
+      1004: 'Reserved',
+      1005: 'No Status Received',
+      1006: 'Abnormal Closure',
+      1007: 'Invalid Frame Payload Data',
+      1008: 'Policy Violation',
+      1009: 'Message Too Big',
+      1010: 'Missing Extension',
+      1011: 'Internal Error',
+      1012: 'Service Restart',
+      1013: 'Try Again Later',
+      1014: 'Bad Gateway',
+      1015: 'TLS Handshake'
+    }
+    return codes[code] || `Unknown Code ${code}`
+  }
+
+  private getWebSocketStateString(state: number): string {
+    const states = {
+      0: 'CONNECTING',
+      1: 'OPEN',
+      2: 'CLOSING',
+      3: 'CLOSED'
+    }
+    return states[state as keyof typeof states] || `UNKNOWN(${state})`
+  }
+    const headers: Record<string, string> = {
+      'x-self-name': bot.config.serverName || bot.selfId,
+      ...(wsConfig.extraHeaders || {}),
+    }
+    if (wsConfig.accessToken) {
+      headers['Authorization'] = `Bearer ${wsConfig.accessToken}`
+    }
+
+    if (this.debug) {
+      logger.info(`[DEBUG] Connecting to WebSocket: ${wsConfig.url}`)
+      logger.info(`[DEBUG] Headers:`, headers)
+    }
+
+    const ws = new WebSocket(wsConfig.url, { headers })
+    this.wsConnections.set(bot.selfId, ws)
+    bot.ws = ws
+
+    // 添加连接超时处理
+    const connectionTimeout = setTimeout(() => {
+      if (ws.readyState === WebSocket.CONNECTING) {
+        if (this.debug) {
+          logger.info(`[DEBUG] WebSocket connection timeout for bot ${bot.selfId}`)
+        }
+        ws.close()
+      }
+    }, 10000) // 10秒超时
+
+    ws.on('open', () => {
+      logger.info(`WebSocket connected for bot ${bot.selfId}`)
+      if (this.debug) {
+        logger.info(`[DEBUG] WebSocket opened successfully for bot ${bot.selfId}`)
+      }
+      // 重置重连尝试次数
+      this.reconnectAttempts.set(bot.selfId, 0)
+      bot.online()
+      clearTimeout(connectionTimeout)
+    })
+
+    ws.on('message', (data: WebSocket.RawData) => {
+      try {
+        const text = data.toString('utf8')
+        if (this.debug) {
+          logger.info(`[DEBUG] Received WebSocket message for bot ${bot.selfId}:`, text)
+          logger.info(`[DEBUG] Message length: ${text.length} characters`)
+        }
+
+        const obj = JSON.parse(text)
+        const type = obj.type || obj.event || 'unknown'
+        const payload = obj.data ?? obj
+
+        if (this.debug) {
+          logger.info(`[DEBUG] Parsed message type: ${type}, payload:`, payload)
+        }
+
+        const session = this.createSession(bot, type, payload)
+        if (session) {
+          if (this.debug) {
+            logger.info(`[DEBUG] Created session:`, session)
+            logger.info(`[DEBUG] Dispatching session to bot ${bot.selfId}`)
+          }
+          bot.dispatch(session)
+          if (this.debug) {
+            logger.info(`[DEBUG] Session dispatched successfully`)
+          }
+        } else {
+          if (this.debug) {
+            logger.info(`[DEBUG] No session created for message type: ${type}`)
+          }
+        }
+      } catch (error) {
+        logger.warn('Failed to process WebSocket message:', error)
+        if (this.debug) {
+          logger.info(`[DEBUG] Raw message data:`, data.toString('utf8'))
+          logger.info(`[DEBUG] Parse error:`, error.message, error.stack)
+        }
+      }
+    })
+
+    ws.on('close', (code, reason) => {
+      logger.warn(`WebSocket disconnected for bot ${bot.selfId} (code: ${code}, reason: ${reason.toString()})`)
+      if (this.debug) {
+        logger.info(`[DEBUG] Close code details:`, this.getWebSocketCloseCode(code))
+        logger.info(`[DEBUG] Close reason:`, reason.toString())
+      }
+      bot.offline()
+
+      const attempts = this.reconnectAttempts.get(bot.selfId) || 0
+      if (attempts < this.maxReconnectAttempts) {
+        this.reconnectAttempts.set(bot.selfId, attempts + 1)
+        const delay = this.reconnectInterval * Math.pow(2, attempts) // 指数退避
+        if (this.debug) {
+          logger.info(`[DEBUG] Attempting to reconnect WebSocket for bot ${bot.selfId} in ${delay}ms (attempt ${attempts + 1}/${this.maxReconnectAttempts})`)
+        }
+        setTimeout(() => {
+          if (!this.wsConnections.has(bot.selfId)) {
+            this.connectWebSocket(bot, wsConfig)
+          }
+        }, delay)
+      } else {
+        logger.error(`Max reconnect attempts reached for bot ${bot.selfId}`)
+      }
+    })
+
+    ws.on('error', (error) => {
+      logger.warn(`WebSocket error for bot ${bot.selfId}:`, error)
+      if (this.debug) {
+        logger.info(`[DEBUG] WebSocket error details:`, error.message, error.stack)
+      }
+    })
+
+    ws.on('ping', () => {
+      if (this.debug) {
+        logger.info(`[DEBUG] Received ping from server for bot ${bot.selfId}`)
+      }
+    })
+
+    ws.on('pong', () => {
+      if (this.debug) {
+        logger.info(`[DEBUG] Received pong from server for bot ${bot.selfId}`)
+      }
+    })
+  }
+
+  private createSession(bot: MinecraftBot<C>, type: string, payload: any): Session | undefined {
+    if (this.debug) {
+      logger.info(`[DEBUG] Creating session for event type: ${type}, payload:`, payload)
+    }
+
+    switch (type) {
+      case 'chat':
+      case 'player_chat':
+        return {
+          type: 'message',
+          subtype: 'private',
+          platform: 'minecraft',
+          selfId: bot.selfId,
+          userId: payload.player || payload.name || 'unknown',
+          channelId: `mc:${payload.player || payload.name || 'unknown'}`,
+          guildId: 'minecraft',
+          content: payload.message || payload.text || '',
+          timestamp: Date.now(),
+          author: {
+            userId: payload.player || payload.name || 'unknown',
+            username: payload.player || payload.name || 'unknown',
+          },
+        } as Session
+
+      case 'join':
+      case 'player_join':
+        return {
+          type: 'guild-member-added',
+          platform: 'minecraft',
+          selfId: bot.selfId,
+          userId: payload.player || payload.name || 'unknown',
+          guildId: 'minecraft',
+          timestamp: Date.now(),
+        } as Session
+
+      case 'leave':
+      case 'quit':
+      case 'player_quit':
+        return {
+          type: 'guild-member-removed',
+          platform: 'minecraft',
+          selfId: bot.selfId,
+          userId: payload.player || payload.name || 'unknown',
+          guildId: 'minecraft',
+          timestamp: Date.now(),
+        } as Session
+
+      case 'death':
+      case 'player_death':
+        return {
+          type: 'message',
+          subtype: 'private',
+          platform: 'minecraft',
+          selfId: bot.selfId,
+          userId: payload.player || payload.name || 'unknown',
+          channelId: 'minecraft',
+          guildId: 'minecraft',
+          content: `💀 ${payload.player || payload.name || 'unknown'} ${payload.deathMessage || 'died'}`,
+          timestamp: Date.now(),
+          author: {
+            userId: payload.player || payload.name || 'unknown',
+            username: payload.player || payload.name || 'unknown',
+          },
+        } as Session
+
+      case 'advancement':
+      case 'achievement':
+        return {
+          type: 'message',
+          subtype: 'private',
+          platform: 'minecraft',
+          selfId: bot.selfId,
+          userId: payload.player || payload.name || 'unknown',
+          channelId: 'minecraft',
+          guildId: 'minecraft',
+          content: `🏆 ${payload.player || payload.name || 'unknown'} achieved: ${payload.advancement || payload.achievement}`,
+          timestamp: Date.now(),
+          author: {
+            userId: payload.player || payload.name || 'unknown',
+            username: payload.player || payload.name || 'unknown',
+          },
+        } as Session
+
+      default:
+        // 自定义事件可以通过其他方式处理
+        if (this.debug) {
+          logger.info(`[DEBUG] Unhandled event type: ${type}, payload:`, payload)
+        }
+        logger.debug(`Unhandled event type: ${type}`, payload)
+        return undefined
+    }
+  }
+
+  async sendPrivateMessage(player: string, message: string): Promise<void> {
+    // 优先使用 WebSocket 发送
+    for (const [botId, ws] of this.wsConnections) {
+      if (ws.readyState === WebSocket.OPEN) {
+        const payload = {
+          api: 'tell',
+          data: { player, message }
+        }
+        ws.send(JSON.stringify(payload))
+        return
+      }
+    }
+
+    // 回退到 RCON
+    for (const [botId, rcon] of this.rconConnections) {
+      try {
+        const json = JSON.stringify([{ text: message }])
+        await rcon.send(`tellraw ${player} ${json}`)
+        return
+      } catch (error) {
+        logger.warn(`Failed to send message via RCON for bot ${botId}:`, error)
+      }
+    }
+
+    throw new Error('No available connection to send message')
+  }
+
+  async broadcast(message: string): Promise<void> {
+    // 优先使用 WebSocket 发送
+    for (const [botId, ws] of this.wsConnections) {
+      if (ws.readyState === WebSocket.OPEN) {
+        const payload = {
+          api: 'broadcast',
+          data: { message }
+        }
+        ws.send(JSON.stringify(payload))
+        return
+      }
+    }
+
+    // 回退到 RCON
+    for (const [botId, rcon] of this.rconConnections) {
+      try {
+        await rcon.send(`say ${message}`)
+        return
+      } catch (error) {
+        logger.warn(`Failed to broadcast via RCON for bot ${botId}:`, error)
+      }
+    }
+
+    throw new Error('No available connection to broadcast message')
+  }
+
+  async stop() {
+    // 关闭所有连接
+    for (const [botId, ws] of this.wsConnections) {
+      try {
+        ws.close()
+      } catch (error) {
+        logger.warn(`Failed to close WebSocket for bot ${botId}:`, error)
+      }
+    }
+    this.wsConnections.clear()
+
+    for (const [botId, rcon] of this.rconConnections) {
+      try {
+        rcon.end()
+      } catch (error) {
+        logger.warn(`Failed to close RCON for bot ${botId}:`, error)
+      }
+    }
+    this.rconConnections.clear()
+  }
+}
+
+export namespace MinecraftAdapter {
+  export const Config: Schema<MinecraftAdapterConfig> = Schema.object({
+    debug: Schema.boolean().description('启用调试模式，输出详细日志').default(false),
+    reconnectInterval: Schema.number().description('重连间隔时间(ms)').default(5000),
+    maxReconnectAttempts: Schema.number().description('最大重连尝试次数').default(10),
+    bots: Schema.array(Schema.object({
+      selfId: Schema.string().description('机器人 ID').required(),
+      serverName: Schema.string().description('服务器名称'),
+      rcon: Schema.object({
+        host: Schema.string().description('RCON 主机地址').default('127.0.0.1'),
+        port: Schema.number().description('RCON 端口').default(25575),
+        password: Schema.string().description('RCON 密码').required(),
+        timeout: Schema.number().description('RCON 超时时间(ms)').default(5000),
+      }).description('RCON 配置'),
+      websocket: Schema.object({
+        url: Schema.string().description('WebSocket 地址').required(),
+        accessToken: Schema.string().description('访问令牌'),
+        extraHeaders: Schema.dict(String).description('额外请求头'),
+      }).description('WebSocket 配置'),
+    })).description('机器人配置列表').default([]),
+  })
+}
+
+export default MinecraftAdapter

package/lib/rcon.d.ts

@@ -0,0 +1,63 @@
+export interface RconOptions {
+    host: string;
+    port?: number;
+    password: string;
+    timeout?: number;
+    debug?: boolean;
+}
+/**
+ * 轻量级 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;
+    private debug;
+    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,218 @@
+"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;
+    debug;
+    constructor(options) {
+        this.host = options.host;
+        this.port = options.port ?? 25575;
+        // 关键修复：强制转为字符串，防止 YAML 将纯数字/布尔密码解析为非 string 类型
+        this.password = String(options.password ?? '');
+        this.timeout = options.timeout ?? 5000;
+        this.debug = options.debug ?? false;
+    }
+    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)
+            const authPkt = this.encode(authId, 3, this.password);
+            socket.write(authPkt);
+        });
+    }
+    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.11",
   "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": {