blockmine 1.25.0 → 1.27.0

package/backend/src/core/nodes/navigation/go_to_player.js

@@ -1,70 +1,65 @@
-const { goals } = require('mineflayer-pathfinder');
-
-/**
- * navigation:go_to_player - Идти к игроку
- */
-async function evaluate(node, pinId, context, helpers) {
-  const bot = context.bot;
-
-  if (pinId === 'exec' || pinId === 'exec_failed') {
-    return true;
-  }
-
-  if (!bot?.pathfinder) {
-    if (pinId === 'success') return false;
-    if (pinId === 'playerPosition') return null;
-    return null;
-  }
-
-  const playerName = await helpers.resolvePinValue(node, 'playerName');
-  const range = (await helpers.resolvePinValue(node, 'range')) || 2;
-
-  if (!playerName) {
-    if (pinId === 'success') return false;
-    if (pinId === 'playerPosition') return null;
-    context._nextExecPin = 'exec_failed';
-    return null;
-  }
-
-  try {
-    const player = bot.players[playerName];
-
-    if (!player?.entity) {
-      console.error(`[navigation:go_to_player] Player "${playerName}" not found or not visible`);
-      if (pinId === 'success') return false;
-      if (pinId === 'playerPosition') return null;
-      context._nextExecPin = 'exec_failed';
-      return null;
-    }
-
-    const playerPos = player.entity.position;
-
-    if (pinId === 'playerPosition') {
-      return {
-        x: playerPos.x,
-        y: playerPos.y,
-        z: playerPos.z
-      };
-    }
-
-    const goal = new goals.GoalNear(playerPos.x, playerPos.y, playerPos.z, range);
-    await bot.pathfinder.goto(goal);
-
-    if (pinId === 'success') {
-      return true;
-    }
-
-    context._nextExecPin = 'exec';
-  } catch (error) {
-    console.error('[navigation:go_to_player] Error:', error.message);
-
-    if (pinId === 'success') return false;
-    if (pinId === 'playerPosition') return null;
-
-    context._nextExecPin = 'exec_failed';
-  }
-
-  return null;
-}
-
-module.exports = { evaluate };
+const { goals } = require('mineflayer-pathfinder');
+
+async function execute(node, context, helpers) {
+  const { resolvePinValue, traverse, memo } = helpers;
+  const bot = context.bot;
+
+  if (!bot?.pathfinder) {
+    memo.set(`${node.id}:success`, false);
+    await traverse(node, 'exec_failed');
+    return;
+  }
+
+  const playerName = await resolvePinValue(node, 'playerName', node.data?.playerName);
+  const range = await resolvePinValue(node, 'range', node.data?.range) ?? 3;
+
+  if (!playerName) {
+    memo.set(`${node.id}:success`, false);
+    await traverse(node, 'exec_failed');
+    return;
+  }
+
+  try {
+    const player = bot.players[playerName];
+
+    if (!player?.entity) {
+      console.error(`[navigation:go_to_player] Player "${playerName}" not found or not visible`);
+      memo.set(`${node.id}:success`, false);
+      await traverse(node, 'exec_failed');
+      return;
+    }
+
+    const playerPos = player.entity.position;
+
+    memo.set(`${node.id}:playerPosition`, {
+      x: playerPos.x,
+      y: playerPos.y,
+      z: playerPos.z
+    });
+
+    const goal = new goals.GoalNear(playerPos.x, playerPos.y, playerPos.z, Number(range));
+    await bot.pathfinder.goto(goal);
+
+    memo.set(`${node.id}:success`, true);
+    await traverse(node, 'exec');
+  } catch (error) {
+    console.error('[navigation:go_to_player] Error:', error.message);
+    memo.set(`${node.id}:success`, false);
+    await traverse(node, 'exec_failed');
+  }
+}
+
+async function evaluate(node, pinId, context, helpers) {
+  const { memo } = helpers;
+
+  if (pinId === 'success') {
+    return memo.get(`${node.id}:success`) ?? false;
+  }
+  if (pinId === 'playerPosition') {
+    return memo.get(`${node.id}:playerPosition`) ?? null;
+  }
+
+  return null;
+}
+
+module.exports = { execute, evaluate };

package/backend/src/core/nodes/navigation/stop.js

