PowerBot

Sleeping

App Files Files Community

Tokipo commited on Oct 6, 2025

Commit

7907878

verified ·

1 Parent(s): 78662ef

Update app.py

Browse files

Files changed (1) hide show

app.py +349 -615

app.py CHANGED Viewed

@@ -1,746 +1,480 @@
 import os
-import json
 import time
 import threading
-import requests
-from flask import Flask, render_template_string, jsonify, request
-from datetime import datetime, timedelta
 import subprocess
 import signal
 import sys
 app = Flask(__name__)
-# Working directory for bot files
-WORK_DIR = "/tmp"
-BOT_SCRIPT_PATH = os.path.join(WORK_DIR, "bot.js")
-# Google Sheets configuration
-SHEET_ID = os.environ.get("SHEET_ID")
 SHEET_URL = f"https://docs.google.com/spreadsheets/d/{SHEET_ID}/export?format=csv"
-# Bot storage
 bots = {}
 bot_processes = {}
-last_rejoin_times = {}
-server_bots = {}  # Track one bot per server
-# Node.js bot script
-BOT_SCRIPT = """
 const mineflayer = require('mineflayer');
-const args = process.argv.slice(2);
-const botName = args[0];
-const host = args[1];
-const port = parseInt(args[2]);
-const version = args[3] || '1.20.1';
-console.log(`Starting bot ${botName} for ${host}:${port}`);
 const bot = mineflayer.createBot({
     host: host,
-    port: port,
     username: botName,
-    version: version,
-    hideErrors: true,
-    checkTimeoutInterval: 60000,
-    auth: 'offline'
 });
-let afkInterval;
-bot.on('spawn', () => {
-    console.log('CONNECTED');
-    // Anti-AFK system
-    afkInterval = setInterval(() => {
-        const actions = [
-            () => {
-                bot.setControlState('forward', true);
-                setTimeout(() => bot.setControlState('forward', false), 100);
-            },
-            () => {
-                bot.setControlState('back', true);
-                setTimeout(() => bot.setControlState('back', false), 100);
-            },
-            () => {
-                bot.setControlState('left', true);
-                setTimeout(() => bot.setControlState('left', false), 100);
-            },
-            () => {
-                bot.setControlState('right', true);
-                setTimeout(() => bot.setControlState('right', false), 100);
-            },
-            () => {
-                bot.setControlState('jump', true);
-                setTimeout(() => bot.setControlState('jump', false), 100);
-            },
-            () => {
-                bot.setControlState('sneak', true);
-                setTimeout(() => bot.setControlState('sneak', false), 100);
-            }
-        ];
-        const randomAction = actions[Math.floor(Math.random() * actions.length)];
-        randomAction();
-    }, 30000); // Move every 30 seconds
 });
 bot.on('death', () => {
     console.log('DIED');
-    setTimeout(() => {
-        if (bot.health !== undefined) {
-            bot.respawn();
-        }
-    }, 5000);
 });
 bot.on('kicked', (reason) => {
-    console.log('KICKED:', reason);
-    if (afkInterval) clearInterval(afkInterval);
 });
 bot.on('error', (err) => {
-    console.log('ERROR:', err.message);
 });
-bot.on('end', () => {
-    console.log('DISCONNECTED');
-    if (afkInterval) clearInterval(afkInterval);
     process.exit();
 });
-// Handle process termination
 process.on('SIGTERM', () => {
-    if (afkInterval) clearInterval(afkInterval);
     bot.quit();
     process.exit();
 });
-"""
-HTML_TEMPLATE = """
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Mineflayer Bot Manager</title>
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <style>
-        * {
-            margin: 0;
-            padding: 0;
-            box-sizing: border-box;
-        }
-        body {
-            font-family: 'Segoe UI', Arial, sans-serif;
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-            min-height: 100vh;
-            padding: 20px;
-        }
-        .container {
-            max-width: 1400px;
-            margin: 0 auto;
-        }
-        .header {
-            text-align: center;
-            margin-bottom: 30px;
-        }
-        h1 {
-            color: white;
-            text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
-            margin-bottom: 10px;
-        }
-        .subtitle {
-            color: rgba(255,255,255,0.9);
-            font-size: 0.9em;
-        }
-        .stats {
-            display: flex;
-            gap: 20px;
-            margin-bottom: 30px;
-            flex-wrap: wrap;
-        }
-        .stat-card {
-            background: white;
-            padding: 20px;
-            border-radius: 10px;
-            flex: 1;
-            min-width: 200px;
-            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
-            animation: slideIn 0.5s ease;
-        }
-        .stat-card h3 {
-            color: #667eea;
-            margin-bottom: 10px;
-            font-size: 0.9em;
-            text-transform: uppercase;
-            letter-spacing: 1px;
-        }
-        .stat-card .number {
-            font-size: 2em;
-            font-weight: bold;
-            color: #333;
-        }
-        .controls {
-            margin-bottom: 20px;
-            display: flex;
-            gap: 10px;
-            flex-wrap: wrap;
-        }
-        .refresh-btn, .reload-sheet-btn {
-            background: white;
-            color: #667eea;
-            padding: 10px 20px;
-            border: 2px solid #667eea;
-            border-radius: 5px;
-            cursor: pointer;
-            font-weight: bold;
-            transition: all 0.3s;
-        }
-        .refresh-btn:hover, .reload-sheet-btn:hover {
-            background: #667eea;
-            color: white;
-            transform: translateY(-2px);
-        }
-        .bot-grid {
-            display: grid;
-            grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
-            gap: 20px;
-        }
-        .bot-card {
-            background: white;
-            border-radius: 10px;
-            padding: 20px;
-            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
-            transition: all 0.3s;
-            animation: fadeIn 0.5s ease;
-        }
-        .bot-card:hover {
-            transform: translateY(-5px);
-            box-shadow: 0 8px 15px rgba(0,0,0,0.2);
-        }
-        .bot-name {
-            font-size: 1.1em;
-            font-weight: bold;
-            color: #333;
-            margin-bottom: 10px;
-            white-space: nowrap;
-            overflow: hidden;
-            text-overflow: ellipsis;
-        }
-        .bot-info {
-            color: #666;
-            margin: 5px 0;
-            font-size: 0.9em;
-        }
-        .status {
-            display: inline-block;
-            padding: 5px 12px;
-            border-radius: 20px;
-            font-size: 0.85em;
-            font-weight: bold;
-            margin: 10px 0;
-            text-transform: uppercase;
-            letter-spacing: 0.5px;
-        }
-        .status.connected {
-            background: linear-gradient(135deg, #10b981, #059669);
-            color: white;
-        }
-        .status.disconnected {
-            background: linear-gradient(135deg, #ef4444, #dc2626);
-            color: white;
-        }
-        .status.connecting {
-            background: linear-gradient(135deg, #f59e0b, #d97706);
-            color: white;
-            animation: pulse 1.5s infinite;
-        }
-        @keyframes pulse {
-            0%, 100% { opacity: 1; }
-            50% { opacity: 0.7; }
-        }
-        @keyframes slideIn {
-            from { transform: translateX(-20px); opacity: 0; }
-            to { transform: translateX(0); opacity: 1; }
-        }
-        @keyframes fadeIn {
-            from { opacity: 0; }
-            to { opacity: 1; }
-        }
-        .btn {
-            padding: 8px 16px;
-            border: none;
-            border-radius: 5px;
-            cursor: pointer;
-            font-weight: bold;
-            transition: all 0.3s;
-            margin-top: 10px;
-            font-size: 0.9em;
-        }
-        .btn-rejoin {
-            background: linear-gradient(135deg, #667eea, #764ba2);
-            color: white;
-        }
-        .btn-rejoin:hover:not(:disabled) {
-            transform: scale(1.05);
-            box-shadow: 0 4px 10px rgba(102, 126, 234, 0.4);
-        }
-        .btn:disabled {
-            opacity: 0.5;
-            cursor: not-allowed;
-        }
-        .timer {
-            font-size: 0.85em;
-            color: #999;
-            margin-top: 5px;
-        }
-        .loading {
-            text-align: center;
-            color: white;
-            font-size: 1.2em;
-            margin-top: 50px;
-        }
-        .error-msg {
-            background: #fee;
-            color: #c00;
-            padding: 10px;
-            border-radius: 5px;
-            margin: 10px 0;
-        }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <div class="header">
-            <h1>🤖 Mineflayer Bot Manager</h1>
-            <div class="subtitle">Manage your Minecraft bots from Google Sheets</div>
-        </div>
-        <div class="stats">
-            <div class="stat-card">
-                <h3>Total Bots</h3>
-                <div class="number" id="total-bots">0</div>
-            </div>
-            <div class="stat-card">
-                <h3>Connected</h3>
-                <div class="number" id="connected-bots">0</div>
-            </div>
-            <div class="stat-card">
-                <h3>Disconnected</h3>
-                <div class="number" id="disconnected-bots">0</div>
-            </div>
-            <div class="stat-card">
-                <h3>Connecting</h3>
-                <div class="number" id="connecting-bots">0</div>
-            </div>
-        </div>
-        <div class="controls">
-            <button class="refresh-btn" onclick="refreshBots()">🔄 Refresh Status</button>
-            <button class="reload-sheet-btn" onclick="reloadSheet()">📊 Reload from Sheet</button>
-        </div>
-        <div id="error-container"></div>
-        <div class="bot-grid" id="bot-grid">
-            <div class="loading">Loading bots...</div>
-        </div>
-    </div>
-    <script>
-        let botsData = {};
-        async function fetchBots() {
-            try {
-                const response = await fetch('/api/bots');
-                if (!response.ok) throw new Error('Failed to fetch');
-                botsData = await response.json();
-                updateUI();
-                clearError();
-            } catch (error) {
-                console.error('Error fetching bots:', error);
-                showError('Failed to fetch bot status');
-            }
-        }
-        async function rejoinBot(botName) {
-            if (!confirm(`Rejoin bot ${botName}?`)) return;
-            try {
-                const response = await fetch('/api/rejoin', {
-                    method: 'POST',
-                    headers: {'Content-Type': 'application/json'},
-                    body: JSON.stringify({bot_name: botName})
-                });
-                const result = await response.json();
-                if (result.error) {
-                    alert(result.error);
-                } else {
-                    await fetchBots();
-                }
-            } catch (error) {
-                console.error('Error rejoining bot:', error);
-                alert('Failed to rejoin bot');
-            }
-        }
-        async function refreshBots() {
-            await fetchBots();
-        }
-        async function reloadSheet() {
-            try {
-                const response = await fetch('/api/refresh', {method: 'POST'});
-                if (!response.ok) throw new Error('Failed to reload');
-                await fetchBots();
-                clearError();
-            } catch (error) {
-                console.error('Error reloading sheet:', error);
-                showError('Failed to reload from sheet');
-            }
-        }
-        function showError(message) {
-            const container = document.getElementById('error-container');
-            container.innerHTML = `<div class="error-msg">${message}</div>`;
-        }
-        function clearError() {
-            document.getElementById('error-container').innerHTML = '';
-        }
-        function formatTime(seconds) {
-            const minutes = Math.floor(seconds / 60);
-            const secs = seconds % 60;
-            return `${minutes}m ${secs}s`;
-        }
-        function updateUI() {
-            const grid = document.getElementById('bot-grid');
-            grid.innerHTML = '';
-            let total = 0;
-            let connected = 0;
-            let disconnected = 0;
-            let connecting = 0;
-            for (const [botName, botInfo] of Object.entries(botsData)) {
-                total++;
-                if (botInfo.status === 'connected') connected++;
-                else if (botInfo.status === 'disconnected') disconnected++;
-                else if (botInfo.status === 'connecting') connecting++;
-                const card = document.createElement('div');
-                card.className = 'bot-card';
-                let statusClass = botInfo.status;
-                let canRejoin = botInfo.can_rejoin;
-                let timeRemaining = '';
-                if (botInfo.time_until_rejoin && botInfo.time_until_rejoin > 0) {
-                    timeRemaining = `⏱️ ${formatTime(botInfo.time_until_rejoin)}`;
-                }
-                // Escape bot name for HTML
-                const safeBotName = botName.replace(/'/g, "\\'").replace(/"/g, "&quot;");
-                card.innerHTML = `
-                    <div class="bot-name" title="${safeBotName}">🎮 ${safeBotName}</div>
-                    <div class="bot-info">📦 Version: ${botInfo.version}</div>
-                    <div class="status ${statusClass}">${botInfo.status}</div>
-                    ${timeRemaining ? `<div class="timer">${timeRemaining}</div>` : ''}
-                    ${botInfo.status === 'disconnected' ?
-                        `<button class="btn btn-rejoin"
-                            onclick="rejoinBot('${safeBotName}')"
-                            ${!canRejoin ? 'disabled' : ''}>
-                            ${canRejoin ? '🔄 Rejoin' : '⏳ ' + (timeRemaining || 'Cooldown')}
-                        </button>` : ''}
-                `;
-                grid.appendChild(card);
-            }
-            if (total === 0) {
-                grid.innerHTML = '<div class="loading">No bots configured. Add bots to your Google Sheet.</div>';
-            }
-            document.getElementById('total-bots').textContent = total;
-            document.getElementById('connected-bots').textContent = connected;
-            document.getElementById('disconnected-bots').textContent = disconnected;
-            document.getElementById('connecting-bots').textContent = connecting;
-        }
-        // Initial fetch and periodic updates
-        fetchBots();
-        setInterval(fetchBots, 3000); // Update every 3 seconds
-    </script>
-</body>
-</html>
 """
 def write_bot_script():
