blockmine 1.6.3 → 1.12.1

package/backend/src/api/routes/bots.js

@@ -1085,4 +1085,180 @@ router.put('/:botId/event-graphs/:graphId', authorize('management:edit'), async
 router.post('/:botId/visual-editor/save', authorize('management:edit'), async (req, res) => {
 });
 
+router.get('/:botId/ui-extensions', authorize('plugin:list'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const enabledPlugins = await prisma.installedPlugin.findMany({
+            where: { botId: botId, isEnabled: true }
+        });
+
+        const extensions = [];
+        for (const plugin of enabledPlugins) {
+            if (plugin.manifest) {
+                try {
+                    const manifest = JSON.parse(plugin.manifest);
+                    if (manifest.uiExtensions && Array.isArray(manifest.uiExtensions)) {
+                        manifest.uiExtensions.forEach(ext => {
+                            extensions.push({
+                                pluginName: plugin.name,
+                                ...ext
+                            });
+                        });
+                    }
+                } catch (e) {
+                    console.error(`Ошибка парсинга манифеста для плагина ${plugin.name}:`, e);
+                }
+            }
+        }
+        res.json(extensions);
+    } catch (error) {
+        res.status(500).json({ error: 'Не удалось получить расширения интерфейса' });
+    }
+});
+
+router.get('/:botId/plugins/:pluginName/ui-content/:path', authorize('plugin:list'), async (req, res) => {
+    const { botId, pluginName, path: uiPath } = req.params;
+    const numericBotId = parseInt(botId, 10);
+
+    try {
+        const plugin = await prisma.installedPlugin.findFirst({
+            where: { botId: numericBotId, name: pluginName, isEnabled: true }
+        });
+
+        if (!plugin) {
+            return res.status(404).json({ error: `Активный плагин "${pluginName}" не найден для этого бота.` });
+        }
+
+        const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
+        const savedSettings = plugin.settings ? JSON.parse(plugin.settings) : {};
+        const defaultSettings = {};
+
+        if (manifest.settings) {
+            for (const key in manifest.settings) {
+                const config = manifest.settings[key];
+                if (config.type === 'json_file' && config.defaultPath) {
+                    const configFilePath = path.join(plugin.path, config.defaultPath);
+                    try {
+                        const fileContent = await fs.readFile(configFilePath, 'utf-8');
+                        defaultSettings[key] = JSON.parse(fileContent);
+                    } catch (e) { defaultSettings[key] = {}; }
+                } else {
+                    try { defaultSettings[key] = JSON.parse(config.default || 'null'); } 
+                    catch { defaultSettings[key] = config.default; }
+                }
+            }
+        }
+        const finalSettings = { ...defaultSettings, ...savedSettings };
+        
+        const mainFilePath = manifest.main || 'index.js';
+        const pluginEntryPoint = path.join(plugin.path, mainFilePath);
+        
+        delete require.cache[require.resolve(pluginEntryPoint)];
+        const pluginModule = require(pluginEntryPoint);
+
+        if (typeof pluginModule.getUiPageContent !== 'function') {
+            return res.status(501).json({ error: `Плагин "${pluginName}" не предоставляет кастомный UI контент.` });
+        }
+        
+        const botProcess = botManager.bots.get(numericBotId);
+        const botApi = botProcess ? botProcess.api : null;
+        
+        const content = await pluginModule.getUiPageContent({
+            path: uiPath,
+            bot: botApi,
+            botId: numericBotId,
+            settings: finalSettings
+        });
+
+        if (content === null) {
+            return res.status(404).json({ error: `Для пути "${uiPath}" не найдено содержимого в плагине "${pluginName}".` });
+        }
+
+        res.json(content);
+
+    } catch (error) {
+        console.error(`[UI Content] Ошибка при получении контента для плагина "${pluginName}":`, error);
+        res.status(500).json({ error: error.message || 'Внутренняя ошибка сервера.' });
+    }
+});
+
+
+router.post('/:botId/plugins/:pluginName/action', authorize('plugin:list'), async (req, res) => {
+    const { botId, pluginName } = req.params;
+    const { actionName, payload } = req.body;
+    const numericBotId = parseInt(botId, 10);
+
+    if (!actionName) {
+        return res.status(400).json({ error: 'Необходимо указать "actionName".' });
+    }
+
+    try {
+        const botProcess = botManager.bots.get(numericBotId);
+        
+        if (!botProcess) {
+            return res.status(404).json({ error: 'Бот не найден или не запущен.' });
+        }
+
+        const plugin = await prisma.installedPlugin.findFirst({
+            where: { botId: numericBotId, name: pluginName, isEnabled: true }
+        });
+
+        if (!plugin) {
+            return res.status(404).json({ error: `Активный плагин с таким именем "${pluginName}" не найден.` });
+        }
+
+        const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
+        const savedSettings = plugin.settings ? JSON.parse(plugin.settings) : {};
+        const defaultSettings = {};
+
+        if (manifest.settings) {
+            for (const key in manifest.settings) {
+                const config = manifest.settings[key];
+                 if (config.type === 'json_file' && config.defaultPath) {
+                    const configFilePath = path.join(plugin.path, config.defaultPath);
+                    try {
+                        const fileContent = await fs.readFile(configFilePath, 'utf-8');
+                        defaultSettings[key] = JSON.parse(fileContent);
+                    } catch (e) { 
+                        console.error(`[Action] Не удалось прочитать defaultPath для ${pluginName}: ${e.message}`);
+                        defaultSettings[key] = {}; 
+                    }
+                } else {
+                    try { 
+                        defaultSettings[key] = JSON.parse(config.default || 'null'); 
+                    } catch { 
+                        defaultSettings[key] = config.default; 
+                    }
+                }
+            }
+        }
+        const finalSettings = { ...defaultSettings, ...savedSettings };
+
+        const mainFilePath = manifest.main || 'index.js';
+        const pluginPath = path.join(plugin.path, mainFilePath);
+        
+        delete require.cache[require.resolve(pluginPath)];
+        const pluginModule = require(pluginPath);
+
+        if (typeof pluginModule.handleAction !== 'function') {
+            return res.status(501).json({ error: `Плагин "${pluginName}" не поддерживает обработку действий.` });
+        }
+        
+        const result = await pluginModule.handleAction({
+            botProcess: botProcess,
+            botId: numericBotId,
+            action: actionName,
+            payload: payload,
+            settings: finalSettings
+        });
+
+        res.json({ success: true, message: 'Действие выполнено.', result: result || null });
+
+    } catch (error) {
+        console.error(`Ошибка выполнения действия "${actionName}" для плагина "${pluginName}":`, error);
+        res.status(500).json({ error: error.message || 'Внутренняя ошибка сервера.' });
+    }
+});
+
+
 module.exports = router;

package/backend/src/api/routes/changelog.js

@@ -0,0 +1,16 @@
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const router = express.Router();
+
+router.get('/', async (req, res) => {
+  try {
+    const file = path.resolve(__dirname, '../../../../CHANGELOG.md');
+    const data = await fs.promises.readFile(file, 'utf8');
+    res.type('text/markdown').send(data);
+  } catch (e) {
+    res.status(500).json({ error: 'changelog_not_found' });
+  }
+});
+
+module.exports = router;

package/backend/src/api/routes/eventGraphs.js

@@ -121,7 +121,17 @@ router.put('/:graphId',
 
           const parsedGraph = JSON.parse(graphJson);
           const eventNodes = parsedGraph.nodes.filter(node => node.type.startsWith('event:'));
-          const eventTypes = eventNodes.map(node => node.type.split(':')[1]);
+          const eventTypes = [...new Set(eventNodes.map(node => node.type.split(':')[1]))];
+          
+          const existingGraph = await prisma.eventGraph.findUnique({
+              where: { id: parseInt(graphId) },
+              include: { triggers: true }
+          });
+          
+          const existingEventTypes = existingGraph?.triggers?.map(t => t.eventType) || [];
+          
+          const eventTypesToDelete = existingEventTypes.filter(et => !eventTypes.includes(et));
+          const eventTypesToCreate = eventTypes.filter(et => !existingEventTypes.includes(et));
           
           dataToUpdate.triggers = {
               deleteMany: {},

package/backend/src/api/routes/plugins.js

@@ -53,6 +53,17 @@ router.post('/update/:pluginId', authenticate, authorize('plugin:update'), async
     }
 });
 
+router.post('/:id/clear-data', authenticate, authorize('plugin:settings:edit'), async (req, res) => {
+    try {
+        const pluginId = parseInt(req.params.id);
+        await pluginManager.clearPluginData(pluginId);
+        res.status(200).json({ message: 'Данные плагина успешно очищены.' });
+    } catch (error) {
+        console.error(`[API Error] /plugins/:id/clear-data:`, error);
+        res.status(500).json({ error: error.message || 'Не удалось очистить данные плагина.' });
+    }
+});
+
 router.get('/catalog/:name', async (req, res) => {
     try {
         const pluginName = req.params.name;

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') {