npm install @dimzxzzx07/minebot
npm install -g @dimzxzzx07/minebot

const { createBot } = require('@dimzxzzx07/minebot');

async function main() {
  const bot = await createBot({
    target: 'play.example.com',
    port: 25565,
    version: '1.20.4',
    auth: {
      type: 'offline',
      username: 'MyBot'
    },
    behavior: {
      antiAFK: { enabled: true, type: 'swing', interval: 10000 }
    }
  });

  bot.on('ready', () => {
    console.log('Bot ready!');
    bot.sendChat('Hello everyone!');
  });

  bot.on('chat', (msg) => {
    console.log(`Chat: ${msg}`);
  });
}

main();

const { spawnSpamBots } = require('@dimzxzzx07/minebot');

async function main() {
  await spawnSpamBots({
    target: 'play.example.com',
    port: 25565,
    count: 10,
    delay: 3000,
    randomName: true,
    humanLike: true,
    keepAlive: true,
    autoChat: 'Hello!'
  });
}

main();

# Start a basic bot
mc-bot start -t play.example.com -p 25565 -u MyBot --anti-afk

# OSINT mode with watchlist
mc-bot osint -t play.example.com -p 25565 -u Scanner -w "Admin,Owner"

# Stress test with 50 bots
mc-bot stress -t play.example.com -p 25565 -c 50 -d 60

# Spam bots with anti-detection
mc-bot spam -t play.example.com -p 25565 -c 10 -d 3000 --random-delay --random-name --human-like

# Stealth mode spam
mc-bot spam -t play.example.com -p 25565 -c 5 --stealth-mode --random-delay --keep-alive

const { createBot } = require('@dimzxzzx07/minebot');

const bot = await createBot({
  target: 'play.example.com',
  port: 25565,
  version: '1.20.4',
  timeout: 5000,

  auth: {
    type: 'offline',
    username: 'MyBot',
    uuid: null
  },

  behavior: {
    autoReconnect: true,
    reconnectDelay: 3000,
    antiAFK: {
      enabled: true,
      type: 'swing',
      interval: 10000
    },
    chatResponse: {
      enabled: true,
      prefix: '!',
      allowlist: ['MyUsername']
    }
  },

  antiDetection: {
    enabled: true,
    randomDelayBetweenPackets: true,
    randomUsernameSuffix: true,
    humanLikeTyping: true,
    randomMovement: true,
    slowMode: false,
    stealthMode: false
  },

  debug: false,
  osintMode: false
});

const bot = await createBot({
  target: string,
  port: number,
  version: string,
  auth: AuthConfig,
  behavior: BehaviorConfig,
  antiDetection: AntiDetectionConfig
});

const { createBot } = require('@dimzxzzx07/minebot');
const TelegramBot = require('node-telegram-bot-api');

const telegramToken = 'YOUR_TELEGRAM_BOT_TOKEN';
const telegramBot = new TelegramBot(telegramToken, { polling: true });
const chatId = 'YOUR_CHAT_ID';

async function startMinecraftBot() {
  const bot = await createBot({
    target: 'play.example.com',
    port: 25565,
    auth: { type: 'offline', username: 'TelegramBot' },
    behavior: { chatResponse: { enabled: true, prefix: '!', allowlist: [] } }
  });

  bot.on('chat', (message) => {
    if (message.includes('@bot')) {
      telegramBot.sendMessage(chatId, `Minecraft Chat: ${message}`);
    }
  });

  bot.on('player-join', (player) => {
    telegramBot.sendMessage(chatId, `Player joined: ${player}`);
  });

  telegramBot.onText(/\/status/, async () => {
    const pos = bot.getPosition();
    telegramBot.sendMessage(chatId, `Bot position: ${pos.x}, ${pos.y}, ${pos.z}`);
  });

  telegramBot.onText(/\/say (.+)/, (msg, match) => {
    bot.sendChat(match[1]);
  });
}

startMinecraftBot();

const express = require('express');
const { createBot } = require('@dimzxzzx07/minebot');

const app = express();
app.use(express.json());

let minecraftBot = null;

app.post('/api/bot/start', async (req, res) => {
  const { target, port, username } = req.body;

  minecraftBot = await createBot({
    target: target,
    port: port,
    auth: { type: 'offline', username: username },
    behavior: { antiAFK: { enabled: true, type: 'swing', interval: 10000 } }
  });

  minecraftBot.on('chat', (msg) => {
    console.log(`Chat: ${msg}`);
  });

  res.json({ status: 'started', username: username });
});

app.post('/api/bot/chat', (req, res) => {
  const { message } = req.body;
  if (minecraftBot) {
    minecraftBot.sendChat(message);
    res.json({ status: 'sent' });
  } else {
    res.status(400).json({ error: 'Bot not running' });
  }
});

app.get('/api/bot/status', (req, res) => {
  if (minecraftBot) {
    res.json({
      connected: minecraftBot.isConnected(),
      position: minecraftBot.getPosition(),
      health: minecraftBot.getHealth()
    });
  } else {
    res.json({ connected: false });
  }
});

app.listen(3000, () => console.log('Server running on port 3000'));

import 'dart:io';
import 'package:http/http.dart' as http;

class MineBotClient {
  final String baseUrl;

  MineBotClient(this.baseUrl);