-    """Write the bot script to /tmp directory"""
     try:
-        os.makedirs(WORK_DIR, exist_ok=True)
-        with open(BOT_SCRIPT_PATH, 'w') as f:
-            f.write(BOT_SCRIPT)
-        print(f"Bot script written to {BOT_SCRIPT_PATH}")
-        return True
     except Exception as e:
         print(f"Error writing bot script: {e}")
-        return False
-def fetch_sheet_data():
-    """Fetch bot configuration from Google Sheets"""
     try:
-        response = requests.get(SHEET_URL, timeout=10)
-        if response.status_code == 200:
-            lines = response.text.strip().split('\n')
-            if len(lines) > 1:
-                data = []
-                for line in lines[1:]:  # Skip header
-                    # Handle CSV parsing properly
-                    parts = line.split(',')
-                    if len(parts) >= 3:
-                        bot_name = parts[0].strip().strip('"')
-                        ip = parts[1].strip().strip('"')
-                        port = parts[2].strip().strip('"')
-                        version = parts[3].strip().strip('"') if len(parts) > 3 else "1.20.1"
-                        # Skip empty rows
-                        if bot_name and ip and port and port.isdigit():
-                            data.append({
-                                'bot_name': bot_name,
-                                'ip': ip,
-                                'port': port,
-                                'version': version if version else "1.20.1"
-                            })
-                print(f"Fetched {len(data)} bots from sheet")
-                return data
     except Exception as e:
