blockmine 1.21.0 → 1.23.0

package/backend/src/core/services/MinecraftBotManager.js

@@ -0,0 +1,259 @@
+const mineflayer = require('mineflayer');
+const { pathfinder, Movements, goals } = require('mineflayer-pathfinder');
+const Vec3 = require('vec3').Vec3;
+
+class MinecraftBotManager {
+    constructor({ logger }) {
+        this.logger = logger;
+        this.bots = new Map();
+        this.sessionIdCounter = 0;
+    }
+
+    async createBot(sessionId, config) {
+        const { host, port, version, username, password } = config;
+
+        if (this.bots.has(sessionId)) {
+            await this.disconnectBot(sessionId);
+        }
+
+        this.logger.info(`[Minecraft] Creating bot ${username} for session ${sessionId}`);
+
+        const bot = mineflayer.createBot({
+            host,
+            port: port || 25565,
+            username,
+            password: password || undefined,
+            version: version || '1.19.2',
+            hideErrors: false
+        });
+
+        bot.loadPlugin(pathfinder);
+
+        const botState = {
+            bot,
+            config,
+            status: 'connecting',
+            health: 20,
+            food: 20,
+            position: null,
+            yaw: 0,
+            pitch: 0
+        };
+
+        this.bots.set(sessionId, botState);
+        this._attachEventHandlers(sessionId, bot);
+
+        return sessionId;
+    }
+
+    _attachEventHandlers(sessionId, bot) {
+        bot.on('spawn', () => {
+            this.logger.info(`[Minecraft] Bot spawned for session ${sessionId}`);
+            const state = this.bots.get(sessionId);
+            if (state) {
+                state.status = 'online';
+                state.position = bot.entity.position;
+                state.yaw = bot.entity.yaw;
+                state.pitch = bot.entity.pitch;
+            }
+        });
+
+        bot.on('health', () => {
+            const state = this.bots.get(sessionId);
+            if (state) {
+                state.health = bot.health;
+                state.food = bot.food;
+            }
+        });
+
+        bot.on('move', () => {
+            const state = this.bots.get(sessionId);
+            if (state && bot.entity) {
+                state.position = bot.entity.position;
+                state.yaw = bot.entity.yaw;
+                state.pitch = bot.entity.pitch;
+            }
+        });
+
+        bot.on('end', (reason) => {
+            this.logger.info(`[Minecraft] Bot disconnected for session ${sessionId}: ${reason}`);
+            const state = this.bots.get(sessionId);
+            if (state) {
+                state.status = 'offline';
+            }
+        });
+
+        bot.on('error', (err) => {
+            this.logger.error(`[Minecraft] Bot error for session ${sessionId}:`, err);
+        });
+
+        bot.on('kicked', (reason) => {
+            this.logger.warn(`[Minecraft] Bot kicked for session ${sessionId}: ${reason}`);
+        });
+    }
+
+    async disconnectBot(sessionId) {
+        const state = this.bots.get(sessionId);
+        if (!state) return;
+
+        this.logger.info(`[Minecraft] Disconnecting bot for session ${sessionId}`);
+
+        if (state.bot) {
+            state.bot.quit();
+        }
+
+        this.bots.delete(sessionId);
+    }
+
+    getBotState(sessionId) {
+        const state = this.bots.get(sessionId);
+        if (!state || !state.bot) return null;
+
+        const bot = state.bot;
+
+        return {
+            status: state.status,
+            health: state.health || 20,
+            food: state.food || 20,
+            position: state.position ? {
+                x: state.position.x,
+                y: state.position.y,
+                z: state.position.z
+            } : null,
+            yaw: state.yaw || 0,
+            pitch: state.pitch || 0,
+            gameMode: bot.game?.gameMode,
+            dimension: bot.game?.dimension,
+            inventory: this._getInventory(bot),
+            nearbyPlayers: this._getNearbyPlayers(bot),
+            nearbyMobs: this._getNearbyMobs(bot)
+        };
+    }
+
+    _getInventory(bot) {
+        if (!bot.inventory) return [];
+
+        return bot.inventory.items().map(item => ({
+            name: item.name,
+            displayName: item.displayName,
+            count: item.count,
+            slot: item.slot
+        }));
+    }
+
+    _getNearbyPlayers(bot) {
+        if (!bot.entities) return [];
+
+        return Object.values(bot.entities)
+            .filter(e => e.type === 'player' && e.username !== bot.username)
+            .map(e => ({
+                username: e.username,
+                position: {
+                    x: e.position.x,
+                    y: e.position.y,
+                    z: e.position.z
+                },
+                distance: bot.entity ? bot.entity.position.distanceTo(e.position) : 0
+            }));
+    }
+
+    _getNearbyMobs(bot) {
+        if (!bot.entities) return [];
+
+        return Object.values(bot.entities)
+            .filter(e => e.type === 'mob')
+            .map(e => ({
+                name: e.name || e.displayName,
+                mobType: e.mobType,
+                position: {
+                    x: e.position.x,
+                    y: e.position.y,
+                    z: e.position.z
+                },
+                distance: bot.entity ? bot.entity.position.distanceTo(e.position) : 0
+            }));
+    }
+
+    async handleControlCommand(sessionId, command) {
+        const state = this.bots.get(sessionId);
+        if (!state || !state.bot) return;
+
+        const bot = state.bot;
+
+        try {
+            switch (command.type) {
+                case 'move':
+                    bot.setControlState(command.direction, command.active);
+                    break;
+
+                case 'look':
+                    const yaw = command.yaw !== undefined ? command.yaw : bot.entity.yaw;
+                    const pitch = command.pitch !== undefined ? command.pitch : bot.entity.pitch;
+                    await bot.look(yaw, pitch, true);
+                    break;
+
+                case 'chat':
+                    bot.chat(command.message);
+                    break;
+
+                case 'dig':
+                    await this._digBlock(bot, command.position);
+                    break;
+
+                case 'place':
+                    await this._placeBlock(bot, command.position, command.blockType);
+                    break;
+
+                default:
+                    this.logger.warn(`[Minecraft] Unknown command type: ${command.type}`);
+            }
+        } catch (error) {
+            this.logger.error(`[Minecraft] Error handling command:`, error);
+        }
+    }
+
+    async _digBlock(bot, position) {
+        if (!position) return;
+
+        const block = bot.blockAt(new Vec3(position.x, position.y, position.z));
+        if (!block) return;
+
+        try {
+            await bot.dig(block);
+        } catch (error) {
+            this.logger.error('[Minecraft] Error digging block:', error);
+        }
+    }
+
+    async _placeBlock(bot, position, blockType) {
+        if (!position || !blockType) return;
+
+        const referenceBlock = bot.blockAt(new Vec3(position.x, position.y, position.z));
+        if (!referenceBlock) return;
+
+        const itemToPlace = bot.inventory.items().find(item => item.name === blockType);
+        if (!itemToPlace) return;
+
+        try {
+            await bot.equip(itemToPlace, 'hand');
+            await bot.placeBlock(referenceBlock, new Vec3(0, 1, 0));
+        } catch (error) {
+            this.logger.error('[Minecraft] Error placing block:', error);
+        }
+    }
+
+    getBot(sessionId) {
+        const state = this.bots.get(sessionId);
+        return state?.bot || null;
+    }
+
+    getAllSessions() {
+        return Array.from(this.bots.keys());
+    }
+
+    generateSessionId() {
+        return `mc_${++this.sessionIdCounter}_${Date.now()}`;
+    }
+}
+
+module.exports = MinecraftBotManager;

