@baipiaodajun/mcbots 1.2.0 → 1.2.2

package/README.md

@@ -57,7 +57,7 @@ docker run -d \
   mingli2038/mcbot:latest
 ```
 
-## 🔄 新版本说明
+### 新版本说明
 
 - 新版本引入了 **热更新功能：`SERVER_JSON`**  
 - 目前该功能处于 **实验状态**，可能会导致一些 **意料之外的问题**  
@@ -65,7 +65,7 @@ docker run -d \
 
 ---
 
-## 🛠️ 页面更新
+### 页面更新
 
 在页面底部新增了修复入口：  
 **【更新 MC 机器人配置】**
@@ -74,7 +74,7 @@ docker run -d \
 
 ---
 
-## 🔑 密钥设置
+### 密钥设置
 
 - 默认密钥可从 [Telegram频道](https://t.me/boost/wanjulaji) 获取  
 - 也可以通过环境变量自行设置：

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@baipiaodajun/mcbots",
-    "version": "1.2.0",
+    "version": "1.2.2",
     "description": "Minecraft bot and status dashboard for multi-server management",
     "main": "server.js",
     "scripts": {

package/server.js

@@ -10,6 +10,13 @@ const fs   = require('fs');
 const PORT = process.env.SERVER_PORT || process.env.PORT || 3000 ; 
 const CHAT = process.env.CHAT || false ; 
 const MOVE = process.env.MOVE || false ;
+//debug模式，只有开启时才会有很多日志。
+const DEBUG = (process.env.DEBUG || '').toLowerCase() === 'true';
+function debugPrint(...args) {
+  if (DEBUG) {
+    console.log(...args);
+  }
+}
 // Minecraft服务器配置
 const SERVERS = [
   {
@@ -124,7 +131,7 @@ const BOT_CONFIG = {
 
 const SERVER_CONFIG = {
   statusCheckInterval: 30000,
-  maxFailedAttempts: 3,
+  maxFailedAttempts: 1,
   resetTimeout: 30000
 };
 
@@ -207,6 +214,7 @@ class MinecraftBotManager {
     this.version = version || "1.20.1";
     this.currentBots = 0;
     this.activeBots = new Map();
+    this.pendingReconnect = new Set();   // 等待重连的机器人名字（已断开但优先重用名字）
     this.failedAttempts = 0;
     this.lastUpdate = Date.now();
     this.status = 'initializing';
@@ -231,7 +239,54 @@ class MinecraftBotManager {
       status: 'initializing'
     });
   }
-
+  dispose() {
+    const key = `${this.host}:${this.port}`;
+    console.log(`[${key}] 正在释放 BotManager 所有资源...`);
+  
+    // 1. 停止所有正在运行的机器人（最重要！）
+    this.activeBots.forEach((bot, botName) => {
+      try {
+        if (bot && typeof bot.end === 'function') {
+          bot.removeAllListeners();  // 关键！移除所有事件监听，防止回调残留
+          bot.end();                 // 主动断开连接
+        }
+        console.log(`[${key}] 已断开机器人: ${botName}`);
+      } catch (err) {
+        console.warn(`[${key}] 断开 ${botName} 时出错:`, err.message);
+      }
+    });
+    this.activeBots.clear();
+    this.currentBots = 0;
+  
+    // 2. 清理所有定时器（防止残留 setInterval/setTimeout）
+    if (this.monitoringInterval) {
+      clearInterval(this.monitoringInterval);
+      this.monitoringInterval = null;
+      console.log(`[${key}] 已清理 monitoringInterval`);
+    }
+  
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+  
+    if (this.resetTimer) {
+      clearTimeout(this.resetTimer);
+      this.resetTimer = null;
+      console.log(`[${key}] 已清理 resetTimer`);
+    }
+    // 4. 从全局状态移除（前端立刻看不到）
+    globalServerStatus.servers.delete(key);
+    console.log(`[${key}] 已从 globalServerStatus 中移除`);
+  
+    // 5. 清理自身引用，帮助 GC
+    this.botNames = null;
+    this.activeBots = null;
+    this.status = 'disposed';
+    this.reachable = false;
+  
+    console.log(`[${key}] BotManager 资源释放完成`);
+  }
   // 生成随机机器人名称
   generateBotName() {
     const baseName = this.botNames[Math.floor(Math.random() * this.botNames.length)];
@@ -253,16 +308,52 @@ class MinecraftBotManager {
       this.notice=true;
     }
   }
+  async handleBottimeout(bot,botName){
+    this.timeout = setTimeout(() => {
+      debugPrint(`[${this.host}:${this.port}] ${botName} 连接超时，强制终止`);
+    
+      // 第一步：尝试正常结束（推荐方式）
+      if (typeof bot.end === 'function') {
+        try {
+          bot.end();
+          debugPrint(`[${this.host}:${this.port}] ${botName} 调用 bot.end() 成功`);
+          return; // 如果正常结束，就不需要进一步操作
+        } catch (err) {
+          debugPrint(`[${this.host}:${this.port}] ${botName} bot.end() 抛出异常:`, err.message);
+          // 继续尝试强杀底层 socket
+        }
+      }
+    
+      // 第二步：bot.end 失败或不存在，强制关闭底层 client socket
+      if (bot._client?.socket) {
+        try {
+          bot._client.socket.destroy(); // 最彻底：直接 destroy socket
+          debugPrint(`[${this.host}:${this.port}] ${botName} 强制 destroy 底层 socket`);
+        } catch (err) {
+          debugPrint(`[${this.host}:${this.port}] ${botName} destroy socket 失败:`, err.message);
+        }
+      } else if (bot._client?.end) {
+        try {
+          bot._client.end();
+          debugPrint(`[${this.host}:${this.port}] ${botName} 调用 bot._client.end()`);
+        } catch (err) {
+          debugPrint(`[${this.host}:${this.port}] ${botName} bot._client.end() 失败:`, err.message);
+        }
+      } else {
+        debugPrint(`[${this.host}:${this.port}] ${botName} 无可用 client socket，无法强制关闭`);
+      }
+    
+      // 可选：触发断开处理（确保进入重连逻辑）
+      this.handleBotDisconnect(botName);
+    
+    }, BOT_CONFIG.connectTimeout);
+  }
   // 创建Minecraft机器人
   async createBot(botName) {
     if (this.currentBots >= this.maxBots) {
       console.log(`[${this.host}:${this.port}] 已达到最大机器人限制: ${this.maxBots}`);
       return null;
     }
-    await this.testmc();
-    if (!this.reachable) {
-      return null;
-    }
     if(!botName){
       botName = this.generateBotName();
     }
@@ -277,12 +368,7 @@ class MinecraftBotManager {
           auth: 'offline'
         });
 
-        this.timeout = setTimeout(() => {
-          console.error(`[${this.host}:${this.port}] ${botName}连接超时，放弃等待`);
-          if (typeof bot.end === 'function') {
-            bot.end(); 
-          }
-        }, BOT_CONFIG.connectTimeout);
+        this.handleBottimeout(bot,botName);
 
         // 设置机器人事件处理
         this.setupBotEvents(bot, botName);
@@ -293,7 +379,7 @@ class MinecraftBotManager {
         this.updateStatus();
         return bot;
     } catch (error) {
-      console.log(`[${this.host}:${this.port}] 创建机器人 ${botName} 失败:`, error.message);
+      debugPrint(`[${this.host}:${this.port}] 创建机器人 ${botName} 失败:`, error.message);
       this.handleBotFailure(botName);
       return null;
     }
@@ -307,19 +393,20 @@ class MinecraftBotManager {
         clearTimeout(this.timeout);
         this.timeout = null;
       }
+      this.failedAttempts = 0;
+      this.pendingReconnect.delete(botName);
       this.updateStatus();
     });
 
     bot.on('spawn', () => {
-      console.log(`[${this.host}:${this.port}] 机器人 ${botName} 生成在世界中`);
-      
+      debugPrint(`[${this.host}:${this.port}] 机器人 ${botName} 生成在世界中`);
       // 机器人基础行为
       this.setupBotBehavior(bot, botName);
     });
 
     bot.on('message', (message) => {
       const text = message.toString();
-      console.log(`[${this.host}:${this.port}] ${botName} 收到消息: ${text}`);
+      debugPrint(`[${this.host}:${this.port}] ${botName} 收到消息: ${text}`);
     });
 
     bot.on('error', (error) => {
@@ -333,7 +420,7 @@ class MinecraftBotManager {
 
     bot.on('end', (reason) => {
       console.log(`[${this.host}:${this.port}] 机器人 ${botName} 断开连接:`, reason);
-      console.log(`[${this.host}:${this.port}] ${botName}:失败次数${this.failedAttempts}`);
+      // console.log(`[${this.host}:${this.port}] ${botName}:失败次数${this.failedAttempts}`);
       this.handleBotDisconnect(botName);
     });
 
@@ -372,27 +459,21 @@ class MinecraftBotManager {
     }
   }
 
-  // 处理机器人断开连接 - 增强版本
   handleBotDisconnect(botName) {
     if (this.activeBots.has(botName)) {
-      console.log(`[${this.host}:${this.port}] 从活跃列表中移除机器人: ${botName}`);
+      debugPrint(`[${this.host}:${this.port}] 从活跃列表中移除机器人: ${botName}`);
       this.activeBots.delete(botName);
       this.currentBots = Math.max(0, this.currentBots - 1);
       this.updateStatus();
-      
-      // 记录断开连接时间，用于调试
-      console.log(`[${this.host}:${this.port}] 当前活跃机器人数量: ${this.currentBots}, 目标: ${this.minBots}`);
-      
-      if(this.failedAttempts > SERVER_CONFIG.maxFailedAttempts){
-        console.log(`[${this.host}:${this.port}] 机器人 ${botName} 重连次数太多，跳过`);
-        return;
-      }
-      // 延迟重连，避免频繁重连
+      this.pendingReconnect.add(botName);
+      debugPrint(`[${this.host}:${this.port}] 当前活跃机器人数量: ${this.currentBots}, 目标: ${this.minBots}`);
+  
       setTimeout(() => {
         this.reconnect(botName);
       }, BOT_CONFIG.reconnectDelay);
+  
     } else {
-      console.log(`[${this.host}:${this.port}] 机器人 ${botName} 不在活跃列表中，无需处理`);
+      debugPrint(`[${this.host}:${this.port}] 机器人 ${botName} 不在活跃列表中，无需处理`);
     }
   }
   
@@ -400,62 +481,63 @@ class MinecraftBotManager {
   handleBotFailure(botName) {
     this.failedAttempts++;
     this.updateStatus();
-    if (this.failedAttempts >= SERVER_CONFIG.maxFailedAttempts) {
-      console.log(`[${this.host}:${this.port}] 失败次数过多，${SERVER_CONFIG.resetTimeout / 1000}秒后再次尝试`);
-      setTimeout(() => {
-        this.failedAttempts = 0;
-        this.reconnect(botName);
-      }, SERVER_CONFIG.resetTimeout);
-      return;
-    }
-    setTimeout(() => {
-      this.reconnect(botName);
-    }, BOT_CONFIG.reconnectDelay);
+    this.reconnect(botName);
   }
 
   // 维护机器人数目 - 增强版本
-  maintainBots() {
-    const neededBots = this.minBots - this.currentBots;
-    
-    // console.log(`[${this.host}:${this.port}] 当前机器人: ${this.currentBots}, 需要: ${neededBots}, 失败次数: ${this.failedAttempts}`);
-    if (neededBots > 0 && this.failedAttempts < SERVER_CONFIG.maxFailedAttempts) {
-      if (this.notice) {
-        console.log(`[${this.host}:${this.port}] 需要启动 ${neededBots} 个机器人`);
-        this.notice=false;
-      }
-      for (let i = 0; i < neededBots; i++) {
-        setTimeout(() => {
-          this.createBot();
-        }, i * 8000); // 每隔8秒启动一个
+  async maintainBots() {
+    const neededBots =  this.minBots -this.currentBots;
+    try {
+      debugPrint(`[${this.host}:${this.port}] 当前机器人: ${this.currentBots}, 需要: ${neededBots}, 失败次数: ${this.failedAttempts}`);
+      await this.testmc();
+      if (!this.reachable) {
+        return null;
       }
-    } 
-    // else if (neededBots > 0) {
-    //   console.log(`[${this.host}:${this.port}] 由于失败次数过多，暂停创建新机器人`);
-    // }
-    this.updateStatus();
+      if (neededBots > 0 && this.failedAttempts < SERVER_CONFIG.maxFailedAttempts) {
+        if (this.notice) {
+          console.log(`[${this.host}:${this.port}] 需要启动 ${neededBots} 个机器人`);
+          this.notice=false;
+        }
+        for (let i = 0; i < neededBots; i++) {
+          setTimeout(() => {
+            this.createBot();
+          }, i * 8000); // 每隔8秒启动一个
+        }
+      } 
+      this.updateStatus();
+    }
+    catch (err) {
+      console.error(`[${this.host}:${this.port}] maintainBots 异常:`, err);
+    }
   }
-  reconnect(botName){
-    if (this.failedAttempts < SERVER_CONFIG.maxFailedAttempts) {
-      console.log(`[${this.host}:${this.port}] 第${this.failedAttempts}次重连 ${botName} 机器人`);
-      this.failedAttempts++;
-        setTimeout(() => {
-          this.createBot(botName);
-        }, 5000); 
-    } else{
-      // 如果还没有设置过 resetTimer，就设置一次
+
+  reconnect(botName) {
+    if (this.failedAttempts >= SERVER_CONFIG.maxFailedAttempts) {
       if (!this.resetTimer) {
         this.resetTimer = setTimeout(() => {
           this.failedAttempts = 0;
-          this.resetTimer = null; // 清理标记，允许下次再设置
-          console.log(
-            `[${this.host}:${this.port}] 失败次数已重置，可以重新尝试创建机器人`
-          );
+          this.resetTimer = null;
+          debugPrint(`[${this.host}:${this.port}] 冷却期结束，恢复维护`);
+          this.maintainBots();
         }, SERVER_CONFIG.resetTimeout);
+        debugPrint(`[${this.host}:${this.port}] 失败过多，进入冷却 ${ SERVER_CONFIG.resetTimeout/ 1000}s`);
       }
-      console.log(`[${this.host}:${this.port}] 由于失败次数过多，暂停创建新机器人`);
+      return;
     }
-    this.updateStatus();
+
+    this.failedAttempts++;
+
+    // 如果传入 botName（来自断开重连），且它还在待重连名单中 → 优先用原名字
+    if (botName && this.pendingReconnect.has(botName)) {
+      debugPrint(`[${this.host}:${this.port}] 第 ${this.failedAttempts} 次尝试重连原机器人: ${botName}`);
+      this.createBot(botName);  // 传名字，保持固定
+      return;
+    }
+    // 否则（新补人或名字已被放弃）→ 不传名字，生成新的
+    debugPrint(`[${this.host}:${this.port}] 第 ${this.failedAttempts} 次连接失败，触发维护补人`);
+    this.maintainBots();
   }
+
   // 更新状态
   updateStatus() {
     const serverInfo = globalServerStatus.servers.get(`${this.host}:${this.port}`);
@@ -1551,29 +1633,14 @@ async function hotUpdateServers() {
     const key = `${config.host}:${config.port}`;
     console.log(`热更新: 新增服务器 ${key} (${config.minBots}-${config.maxBots})`);
     toAdd.push(config);
-
-    // 立即在前台状态中注册（前端马上能看到 initializing）
-    globalServerStatus.servers.set(key, {
-      host: config.host,
-      port: config.port,
-      minBots: config.minBots,
-      maxBots: config.maxBots,
-      currentBots: 0,
-      activeBots: [],
-      lastUpdate: Date.now(),
-      status: 'initializing'
-    });
   }
 
   // 3. 先关闭 + 移除旧的管理器
   for (const manager of toRemove) {
-    manager.stopAllBots();
-    if (typeof manager.stopMonitoring === 'function') {
-      manager.stopMonitoring();
-    }
+    manager.dispose(); // 统一释放资源
     const idx = botManagers.indexOf(manager);
     if (idx !== -1) botManagers.splice(idx, 1);
-  }
+  }  
 
   // 4. 创建新的管理器（构造函数里会自动注册到 globalServerStatus）
   for (const config of toAdd) {
@@ -1587,7 +1654,6 @@ async function hotUpdateServers() {
     newManager.startMonitoring();
     botManagers.push(newManager);
   }
-
   console.log(`热更新完成，当前运行服务器数量: ${botManagers.length}，前端状态已同步`);
 }
 
@@ -1607,6 +1673,16 @@ function shutdown() {
 
 // 启动
 if (require.main === module) {
+  process.on('unhandledRejection', (reason, promise) => {
+    console.error('未处理的 Promise Rejection:', reason);
+    // 不退出进程，但至少能看到问题
+  });
+
+  process.on('uncaughtException', (error) => {
+    console.error('未捕获的异常:', error);
+    // process.exit(1);
+  });
+  
   initialize().catch(error => {
     console.error('初始化失败:', error);
     process.exit(1);