blockmine 1.24.0 → 1.27.0

package/backend/src/core/BotProcess.js

@@ -6,12 +6,14 @@ const { Vec3 } = require('vec3');
 const { PrismaClient } = require('@prisma/client');
 const { loadCommands } = require('./system/CommandRegistry');
 const { getRuntimeCommandRegistry } = require('./system/RuntimeCommandRegistry');
-const { initializePlugins } = require('./PluginLoader');
+const { initializePlugins, ensurePluginDependencies } = require('./PluginLoader');
 const MessageQueue = require('./MessageQueue');
 const Command = require('./system/Command');
 const { parseArguments } = require('./system/parseArguments');
 const GraphExecutionEngine = require('./GraphExecutionEngine');
 const NodeRegistry = require('./NodeRegistry');
+const { createBotApi } = require('./ipc/botApiFactory');
+const { MessageTypes, EventTypes } = require('./ipc/ipcMessageTypes');
 
 const UserService = require('./UserService');
 const PermissionManager = require('./ipc/PermissionManager.stub.js');
@@ -40,7 +42,7 @@ JSON.parse = function (text, reviver) {
 
 function sendLog(content) {
     if (process.send) {
-        process.send({ type: 'log', content });
+        process.send({ type: MessageTypes.BOT.LOG, content });
     } else {
         console.log(`[ChildProcess Log] ${content}`);
     }
@@ -49,7 +51,6 @@ function sendLog(content) {
 
 function sendEvent(eventName, eventArgs) {
     if (process.send) {
-        // Добавляем информацию о боте (позицию) во все события
         const enrichedArgs = {
             ...eventArgs,
             botEntity: bot && bot.entity ? {
@@ -58,7 +59,7 @@ function sendEvent(eventName, eventArgs) {
                 pitch: bot.entity.pitch
             } : null
         };
-        process.send({ type: 'event', eventType: eventName, args: enrichedArgs });
+        process.send({ type: MessageTypes.BOT.EVENT, eventType: eventName, args: enrichedArgs });
     }
 }
 
@@ -145,7 +146,7 @@ function handleIncomingCommand(type, username, message) {
 
         if (process.send) {
             process.send({
-                type: 'validate_and_run_command',
+                type: MessageTypes.COMMAND.VALIDATE_AND_RUN,
                 commandName: commandInstance.name,
                 username,
                 args: processedArgs,
@@ -159,17 +160,17 @@ function handleIncomingCommand(type, username, message) {
 }
 
 process.on('message', async (message) => {
-    if (message.type === 'plugin:ui:start-updates') {
+    if (message.type === MessageTypes.PLUGIN.UI_START_UPDATES) {
         const { pluginName } = message;
         const state = pluginUiState.get(pluginName);
         if (state && process.send) {
             process.send({
-                type: 'plugin:data',
+                type: MessageTypes.PLUGIN.UI_DATA,
                 plugin: pluginName,
                 payload: state
             });
         }
-    } else if (message.type === 'user_action_response') {
+    } else if (message.type === MessageTypes.USER.ACTION_RESPONSE) {
         if (pendingRequests.has(message.requestId)) {
             const { resolve, reject } = pendingRequests.get(message.requestId);
             if (message.error) {
@@ -179,16 +180,26 @@ process.on('message', async (message) => {
             }
             pendingRequests.delete(message.requestId);
         }
-    } else if (message.type === 'system:get_player_list') {
+    } else if (message.type === MessageTypes.USER.CREDENTIALS_OPERATION_RESPONSE) {
+        if (pendingRequests.has(message.requestId)) {
+            const { resolve, reject } = pendingRequests.get(message.requestId);
+            if (message.error) {
+                reject(new Error(message.error));
+            } else {
+                resolve(message.payload);
+            }
+            pendingRequests.delete(message.requestId);
+        }
+    } else if (message.type === MessageTypes.SYSTEM.GET_PLAYER_LIST) {
         const playerList = bot ? Object.keys(bot.players) : [];
         if (process.send) {
             process.send({
-                type: 'get_player_list_response',
+                type: MessageTypes.SYSTEM.GET_PLAYER_LIST_RESPONSE,
                 requestId: message.requestId,
                 payload: { players: playerList }
             });
         }
-    } else if (message.type === 'system:get_nearby_entities') {
+    } else if (message.type === MessageTypes.SYSTEM.GET_NEARBY_ENTITIES) {
         const entities = [];
         if (bot && bot.entities) {
             const centerPos = message.payload?.position || bot.entity?.position;
@@ -215,12 +226,12 @@ process.on('message', async (message) => {
 
         if (process.send) {
             process.send({
-                type: 'get_nearby_entities_response',
+                type: MessageTypes.SYSTEM.GET_NEARBY_ENTITIES_RESPONSE,
                 requestId: message.requestId,
                 payload: { entities }
             });
         }
-    } else if (message.type === 'viewer:get_state') {
+    } else if (message.type === MessageTypes.VIEWER.GET_STATE) {
         if (bot && process.send) {
             let blocks = undefined;
 
@@ -287,12 +298,12 @@ process.on('message', async (message) => {
             };
 
             process.send({
-                type: 'viewer:state_response',
+                type: MessageTypes.VIEWER.STATE_RESPONSE,
                 requestId: message.requestId,
                 payload: state
             });
         }
-    } else if (message.type === 'viewer:control') {
+    } else if (message.type === MessageTypes.VIEWER.CONTROL) {
         const { command } = message;
         if (!bot) return;
 
@@ -357,58 +368,12 @@ process.on('message', async (message) => {
         } catch (error) {
             sendLog(`[Viewer] Control error: ${error.message}`);
         }
-    } else if (message.type === 'execute_event_graph') {
-        // Выполнение event графа в child process
+    } else if (message.type === MessageTypes.GRAPH.EXECUTE_EVENT_GRAPH) {
         const { botId, graph, eventType, eventArgs } = message;
 
         try {
-
             const playerList = bot ? Object.keys(bot.players) : [];
-            const botApi = {
-                sendMessage: (chatType, message, recipient) => {
-                    if (!bot || !bot.messageQueue) {
-                        sendLog('[EventGraph] Bot not ready');
-                        return;
-                    }
-
-                    bot.messageQueue.enqueue(chatType, message, recipient);
-                },
-                executeCommand: (command) => {
-                    if (!bot || !bot.messageQueue) {
-                        sendLog('[EventGraph] Bot not ready');
-                        return;
-                    }
-                    bot.messageQueue.enqueue('command', command);
-                },
-                lookAt: async (x, y, z) => {
-                    if (!bot) return;
-                    const target = new Vec3(x, y, z);
-                    await bot.lookAt(target);
-                },
-                navigate: async (x, y, z) => {
-                    if (!bot || !bot.pathfinder) return;
-                    const goal = new (require('mineflayer-pathfinder').goals.GoalBlock)(x, y, z);
-                    await bot.pathfinder.goto(goal);
-                },
-                attack: (entityId) => {
-                    if (!bot) return;
-                    const entity = bot.entities[entityId];
-                    if (entity) bot.attack(entity);
-                },
-                follow: (username) => {
-                    if (!bot || !bot.pathfinder) return;
-                    const player = bot.players[username];
-                    if (player && player.entity) {
-                        const goal = new (require('mineflayer-pathfinder').goals.GoalFollow)(player.entity, 3);
-                        bot.pathfinder.setGoal(goal, true);
-                    }
-                },
-                stopFollow: () => {
-                    if (bot && bot.pathfinder) {
-                        bot.pathfinder.setGoal(null);
-                    }
-                }
-            };
+            const botApi = createBotApi(bot, { enableLogging: true });
 
             const context = {
                 bot: bot,  // Полный mineflayer bot
@@ -436,7 +401,7 @@ process.on('message', async (message) => {
             sendLog(`[EventGraph] Error executing ${eventType} graph: ${error.message}`);
             sendLog(`[EventGraph] Stack: ${error.stack}`);
         }
-    } else if (message.type === 'start') {
+    } else if (message.type === MessageTypes.BOT.START) {
         const config = message.config;
         sendLog(`[System] Получена команда на запуск бота ${config.username}...`);
         try {
@@ -503,6 +468,9 @@ process.on('message', async (message) => {
             bot.sendLog = sendLog;
             bot.messageQueue = new MessageQueue(bot);
 
+            // Plugin Registry для экспорта API между плагинами
+            bot.pluginRegistry = new Map();
+
             const installedPluginNames = config.plugins.map(p => p.name);
             bot.api = {
                 Command: Command,
@@ -511,7 +479,7 @@ process.on('message', async (message) => {
                     if (type === 'websocket') {
                         if (process.send) {
                             process.send({
-                                type: 'send_websocket_message',
+                                type: MessageTypes.WEBSOCKET.SEND_MESSAGE,
                                 payload: {
                                     botId: bot.config.id,
                                     message: message,
@@ -620,7 +588,7 @@ process.on('message', async (message) => {
 
                         if (process.send) {
                             process.send({
-                                type: 'register_command',
+                                type: MessageTypes.COMMAND.REGISTER,
                                 commandConfig: {
                                     name: command.name,
                                     description: command.description,
@@ -651,7 +619,7 @@ process.on('message', async (message) => {
 
                         if (process.send) {
                             process.send({
-                                type: 'request_user_action',
+                                type: MessageTypes.USER.REQUEST_ACTION,
                                 requestId,
                                 payload: {
                                     targetUsername: username,
@@ -778,15 +746,97 @@ process.on('message', async (message) => {
 
                     if (process.send) {
                         process.send({
-                            type: 'plugin:data',
+                            type: MessageTypes.PLUGIN.UI_DATA,
                             plugin: pluginName,
                             payload: newState
                         });
                     }
+                },
+
+                // === Методы для управления credentials ===
+                updateCredentials: async ({ username, password }) => {
+                    return new Promise((resolve, reject) => {
+                        const requestId = uuidv4();
+                        pendingRequests.set(requestId, { resolve, reject });
+
+                        if (process.send) {
+                            process.send({
+                                type: MessageTypes.BOT.UPDATE_CREDENTIALS,
+                                requestId,
+                                payload: {
+                                    botId: bot.config.id,
+                                    username,
+                                    password
+                                }
+                            });
+                        } else {
+                            reject(new Error('IPC channel is not available.'));
+                        }
+
+                        setTimeout(() => {
+                            if (pendingRequests.has(requestId)) {
+                                reject(new Error('Request to update credentials timed out.'));
+                                pendingRequests.delete(requestId);
+                            }
+                        }, 10000);
+                    });
+                },
+
+                restart: async () => {
+                    return new Promise((resolve, reject) => {
+                        const requestId = uuidv4();
+                        pendingRequests.set(requestId, { resolve, reject });
+
+                        if (process.send) {
+                            process.send({
+                                type: MessageTypes.BOT.RESTART,
+                                requestId,
+                                payload: {
+                                    botId: bot.config.id
+                                }
+                            });
+                        } else {
+                            reject(new Error('IPC channel is not available.'));
+                        }
+
+                        setTimeout(() => {
+                            if (pendingRequests.has(requestId)) {
+                                reject(new Error('Request to restart bot timed out.'));
+                                pendingRequests.delete(requestId);
+                            }
+                        }, 10000);
+                    });
+                },
+
+                changeCredentials: async ({ username, password }) => {
+                    return new Promise((resolve, reject) => {
+                        const requestId = uuidv4();
+                        pendingRequests.set(requestId, { resolve, reject });
+
+                        if (process.send) {
+                            process.send({
+                                type: MessageTypes.BOT.CHANGE_CREDENTIALS,
+                                requestId,
+                                payload: {
+                                    botId: bot.config.id,
+                                    username,
+                                    password
+                                }
+                            });
+                        } else {
+                            reject(new Error('IPC channel is not available.'));
+                        }
+
+                        setTimeout(() => {
+                            if (pendingRequests.has(requestId)) {
+                                reject(new Error('Request to change credentials timed out.'));
+                                pendingRequests.delete(requestId);
+                            }
+                        }, 10000);
+                    });
                 }
             };
 
-            // Упрощенный alias для отправки сообщений (используется в командах и нодах)
             bot.sendMessage = (type, message, username) => {
                 bot.api.sendMessage(type, message, username);
             };
@@ -797,7 +847,7 @@ process.on('message', async (message) => {
             const processApi = {
                 appendLog: (botId, message) => {
                     if (process.send) {
-                        process.send({ type: 'log', content: message });
+                        process.send({ type: MessageTypes.BOT.LOG, content: message });
                     }
                 }
             };
@@ -895,7 +945,7 @@ process.on('message', async (message) => {
             if (process.send) {
                 for (const cmd of bot.commands.values()) {
                     process.send({
-                        type: 'register_command',
+                        type: MessageTypes.COMMAND.REGISTER,
                         commandConfig: {
                             name: cmd.name,
                             description: cmd.description,
@@ -909,6 +959,7 @@ process.on('message', async (message) => {
                 }
             }
 
+            await ensurePluginDependencies(config.plugins, sendLog);
             await initializePlugins(bot, config.plugins, prisma);
             sendLog('[System] Все системы инициализированы.');
 
@@ -932,7 +983,7 @@ process.on('message', async (message) => {
 
                 if (process.send && rawMessageText.trim()) {
                     process.send({
-                        type: 'viewer:chat',
+                        type: MessageTypes.VIEWER.CHAT,
                         payload: {
                             rawText: rawMessageText,
                             timestamp: Date.now()
@@ -954,12 +1005,22 @@ process.on('message', async (message) => {
 
             bot.on('chat', (username, message) => {
                 if (messageHandledByCustomParser) return;
-                handleIncomingCommand('chat', username, message);
+                bot.events.emit('chat:message', {
+                    username,
+                    message,
+                    type: EventTypes.CHAT,
+                    raw: message
+                });
             });
 
             bot.on('whisper', (username, message) => {
                 if (messageHandledByCustomParser) return;
-                handleIncomingCommand('whisper', username, message);
+                bot.events.emit('chat:message', {
+                    username,
+                    message,
+                    type: EventTypes.WHISPER,
+                    raw: message
+                });
             });
 
             bot.on('userAction', async ({ action, target, ...data }) => {
@@ -990,8 +1051,8 @@ process.on('message', async (message) => {
                 }
                 sendLog('[Event: login] Успешно залогинился!');
                 if (process.send && !botReadySent) {
-                    process.send({ type: 'bot_ready' });
-                    process.send({ type: 'status', status: 'running' });
+                    process.send({ type: MessageTypes.BOT.READY });
+                    process.send({ type: MessageTypes.BOT.STATUS, status: 'running' });
                     botReadySent = true;
                 }
             });
@@ -1010,7 +1071,13 @@ process.on('message', async (message) => {
 
             bot.on('kicked', (reason) => {
                 let reasonText;
-                try { reasonText = JSON.parse(reason).text || reason; } catch (e) { reasonText = reason; }
+                if (typeof reason === 'string') {
+                    try { reasonText = JSON.parse(reason).text || reason; } catch (e) { reasonText = reason; }
+                } else if (reason && typeof reason === 'object') {
+                    reasonText = reason.text || reason.message || reason.reason || JSON.stringify(reason);
+                } else {
+                    reasonText = String(reason);
+                }
                 sendLog(`[Event: kicked] Меня кикнули. Причина: ${reasonText}.`);
                 process.exit(0);
             });
@@ -1084,7 +1151,7 @@ process.on('message', async (message) => {
                 // Отправка события для viewer
                 if (process.send) {
                     process.send({
-                        type: 'viewer:spawn',
+                        type: MessageTypes.VIEWER.SPAWN,
                         payload: {
                             position: bot.entity?.position,
                             yaw: bot.entity?.yaw,
@@ -1097,7 +1164,7 @@ process.on('message', async (message) => {
             bot.on('health', () => {
                 if (process.send) {
                     process.send({
-                        type: 'viewer:health',
+                        type: MessageTypes.VIEWER.HEALTH,
                         payload: {
                             health: bot.health,
                             food: bot.food
@@ -1109,7 +1176,7 @@ process.on('message', async (message) => {
             bot.on('move', () => {
                 if (process.send) {
                     process.send({
-                        type: 'viewer:move',
+                        type: MessageTypes.VIEWER.MOVE,
                         payload: {
                             position: bot.entity?.position,
                             yaw: bot.entity?.yaw,
@@ -1145,7 +1212,7 @@ process.on('message', async (message) => {
             sendLog(`[CRITICAL] Критическая ошибка при создании бота: ${err.stack}`);
             process.exit(1);
         }
-    } else if (message.type === 'config:reload') {
+    } else if (message.type === MessageTypes.CONFIG.RELOAD) {
         sendLog('[System] Received config:reload command. Reloading configuration...');
         try {
             const newConfig = await fetchNewConfig(bot.config.id, prisma);
@@ -1162,7 +1229,7 @@ process.on('message', async (message) => {
         } catch (error) {
             sendLog(`[System] Error reloading configuration: ${error.message}`);
         }
-    } else if (message.type === 'stop') {
+    } else if (message.type === MessageTypes.BOT.STOP) {
         if (connectionTimeout) {
             clearTimeout(connectionTimeout);
             connectionTimeout = null;
@@ -1170,12 +1237,12 @@ process.on('message', async (message) => {
         botReadySent = false;
         if (bot) bot.quit();
         else process.exit(0);
-    } else if (message.type === 'chat') {
+    } else if (message.type === MessageTypes.CHAT.CHAT) {
         if (bot && bot.entity) {
             const { message: msg, chatType, username } = message.payload;
             bot.messageQueue.enqueue(chatType, msg, username);
         }
-    } else if (message.type === 'register_temp_command') {
+    } else if (message.type === MessageTypes.COMMAND.REGISTER_TEMP) {
         // Регистрация временной команды из главного процесса
         const { commandData } = message;
 
@@ -1207,7 +1274,7 @@ process.on('message', async (message) => {
         } catch (error) {
             sendLog(`[BotProcess] Ошибка регистрации временной команды: ${error.message}`);
         }
-    } else if (message.type === 'unregister_temp_command') {
+    } else if (message.type === MessageTypes.COMMAND.UNREGISTER_TEMP) {
         const { commandName, aliases } = message;
 
         try {
@@ -1225,7 +1292,7 @@ process.on('message', async (message) => {
         } catch (error) {
             sendLog(`[BotProcess] Ошибка удаления временной команды: ${error.message}`);
         }
-    } else if (message.type === 'execute_handler') {
+    } else if (message.type === MessageTypes.GRAPH.EXECUTE_HANDLER) {
         const { commandName, username, args, typeChat } = message;
         const commandInstance = bot.commands.get(commandName);
         if (commandInstance) {
@@ -1248,7 +1315,7 @@ process.on('message', async (message) => {
                 }
             })();
         }
-    } else if (message.type === 'execute_command_request') {
+    } else if (message.type === MessageTypes.GRAPH.EXECUTE_COMMAND_REQUEST) {
         const { requestId, payload } = message;
         const { commandName, args, username, typeChat } = payload;
 
@@ -1272,7 +1339,7 @@ process.on('message', async (message) => {
                     if (typeChat === 'websocket') {
                         result = await commandInstance.handler(context);
                         if (process.send) {
-                            process.send({ type: 'execute_command_response', requestId, result });
+                            process.send({ type: MessageTypes.GRAPH.EXECUTE_COMMAND_RESPONSE, requestId, result });
                         }
                     } else {
                         commandInstance.handler(context).catch(e => {
@@ -1301,7 +1368,7 @@ process.on('message', async (message) => {
                             result = sendMessageCalled ? resultFromSendMessage : returnValue;
 
                             if (process.send) {
-                                process.send({ type: 'execute_command_response', requestId, result });
+                                process.send({ type: MessageTypes.GRAPH.EXECUTE_COMMAND_RESPONSE, requestId, result });
                             }
                         } finally {
                             bot.sendMessage = originalSendMessage;
@@ -1316,15 +1383,15 @@ process.on('message', async (message) => {
 
             } catch (error) {
                 if (process.send) {
-                    process.send({ type: 'execute_command_response', requestId, error: error.message });
+                    process.send({ type: MessageTypes.GRAPH.EXECUTE_COMMAND_RESPONSE, requestId, error: error.message });
                 }
             }
         })();
-    } else if (message.type === 'invalidate_user_cache') {
+    } else if (message.type === MessageTypes.USER.INVALIDATE_USER_CACHE) {
         if (message.username && bot && bot.config) {
             UserService.clearCache(message.username, bot.config.id);
         }
-    } else if (message.type === 'invalidate_all_user_cache') {
+    } else if (message.type === MessageTypes.USER.INVALIDATE_ALL_USER_CACHE) {
         if (bot && bot.config) {
             for (const [cacheKey, user] of UserService.cache.entries()) {
                 if (cacheKey.startsWith(`${bot.config.id}:`)) {
@@ -1333,7 +1400,7 @@ process.on('message', async (message) => {
             }
             sendLog(`[BotProcess] Кэш пользователей очищен для бота ${bot.config.id}`);
         }
-    } else if (message.type === 'handle_permission_error') {
+    } else if (message.type === MessageTypes.COMMAND.HANDLE_PERMISSION_ERROR) {
         const { commandName, username, typeChat } = message;
         const commandInstance = bot.commands.get(commandName);
         if (commandInstance) {
@@ -1343,7 +1410,7 @@ process.on('message', async (message) => {
                 bot.api.sendMessage(typeChat, `У вас нет прав для выполнения команды ${commandName}.`, username);
             }
         }
-    } else if (message.type === 'handle_wrong_chat') {
+    } else if (message.type === MessageTypes.COMMAND.HANDLE_WRONG_CHAT) {
         const { commandName, username, typeChat } = message;
         const commandInstance = bot.commands.get(commandName);
         if (commandInstance) {
@@ -1353,7 +1420,7 @@ process.on('message', async (message) => {
                 bot.api.sendMessage('private', `Команду ${commandName} нельзя использовать в этом типе чата - ${typeChat}.`, username);
             }
         }
-    } else if (message.type === 'handle_cooldown') {
+    } else if (message.type === MessageTypes.COMMAND.HANDLE_COOLDOWN) {
         const { commandName, username, typeChat, timeLeft } = message;
         const commandInstance = bot.commands.get(commandName);
         if (commandInstance) {
@@ -1363,7 +1430,7 @@ process.on('message', async (message) => {
                 bot.api.sendMessage(typeChat, `Команду ${commandName} можно будет использовать через ${timeLeft} сек.`, username);
             }
         }
-    } else if (message.type === 'handle_blacklist') {
+    } else if (message.type === MessageTypes.COMMAND.HANDLE_BLACKLIST) {
         const { commandName, username, typeChat } = message;
         const commandInstance = bot.commands.get(commandName);
         if (commandInstance) {
@@ -1371,12 +1438,12 @@ process.on('message', async (message) => {
                 commandInstance.onBlacklisted(bot, typeChat, { username });
             }
         }
-    } else if (message.type === 'send_message') {
+    } else if (message.type === MessageTypes.CHAT.SEND_MESSAGE) {
         const { typeChat, message: msg, username } = message;
         if (bot && bot.api) {
             bot.api.sendMessage(typeChat, msg, username);
         }
-    } else if (message.type === 'action') {
+    } else if (message.type === MessageTypes.CHAT.ACTION) {
         if (message.name === 'lookAt' && bot && message.payload.position) {
             const { x, y, z } = message.payload.position;
             if (typeof x === 'number' && typeof y === 'number' && typeof z === 'number') {
@@ -1385,7 +1452,7 @@ process.on('message', async (message) => {
                 sendLog(`[BotProcess] Ошибка lookAt: получены невалидные координаты: ${JSON.stringify(message.payload.position)}`);
             }
         }
-    } else if (message.type === 'plugins:reload') {
+    } else if (message.type === MessageTypes.PLUGINS.RELOAD) {
         sendLog('[System] Получена команда на перезагрузку плагинов...');
         const newConfig = await fetchNewConfig(bot.config.id, prisma);
         if (newConfig) {
@@ -1399,12 +1466,11 @@ process.on('message', async (message) => {
         } else {
             sendLog('[System] Не удалось получить новую конфигурацию для перезагрузки плагинов.');
         }
-    } else if (message.type === 'server_command') {
+    } else if (message.type === MessageTypes.SERVER.COMMAND) {
         if (bot && bot.messageQueue && message.payload && message.payload.command) {
             bot.messageQueue.enqueue('command', message.payload.command);
         }
-    } else if (message.type === 'execute_event_graph') {
-        // Выполнение event графа в child process
+    } else if (message.type === MessageTypes.GRAPH.EXECUTE_EVENT_GRAPH) {
         const { graph, eventType, eventArgs } = message;
 
         try {
@@ -1419,44 +1485,7 @@ process.on('message', async (message) => {
                 return;
             }
 
-            const botApi = {
-                sendMessage: (chatType, messageText, recipient) => {
-                    if (!bot || !bot.messageQueue) return;
-                    bot.messageQueue.enqueue(chatType, messageText, recipient);
-                },
-                executeCommand: (command) => {
-                    if (!bot || !bot.messageQueue) return;
-                    bot.messageQueue.enqueue('command', command);
-                },
-                lookAt: async (x, y, z) => {
-                    if (!bot) return;
-                    const target = new Vec3(x, y, z);
-                    await bot.lookAt(target);
-                },
-                navigate: async (x, y, z) => {
-                    if (!bot || !bot.pathfinder) return;
-                    const goal = new (require('mineflayer-pathfinder').goals.GoalBlock)(x, y, z);
-                    await bot.pathfinder.goto(goal);
-                },
-                attack: (entityId) => {
-                    if (!bot) return;
-                    const entity = bot.entities[entityId];
-                    if (entity) bot.attack(entity);
-                },
-                follow: (username) => {
-                    if (!bot || !bot.pathfinder) return;
-                    const player = bot.players[username];
-                    if (player && player.entity) {
-                        const goal = new (require('mineflayer-pathfinder').goals.GoalFollow)(player.entity, 3);
-                        bot.pathfinder.setGoal(goal, true);
-                    }
-                },
-                stopFollow: () => {
-                    if (bot && bot.pathfinder) {
-                        bot.pathfinder.setGoal(null);
-                    }
-                }
-            };
+            const botApi = createBotApi(bot);
 
             const players = bot ? Object.keys(bot.players) : [];
 

package/backend/src/core/EventGraphManager.js

@@ -7,14 +7,18 @@ const botHistoryStore = require('./BotHistoryStore');
 const prisma = prismaService.getClient();
 
 class EventGraphManager {
-    constructor(botManager = null) {
-        this.botManager = botManager;
+    constructor() {
+        this._botManager = null;
         this.activeGraphs = new Map();
         this.graphStates = new Map();
     }
 
+    get botManager() {
+        return this._botManager;
+    }
+
     setBotManager(botManager) {
-        this.botManager = botManager;
+        this._botManager = botManager;
     }
 
     async loadGraphsForBot(botId) {