-        print(f"Error fetching sheet: {e}")
-    return []
-def start_bot(bot_data):
-    """Start a Minecraft bot"""
-    bot_name = bot_data['bot_name']
-    server_key = f"{bot_data['ip']}:{bot_data['port']}"
     # Check if server already has a bot
-    if server_key in server_bots and server_bots[server_key] != bot_name:
         return False, "Server already has a bot"
-    # Kill existing process if any
-    if bot_name in bot_processes:
         try:
-            process = bot_processes[bot_name]
-            process.terminate()
-            process.wait(timeout=5)
         except:
             pass
-    # Start new bot process
     try:
-        # Change working directory to /app where node_modules are installed
-        process = subprocess.Popen(
-            ['node', BOT_SCRIPT_PATH, bot_name, bot_data['ip'], bot_data['port'], bot_data['version']],
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
             text=True,
-            bufsize=1,
-            cwd='/app'  # Use /app as working directory
         )
-        bot_processes[bot_name] = process
-        server_bots[server_key] = bot_name
-        bots[bot_name] = {
             'status': 'connecting',
-            'ip': bot_data['ip'],
-            'port': bot_data['port'],
-            'version': bot_data['version'],
-            'server_key': server_key
         }
-        # Start monitoring thread
-        threading.Thread(target=monitor_bot, args=(bot_name,), daemon=True).start()
-        return True, "Bot started"
     except Exception as e:
