PowerBot

Sleeping

App Files Files Community

Tokipo commited on Oct 6, 2025

Commit

effc3d9

verified ·

1 Parent(s): 14e43e4

Create app.py

Browse files

Files changed (1) hide show

app.py +547 -0

app.py ADDED Viewed

	@@ -0,0 +1,547 @@

+import os
+import json
+import time
+import threading
+import requests
+import pandas as pd
+from flask import Flask, render_template_string, jsonify, request
+from datetime import datetime, timedelta
+import subprocess
+import socket
+app = Flask(__name__)
+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
+});
+bot.on('spawn', () => {
+    console.log('CONNECTED');
+    setInterval(() => {
+        // Random movement for anti-AFK
+        const actions = [
+            () => bot.setControlState('forward', true),
+            () => bot.setControlState('back', true),
+            () => bot.setControlState('left', true),
+            () => bot.setControlState('right', true),
+            () => bot.setControlState('jump', true)
+        ];
+        const randomAction = actions[Math.floor(Math.random() * actions.length)];
+        randomAction();
+        setTimeout(() => {
+            bot.clearControlStates();
+        }, 100);
+    }, 30000); // Move every 30 seconds
+});
+bot.on('death', () => {
+    console.log('DIED');
+});
+bot.on('kicked', (reason) => {
+    console.log('KICKED:', reason);
+});
+bot.on('error', (err) => {
+    console.log('ERROR:', err.message);
+});
+bot.on('end', () => {
+    console.log('DISCONNECTED');
+    process.exit();
+});
+"""
+HTML_TEMPLATE = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Mineflayer Bot Manager</title>
+    <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;
+        }
+        h1 {
+            color: white;
+            text-align: center;
+            margin-bottom: 30px;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+        }
+        .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);
+        }
+        .stat-card h3 {
+            color: #667eea;
+            margin-bottom: 10px;
+        }
+        .stat-card .number {
+            font-size: 2em;
+            font-weight: bold;
+            color: #333;
+        }
+        .bot-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+            gap: 20px;
+        }
+        .bot-card {
+            background: white;
+            border-radius: 10px;
+            padding: 20px;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+            transition: transform 0.3s;
+        }
+        .bot-card:hover {
+            transform: translateY(-5px);
+            box-shadow: 0 6px 12px rgba(0,0,0,0.15);
+        }
+        .bot-name {
+            font-size: 1.2em;
+            font-weight: bold;
+            color: #333;
+            margin-bottom: 10px;
+        }
+        .bot-info {
+            color: #666;
+            margin: 5px 0;
+        }
+        .status {
+            display: inline-block;
+            padding: 5px 10px;
+            border-radius: 20px;
+            font-size: 0.9em;
+            font-weight: bold;
+            margin: 10px 0;
+        }
+        .status.connected {
+            background: #10b981;
+            color: white;
+        }
+        .status.disconnected {
+            background: #ef4444;
+            color: white;
+        }
+        .status.connecting {
+            background: #f59e0b;
+            color: white;
+        }
+        .btn {
+            padding: 10px 20px;
+            border: none;
+            border-radius: 5px;
+            cursor: pointer;
+            font-weight: bold;
+            transition: all 0.3s;
+            margin-top: 10px;
+        }
+        .btn-rejoin {
+            background: #667eea;
+            color: white;
+        }
+        .btn-rejoin:hover:not(:disabled) {
+            background: #5a67d8;
+        }
+        .btn:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+        }
+        .refresh-btn {
+            background: white;
+            color: #667eea;
+            padding: 10px 20px;
+            border: 2px solid #667eea;
+            border-radius: 5px;
+            cursor: pointer;
+            font-weight: bold;
+            margin-bottom: 20px;
+        }
+        .refresh-btn:hover {
+            background: #667eea;
+            color: white;
+        }
+        .timer {
+            font-size: 0.9em;
+            color: #999;
+            margin-top: 5px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🤖 Mineflayer Bot Manager</h1>
+        <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>
+        <button class="refresh-btn" onclick="refreshBots()">🔄 Refresh from Sheet</button>
+        <div class="bot-grid" id="bot-grid">
+            <!-- Bot cards will be inserted here -->
+        </div>
+    </div>
+    <script>
+        let botsData = {};
+        async function fetchBots() {
+            try {
+                const response = await fetch('/api/bots');
+                botsData = await response.json();
+                updateUI();
+            } catch (error) {
+                console.error('Error fetching bots:', error);
+            }
+        }
+        async function rejoinBot(botName) {
+            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);
+                }
+                fetchBots();
+            } catch (error) {
+                console.error('Error rejoining bot:', error);
+            }
+        }
+        async function refreshBots() {
+            try {
+                await fetch('/api/refresh', {method: 'POST'});
+                fetchBots();
+            } catch (error) {
+                console.error('Error refreshing:', error);
+            }
+        }
+        function updateUI() {
+            const grid = document.getElementById('bot-grid');
+            grid.innerHTML = '';
+            let total = 0;
+            let connected = 0;
+            let disconnected = 0;
+            for (const [botName, botInfo] of Object.entries(botsData)) {
+                total++;
+                if (botInfo.status === 'connected') connected++;
+                else if (botInfo.status === 'disconnected') disconnected++;
+                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) {
+                    const minutes = Math.floor(botInfo.time_until_rejoin / 60);
+                    const seconds = botInfo.time_until_rejoin % 60;
+                    timeRemaining = `Wait: ${minutes}m ${seconds}s`;
+                }
+                card.innerHTML = `
+                    <div class="bot-name">${botName}</div>
+                    <div class="bot-info">Server: Hidden</div>
+                    <div class="bot-info">Version: ${botInfo.version}</div>
+                    <div class="status ${statusClass}">${botInfo.status.toUpperCase()}</div>
+                    ${timeRemaining ? `<div class="timer">${timeRemaining}</div>` : ''}
+                    ${botInfo.status === 'disconnected' ?
+                        `<button class="btn btn-rejoin"
+                            onclick="rejoinBot('${botName}')"
+                            ${!canRejoin ? 'disabled' : ''}>
+                            ${canRejoin ? 'Rejoin' : timeRemaining || 'Wait...'}
+                        </button>` : ''}
+                `;
+                grid.appendChild(card);
+            }
+            document.getElementById('total-bots').textContent = total;
+            document.getElementById('connected-bots').textContent = connected;
+            document.getElementById('disconnected-bots').textContent = disconnected;
+        }
+        // Initial fetch and periodic updates
+        fetchBots();
+        setInterval(fetchBots, 5000);
+    </script>
+</body>
+</html>
+"""
+def write_bot_script():
+    with open('bot.js', 'w') as f:
+        f.write(BOT_SCRIPT)
+def fetch_sheet_data():
+    try:
+        response = requests.get(SHEET_URL)
+        if response.status_code == 200:
+            lines = response.text.strip().split('\n')
+            if len(lines) > 1:
+                data = []
+                for line in lines[1:]:  # Skip header
+                    parts = line.split(',')
+                    if len(parts) >= 4:
+                        bot_name = parts[0].strip()
+                        ip = parts[1].strip()
+                        port = parts[2].strip()
+                        version = parts[3].strip() if len(parts) > 3 else "1.20.1"
+                        if bot_name and ip and port:
+                            data.append({
+                                'bot_name': bot_name,
+                                'ip': ip,
+                                'port': port,
+                                'version': version
+                            })
+                return data
+    except Exception as e:
+        print(f"Error fetching sheet: {e}")
+    return []
+def start_bot(bot_data):
+    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:
+            bot_processes[bot_name].terminate()
+        except:
+            pass
+    # Start new bot process
+    try:
+        process = subprocess.Popen(
+            ['node', 'bot.js', bot_name, bot_data['ip'], bot_data['port'], bot_data['version']],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        bot_processes[bot_name] = process
+        server_bots[server_key] = bot_name
+        # Check initial connection
+        time.sleep(2)
+        output = ""
+        if process.poll() is None:
+            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:
+        return False, str(e)
+    return False, "Failed to start bot"
+def monitor_bot(bot_name):
+    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'
+                # Remove from server_bots
+                server_key = bots[bot_name].get('server_key')
+                if server_key and server_key in server_bots:
+                    del server_bots[server_key]
+            break
+        try:
+            line = process.stdout.readline()
+            if line:
+                if 'CONNECTED' in line:
+                    bots[bot_name]['status'] = 'connected'
+                elif 'DISCONNECTED' in line or 'KICKED' in line or 'ERROR' in line:
+                    bots[bot_name]['status'] = 'disconnected'
+                elif 'DIED' in line:
+                    bots[bot_name]['status'] = 'disconnected'
+        except:
+            pass
+        time.sleep(0.1)
+def update_bots_from_sheet():
+    sheet_data = fetch_sheet_data()
+    for bot_data in sheet_data:
+        bot_name = bot_data['bot_name']
+        if bot_name not in bots:
+            # New bot, add it
+            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():
+    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():
+    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 if can rejoin (1 hour 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
+    # Check if bot is already connected
+    if bots[bot_name]['status'] == 'connected':
+        return jsonify({'error': 'Bot is already connected'}), 400
+    # Rejoin the bot
+    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():
+    update_bots_from_sheet()
+    return jsonify({'success': True})
+if __name__ == '__main__':
+    # Write bot script
+    write_bot_script()
+    # 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
+            update_bots_from_sheet()
+    threading.Thread(target=periodic_update, daemon=True).start()
+    # Start Flask app
+    app.run(host='0.0.0.0', port=7860, debug=False)