@@ -1,26 +1,17 @@
-/**
- * navigation:stop - Остановить движение бота
- */
-async function evaluate(node, pinId, context, helpers) {
-  const bot = context.bot;
-
-  if (pinId === 'exec') {
-    return true;
-  }
-
-  if (!bot?.pathfinder) {
-    return null;
-  }
-
-  try {
-    bot.pathfinder.setGoal(null);
-
-    bot.clearControlStates();
-  } catch (error) {
-    console.error('[navigation:stop] Error:', error.message);
-  }
-
-  return null;
-}
-
-module.exports = { evaluate };
+async function execute(node, context, helpers) {
+  const { traverse } = helpers;
+  const bot = context.bot;
+
+  try {
+    if (bot?.pathfinder) {
+      bot.pathfinder.setGoal(null);
+      bot.clearControlStates();
+    }
+    await traverse(node, 'exec');
+  } catch (error) {
+    console.error('[navigation:stop] Error:', error.message);
+    await traverse(node, 'exec');
+  }
+}
+
+module.exports = { execute };

package/backend/src/core/nodes/users/add_to_group.js

@@ -0,0 +1,24 @@
+const User = require('../../UserService');
+
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse } = helpers;
+
+    const userIdentifier = await resolvePinValue(node, 'user', null);
+    const groupName = await resolvePinValue(node, 'group', node.data?.group || '');
+
+    let username = null;
+    if (typeof userIdentifier === 'string') username = userIdentifier;
+    else if (userIdentifier?.username) username = userIdentifier.username;
+
+    if (username && groupName) {
+        const user = await User.getUser(username, context.botId);
+        if (user) {
+            await user.addGroup(groupName);
+            User.clearCache(username, context.botId);
+        }
+    }
+
+    await traverse(node, 'exec');
+}
+
+module.exports = { execute };

package/backend/src/core/nodes/users/check_permission.js

@@ -0,0 +1,26 @@
+const User = require('../../UserService');
+
+async function evaluate(node, pinId, context, helpers) {
+    if (pinId !== 'has_permission') return null;
+    const { resolvePinValue } = helpers;
+
+    const userIdentifier = await resolvePinValue(node, 'user', null);
+    const permission = await resolvePinValue(node, 'permission', node.data?.permission || '');
+
+    let username = null;
+    if (typeof userIdentifier === 'string') username = userIdentifier;
+    else if (userIdentifier?.username) username = userIdentifier.username;
+
+    if (!username || !permission) return false;
+
+    const user = await User.getUser(username, context.botId);
+    if (!user) return false;
+
+    if (user.permissionsSet) {
+        return user.permissionsSet.has('*') || user.permissionsSet.has(permission);
+    }
+
+    return false;
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/users/remove_from_group.js

@@ -0,0 +1,24 @@
+const User = require('../../UserService');
+
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse } = helpers;
+
+    const userIdentifier = await resolvePinValue(node, 'user', null);
+    const groupName = await resolvePinValue(node, 'group', node.data?.group || '');
+
+    let username = null;
+    if (typeof userIdentifier === 'string') username = userIdentifier;
+    else if (userIdentifier?.username) username = userIdentifier.username;
+
+    if (username && groupName) {
+        const user = await User.getUser(username, context.botId);
+        if (user) {
+            await user.removeGroup(groupName);
+            User.clearCache(username, context.botId);
+        }
+    }
+
+    await traverse(node, 'exec');
+}
+
+module.exports = { execute };

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