-        print(f"Error starting bot {bot_name}: {e}")
         return False, str(e)
-def monitor_bot(bot_name):
-    """Monitor bot process output"""
-    if bot_name not in bot_processes:
         return
-    process = bot_processes[bot_name]
-    while True:
-        if process.poll() is not None:
-            # Process ended
-            if bot_name in bots:
-                bots[bot_name]['status'] = 'disconnected'
-                server_key = bots[bot_name].get('server_key')
-                if server_key and server_key in server_bots and server_bots[server_key] == bot_name:
-                    del server_bots[server_key]
-            break
-        try:
-            line = process.stdout.readline()
-            if line:
-                print(f"[{bot_name}] {line.strip()}")
-                if 'CONNECTED' in line:
-                    if bot_name in bots:
-                        bots[bot_name]['status'] = 'connected'
-                elif any(x in line for x in ['DISCONNECTED', 'KICKED', 'ERROR', 'DIED']):
-                    if bot_name in bots:
-                        bots[bot_name]['status'] = 'disconnected'
-        except:
-            pass
-        time.sleep(0.1)
-def update_bots_from_sheet():
-    """Update bots from Google Sheet"""
-    print("Updating bots from sheet...")
-    sheet_data = fetch_sheet_data()
-    # Remove bots that are no longer in sheet
-    current_bot_names = {bot['bot_name'] for bot in sheet_data}
-    bots_to_remove = []
-    for bot_name in list(bots.keys()):
-        if bot_name not in current_bot_names:
-            bots_to_remove.append(bot_name)
-    for bot_name in bots_to_remove:
-        if bot_name in bot_processes:
-            try:
-                bot_processes[bot_name].terminate()
-            except:
-                pass
-        if bot_name in bots:
-            server_key = bots[bot_name].get('server_key')
-            if server_key in server_bots:
-                del server_bots[server_key]
-            del bots[bot_name]
-        print(f"Removed bot: {bot_name}")
     # Add new bots
