koishi-plugin-minecraft-adapter 1.0.10 → 1.0.11

package/lib/index.js

@@ -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, String(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_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

@@ -3,6 +3,7 @@ export interface RconOptions {
     port?: number;
     password: string;
     timeout?: number;
+    debug?: boolean;
 }
 /**
  * 轻量级 Minecraft RCON 客户端
@@ -26,6 +27,7 @@ export declare class Rcon {
     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;

package/lib/rcon.js

@@ -27,12 +27,14 @@ class Rcon {
     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);
@@ -105,7 +107,8 @@ class Rcon {
             }, this.timeout);
             this.authCb = { id: authId, resolve, reject, timer };
             // Auth packet: type = 3 (SERVERDATA_AUTH)
-            socket.write(this.encode(authId, 3, this.password));
+            const authPkt = this.encode(authId, 3, this.password);
+            socket.write(authPkt);
         });
     }
     async send(command) {

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.10",
+  "version": "1.0.11",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [