blockmine 1.6.3 → 1.13.0

package/backend/src/core/BotManager.js

@@ -1,6 +1,5 @@
 const { fork } = require('child_process');
 const path = require('path');
-const { getIO } = require('../real-time/socketHandler');
 const prisma = require('../lib/prisma');
 const pidusage = require('pidusage');
 const DependencyService = require('./DependencyService');
@@ -12,8 +11,6 @@ const crypto = require('crypto');
 const { decrypt } = require('./utils/crypto');
 const EventGraphManager = require('./EventGraphManager');
 const nodeRegistry = require('./NodeRegistry');
-const GraphExecutionEngine = require('./GraphExecutionEngine');
-
 const UserService = require('./UserService');
 
 const cooldowns = new Map();
@@ -53,8 +50,8 @@ class BotManager {
         this.nodeRegistry = nodeRegistry;
         this.pendingPlayerListRequests = new Map();
         this.playerListCache = new Map();
-        this.graphEngine = new GraphExecutionEngine(this.nodeRegistry, this);
         this.eventGraphManager = null;
+        this.uiSubscriptions = new Map();
 
         getInstanceId();
         setInterval(() => this.updateAllResourceUsage(), 5000);
@@ -69,6 +66,55 @@ class BotManager {
         }
     }
 
+    subscribeToPluginUi(botId, pluginName, socket) {
+        if (!this.uiSubscriptions.has(botId)) {
+            this.uiSubscriptions.set(botId, new Map());
+        }
+        const botSubscriptions = this.uiSubscriptions.get(botId);
+
+        if (!botSubscriptions.has(pluginName)) {
+            botSubscriptions.set(pluginName, new Set());
+        }
+        const pluginSubscribers = botSubscriptions.get(pluginName);
+
+        pluginSubscribers.add(socket);
+        console.log(`[UI Sub] Сокет ${socket.id} подписался на ${pluginName} для бота ${botId}. Всего подписчиков: ${pluginSubscribers.size}`);
+
+        const botProcess = this.bots.get(botId);
+        if (botProcess && !botProcess.killed) {
+            botProcess.send({ type: 'plugin:ui:start-updates', pluginName });
+        }
+    }
+
+    unsubscribeFromPluginUi(botId, pluginName, socket) {
+        const botSubscriptions = this.uiSubscriptions.get(botId);
+        if (!botSubscriptions) return;
+
+        const pluginSubscribers = botSubscriptions.get(pluginName);
+        if (!pluginSubscribers) return;
+
+        pluginSubscribers.delete(socket);
+        console.log(`[UI Sub] Сокет ${socket.id} отписался от ${pluginName} для бота ${botId}. Осталось: ${pluginSubscribers.size}`);
+
+        if (pluginSubscribers.size === 0) {
+            const botProcess = this.bots.get(botId);
+            if (botProcess && !botProcess.killed) {
+                botProcess.send({ type: 'plugin:ui:stop-updates', pluginName });
+            }
+            botSubscriptions.delete(pluginName);
+        }
+    }
+
+    handleSocketDisconnect(socket) {
+        this.uiSubscriptions.forEach((botSubscriptions, botId) => {
+            botSubscriptions.forEach((pluginSubscribers, pluginName) => {
+                if (pluginSubscribers.has(socket)) {
+                    this.unsubscribeFromPluginUi(botId, pluginName, socket);
+                }
+            });
+        });
+    }
+
     async loadConfigForBot(botId) {
         console.log(`[BotManager] Caching configuration for bot ID ${botId}...`);
         try {
@@ -108,6 +154,7 @@ class BotManager {
     }
 
     reloadBotConfigInRealTime(botId) {
+        const { getIO } = require('../real-time/socketHandler');
         this.invalidateConfigCache(botId);
         const child = this.bots.get(botId);
         if (child && !child.killed) {
@@ -214,6 +261,7 @@ class BotManager {
     }
 
     async updateAllResourceUsage() {
+        const { getIO } = require('../real-time/socketHandler');
         if (this.bots.size === 0) {
             if (this.resourceUsage.size > 0) {
                 this.resourceUsage.clear();
@@ -270,12 +318,13 @@ class BotManager {
     }
 
     emitStatusUpdate(botId, status, message = null) {
-        // console.log(`[BotManager] Отправка статуса для бота ${botId}: status=${status}, message=${message || 'null'}`);
+        const { getIO } = require('../real-time/socketHandler');
         if (message) this.appendLog(botId, `[SYSTEM] ${message}`);
         getIO().emit('bot:status', { botId, status, message });
     }
     
     appendLog(botId, logContent) {
+        const { getIO } = require('../real-time/socketHandler');
         const logEntry = {
             id: Date.now() + Math.random(),
             content: logContent,
@@ -333,6 +382,17 @@ class BotManager {
 
         child.botConfig = botConfig;
 
+        child.api = {
+            sendMessage: (type, message, username) => {
+                if (!child.killed) {
+                    child.send({ type: 'chat', payload: { message, chatType: type, username } });
+                }
+            },
+            sendLog: (message) => {
+                this.appendLog(botConfig.id, message);
+            }
+        };
+
         child.on('message', async (message) => {
             const botId = botConfig.id;
             try {
@@ -342,6 +402,21 @@ class BotManager {
                             this.eventGraphManager.handleEvent(botId, message.eventType, message.args);
                         }
                         break;
+                    case 'plugin:data': {
+                        const { plugin: pluginName, payload } = message;
+                        const botSubscriptions = this.uiSubscriptions.get(botId);
+                        if (!botSubscriptions) break;
+
+                        const pluginSubscribers = botSubscriptions.get(pluginName);
+                        if (pluginSubscribers && pluginSubscribers.size > 0) {
+                            pluginSubscribers.forEach(socket => {
+                                socket.emit('plugin:ui:dataUpdate', payload);
+                            });
+                        }
+                        break;
+                    }
+                    case 'plugin:stopped':
+                        break;
                     case 'log':
                         this.appendLog(botId, message.content);
                         break;
@@ -444,6 +519,7 @@ class BotManager {
         await this.eventGraphManager.loadGraphsForBot(botConfig.id);
         
         this.triggerHeartbeat();
+        const { getIO } = require('../real-time/socketHandler');
         getIO().emit('bot:status', { botId: botConfig.id, status: 'starting' });
         return child;
     }
@@ -505,41 +581,17 @@ class BotManager {
                 cooldowns.set(cooldownKey, now);
             }
 
-            if (dbCommand.isVisual) {
-                const graph = dbCommand.graphJson;
-                if (graph) {
-                    const players = await this.getPlayerList(botId);
-                    console.log('[BotManager] Received player list for graph:', players);
-
-                    const botAPI = {
-                        sendMessage: (type, message, recipient) => {
-                            this.sendMessageToBot(botId, message, type, recipient);
-                        },
-                        executeCommand: (command) => {
-                            this.sendServerCommandToBot(botId, command);
-                        },
-                    };
-
-                    const graphContext = {
-                        bot: botAPI,
-                        botId: botId,
-                        user,
-                        args,
-                        typeChat,
-                        players,
-                    };
-                    
-                    try {
-                        const resultContext = await this.graphEngine.execute(graph, graphContext, 'command');
-                    } catch (e) {
-                        console.error(`[BotManager] Ошибка выполнения визуальной команды '${commandName}':`, e);
-                        this.sendMessageToBot(botId, 'Произошла внутренняя ошибка при выполнении команды.', 'private', username);
-                    }
-                }
-            } else {
-                child.send({ type: 'execute_handler', commandName: dbCommand.name, username, args, typeChat });
+            if (this.eventGraphManager) {
+                this.eventGraphManager.handleEvent(botId, 'command', {
+                    commandName: dbCommand.name,
+                    user: { username },
+                    args,
+                    typeChat
+                });
             }
 
+            child.send({ type: 'execute_handler', commandName: dbCommand.name, username, args, typeChat });
+
         } catch (error) {
             console.error(`[BotManager] Command validation error for botId: ${botId}`, {
                 command: commandName, user: username, error: error.message, stack: error.stack
@@ -685,7 +737,7 @@ class BotManager {
     sendMessageToBot(botId, message, chatType = 'command', username = null) {
         const child = this.bots.get(botId);
         if (child) {
-            child.send({ type: 'chat', payload: { message, chatType, username } });
+            child.api.sendMessage(chatType, message, username);
             return { success: true };
         }
         return { success: false, message: 'Бот не найден или не запущен' };
@@ -786,4 +838,4 @@ class BotManager {
     }
 }
 
-module.exports = new BotManager();
+module.exports = new BotManager();

package/backend/src/core/BotProcess.js

@@ -16,6 +16,8 @@ const UserService = require('./UserService');
 const PermissionManager = require('./ipc/PermissionManager.stub.js');
 
 let bot = null;
+const prisma = new PrismaClient();
+const pluginUiState = new Map();
 const pendingRequests = new Map();
 const entityMoveThrottles = new Map();
 
@@ -34,8 +36,7 @@ function sendEvent(eventName, eventArgs) {
     }
 }
 
-async function fetchNewConfig(botId) {
-    const prisma = new PrismaClient();
+async function fetchNewConfig(botId, prisma) {
     try {
         const botData = await prisma.bot.findUnique({
             where: { id: botId },
@@ -55,8 +56,6 @@ async function fetchNewConfig(botId) {
     } catch (error) {
         sendLog(`[fetchNewConfig] Error: ${error.message}`);
         return null;
-    } finally {
-        await prisma.$disconnect();
     }
 }
 
@@ -129,7 +128,17 @@ function handleIncomingCommand(type, username, message) {
 }
 
 process.on('message', async (message) => {
-    if (message.type === 'user_action_response') {
+        if (message.type === 'plugin:ui:start-updates') {
+            const { pluginName } = message;
+            const state = pluginUiState.get(pluginName);
+            if (state && process.send) {
+                process.send({
+                    type: 'plugin:data',
+                    plugin: pluginName,
+                    payload: state
+                });
+            }
+        } else if (message.type === 'user_action_response') {
         if (pendingRequests.has(message.requestId)) {
             const { resolve, reject } = pendingRequests.get(message.requestId);
             if (message.error) {
@@ -193,6 +202,8 @@ process.on('message', async (message) => {
 
             bot = mineflayer.createBot(botOptions);
 
+            bot.pluginUiState = pluginUiState;
+
             let isReady = false;
 
             bot.events = new EventEmitter();
@@ -214,8 +225,7 @@ process.on('message', async (message) => {
                 registerGroup: (groupConfig) => PermissionManager.registerGroup(bot.config.id, groupConfig),
                 addPermissionsToGroup: (groupName, permissionNames) => PermissionManager.addPermissionsToGroup(bot.config.id, groupName, permissionNames),
                 installedPlugins: installedPluginNames,
-                registerCommand: async (command) => { // похуй. пляшем
-                    const prisma = new PrismaClient();
+                registerCommand: async (command) => { 
                     try {
                         let permissionId = null;
                         if (command.permissions) {
@@ -231,7 +241,7 @@ process.on('message', async (message) => {
                             if (permission) {
                                 permissionId = permission.id;
                             } else {
-                                sendLog(`[API] Внимание: право "${command.permissions}" не найдено для команды "${command.name}". Команда будет создана без привязанного права.`);
+                                sendLog(`[API] Внимание: право \"${command.permissions}\" не найдено для команды \"${command.name}\". Команда будет создана без привязанного права.`);
                             }
                         }
 
@@ -281,7 +291,7 @@ process.on('message', async (message) => {
                                  }
                              });
                          }
-                         sendLog(`[API] Команда "${command.name}" от плагина "${command.owner}" зарегистрирована в процессе.`);
+                         sendLog(`[API] Команда \"${command.name}\" от плагина \"${command.owner}\" зарегистрирована в процессе.`);
 
                          if (!bot.commands) bot.commands = new Map();
                          bot.commands.set(command.name, command);
@@ -292,8 +302,6 @@ process.on('message', async (message) => {
                          }
                     } catch (error) {
                         sendLog(`[API] Ошибка при регистрации команды: ${error.message}`);
-                    } finally {
-                        await prisma.$disconnect();
                     }
                 },
                 performUserAction: (username, action, data = {}) => {
@@ -331,6 +339,20 @@ process.on('message', async (message) => {
                     if (bot && position) {
                         bot.lookAt(position);
                     }
+                },
+                sendUiUpdate: (pluginName, stateUpdate) => {
+                    const currentState = pluginUiState.get(pluginName) || {};
+                    const newState = { ...currentState, ...stateUpdate };
+                    pluginUiState.set(pluginName, newState);
+                    
+
+                    if (process.send) {
+                        process.send({
+                            type: 'plugin:data',
+                            plugin: pluginName,
+                            payload: newState
+                        });
+                    }
                 }
             };
 
@@ -346,9 +368,7 @@ process.on('message', async (message) => {
 
             bot.commands = await loadCommands();
 
-            const prisma = new PrismaClient();
             const dbCommands = await prisma.command.findMany({ where: { botId: config.id } });
-            await prisma.$disconnect();
 
             for (const dbCommand of dbCommands) {
                 if (!dbCommand.isEnabled) {
@@ -406,7 +426,7 @@ process.on('message', async (message) => {
                 }
             }
             
-            await initializePlugins(bot, config.plugins);
+            await initializePlugins(bot, config.plugins, prisma);
             sendLog('[System] Все системы инициализированы.');
 
             let messageHandledByCustomParser = false;
@@ -540,13 +560,13 @@ process.on('message', async (message) => {
     } else if (message.type === 'config:reload') {
         sendLog('[System] Received config:reload command. Reloading configuration...');
         try {
-            const newConfig = await fetchNewConfig(bot.config.id);
+            const newConfig = await fetchNewConfig(bot.config.id, prisma);
             if (newConfig) {
                 bot.config = { ...bot.config, ...newConfig };
                 const newCommands = await loadCommands();
                 const newPlugins = bot.config.plugins;
                 bot.commands = newCommands;
-                await initializePlugins(bot, newPlugins, true);
+                await initializePlugins(bot, newPlugins, prisma);
                 sendLog('[System] Bot configuration and plugins reloaded successfully.');
             } else {
                 sendLog('[System] Failed to fetch new configuration.');
@@ -610,14 +630,14 @@ process.on('message', async (message) => {
         }
     } else if (message.type === 'plugins:reload') {
         sendLog('[System] Получена команда на перезагрузку плагинов...');
-        const newConfig = await fetchNewConfig(bot.config.id);
-        if (newConfig) {
-            bot.config.plugins = newConfig.installedPlugins;
-            bot.commands.clear();
-            await loadCommands(bot, newConfig.commands);
-            await initializePlugins(bot, newConfig.installedPlugins);
-            sendLog('[System] Плагины успешно перезагружены.');
-        } else {
+            const newConfig = await fetchNewConfig(bot.config.id, prisma);
+            if (newConfig) {
+                bot.config.plugins = newConfig.installedPlugins;
+                bot.commands.clear();
+                await loadCommands(bot, newConfig.commands);
+                await initializePlugins(bot, newConfig.installedPlugins, prisma);
+                sendLog('[System] Плагины успешно перезагружены.');
+            } else {
             sendLog('[System] Не удалось получить новую конфигурацию для перезагрузки плагинов.');
         }
     } else if (message.type === 'server_command') {

package/backend/src/core/EventGraphManager.js

@@ -1,13 +1,14 @@
 const { PrismaClient } = require('@prisma/client');
+const GraphExecutionEngine = require('./GraphExecutionEngine');
+const nodeRegistry = require('./NodeRegistry');
 
 const prisma = new PrismaClient();
 
 class EventGraphManager {
     constructor(botManager) {
         this.botManager = botManager;
-        this.graphEngine = botManager.graphEngine;
+        this.graphEngine = new GraphExecutionEngine(nodeRegistry, botManager);
         this.activeGraphs = new Map();
-        // Хранилище для состояний (переменных) каждого графа
         this.graphStates = new Map();
     }
 
@@ -26,7 +27,6 @@ class EventGraphManager {
                 const parsedGraph = JSON.parse(graph.graphJson);
                 if (!parsedGraph.nodes) continue;
 
-                // Инициализация начального состояния переменных для этого графа
                 const initialState = {};
                 if (graph.variables) {
                     try {
@@ -56,6 +56,7 @@ class EventGraphManager {
                         name: graph.name,
                         nodes: parsedGraph.nodes,
                         connections: parsedGraph.connections,
+                        variables: parsedGraph.variables || [],
                     });
                 }
             } catch (e) {
@@ -69,7 +70,6 @@ class EventGraphManager {
 
     unloadGraphsForBot(botId) {
         this.activeGraphs.delete(botId);
-        // Также очищаем состояния при выгрузке
         for (const key of this.graphStates.keys()) {
             if (key.startsWith(`${botId}-`)) {
                 this.graphStates.delete(key);
@@ -120,7 +120,25 @@ class EventGraphManager {
         initialContext.botId = botId;
         initialContext.players = players;
         initialContext.botState = eventArgs.botState || {};
-        initialContext.variables = { ...(this.graphStates.get(stateKey) || {}) };
+        
+        const savedVariables = { ...(this.graphStates.get(stateKey) || {}) };
+        
+        if (graph.variables && Array.isArray(graph.variables)) {
+            for (const v of graph.variables) {
+                if (!savedVariables.hasOwnProperty(v.name)) {
+                    let val;
+                    switch (v.type) {
+                        case 'number': val = Number(v.value) || 0; break;
+                        case 'boolean': val = v.value === 'true'; break;
+                        case 'array': try { val = Array.isArray(JSON.parse(v.value)) ? JSON.parse(v.value) : []; } catch { val = []; } break;
+                        default: val = v.value;
+                    }
+                    savedVariables[v.name] = val;
+                }
+            }
+        }
+        
+        initialContext.variables = savedVariables;
 
         try {
             const finalContext = await this.graphEngine.execute(graph, initialContext, eventType);
@@ -162,6 +180,12 @@ class EventGraphManager {
             case 'entityGone':
                 context.entity = args.entity;
                 break;
+            case 'command':
+                context.command_name = args.commandName;
+                context.user = args.user;
+                context.args = args.args;
+                context.chat_type = args.typeChat;
+                break;
         }
         return context;
     }

package/backend/src/core/GraphExecutionEngine.js

@@ -219,6 +219,34 @@ class GraphExecutionEngine {
             await this.traverse(node, 'completed');
             break;
           }
+          case 'flow:while': {
+            let iteration = 0;
+            const maxIterations = 1000;
+            
+            try {
+                while (iteration < maxIterations) {
+                    const condition = await this.resolvePinValue(node, 'condition', false);
+                    if (!condition) break;
+                    
+                    this.memo.set(`${node.id}:iteration`, iteration);
+                    this.clearLoopBodyMemo(node);
+                    await this.traverse(node, 'loop_body');
+                    iteration++;
+                }
+                
+                if (iteration >= maxIterations) {
+                    console.warn(`[GraphExecutionEngine] Цикл while достиг максимального количества итераций (${maxIterations})`);
+                }
+            } catch (e) {
+                if (e instanceof BreakLoopSignal) {
+                } else {
+                    throw e;
+                }
+            }
+            
+            await this.traverse(node, 'completed');
+            break;
+          }
           case 'flow:sequence': {
               const pinCount = node.data?.pinCount || 2;
               for (let i = 0; i < pinCount; i++) {
@@ -375,7 +403,7 @@ class GraphExecutionEngine {
           case 'event:command':
               if (pinId === 'args') result = this.context.args || {};
               else if (pinId === 'user') result = this.context.user || {};
-              else if (pinId === 'chat_type') result = this.context.typeChat || 'local';
+              else if (pinId === 'chat_type') result = this.context.typeChat || 'chat';
               else result = this.context[pinId];
               break;
           case 'event:chat':
@@ -399,8 +427,13 @@ class GraphExecutionEngine {
               break;
           
           case 'data:get_variable':
-              const varName = node.data?.variableName || '';
-              result = this.context.variables.hasOwnProperty(varName) ? this.context.variables[varName] : null;
+              const varName = node.data?.variableName || node.data?.selectedVariable || '';
+              if (!varName) {
+                  console.warn('[GraphExecutionEngine] data:get_variable: не указано имя переменной', node.data);
+                  result = null;
+              } else {
+                  result = this.context.variables.hasOwnProperty(varName) ? this.context.variables[varName] : null;
+              }
               break;
           
 
@@ -471,17 +504,13 @@ class GraphExecutionEngine {
           case 'logic:operation': {
             const op = node.data?.operation || 'AND';
             const inputs = [];
-            for (const key in node.data) {
-                if (key.startsWith('pin_')) {
-                    inputs.push(await this.resolvePinValue(node, key, false));
-                }
-            }
-            if (inputs.length === 0) {
-                inputs.push(await this.resolvePinValue(node, 'a', false));
-                inputs.push(await this.resolvePinValue(node, 'b', false));
+            const pinCount = node.data?.pinCount || 2;
+            
+            for (let i = 0; i < pinCount; i++) {
+                const value = await this.resolvePinValue(node, `pin_${i}`, false);
+                inputs.push(value);
             }
 
-
             switch (op) {
                 case 'AND': result = inputs.every(Boolean); break;
                 case 'OR': result = inputs.some(Boolean); break;
@@ -738,6 +767,12 @@ class GraphExecutionEngine {
             }
             break;
           }
+          case 'flow:while': {
+            if (pinId === 'iteration') {
+                result = this.memo.get(`${node.id}:iteration`);
+            }
+            break;
+          }
           
           case 'string:equals': {
               const strA = String(await this.resolvePinValue(node, 'a', ''));
@@ -798,6 +833,13 @@ class GraphExecutionEngine {
 
     return false;
   }
+
+  hasConnection(node, pinId) {
+      if (!this.activeGraph || !this.activeGraph.connections) return false;
+      return this.activeGraph.connections.some(conn => 
+          conn.targetNodeId === node.id && conn.targetPinId === pinId
+      );
+  }
 }
 
 module.exports = GraphExecutionEngine;

package/backend/src/core/MessageQueue.js

@@ -33,7 +33,16 @@ class MessageQueue {
     enqueue(chatType, message, username = null) {
         const typeConfig = this.chatTypes[chatType];
         if (!typeConfig) return;
-        this._enqueue({ type: 'simple', chatType, ...typeConfig, message, username });
+
+        if (Array.isArray(message)) {
+            for (const msg of message) {
+                if (typeof msg === 'string' && msg.trim().length > 0) {
+                    this._enqueue({ type: 'simple', chatType, ...typeConfig, message: msg, username });
+                }
+            }
+        } else if (typeof message === 'string') {
+            this._enqueue({ type: 'simple', chatType, ...typeConfig, message, username });
+        }
     }
 
     enqueueAndWait(command, patterns, timeout) {

package/backend/src/core/NodeRegistry.js

@@ -102,11 +102,12 @@ class NodeRegistry {
       label: '▶️ При выполнении команды',
       category: 'События',
       description: 'Стартовая точка для графа команды.',
-      graphType: command,
+      graphType: 'all',
       pins: {
         inputs: [],
         outputs: [
           { id: 'exec', name: 'Выполнить', type: 'Exec' },
+          { id: 'command_name', name: 'Имя команды', type: 'String' },
           { id: 'user', name: 'Пользователь', type: 'User' },
           { id: 'args', name: 'Аргументы', type: 'Object' },
           { id: 'chat_type', name: 'Тип чата', type: 'String' }