-    for bot_data in sheet_data:
-        bot_name = bot_data['bot_name']
-        if bot_name not in bots:
-            success, message = start_bot(bot_data)
-            print(f"Starting {bot_name}: {message}")
 @app.route('/')
 def index():
-    return render_template_string(HTML_TEMPLATE)
 @app.route('/api/bots')
-def get_bots():
-    """Get all bot statuses"""
     result = {}
-    current_time = datetime.now()
-    for bot_name, bot_info in bots.items():
         can_rejoin = True
-        time_until_rejoin = 0
-        if bot_name in last_rejoin_times:
-            time_passed = current_time - last_rejoin_times[bot_name]
-            if time_passed < timedelta(hours=1):
                 can_rejoin = False
-                time_until_rejoin = int((timedelta(hours=1) - time_passed).total_seconds())
-        result[bot_name] = {
-            'status': bot_info['status'],
-            'version': bot_info['version'],
             'can_rejoin': can_rejoin,
-            'time_until_rejoin': time_until_rejoin
         }
     return jsonify(result)
 @app.route('/api/rejoin', methods=['POST'])
-def rejoin_bot():
-    """Rejoin a disconnected bot"""
-    data = request.json
-    bot_name = data.get('bot_name')
-    if bot_name not in bots:
         return jsonify({'error': 'Bot not found'}), 404
-    current_time = datetime.now()
     # Check cooldown
-    if bot_name in last_rejoin_times:
-        time_passed = current_time - last_rejoin_times[bot_name]
-        if time_passed < timedelta(hours=1):
-            remaining = timedelta(hours=1) - time_passed
-            return jsonify({'error': f'Please wait {int(remaining.total_seconds() / 60)} minutes'}), 429
-    if bots[bot_name]['status'] == 'connected':
-        return jsonify({'error': 'Bot is already connected'}), 400
-    bot_data = {
-        'bot_name': bot_name,
-        'ip': bots[bot_name]['ip'],
-        'port': bots[bot_name]['port'],
-        'version': bots[bot_name]['version']
     }
-    success, message = start_bot(bot_data)
     if success:
-        last_rejoin_times[bot_name] = current_time
-        return jsonify({'success': True, 'message': message})
     else:
-        return jsonify({'error': message}), 500
-@app.route('/api/refresh', methods=['POST'])
-def refresh():
-    """Refresh bots from Google Sheet"""
-    update_bots_from_sheet()
     return jsonify({'success': True})
-def signal_handler(sig, frame):
-    """Handle shutdown gracefully"""
-    print("\nShutting down gracefully...")
-    for bot_name, process in bot_processes.items():
         try:
-            process.terminate()
         except:
             pass
     sys.exit(0)
 if __name__ == '__main__':
-    signal.signal(signal.SIGINT, signal_handler)
-    signal.signal(signal.SIGTERM, signal_handler)
-    # Write bot script to /tmp
-    if not write_bot_script():
-        print("Failed to write bot script, exiting...")
         sys.exit(1)
-    # Initial load from sheet
-    print("Loading bots from Google Sheet...")
-    update_bots_from_sheet()
-    # Start periodic sheet updates
-    def periodic_update():
         while True:
-            time.sleep(60)  # Check every minute
             try:
-                update_bots_from_sheet()
             except Exception as e:
-                print(f"Error in periodic update: {e}")
-    threading.Thread(target=periodic_update, daemon=True).start()
-    # Start Flask app
-    print("Starting web server on port 7860...")
     app.run(host='0.0.0.0', port=7860, debug=False)

 import os
 import time
+import json
 import threading
 import subprocess
 import signal
 import sys
+import requests
+from flask import Flask, render_template_string, jsonify, request
+from datetime import datetime, timedelta
 app = Flask(__name__)
+# Configuration
+SHEET_ID = "109roJQr-Y4YCLTkCqaK6iwShC-Dr2Jb-hB0qE2phNqQ"
 SHEET_URL = f"https://docs.google.com/spreadsheets/d/{SHEET_ID}/export?format=csv"
+# Storage
 bots = {}
 bot_processes = {}
+last_rejoin = {}
+server_locks = {}
+# Minimal HTML/CSS
+HTML = """<!DOCTYPE html>
+<html>
+<head>
+<title>Bot Manager</title>
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{font-family:monospace;background:#222;color:#fff;padding:10px}
+.h{background:#333;padding:15px;margin-bottom:10px;border-radius:5px}
+h1{font-size:1.5em;margin-bottom:10px}
+.stats{display:flex;gap:10px;flex-wrap:wrap;margin-bottom:15px}
+.stat{background:#444;padding:10px;border-radius:3px;flex:1;min-width:100px}
+.stat b{color:#0f0;display:block;font-size:1.5em}
+.btn{background:#555;border:none;color:#fff;padding:8px 15px;border-radius:3px;cursor:pointer;margin:5px}
+.btn:hover{background:#666}
+.btn:disabled{opacity:0.5;cursor:not-allowed}
+.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(250px,1fr));gap:10px}
+.bot{background:#333;padding:10px;border-radius:5px;border-left:3px solid #555}
+.bot.on{border-color:#0f0}
+.bot.off{border-color:#f00}
+.bot.wait{border-color:#fa0}
+.name{font-weight:bold;margin-bottom:5px}
+.info{font-size:0.9em;color:#aaa;margin:2px 0}
+.status{display:inline-block;padding:2px 8px;border-radius:2px;font-size:0.8em;margin:5px 0}
+.on .status{background:#0f0;color:#000}
+.off .status{background:#f00}
+.wait .status{background:#fa0;color:#000}
+</style>
+</head>
+<body>
+<div class="h">
+<h1>🎮 Minecraft Bot Manager</h1>
+<div class="stats">
+<div class="stat">Total<b id="total">0</b></div>
+<div class="stat">Online<b id="on">0</b></div>
+<div class="stat">Offline<b id="off">0</b></div>
+</div>
+<button class="btn" onclick="reload()">📋 Reload Sheet</button>
+<button class="btn" onclick="update()">🔄 Refresh</button>
+</div>
+<div class="grid" id="grid"></div>
+<script>
+let data={};
+async function update(){
+try{
+const r=await fetch('/api/bots');
+data=await r.json();
+render();
+}catch(e){console.error(e)}
+}
+async function rejoin(name){
+try{
+const r=await fetch('/api/rejoin',{
+method:'POST',
+headers:{'Content-Type':'application/json'},
+body:JSON.stringify({name:name})
+});
+const d=await r.json();
+if(d.error)alert(d.error);
+update();
+}catch(e){alert('Error: '+e)}
+}
+async function reload(){
+await fetch('/api/reload',{method:'POST'});
+update();
+}
+function render(){
+const g=document.getElementById('grid');
+g.innerHTML='';
+let t=0,on=0,off=0;
+for(const[name,bot]of Object.entries(data)){
+t++;
+if(bot.status=='online')on++;
+else off++;
+const div=document.createElement('div');
+div.className='bot '+(bot.status=='online'?'on':bot.status=='connecting'?'wait':'off');
+let btn='';
+if(bot.status=='offline'){
+if(bot.can_rejoin){
+btn=`<button class="btn" onclick="rejoin('${name}')">Join</button>`;
+}else if(bot.cooldown>0){
+const m=Math.floor(bot.cooldown/60);
+const s=bot.cooldown%60;
+btn=`<button class="btn" disabled>Wait ${m}:${s<10?'0':''}${s}</button>`;
+}
+}
+div.innerHTML=`
+<div class="name">${name}</div>
+<div class="info">Version: ${bot.version||'1.20.1'}</div>
+<div class="status">${bot.status.toUpperCase()}</div>
+${btn}`;
+g.appendChild(div);
+}
+document.getElementById('total').textContent=t;
+document.getElementById('on').textContent=on;
+document.getElementById('off').textContent=off;
+}
+update();
+setInterval(update,3000);
+</script>
+</body>
+</html>"""
+# Bot JavaScript code
+BOT_CODE = """
 const mineflayer = require('mineflayer');
+const [botName, host, port, version] = process.argv.slice(2);
+console.log('STARTING', botName, host, port, version);
 const bot = mineflayer.createBot({
     host: host,
+    port: parseInt(port) || 25565,
     username: botName,
+    version: version || false,
+    auth: 'offline',
+    hideErrors: false,
+    logErrors: true,
+    checkTimeoutInterval: 30000,
+    loadInternalPlugins: true,
+    physicsEnabled: true,
+    viewDistance: 'short'
 });
+let connected = false;
+let afkTimer = null;
+function startAfk() {
+    if (afkTimer) clearInterval(afkTimer);
+    afkTimer = setInterval(() => {
+        if (!bot.entity) return;
+        // Random movement
+        const moves = ['forward', 'back', 'left', 'right', 'jump'];
+        const move = moves[Math.floor(Math.random() * moves.length)];
+        bot.setControlState(move, true);
+        setTimeout(() => bot.setControlState(move, false), 100);
+        // Random look
+        if (Math.random() > 0.7) {
+            bot.look(
+                bot.entity.yaw + (Math.random() - 0.5) * 0.5,
+                bot.entity.pitch + (Math.random() - 0.5) * 0.5
+            );
+        }
+    }, 20000);
+}
+bot.once('spawn', () => {
+    console.log('ONLINE');
+    connected = true;
+    startAfk();
+});
+bot.on('respawn', () => {
+    console.log('RESPAWNED');
+    startAfk();
 });
 bot.on('death', () => {
     console.log('DIED');
 });
 bot.on('kicked', (reason) => {
+    console.log('KICKED', reason);
+    connected = false;
 });
 bot.on('error', (err) => {
+    console.log('ERROR', err.message || err);
 });
+bot.on('end', (reason) => {
+    console.log('OFFLINE', reason || '');
+    if (afkTimer) clearInterval(afkTimer);
+    connected = false;
     process.exit();
 });
+// Keep alive
+setInterval(() => {
+    if (connected) console.log('ALIVE');
+}, 10000);
+// Graceful shutdown
 process.on('SIGTERM', () => {
+    if (afkTimer) clearInterval(afkTimer);
     bot.quit();
     process.exit();
 });
+process.on('SIGINT', () => {
+    if (afkTimer) clearInterval(afkTimer);
+    bot.quit();
+    process.exit();
+});
 """
 def write_bot_script():