  Future<Map<String, dynamic>> startBot(String target, int port, String username) async {
    final response = await http.post(
      Uri.parse('$baseUrl/api/bot/start'),
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({
        'target': target,
        'port': port,
        'username': username
      }),
    );
    return jsonDecode(response.body);
  }

  Future<Map<String, dynamic>> sendChat(String message) async {
    final response = await http.post(
      Uri.parse('$baseUrl/api/bot/chat'),
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({'message': message}),
    );
    return jsonDecode(response.body);
  }

  Future<Map<String, dynamic>> getStatus() async {
    final response = await http.get(Uri.parse('$baseUrl/api/bot/status'));
    return jsonDecode(response.body);
  }
}

void main() async {
  final client = MineBotClient('http://localhost:3000');

  await client.startBot('play.example.com', 25565, 'DartBot');
  await client.sendChat('Hello from Dart!');
  final status = await client.getStatus();
  print('Bot status: $status');
}

import kotlinx.coroutines.*
import okhttp3.*
import com.google.gson.Gson

data class BotRequest(val target: String, val port: Int, val username: String)
data class ChatRequest(val message: String)

class MineBotClient(private val baseUrl: String) {
    private val client = OkHttpClient()
    private val gson = Gson()

    suspend fun startBot(target: String, port: Int, username: String): String = withContext(Dispatchers.IO) {
        val request = BotRequest(target, port, username)
        val body = RequestBody.create(
            MediaType.parse("application/json"),
            gson.toJson(request)
        )

        val httpRequest = Request.Builder()
            .url("$baseUrl/api/bot/start")
            .post(body)
            .build()

        client.newCall(httpRequest).execute().use { response ->
            return@withContext response.body?.string() ?: "{}"
        }
    }

    suspend fun sendChat(message: String): String = withContext(Dispatchers.IO) {
        val request = ChatRequest(message)
        val body = RequestBody.create(
            MediaType.parse("application/json"),
            gson.toJson(request)
        )

        val httpRequest = Request.Builder()
            .url("$baseUrl/api/bot/chat")
            .post(body)
            .build()

        client.newCall(httpRequest).execute().use { response ->
            return@withContext response.body?.string() ?: "{}"
        }
    }
}

fun main() = runBlocking {
    val client = MineBotClient("http://localhost:3000")

    val result = client.startBot("play.example.com", 25565, "KotlinBot")
    println("Start result: $result")

    client.sendChat("Hello from Kotlin!")
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.google.gson.Gson;

public class MineBotClient {
    private final String baseUrl;
    private final HttpClient client;
    private final Gson gson;

    public MineBotClient(String baseUrl) {
        this.baseUrl = baseUrl;
        this.client = HttpClient.newHttpClient();
        this.gson = new Gson();
    }

    public static class BotRequest {
        String target;
        int port;
        String username;

        public BotRequest(String target, int port, String username) {
            this.target = target;
            this.port = port;
            this.username = username;
        }
    }

    public static class ChatRequest {
        String message;

        public ChatRequest(String message) {
            this.message = message;
        }
    }

    public String startBot(String target, int port, String username) throws Exception {
        BotRequest request = new BotRequest(target, port, username);
        String json = gson.toJson(request);

        HttpRequest httpRequest = HttpRequest.newBuilder()
            .uri(URI.create(baseUrl + "/api/bot/start"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(json))
            .build();

        HttpResponse<String> response = client.send(httpRequest, HttpResponse.BodyHandlers.ofString());
        return response.body();
    }

    public String sendChat(String message) throws Exception {
        ChatRequest request = new ChatRequest(message);
        String json = gson.toJson(request);

        HttpRequest httpRequest = HttpRequest.newBuilder()
            .uri(URI.create(baseUrl + "/api/bot/chat"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(json))
            .build();

        HttpResponse<String> response = client.send(httpRequest, HttpResponse.BodyHandlers.ofString());
        return response.body();
    }

    public static void main(String[] args) {
        MineBotClient client = new MineBotClient("http://localhost:3000");

        try {
            String result = client.startBot("play.example.com", 25565, "JavaBot");
            System.out.println("Start result: " + result);

            client.sendChat("Hello from Java!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

extends Node

var http = HTTPRequest.new()

func _ready():
    add_child(http)
    http.connect("request_completed", self, "_on_request_completed")

func start_bot(target, port, username):
    var url = "http://localhost:3000/api/bot/start"
    var headers = ["Content-Type: application/json"]
    var body = JSON.print({
        "target": target,
        "port": port,
        "username": username
    })
    http.request(url, headers, true, HTTPClient.METHOD_POST, body)

func send_chat(message):
    var url = "http://localhost:3000/api/bot/chat"
    var headers = ["Content-Type: application/json"]
    var body = JSON.print({"message": message})
    http.request(url, headers, true, HTTPClient.METHOD_POST, body)

func get_bot_status():
    var url = "http://localhost:3000/api/bot/status"
    http.request(url, [], true, HTTPClient.METHOD_GET)

func _on_request_completed(result, response_code, headers, body):
    var json = JSON.parse(body.get_string_from_utf8())
    if json.error == OK:
        print("Response: ", json.result)

        if json.result.has("position"):
            print("Bot position: ", json.result.position)

func _process(delta):
    if Input.is_action_just_pressed("ui_accept"):
        start_bot("play.example.com", 25565, "GodotBot")

    if Input.is_action_just_pressed("ui_text_newline"):
        send_chat("Hello from Godot!")