package/backend/src/core/services/MinecraftViewerService.js

@@ -0,0 +1,216 @@
+const { v4: uuidv4 } = require('uuid');
+
+class MinecraftViewerService {
+    constructor({ io, botProcessManager, logger }) {
+        this.processManager = botProcessManager;
+        this.logger = logger;
+        this.viewerNamespace = io.of('/minecraft-viewer');
+        this.activeViewers = new Map(); // botId -> Set<socketId>
+        this.pendingRequests = new Map();
+
+        this._setupNamespace();
+        this._setupIPCHandlers();
+    }
+
+    _setupNamespace() {
+        this.viewerNamespace.on('connection', (socket) => {
+            this.logger.info(`[MinecraftViewer] Client connected: ${socket.id}`);
+
+            socket.on('viewer:connect', ({ botId }) => {
+                const child = this.processManager.getProcess(botId);
+                if (!child) {
+                    socket.emit('viewer:error', { message: 'Bot not running' });
+                    return;
+                }
+
+                socket.botId = botId;
+                socket.join(`bot:${botId}`);
+
+                if (!this.activeViewers.has(botId)) {
+                    this.activeViewers.set(botId, new Set());
+                }
+                this.activeViewers.get(botId).add(socket.id);
+
+                this.logger.info(`[MinecraftViewer] Socket ${socket.id} connected to bot ${botId}`);
+
+                const requestId = uuidv4();
+                this.processManager.sendMessage(botId, {
+                    type: 'viewer:get_state',
+                    requestId,
+                    includeBlocks: true
+                });
+
+                this.pendingRequests.set(requestId, {
+                    resolve: (state) => {
+                        socket.emit('viewer:connected', { botId });
+                        socket.emit('viewer:state', state);
+                    },
+                    reject: (error) => {
+                        socket.emit('viewer:error', { message: error.message });
+                    }
+                });
+
+                this._startStateStream(botId);
+            });
+
+            socket.on('viewer:control', ({ command }) => {
+                const botId = socket.botId;
+                if (!botId) return;
+
+                this.processManager.sendMessage(botId, {
+                    type: 'viewer:control',
+                    command
+                });
+            });
+
+            socket.on('viewer:disconnect', () => {
+                const botId = socket.botId;
+                if (botId) {
+                    this._removeViewer(botId, socket.id);
+                }
+            });
+
+            socket.on('disconnect', () => {
+                this.logger.info(`[MinecraftViewer] Client disconnected: ${socket.id}`);
+                const botId = socket.botId;
+                if (botId) {
+                    this._removeViewer(botId, socket.id);
+                }
+            });
+        });
+    }
+
+    _setupIPCHandlers() {
+        this.processManager.getAllProcesses().forEach((child, botId) => {
+            this._attachChildHandlers(child, botId);
+        });
+
+        const originalSpawn = this.processManager.spawn.bind(this.processManager);
+        this.processManager.spawn = async (...args) => {
+            const child = await originalSpawn(...args);
+            const botId = child.botConfig.id;
+            this._attachChildHandlers(child, botId);
+            return child;
+        };
+    }
+
+    _attachChildHandlers(child, botId) {
+        child.on('message', (message) => {
+            if (message.type === 'viewer:state_response') {
+                const pending = this.pendingRequests.get(message.requestId);
+                if (pending) {
+                    pending.resolve(message.payload);
+                    this.pendingRequests.delete(message.requestId);
+                }
+            } else if (message.type === 'viewer:spawn') {
+                this.viewerNamespace.to(`bot:${botId}`).emit('viewer:spawn', message.payload);
+            } else if (message.type === 'viewer:move') {
+                this.viewerNamespace.to(`bot:${botId}`).emit('viewer:move', message.payload);
+            } else if (message.type === 'viewer:health') {
+                this.viewerNamespace.to(`bot:${botId}`).emit('viewer:health', message.payload);
+            } else if (message.type === 'viewer:chat') {
+                this.viewerNamespace.to(`bot:${botId}`).emit('viewer:chat', message.payload);
+            }
+        });
+    }
+
+    _startStateStream(botId) {
+        if (this.activeViewers.get(botId)?.size === 1) {
+            let lastPosition = null;
+            let lastSentPosition = null;
+            let lastSentPlayers = new Map(); // username -> {x, y, z, yaw, pitch}
+            let tickCounter = 0;
+
+            const interval = setInterval(() => {
+                if (this.activeViewers.get(botId)?.size > 0) {
+                    tickCounter++;
+                    const shouldSendBlocks = tickCounter % 60 === 0;
+
+                    const requestId = uuidv4();
+                    this.processManager.sendMessage(botId, {
+                        type: 'viewer:get_state',
+                        requestId,
+                        includeBlocks: shouldSendBlocks
+                    });
+
+                    this.pendingRequests.set(requestId, {
+                        resolve: (state) => {
+                            const currentPos = state.position;
+
+                            // Проверяем изменения в nearbyPlayers
+                            let playersChanged = false;
+                            if (state.nearbyPlayers) {
+                                // Проверяем количество
+                                if (state.nearbyPlayers.length !== lastSentPlayers.size) {
+                                    playersChanged = true;
+                                } else {
+                                    // Проверяем каждого игрока
+                                    for (const player of state.nearbyPlayers) {
+                                        const last = lastSentPlayers.get(player.username);
+                                        if (!last ||
+                                            Math.abs(last.x - player.position.x) > 0.1 ||
+                                            Math.abs(last.y - player.position.y) > 0.1 ||
+                                            Math.abs(last.z - player.position.z) > 0.1 ||
+                                            Math.abs(last.yaw - player.yaw) > 0.05 ||
+                                            Math.abs(last.pitch - player.pitch) > 0.05) {
+                                            playersChanged = true;
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+
+                            // Отправляем если позиция бота изменилась, игроки изменились, или пора отправлять блоки
+                            const shouldSend = shouldSendBlocks || playersChanged || !lastSentPosition ||
+                                Math.abs(currentPos?.x - lastSentPosition.x) > 0.1 ||
+                                Math.abs(currentPos?.y - lastSentPosition.y) > 0.1 ||
+                                Math.abs(currentPos?.z - lastSentPosition.z) > 0.1;
+
+                            if (shouldSend) {
+                                this.viewerNamespace.to(`bot:${botId}`).emit('viewer:update', state);
+                                lastSentPosition = currentPos ? { ...currentPos } : null;
+
+                                // Обновляем кэш игроков
+                                lastSentPlayers.clear();
+                                if (state.nearbyPlayers) {
+                                    state.nearbyPlayers.forEach(player => {
+                                        lastSentPlayers.set(player.username, {
+                                            x: player.position.x,
+                                            y: player.position.y,
+                                            z: player.position.z,
+                                            yaw: player.yaw,
+                                            pitch: player.pitch
+                                        });
+                                    });
+                                }
+                            }
+
+                            // Обновляем lastPosition для блоков
+                            if (shouldSendBlocks || !lastPosition ||
+                                Math.abs(currentPos?.x - lastPosition.x) > 8 ||
+                                Math.abs(currentPos?.y - lastPosition.y) > 8 ||
+                                Math.abs(currentPos?.z - lastPosition.z) > 8) {
+                                lastPosition = currentPos ? { ...currentPos } : null;
+                            }
+                        },
+                        reject: () => {}
+                    });
+                } else {
+                    clearInterval(interval);
+                }
+            }, 100);
+        }
+    }
+
+    _removeViewer(botId, socketId) {
+        const viewers = this.activeViewers.get(botId);
+        if (viewers) {
+            viewers.delete(socketId);
+            if (viewers.size === 0) {
+                this.activeViewers.delete(botId);
+            }
+        }
+    }
+}
+
+module.exports = MinecraftViewerService;

package/backend/src/core/services/ResourceMonitorService.js

@@ -0,0 +1,90 @@
+const pidusage = require('pidusage');
+
+class ResourceMonitorService {
+    constructor({ botProcessManager, logger }) {
+        this.processManager = botProcessManager;
+        this.logger = logger;
+        this.resourceUsage = new Map();
+        this.updateInterval = null;
+    }
+
+    startMonitoring(intervalMs = 5000) {
+        if (this.updateInterval) {
+            clearInterval(this.updateInterval);
+        }
+        this.updateInterval = setInterval(() => this.updateAllResourceUsage(), intervalMs);
+    }
+
+    stopMonitoring() {
+        if (this.updateInterval) {
+            clearInterval(this.updateInterval);
+            this.updateInterval = null;
+        }
+    }
+
+    async updateAllResourceUsage() {
+        const processes = this.processManager.getAllProcesses();
+
+        if (processes.size === 0) {
+            if (this.resourceUsage.size > 0) {
+                this.resourceUsage.clear();
+            }
+            return [];
+        }
+
+        const pids = Array.from(processes.values())
+            .map(child => child.pid)
+            .filter(Boolean);
+
+        if (pids.length === 0) return [];
+
+        try {
+            const stats = await pidusage(pids);
+            const usageData = [];
+
+            for (const pid in stats) {
+                if (!stats[pid]) continue;
+
+                const botId = this.getBotIdByPid(parseInt(pid, 10));
+                if (botId) {
+                    const usage = {
+                        botId: botId,
+                        cpu: parseFloat(stats[pid].cpu.toFixed(1)),
+                        memory: parseFloat((stats[pid].memory / 1024 / 1024).toFixed(1)),
+                    };
+                    this.resourceUsage.set(botId, usage);
+                    usageData.push(usage);
+                }
+            }
+
+            return usageData;
+        } catch (error) {
+            this.logger.error({ error }, 'Ошибка обновления ресурсов');
+            return [];
+        }
+    }
+
+    getBotIdByPid(pid) {
+        const processes = this.processManager.getAllProcesses();
+        for (const [botId, child] of processes.entries()) {
+            if (child.pid === pid) {
+                return botId;
+            }
+        }
+        return null;
+    }
+
+    getResourceUsage(botId) {
+        return this.resourceUsage.get(botId);
+    }
+
+    getAllResourceUsage() {
+        return Array.from(this.resourceUsage.values());
+    }
+
+    clearResourceUsage(botId) {
+        this.resourceUsage.delete(botId);
+    }
+}
+
+module.exports = ResourceMonitorService;

package/backend/src/core/services/TelemetryService.js

@@ -0,0 +1,124 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+
+class TelemetryService {
+    constructor({ config, botProcessManager, logger }) {
+        this.config = config;
+        this.processManager = botProcessManager;
+        this.logger = logger;
+        this.instanceId = null;
+        this.heartbeatDebounceTimer = null;
+        this.heartbeatInterval = null;
+
+        this.STATS_SERVER_URL = 'http://185.65.200.184:3000';
+        this.DATA_DIR = path.join(os.homedir(), '.blockmine');
+        this.INSTANCE_ID_PATH = path.join(this.DATA_DIR, '.instance_id');
+
+        this.loadInstanceId();
+    }
+
+    loadInstanceId() {
+        if (this.instanceId) return this.instanceId;
+
+        try {
+            if (fs.existsSync(this.INSTANCE_ID_PATH)) {
+                this.instanceId = fs.readFileSync(this.INSTANCE_ID_PATH, 'utf-8');
+            } else {
+                this.instanceId = uuidv4();
+                if (!fs.existsSync(this.DATA_DIR)) {
+                    fs.mkdirSync(this.DATA_DIR, { recursive: true });
+                }
+                fs.writeFileSync(this.INSTANCE_ID_PATH, this.instanceId, 'utf-8');
+            }
+        } catch (error) {
+            this.logger.error({ error }, 'Ошибка загрузки Instance ID');
+            return null;
+        }
+
+        return this.instanceId;
+    }
+
+    getInstanceId() {
+        return this.instanceId;
+    }
+
+    startHeartbeat(intervalMs = 5 * 60 * 1000) {
+        if (!this.config.telemetry?.enabled) return;
+
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+
+        this.heartbeatInterval = setInterval(() => this.sendHeartbeat(), intervalMs);
+    }
+
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+
+    triggerHeartbeat() {
+        if (!this.config.telemetry?.enabled) return;
+
+        if (this.heartbeatDebounceTimer) {
+            clearTimeout(this.heartbeatDebounceTimer);
+        }
+
+        this.heartbeatDebounceTimer = setTimeout(() => {
+            this.sendHeartbeat();
+        }, 3000);
+    }
+
+    async sendHeartbeat() {
+        if (!this.config.telemetry?.enabled || !this.instanceId) return;
+
+        try {
+            const processes = this.processManager.getAllProcesses();
+            const runningBots = Array.from(processes.values())
+                .filter(p => p.botConfig)
+                .map(p => ({
+                    username: p.botConfig.username,
+                    serverHost: p.botConfig.server.host,
+                    serverPort: p.botConfig.server.port
+                }));
+
+            if (runningBots.length === 0) return;
+
+            const challengeRes = await fetch(`${this.STATS_SERVER_URL}/api/challenge?uuid=${this.instanceId}`);
+            if (!challengeRes.ok) throw new Error(`Challenge server error: ${challengeRes.statusText}`);
+
+            const { challenge, difficulty, prefix } = await challengeRes.json();
+
+            // Proof of work
+            let nonce = 0;
+            let hash = '';
+            do {
+                nonce++;
+                hash = crypto.createHash('sha256').update(prefix + challenge + nonce).digest('hex');
+            } while (!hash.startsWith('0'.repeat(difficulty)));
+
+            const packageJson = require('../../../../package.json');
+            await fetch(`${this.STATS_SERVER_URL}/api/heartbeat`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    instanceUuid: this.instanceId,
+                    appVersion: packageJson.version,
+                    bots: runningBots,
+                    nonce: nonce
+                })
+            });
+
+            this.logger.debug('Heartbeat отправлен успешно');
+        } catch (error) {
+            this.logger.error({ error }, 'Не удалось отправить heartbeat');
+        }
+    }
+}
+
+module.exports = TelemetryService;