+    """Write bot script to temp directory"""
+    path = '/tmp/bot.js'
     try:
+        with open(path, 'w') as f:
+            f.write(BOT_CODE)
+        return path
     except Exception as e:
         print(f"Error writing bot script: {e}")
+        return None
+def get_sheet_data():
+    """Fetch data from Google Sheets"""
     try:
+        resp = requests.get(SHEET_URL, timeout=10)
+        if resp.status_code != 200:
+            return []
+        lines = resp.text.strip().split('\n')
+        data = []
+        for line in lines[1:]:  # Skip header
+            parts = [p.strip().strip('"') for p in line.split(',')]
+            if len(parts) >= 3:
+                name = parts[0]
+                ip = parts[1]
+                port = parts[2]
+                version = parts[3] if len(parts) > 3 else "1.20.1"
+                if name and ip and port and port.isdigit():
+                    data.append({
+                        'name': name,
+                        'ip': ip,
+                        'port': port,
+                        'version': version or "1.20.1"
+                    })
+        print(f"Loaded {len(data)} bots from sheet")
+        return data
     except Exception as e:
+        print(f"Sheet error: {e}")
+        return []
+def start_bot(config):
+    """Start a bot process"""
+    name = config['name']
+    server = f"{config['ip']}:{config['port']}"
     # Check if server already has a bot
+    if server in server_locks and server_locks[server] != name:
         return False, "Server already has a bot"
+    # Kill existing process
+    if name in bot_processes:
         try:
+            bot_processes[name].terminate()
+            bot_processes[name].wait(timeout=3)
         except:
             pass
     try:
+        # Start bot process
+        proc = subprocess.Popen(
+            ['node', '/tmp/bot.js', name, config['ip'], config['port'], config['version']],
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
             text=True,
+            bufsize=1
         )
+        bot_processes[name] = proc
+        server_locks[server] = name
+        bots[name] = {
             'status': 'connecting',
+            'ip': config['ip'],
+            'port': config['port'],
+            'version': config['version'],
+            'server': server
         }
