Update server.js

server.js

@@ -5,6 +5,7 @@ const mineflayer = require('mineflayer');
 const fetch = require('node-fetch');
 const { parse } = require('csv-parse/sync');
 const path = require('path');
+const dns = require('dns').promises;
 
 const app = express();
 const server = http.createServer(app);
@@ -18,6 +19,23 @@ const SHEET_URL = `https://docs.google.com/spreadsheets/d/${SHEET_ID}/export?for
 const bots = new Map();
 const serverBotMap = new Map(); // Track one bot per server
 
+// Function to resolve domain to IP
+async function resolveToIP(hostname) {
+    try {
+        // Check if it's already an IP address
+        if (/^(\d{1,3}\.){3}\d{1,3}$/.test(hostname)) {
+            return hostname;
+        }
+        
+        // Resolve domain to IP
+        const addresses = await dns.resolve4(hostname);
+        return addresses[0]; // Return first IP
+    } catch (error) {
+        console.error(`Failed to resolve ${hostname}:`, error.message);
+        return hostname; // Return original if resolution fails
+    }
+}
+
 class BotManager {
     constructor(botName, ip, port, version) {
         this.botName = botName;
@@ -31,22 +49,28 @@ class BotManager {
         this.lastReconnectTime = null;
         this.isManualDisconnect = false;
         this.startTime = Date.now();
-        this.inSheet = true; // Track if bot is still in sheet
+        this.connectedTime = null;
+        this.inSheet = true;
+        this.resolvedIP = null;
     }
 
     async connect() {
         try {
+            // Resolve domain to IP for comparison
+            this.resolvedIP = await resolveToIP(this.ip);
+            const serverKey = `${this.resolvedIP}:${this.port}`;
+            
             // Check if server already has a bot
-            const serverKey = `${this.ip}:${this.port}`;
             const existingBot = serverBotMap.get(serverKey);
             if (existingBot && existingBot !== this.botName) {
                 this.status = 'Server already has a bot';
+                console.log(`Bot ${this.botName} blocked: Server ${serverKey} already has bot ${existingBot}`);
                 return false;
             }
 
             this.status = 'Connecting...';
             this.bot = mineflayer.createBot({
-                host: this.ip,
+                host: this.ip, // Use original hostname/IP for connection
                 port: parseInt(this.port),
                 username: this.botName,
                 auth: 'offline',
@@ -55,13 +79,15 @@ class BotManager {
                 checkTimeoutInterval: 30000
             });
 
-            // Register this bot for the server
+            // Register this bot for the server using resolved IP
             serverBotMap.set(serverKey, this.botName);
+            console.log(`Registering bot ${this.botName} for server ${serverKey}`);
 
             this.bot.once('spawn', () => {
                 this.status = 'Connected';
+                this.connectedTime = Date.now();
                 this.disconnectTime = null;
-                console.log(`Bot ${this.botName} spawned on ${this.ip}:${this.port}`);
+                console.log(`Bot ${this.botName} spawned on ${this.ip}:${this.port} (resolved: ${this.resolvedIP})`);
                 
                 // Start AFK behavior
                 this.startAFK();
@@ -91,20 +117,33 @@ class BotManager {
         } catch (error) {
             console.error(`Failed to connect bot ${this.botName}:`, error);
             this.status = 'Connection Failed';
+            
+            // Clean up server registration if connection failed
+            if (this.resolvedIP) {
+                const serverKey = `${this.resolvedIP}:${this.port}`;
+                if (serverBotMap.get(serverKey) === this.botName) {
+                    serverBotMap.delete(serverKey);
+                }
+            }
+            
             return false;
         }
     }
 
     handleDisconnect() {
-        const serverKey = `${this.ip}:${this.port}`;
-        if (serverBotMap.get(serverKey) === this.botName) {
-            serverBotMap.delete(serverKey);
+        if (this.resolvedIP) {
+            const serverKey = `${this.resolvedIP}:${this.port}`;
+            if (serverBotMap.get(serverKey) === this.botName) {
+                serverBotMap.delete(serverKey);
+                console.log(`Unregistering bot ${this.botName} from server ${serverKey}`);
+            }
         }
         
         if (this.status !== 'Dead') {
             this.status = 'Disconnected';
         }
         this.disconnectTime = Date.now();
+        this.connectedTime = null;
         this.bot = null;
         
         console.log(`Bot ${this.botName} disconnected from ${this.ip}:${this.port}`);
@@ -168,18 +207,20 @@ class BotManager {
         const timeElapsed = Date.now() - this.lastReconnectTime;
         const hourInMs = 60 * 60 * 1000;
         const timeRemaining = Math.max(0, hourInMs - timeElapsed);
-        return Math.ceil(timeRemaining / 1000); // Return seconds
+        return Math.ceil(timeRemaining / 1000);
+    }
+
+    getConnectedDuration() {
+        if (!this.connectedTime || this.status !== 'Connected') return 0;
+        return Math.floor((Date.now() - this.connectedTime) / 1000);
     }
 
     getInfo() {
-        const uptime = this.status === 'Connected' ? 
-            Math.floor((Date.now() - this.startTime) / 1000) : 0;
-        
         return {
             botName: this.botName,
             status: this.status,
             deathCount: this.deathCount,
-            uptime: uptime,
+            connectedDuration: this.getConnectedDuration(),
             canReconnect: this.canReconnect(),
             disconnectTime: this.disconnectTime,
             timeUntilReconnect: this.getTimeUntilReconnect(),
@@ -230,7 +271,7 @@ async function updateBots() {
         if (!bots.has(botName)) {
             const botManager = new BotManager(botName, ip, port, version);
             bots.set(botName, botManager);
-            // Don't auto-connect, wait for manual connection
+            console.log(`Added new bot from sheet: ${botName} for ${ip}:${port}`);
         } else {
             // Mark existing bot as still in sheet
             bots.get(botName).inSheet = true;
@@ -240,10 +281,13 @@ async function updateBots() {
     // Remove bots that are no longer in the sheet
     for (const [botName, botManager] of bots.entries()) {
         if (!botManager.inSheet) {
+            console.log(`Removing bot ${botName} - no longer in sheet`);
             botManager.disconnect();
             bots.delete(botName);
         }
     }
+    
+    console.log(`Total bots: ${bots.size}, Active servers: ${serverBotMap.size}`);
 }
 
 // Socket.IO events