@@ -0,0 +1,337 @@
+class BotIPCMessageRouter {
+    constructor(deps) {
+        this.eventGraphManager = deps.eventGraphManager;
+        this.commandExecutionService = deps.commandExecutionService;
+        this.processManager = deps.processManager;
+        this.logger = deps.logger;
+        this.crashRestartManager = deps.crashRestartManager;
+        this.appendLog = deps.appendLog;
+        this.emitStatusUpdate = deps.emitStatusUpdate;
+        this.restartBot = deps.restartBot;
+        this.stopBot = deps.stopBot;
+        this.getBotConfig = deps.getBotConfig;
+    }
+
+    attachToChild(child, botConfig) {
+        const botId = botConfig.id;
+
+        child.on('message', async (message) => {
+            try {
+                await this._routeMessage(botId, child, message);
+            } catch (error) {
+                this.appendLog(botId, `[SYSTEM-ERROR] Критическая ошибка в обработчике: ${error.stack}`);
+                this.logger.error({ botId, error }, 'Критическая ошибка в обработчике сообщений');
+            }
+        });
+
+        child.on('error', (err) => this.appendLog(botId, `[PROCESS FATAL] ${err.stack}`));
+        child.stdout.on('data', (data) => console.log(data.toString()));
+        child.stderr.on('data', (data) => this.appendLog(botId, `[STDERR] ${data.toString()}`));
+
+        child.on('exit', (code, signal) => {
+            this._handleExit(botId, botConfig, code, signal);
+        });
+    }
+
+    async _routeMessage(botId, child, message) {
+        const handlers = {
+            'event': () => this._handleEvent(botId, message),
+            'plugin:data': () => this._handlePluginData(botId, message),
+            'send_websocket_message': () => this._handleWebSocketMessage(message),
+            'log': () => this._handleLog(botId, message),
+            'plugin-log': () => this._handlePluginLog(message),
+            'status': () => this._handleStatus(botId, message),
+            'bot_ready': () => this._handleBotReady(botId),
+            'validate_and_run_command': () => this._handleCommandValidation(botId, child, message),
+            'request_user_action': () => this._handleUserAction(botId, child, message),
+            'get_player_list_response': () => this._handlePlayerListResponse(message),
+            'get_nearby_entities_response': () => this._handleNearbyEntitiesResponse(message),
+            'execute_command_response': () => this._handleCommandResponse(message),
+            'register_command': () => this._handleRegisterCommand(botId, message),
+            'register_permissions': () => this._handlePermissions(botId, message),
+            'register_group': () => this._handleGroup(botId, message),
+            'add_permissions_to_group': () => this._handleAddPermissions(botId, message),
+            'trace:completed': () => this._handleTrace(botId, message),
+            'debug:check_breakpoint': () => this._handleBreakpoint(botId, child, message),
+            'debug:check_step_mode': () => this._handleStepMode(botId, child, message),
+            'update_credentials': () => this._handleUpdateCredentials(botId, child, message),
+            'restart_bot': () => this._handleRestartBot(botId, child, message),
+            'stop': () => this._handleStopBot(botId),
+            'change_credentials': () => this._handleChangeCredentials(botId, child, message),
+        };
+
+        const handler = handlers[message.type];
+        if (handler) {
+            await handler();
+        }
+    }
+
+    _handleEvent(botId, message) {
+        if (message.eventType === 'raw_message') {
+            try {
+                const { getIOSafe } = require('../../real-time/socketHandler');
+                const { broadcastToApiClients } = require('../../real-time/botApi');
+                broadcastToApiClients(getIOSafe(), botId, 'chat:raw_message', {
+                    raw_message: message.args.rawText || message.args.raw_message,
+                    json: message.args.json
+                });
+            } catch (e) {}
+        }
+
+        try {
+            const { broadcastToPanelNamespace } = require('../../real-time/panelNamespace');
+            broadcastToPanelNamespace(botId, 'bot:event', {
+                botId,
+                eventType: message.eventType,
+                data: message.args || {},
+                timestamp: new Date().toISOString()
+            });
+        } catch (e) {}
+
+        if (this.eventGraphManager) {
+            this.eventGraphManager.handleEvent(botId, message.eventType, message.args);
+        }
+    }
+
+    _handlePluginData(botId, message) {
+        const { plugin: pluginName, payload } = message;
+        const pluginSubscribers = this.processManager.getPluginSubscribers(botId, pluginName);
+        if (pluginSubscribers && pluginSubscribers.size > 0) {
+            pluginSubscribers.forEach(socket => socket.emit('plugin:ui:dataUpdate', payload));
+        }
+    }
+
+    _handlePluginLog(logData) {
+        const { getIOSafe, addPluginLogToBuffer } = require('../../real-time/socketHandler');
+        const { botId, pluginName } = logData;
+        addPluginLogToBuffer(botId, pluginName, logData);
+        const io = getIOSafe();
+        if (io) {
+            io.to(`plugin-logs:${botId}:${pluginName}`).emit('plugin-log', logData);
+        }
+    }
+
+    _handleWebSocketMessage(message) {
+        const { getIOSafe } = require('../../real-time/socketHandler');
+        const { botId, message: msg } = message.payload;
+        getIOSafe().to(`bot_${botId}`).emit('bot:message', { message: msg });
+    }
+
+    _handleLog(botId, message) {
+        this.appendLog(botId, message.content);
+    }
+
+    _handleStatus(botId, message) {
+        this.emitStatusUpdate(botId, message.status);
+    }
+
+    _handleBotReady(botId) {
+        this.crashRestartManager.resetCounter(botId);
+        this.emitStatusUpdate(botId, 'running', 'Бот успешно подключился к серверу.');
+
+        try {
+            const { getIOSafe } = require('../../real-time/socketHandler');
+            const { broadcastBotStatus } = require('../../real-time/botApi');
+            broadcastBotStatus(getIOSafe(), botId, true);
+        } catch (e) {}
+
+        if (this.eventGraphManager) {
+            this.eventGraphManager.handleEvent(botId, 'botStartup', {});
+        }
+    }
+
+    async _handleCommandValidation(botId, child, message) {
+        if (this.commandExecutionService) {
+            const botConfig = child.botConfig;
+            if (botConfig) {
+                await this.commandExecutionService.handleCommandValidation(botConfig, message);
+            }
+        }
+    }
+
+    async _handleUserAction(botId, child, message) {
+        const { requestId, payload } = message;
+        const { targetUsername, action, data } = payload;
+        const UserService = require('../../core/UserService');
+        const PermissionManager = require('../../core/PermissionManager');
+
+        try {
+            const botConfig = child.botConfig;
+            const user = await UserService.getUser(targetUsername, botId, botConfig);
+            if (!user) throw new Error(`Пользователь ${targetUsername} не найден.`);
+
+            let result;
+            switch (action) {
+                case 'addGroup': result = await user.addGroup(data.group); break;
+                case 'removeGroup': result = await user.removeGroup(data.group); break;
+                case 'getGroups': result = user.groups ? user.groups.map(g => g.group.name) : []; break;
+                case 'getPermissions': result = Array.from(user.permissionsSet); break;
+                case 'isBlacklisted': result = user.isBlacklisted; break;
+                case 'setBlacklisted': result = await user.setBlacklist(data.value); break;
+                default: throw new Error(`Неизвестное действие: ${action}`);
+            }
+
+            child.send({ type: 'user_action_response', requestId, payload: result });
+        } catch (error) {
+            this.logger.error({ botId, action, username: targetUsername, error }, 'Ошибка действия пользователя');
+            child.send({ type: 'user_action_response', requestId, error: error.message });
+        }
+    }
+
+    _handlePlayerListResponse(message) {
+        this.processManager.resolvePlayerListRequest(message.requestId, message.payload.players);
+    }
+
+    _handleNearbyEntitiesResponse(message) {
+        this.processManager.resolveNearbyEntitiesRequest(message.requestId, message.payload.entities);
+    }
+
+    _handleCommandResponse(message) {
+        this.processManager.resolveCommandRequest(message.requestId, message.result, message.error);
+    }
+
+    async _handleRegisterCommand(botId, message) {
+        if (this.commandExecutionService) {
+            await this.commandExecutionService.handleCommandRegistration(botId, message.commandConfig);
+        }
+    }
+
+    async _handlePermissions(botId, message) {
+        const PermissionManager = require('../../core/PermissionManager');
+        await PermissionManager.registerPermissions(botId, message.permissions);
+    }
+
+    async _handleGroup(botId, message) {
+        const PermissionManager = require('../../core/PermissionManager');
+        await PermissionManager.registerGroup(botId, message.groupConfig);
+    }
+
+    async _handleAddPermissions(botId, message) {
+        const PermissionManager = require('../../core/PermissionManager');
+        await PermissionManager.addPermissionsToGroup(botId, message.groupName, message.permissionNames);
+    }
+
+    async _handleTrace(botId, message) {
+        const { getTraceCollector } = require('./TraceCollectorService');
+        await getTraceCollector()._storeCompletedTrace(message.trace);
+    }
+
+    async _handleBreakpoint(botId, child, message) {
+        const { requestId, payload } = message;
+        const { getGlobalDebugManager } = require('./DebugSessionManager');
+        const debugManager = getGlobalDebugManager();
+        const debugState = debugManager.get(payload.graphId);
+
+        if (!debugState || !debugState.breakpoints.get(payload.nodeId)?.enabled) {
+            child.send({ type: 'debug:breakpoint_response', requestId, overrides: null });
+            return;
+        }
+
+        const bp = debugState.breakpoints.get(payload.nodeId);
+        bp.hitCount++;
+
+        const overrides = await debugState.pause({ ...payload, breakpoint: { condition: bp.condition, hitCount: bp.hitCount } });
+        child.send({ type: 'debug:breakpoint_response', requestId, overrides: overrides || null });
+    }
+
+    async _handleStepMode(botId, child, message) {
+        const { requestId, payload } = message;
+        const { getGlobalDebugManager } = require('./DebugSessionManager');
+        const debugManager = getGlobalDebugManager();
+        const debugState = debugManager.get(payload.graphId);
+
+        if (!debugState || !debugState.shouldStepPause(payload.nodeId)) {
+            child.send({ type: 'debug:breakpoint_response', requestId, overrides: null });
+            return;
+        }
+
+        const overrides = await debugState.pause(payload);
+        child.send({ type: 'debug:breakpoint_response', requestId, overrides: overrides || null });
+    }
+
+    async _handleUpdateCredentials(botId, child, message) {
+        const { requestId, payload } = message;
+        const { username, password } = payload;
+        const { encrypt } = require('../../core/utils/crypto');
+        const botRepo = require('../../repositories/BotRepository');
+
+        if (!username?.trim()) {
+            child.send({ type: 'credentials_operation_response', requestId, error: 'Empty username' });
+            return;
+        }
+
+        const data = { username };
+        if (password?.trim()) data.password = encrypt(password);
+
+        await botRepo.update(botId, data);
+
+        if (child.botConfig) {
+            child.botConfig.username = username;
+            if (data.password) child.botConfig.password = data.password;
+        }
+
+        this.appendLog(botId, `[API] Credentials обновлены: ${username}`);
+        child.send({ type: 'credentials_operation_response', requestId, payload: { success: true } });
+    }
+
+    async _handleStopBot(botId) {
+        if (this.stopBot) {
+            await this.stopBot(botId);
+        }
+    }
+
+    async _handleRestartBot(botId, child, message) {
+        const { requestId } = message;
+        child.send({ type: 'credentials_operation_response', requestId, payload: { success: true } });
+
+        setTimeout(() => {
+            const config = { ...child.botConfig };
+            this.restartBot(botId, config);
+        }, 3000);
+    }
+
+    async _handleChangeCredentials(botId, child, message) {
+        const { requestId, payload } = message;
+        const { username, password } = payload;
+        const { encrypt } = require('../../core/utils/crypto');
+        const botRepo = require('../../repositories/BotRepository');
+
+        if (!username?.trim()) {
+            child.send({ type: 'credentials_operation_response', requestId, error: 'Empty username' });
+            return;
+        }
+
+        const data = { username };
+        if (password?.trim()) data.password = encrypt(password);
+
+        await botRepo.update(botId, data);
+
+        if (child.botConfig) {
+            child.botConfig.username = username;
+            if (data.password) child.botConfig.password = data.password;
+        }
+
+        const config = { ...child.botConfig };
+        this.appendLog(botId, `[API] Credentials изменены: ${username}, рестарт...`);
+        child.send({ type: 'credentials_operation_response', requestId, payload: { success: true } });
+
+        setTimeout(() => this.restartBot(botId, config), 3000);
+    }
+
+    _handleExit(botId, botConfig, code, signal) {
+        this.processManager.remove(botId);
+        this.emitStatusUpdate(botId, 'stopped', `Процесс завершился с кодом ${code} (сигнал: ${signal || 'none'}).`);
+
+        try {
+            const { getIOSafe } = require('../../real-time/socketHandler');
+            const { broadcastBotStatus } = require('../../real-time/botApi');
+            broadcastBotStatus(getIOSafe(), botId, false);
+        } catch (e) {}
+
+        if (code === 1) {
+            this.crashRestartManager.handleCrash(botId, botConfig, (msg) => this.appendLog(botId, msg));
+        }
+    }
+}
+
+module.exports = BotIPCMessageRouter;