+        # Start monitor thread
+        threading.Thread(target=monitor_bot, args=(name,), daemon=True).start()
+        return True, "Started"
     except Exception as e:
         return False, str(e)
+def monitor_bot(name):
+    """Monitor bot output"""
+    if name not in bot_processes:
         return
+    proc = bot_processes[name]
+    try:
+        while proc.poll() is None:
+            line = proc.stdout.readline()
+            if not line:
+                continue
+            line = line.strip()
+            if not line:
+                continue
+            print(f"[{name}] {line}")
+            if 'ONLINE' in line or 'ALIVE' in line:
+                bots[name]['status'] = 'online'
+            elif 'OFFLINE' in line or 'KICKED' in line or 'ERROR' in line:
+                bots[name]['status'] = 'offline'
+            elif 'DIED' in line:
+                bots[name]['status'] = 'online'  # Still online, just dead
+    except:
+        pass
+    # Process ended
+    if name in bots:
+        bots[name]['status'] = 'offline'
+        server = bots[name].get('server')
+        if server in server_locks and server_locks[server] == name:
+            del server_locks[server]
+def sync_bots():
+    """Sync bots with sheet data"""
+    data = get_sheet_data()
+    names = {d['name'] for d in data}
+    # Remove deleted bots
+    for name in list(bots.keys()):
+        if name not in names:
+            if name in bot_processes:
+                try:
+                    bot_processes[name].terminate()
+                except:
+                    pass
+            if name in bots:
+                server = bots[name].get('server')
+                if server in server_locks:
+                    del server_locks[server]
+                del bots[name]
     # Add new bots
+    for config in data:
+        if config['name'] not in bots:
+            start_bot(config)
 @app.route('/')
 def index():
+    return HTML
 @app.route('/api/bots')
+def api_bots():
+    """Get bot status"""
     result = {}
+    now = datetime.now()
+    for name, bot in bots.items():
         can_rejoin = True
+        cooldown = 0
+        if name in last_rejoin:
+            elapsed = now - last_rejoin[name]
+            if elapsed < timedelta(hours=1):
                 can_rejoin = False
+                cooldown = int((timedelta(hours=1) - elapsed).total_seconds())
+        result[name] = {
+            'status': bot['status'],
+            'version': bot['version'],
             'can_rejoin': can_rejoin,
+            'cooldown': cooldown
         }
     return jsonify(result)
 @app.route('/api/rejoin', methods=['POST'])
+def api_rejoin():
+    """Rejoin a bot"""
+    name = request.json.get('name')
+    if name not in bots:
         return jsonify({'error': 'Bot not found'}), 404
+    now = datetime.now()
     # Check cooldown
+    if name in last_rejoin:
+        elapsed = now - last_rejoin[name]
+        if elapsed < timedelta(hours=1):
+            mins = int((timedelta(hours=1) - elapsed).total_seconds() / 60)
+            return jsonify({'error': f'Wait {mins} minutes'}), 429
+    if bots[name]['status'] == 'online':
+        return jsonify({'error': 'Already online'}), 400
+    config = {
+        'name': name,
+        'ip': bots[name]['ip'],
+        'port': bots[name]['port'],
+        'version': bots[name]['version']
     }
+    success, msg = start_bot(config)
     if success:
+        last_rejoin[name] = now
+        return jsonify({'success': True})
     else:
+        return jsonify({'error': msg}), 500
+@app.route('/api/reload', methods=['POST'])
+def api_reload():
+    """Reload from sheet"""
+    sync_bots()
     return jsonify({'success': True})
+def cleanup(sig=None, frame=None):
+    """Cleanup on exit"""
+    print("\nShutting down...")
+    for proc in bot_processes.values():
         try:
+            proc.terminate()
         except:
             pass
     sys.exit(0)
 if __name__ == '__main__':
+    signal.signal(signal.SIGINT, cleanup)
+    signal.signal(signal.SIGTERM, cleanup)
+    # Setup
+    script_path = write_bot_script()
+    if not script_path:
+        print("Failed to write bot script!")
         sys.exit(1)
+    print("Bot script ready")
+    # Initial sync
+    sync_bots()
+    # Periodic sync
+    def auto_sync():
         while True:
+            time.sleep(60)
             try:
+                sync_bots()
             except Exception as e:
+                print(f"Sync error: {e}")
+    threading.Thread(target=auto_sync, daemon=True).start()
+    # Start server
+    print("Starting server on port 7860...")
     app.run(host='0.0.0.0', port=7860, debug=False)