Upload 3 files

Dockerfile

@@ -0,0 +1,33 @@
+FROM node:18-slim
+
+# Install dependencies for mineflayer
+RUN apt-get update && apt-get install -y \
+    python3 \
+    make \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm install
+
+# Copy app source
+COPY . .
+
+# Create non-root user
+RUN useradd -m -u 1000 botuser && chown -R botuser:botuser /app
+USER botuser
+
+# Expose port
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+  CMD curl -f http://localhost:7860/health || exit 1
+
+# Start the app
+CMD ["npm", "start"]

index.js

@@ -0,0 +1,319 @@
+const express = require('express');
+const http = require('http');
+const { Server } = require('socket.io');
+const mineflayer = require('mineflayer');
+const path = require('path');
+
+const app = express();
+const server = http.createServer(app);
+const io = new Server(server, {
+    cors: {
+        origin: "*",
+        methods: ["GET", "POST"]
+    }
+});
+
+const PORT = process.env.PORT || 7860;
+
+// Store active bots
+const activeBots = new Map();
+
+// Middleware
+app.use(express.json());
+app.use(express.static('public'));
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+    res.json({ status: true, uptime: process.uptime(), bots: activeBots.size });
+});
+
+// API Routes
+app.get('/api/bots', (req, res) => {
+    const bots = Array.from(activeBots.entries()).map(([id, data]) => ({
+        id,
+        username: data.bot.username,
+        host: data.host,
+        port: data.port,
+        connected: data.connected,
+        players: data.players || []
+    }));
+    res.json(bots);
+});
+
+// Socket.IO Connection
+io.on('connection', (socket) => {
+    console.log('Client connected:', socket.id);
+
+    let currentBot = null;
+    let botId = null;
+
+    // Connect bot to Minecraft server
+    socket.on('connect-bot', (config) => {
+        const { username, host, port = 25565, version } = config;
+
+        if (!username || !host) {
+            socket.emit('error', { message: 'Username and host are required' });
+            return;
+        }
+
+        // Disconnect existing bot for this socket
+        if (currentBot) {
+            currentBot.quit();
+            activeBots.delete(botId);
+        }
+
+        botId = `${socket.id}_${Date.now()}`;
+
+        try {
+            const bot = mineflayer.createBot({
+                host: host,
+                port: parseInt(port),
+                username: username,
+                version: version || false,
+                auth: 'offline',
+                hideErrors: true
+            });
+
+            currentBot = bot;
+
+            const botData = {
+                bot: bot,
+                socket: socket,
+                host: host,
+                port: port,
+                connected: false,
+                players: [],
+                chatHistory: []
+            };
+
+            activeBots.set(botId, botData);
+
+            // Bot Events
+            bot.on('login', () => {
+                botData.connected = true;
+                socket.emit('bot-status', {
+                    status: 'online',
+                    username: bot.username,
+                    host: host,
+                    port: port
+                });
+                console.log(`Bot ${username} connected to ${host}:${port}`);
+            });
+
+            bot.on('spawn', () => {
+                socket.emit('bot-spawned', {
+                    position: bot.entity?.position,
+                    health: bot.health,
+                    food: bot.food
+                });
+                updatePlayersList(bot, socket);
+            });
+
+            bot.on('chat', (username, message) => {
+                if (username === bot.username) return;
+
+                const chatData = {
+                    username: username,
+                    message: message,
+                    timestamp: new Date().toISOString(),
+                    type: 'chat'
+                };
+
+                botData.chatHistory.push(chatData);
+                socket.emit('chat-message', chatData);
+            });
+
+            bot.on('message', (jsonMsg) => {
+                const text = jsonMsg.toString();
+                if (text && !text.includes(bot.username)) {
+                    socket.emit('system-message', {
+                        message: text,
+                        timestamp: new Date().toISOString()
+                    });
+                }
+            });
+
+            bot.on('playerJoined', (player) => {
+                socket.emit('player-joined', {
+                    username: player.username,
+                    timestamp: new Date().toISOString()
+                });
+                updatePlayersList(bot, socket);
+            });
+
+            bot.on('playerLeft', (player) => {
+                socket.emit('player-left', {
+                    username: player.username,
+                    timestamp: new Date().toISOString()
+                });
+                updatePlayersList(bot, socket);
+            });
+
+            bot.on('health', () => {
+                socket.emit('bot-health', {
+                    health: bot.health,
+                    food: bot.food
+                });
+            });
+
+            bot.on('death', () => {
+                socket.emit('bot-death', {
+                    message: 'Bot died!',
+                    timestamp: new Date().toISOString()
+                });
+            });
+
+            bot.on('kicked', (reason) => {
+                socket.emit('bot-kicked', {
+                    reason: reason.toString(),
+                    timestamp: new Date().toISOString()
+                });
+                cleanupBot(botId);
+            });
+
+            bot.on('error', (err) => {
+                console.error('Bot error:', err.message);
+                socket.emit('bot-error', {
+                    message: err.message,
+                    timestamp: new Date().toISOString()
+                });
+            });
+
+            bot.on('end', (reason) => {
+                socket.emit('bot-disconnected', {
+                    reason: reason || 'Connection closed',
+                    timestamp: new Date().toISOString()
+                });
+                cleanupBot(botId);
+            });
+
+        } catch (error) {
+            socket.emit('error', { message: error.message });
+        }
+    });
+
+    // Send chat message
+    socket.on('send-chat', (message) => {
+        if (currentBot && currentBot.chat) {
+            currentBot.chat(message);
+            socket.emit('chat-sent', {
+                username: currentBot.username,
+                message: message,
+                timestamp: new Date().toISOString()
+            });
+        }
+    });
+
+    // Send command
+    socket.on('send-command', (command) => {
+        if (currentBot && currentBot.chat) {
+            currentBot.chat(command);
+        }
+    });
+
+    // Bot actions
+    socket.on('bot-action', (action) => {
+        if (!currentBot) return;
+
+        switch(action.type) {
+            case 'jump':
+                currentBot.setControlState('jump', true);
+                setTimeout(() => currentBot.setControlState('jump', false), 500);
+                break;
+            case 'sneak':
+                currentBot.setControlState('sneak', true);
+                setTimeout(() => currentBot.setControlState('sneak', false), 1000);
+                break;
+            case 'look':
+                if (action.x !== undefined && action.y !== undefined && action.z !== undefined) {
+                    const Vec3 = require('vec3');
+                    currentBot.lookAt(new Vec3(action.x, action.y, action.z));
+                }
+                break;
+            case 'move':
+                if (action.direction) {
+                    currentBot.setControlState(action.direction, true);
+                    setTimeout(() => currentBot.setControlState(action.direction, false), 500);
+                }
+                break;
+        }
+    });
+
+    // Disconnect bot
+    socket.on('disconnect-bot', () => {
+        if (currentBot) {
+            currentBot.quit();
+            cleanupBot(botId);
+            currentBot = null;
+            botId = null;
+        }
+    });
+
+    // Get players list
+    socket.on('get-players', () => {
+        if (currentBot) {
+            updatePlayersList(currentBot, socket);
+        }
+    });
+
+    // Disconnect handler
+    socket.on('disconnect', () => {
+        console.log('Client disconnected:', socket.id);
+        if (currentBot) {
+            currentBot.quit();
+            cleanupBot(botId);
+        }
+    });
+});
+
+function updatePlayersList(bot, socket) {
+    if (!bot.players) return;
+
+    const players = Object.values(bot.players).map(p => ({
+        username: p.username,
+        ping: p.ping,
+        uuid: p.uuid
+    }));
+
+    socket.emit('players-list', players);
+}
+
+function cleanupBot(id) {
+    if (activeBots.has(id)) {
+        const data = activeBots.get(id);
+        if (data.bot) {
+            try {
+                data.bot.quit();
+                data.bot.removeAllListeners();
+            } catch (e) {}
+        }
+        activeBots.delete(id);
+    }
+}
+
+// Start server
+server.listen(PORT, () => {
+    console.log(`🎮 Minecraft Bot Controller running on port ${PORT}`);
+    console.log(`🌐 Access the web interface at http://localhost:${PORT}`);
+});
+
+// Graceful shutdown
+process.on('SIGTERM', () => {
+    console.log('SIGTERM received, shutting down gracefully');
+    activeBots.forEach((data, id) => {
+        cleanupBot(id);
+    });
+    server.close(() => {
+        process.exit(0);
+    });
+});
+
+process.on('SIGINT', () => {
+    console.log('SIGINT received, shutting down gracefully');
+    activeBots.forEach((data, id) => {
+        cleanupBot(id);
+    });
+    server.close(() => {
+        process.exit(0);
+    });
+});

package.json

@@ -0,0 +1,20 @@
+{
+  "name": "minecraft-bot-controller",
+  "version": "1.0.0",
+  "description": "Minecraft Bot with Web Interface for Hugging Face",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "socket.io": "^4.7.2",
+    "mineflayer": "^4.20.0",
+    "mineflayer-pathfinder": "^2.4.5",
+    "mineflayer-collectblock": "^1.4.1",
+    "vec3": "^0.1.10"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}