blockmine 1.23.4 → 1.25.0

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

@@ -89,17 +89,37 @@ router.put('/:botId/users/:username', authenticateUniversal, authorize('manageme
             updateData.isBlacklisted = isBlacklisted;
         }
 
-        if (Array.isArray(groupIds)) {
-            await prisma.userGroup.deleteMany({ where: { userId: user.id } });
-            updateData.groups = {
-                create: groupIds.map(gid => ({ groupId: gid }))
-            };
-        }
+        // Используем транзакцию для атомарного обновления групп
+        const updatedUser = await prisma.$transaction(async (tx) => {
+            // Обновляем основные данные пользователя
+            if (Object.keys(updateData).length > 0) {
+                await tx.user.update({
+                    where: { id: user.id },
+                    data: updateData
+                });
+            }
+
+            // Обновляем группы если переданы
+            if (Array.isArray(groupIds)) {
+                // Удаляем старые связи
+                await tx.userGroup.deleteMany({ where: { userId: user.id } });
+
+                // Создаём новые связи
+                if (groupIds.length > 0) {
+                    await tx.userGroup.createMany({
+                        data: groupIds.map(groupId => ({
+                            userId: user.id,
+                            groupId
+                        }))
+                    });
+                }
+            }
 
-        const updatedUser = await prisma.user.update({
-            where: { id: user.id },
-            data: updateData,
-            include: { groups: { include: { group: true } } }
+            // Возвращаем обновлённого пользователя с группами
+            return tx.user.findUnique({
+                where: { id: user.id },
+                include: { groups: { include: { group: true } } }
+            });
         });
 
         botManager.invalidateUserCache(botId, username);

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

@@ -16,6 +16,7 @@ const apiKeysRouter = require('./apiKeys');
 const { deepMergeSettings } = require('../../core/utils/settingsMerger');
 const { checkBotAccess } = require('../middleware/botAccess');
 const { filterSecretSettings, prepareSettingsForSave, isGroupedSettings } = require('../../core/utils/secretsFilter');
+const PluginHooks = require('../../core/PluginHooks');
 
 const multer = require('multer');
 const archiver = require('archiver');
@@ -476,8 +477,21 @@ router.put('/:id', authenticateUniversal, checkBotAccess, authorize('bot:update'
             const proxyIdValue = dataToUpdate.proxyId;
             delete dataToUpdate.proxyId;
             if (proxyIdValue) {
+                // Используем прокси из списка - очищаем кастомные поля
                 dataToUpdate.proxy = { connect: { id: proxyIdValue } };
+                dataToUpdate.proxyHost = null;
+                dataToUpdate.proxyPort = null;
+                dataToUpdate.proxyUsername = null;
+                dataToUpdate.proxyPassword = null;
+            } else if (!dataToUpdate.proxyHost) {
+                // Отключаем прокси только если нет кастомного proxyHost
+                dataToUpdate.proxy = { disconnect: true };
+                dataToUpdate.proxyHost = null;
+                dataToUpdate.proxyPort = null;
+                dataToUpdate.proxyUsername = null;
+                dataToUpdate.proxyPassword = null;
             } else {
+                // Кастомный прокси: отключаем связь с proxy, но сохраняем кастомные поля
                 dataToUpdate.proxy = { disconnect: true };
             }
         }
@@ -793,21 +807,23 @@ router.put('/:botId/plugins/:pluginId', authenticateUniversal, checkBotAccess, a
         const pluginId = parseInt(req.params.pluginId);
         const { isEnabled, settings } = req.body;
         const dataToUpdate = {};
-        
+
+        // Получаем текущий плагин для проверки изменения статуса
+        const plugin = await prisma.installedPlugin.findUnique({ where: { id: pluginId } });
+        if (!plugin) return res.status(404).json({ error: 'Плагин не найден' });
+
+        const wasEnabled = plugin.isEnabled;
+
         if (typeof isEnabled === 'boolean') dataToUpdate.isEnabled = isEnabled;
-        
+
         if (settings) {
-            // Получаем существующий плагин для обработки секретных значений
-            const plugin = await prisma.installedPlugin.findUnique({ where: { id: pluginId } });
-            if (!plugin) return res.status(404).json({ error: 'Плагин не найден' });
-            
             const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
             const existingSettings = plugin.settings ? JSON.parse(plugin.settings) : {};
             const manifestSettings = manifest.settings || {};
-            
+
             // Определяем тип настроек (обычные или группированные)
             const isGrouped = isGroupedSettings(manifestSettings);
-            
+
             // Подготавливаем настройки для сохранения (сохраняем существующие значения для замаскированных секретов)
             const settingsToSave = prepareSettingsForSave(settings, existingSettings, manifestSettings, isGrouped);
 
@@ -819,13 +835,26 @@ router.put('/:botId/plugins/:pluginId', authenticateUniversal, checkBotAccess, a
 
             dataToUpdate.settings = JSON.stringify(settingsToSave);
         }
-        
+
         if (Object.keys(dataToUpdate).length === 0) return res.status(400).json({ error: "Нет данных для обновления" });
         const updated = await prisma.installedPlugin.update({ where: { id: pluginId }, data: dataToUpdate });
+
+        // Вызываем хуки onEnable/onDisable если статус изменился
+        if (typeof isEnabled === 'boolean' && wasEnabled !== isEnabled) {
+            const pluginHooks = new PluginHooks({ prisma });
+            if (isEnabled) {
+                // Плагин был включён
+                await pluginHooks.callOnEnable(pluginId);
+            } else {
+                // Плагин был выключен
+                await pluginHooks.callOnDisable(pluginId);
+            }
+        }
+
         res.json(updated);
-    } catch (error) { 
+    } catch (error) {
         console.error("[API Error] /plugins/:pluginId PUT:", error);
-        res.status(500).json({ error: 'Не удалось обновить плагин' }); 
+        res.status(500).json({ error: 'Не удалось обновить плагин' });
     }
 });
 
@@ -837,6 +866,8 @@ router.get('/:botId/management-data', authenticateUniversal, checkBotAccess, aut
         const page = parseInt(req.query.page) || 1;
         const pageSize = parseInt(req.query.pageSize) || 100;
         const searchQuery = req.query.search || '';
+        const sortBy = req.query.sortBy || 'username';
+        const sortDir = req.query.sortDir === 'desc' ? 'desc' : 'asc';
 
         const userSkip = (page - 1) * pageSize;
 
@@ -850,21 +881,47 @@ router.get('/:botId/management-data', authenticateUniversal, checkBotAccess, aut
             };
         }
 
+        // Определяем сортировку (для groups сортируем после получения данных)
+        let orderBy = { username: sortDir };
+        if (sortBy === 'isBlacklisted') {
+            orderBy = { isBlacklisted: sortDir };
+        }
+        const sortByGroups = sortBy === 'groups';
+
         const [groups, allPermissions] = await Promise.all([
             prisma.group.findMany({ where: { botId }, include: { permissions: { include: { permission: true } } }, orderBy: { name: 'asc' } }),
             prisma.permission.findMany({ where: { botId }, orderBy: { name: 'asc' } })
         ]);
 
-        const [users, usersCount] = await Promise.all([
-            prisma.user.findMany({
+        let users;
+        let usersCount;
+
+        if (sortByGroups) {
+            // Для сортировки по группам получаем всех пользователей, сортируем, потом пагинируем
+            const allUsers = await prisma.user.findMany({
                 where: whereClause,
                 include: { groups: { include: { group: true } } },
-                orderBy: { username: 'asc' },
-                take: pageSize,
-                skip: userSkip,
-            }),
-            prisma.user.count({ where: whereClause })
-        ]);
+            });
+
+            allUsers.sort((a, b) => {
+                const diff = a.groups.length - b.groups.length;
+                return sortDir === 'asc' ? diff : -diff;
+            });
+
+            usersCount = allUsers.length;
+            users = allUsers.slice(userSkip, userSkip + pageSize);
+        } else {
+            [users, usersCount] = await Promise.all([
+                prisma.user.findMany({
+                    where: whereClause,
+                    include: { groups: { include: { group: true } } },
+                    orderBy,
+                    take: pageSize,
+                    skip: userSkip,
+                }),
+                prisma.user.count({ where: whereClause })
+            ]);
+        }
 
         const templatesMap = new Map(commandManager.getCommandTemplates().map(t => [t.name, t]));
         let dbCommandsFromDb = await prisma.command.findMany({ 
@@ -1161,7 +1218,24 @@ router.put('/:botId/users/:userId', authorize('management:edit'), async (req, re
 router.post('/start-all', authorize('bot:start_stop'), async (req, res) => {
     try {
         console.log('[API] Получен запрос на запуск всех ботов.');
-        const allBots = await prisma.bot.findMany({ include: { server: true, proxy: true } });
+
+        // Определяем фильтр доступа по ботам для пользователя
+        let whereFilter = {};
+        if (req.user && typeof req.user.userId === 'number') {
+            const panelUser = await prisma.panelUser.findUnique({
+                where: { id: req.user.userId },
+                include: { botAccess: { select: { botId: true } } }
+            });
+            if (panelUser && panelUser.allBots === false) {
+                const allowedIds = panelUser.botAccess.map(a => a.botId);
+                whereFilter = { id: { in: allowedIds.length ? allowedIds : [-1] } };
+            }
+        }
+
+        const allBots = await prisma.bot.findMany({
+            where: whereFilter,
+            include: { server: true, proxy: true }
+        });
         let startedCount = 0;
         for (const botConfig of allBots) {
             if (!botManager.bots.has(botConfig.id)) {
@@ -1176,12 +1250,29 @@ router.post('/start-all', authorize('bot:start_stop'), async (req, res) => {
     }
 });
 
-router.post('/stop-all', authorize('bot:start_stop'), (req, res) => {
+router.post('/stop-all', authorize('bot:start_stop'), async (req, res) => {
     try {
         console.log('[API] Получен запрос на остановку всех ботов.');
+
+        // Определяем фильтр доступа по ботам для пользователя
+        let allowedBotIds = null;
+        if (req.user && typeof req.user.userId === 'number') {
+            const panelUser = await prisma.panelUser.findUnique({
+                where: { id: req.user.userId },
+                include: { botAccess: { select: { botId: true } } }
+            });
+            if (panelUser && panelUser.allBots === false) {
+                allowedBotIds = new Set(panelUser.botAccess.map(a => a.botId));
+            }
+        }
+
         const botIds = Array.from(botManager.bots.keys());
         let stoppedCount = 0;
         for (const botId of botIds) {
+            // Если у пользователя есть ограничения, проверяем доступ
+            if (allowedBotIds !== null && !allowedBotIds.has(botId)) {
+                continue;
+            }
             botManager.stopBot(botId);
             stoppedCount++;
         }

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

@@ -39,8 +39,14 @@ router.post('/', authorize('server:create'), async (req, res) => {
         if (!name || !host || !version) {
             return res.status(400).json({ error: 'Имя, хост и версия сервера обязательны' });
         }
+
+        const portNumber = port ? parseInt(port, 10) : 25565;
+        if (isNaN(portNumber) || portNumber < 1 || portNumber > 65535) {
+            return res.status(400).json({ error: 'Порт должен быть числом от 1 до 65535 (максимум 5 цифр)' });
+        }
+
         const newServer = await prisma.server.create({
-            data: { name, host, port: port ? parseInt(port, 10) : 25565, version },
+            data: { name, host, port: portNumber, version },
         });
         res.status(201).json(newServer);
     } catch (error) {
@@ -58,7 +64,13 @@ router.put('/:id', authorize('server:create'), async (req, res) => {
         const dataToUpdate = {};
         if (name !== undefined) dataToUpdate.name = name;
         if (host !== undefined) dataToUpdate.host = host;
-        if (port !== undefined && port !== '') dataToUpdate.port = parseInt(port, 10);
+        if (port !== undefined && port !== '') {
+            const portNumber = parseInt(port, 10);
+            if (isNaN(portNumber) || portNumber < 1 || portNumber > 65535) {
+                return res.status(400).json({ error: 'Порт должен быть числом от 1 до 65535 (максимум 5 цифр)' });
+            }
+            dataToUpdate.port = portNumber;
+        }
         if (version !== undefined) dataToUpdate.version = version;
 
         Object.keys(dataToUpdate).forEach(k => { if (dataToUpdate[k] === undefined) delete dataToUpdate[k]; });

package/backend/src/core/BotProcess.js

@@ -6,7 +6,7 @@ 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');
@@ -68,6 +68,7 @@ async function fetchNewConfig(botId, prisma) {
             where: { id: botId },
             include: {
                 server: true,
+                proxy: true,
                 installedPlugins: {
                     where: { isEnabled: true }
                 },
@@ -178,6 +179,16 @@ process.on('message', async (message) => {
             }
             pendingRequests.delete(message.requestId);
         }
+    } else if (message.type === '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 === 'system:get_player_list') {
         const playerList = bot ? Object.keys(bot.players) : [];
         if (process.send) {
@@ -317,6 +328,13 @@ process.on('message', async (message) => {
                     }
                     break;
 
+                case 'hotbar_slot':
+                    if (command.slot !== undefined && command.slot >= 0 && command.slot <= 8) {
+                        bot.setQuickBarSlot(command.slot);
+                        sendLog(`[Viewer] Hotbar slot changed to ${command.slot}`);
+                    }
+                    break;
+
                 case 'place':
                     if (command.position && command.blockType) {
                         const referenceBlock = bot.blockAt(new Vec3(command.position.x, command.position.y, command.position.z));
@@ -403,7 +421,8 @@ process.on('message', async (message) => {
             };
 
             const context = {
-                bot: botApi,
+                bot: bot,  // Полный mineflayer bot
+                botApi: botApi,  // API для обратной совместимости
                 eventArgs: eventArgs || {},
                 players: playerList,
                 botState: bot ? {
@@ -419,7 +438,7 @@ process.on('message', async (message) => {
                 eventArgs: eventArgs
             };
 
-            const engine = new GraphExecutionEngine(NodeRegistry, botApi);
+            const engine = new GraphExecutionEngine(NodeRegistry, bot);
             await engine.execute(graph, context, eventType);
 
 
@@ -494,6 +513,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,
@@ -774,10 +796,92 @@ process.on('message', async (message) => {
                             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: '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: 'restart_bot',
+                                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: '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);
             };
@@ -841,7 +945,8 @@ process.on('message', async (message) => {
                         } : null;
 
                         const context = {
-                            bot: botInstance.api,
+                            bot: botInstance,  // Полный mineflayer bot для доступа к blockAt, inventory и т.д.
+                            botApi: botInstance.api,  // API для обратной совместимости
                             user,
                             args,
                             typeChat,
@@ -899,6 +1004,7 @@ process.on('message', async (message) => {
                 }
             }
 
+            await ensurePluginDependencies(config.plugins, sendLog);
             await initializePlugins(bot, config.plugins, prisma);
             sendLog('[System] Все системы инициализированы.');
 
@@ -1108,6 +1214,29 @@ process.on('message', async (message) => {
                     });
                 }
             });
+
+            bot.on('blockUpdate', (oldBlock, newBlock) => {
+                if (process.send && oldBlock && newBlock) {
+                    process.send({
+                        type: 'viewer:blockUpdate',
+                        payload: {
+                            position: {
+                                x: newBlock.position.x,
+                                y: newBlock.position.y,
+                                z: newBlock.position.z
+                            },
+                            oldBlock: {
+                                type: oldBlock.type,
+                                name: oldBlock.name
+                            },
+                            newBlock: {
+                                type: newBlock.type,
+                                name: newBlock.name
+                            }
+                        }
+                    });
+                }
+            });
         } catch (err) {
             sendLog(`[CRITICAL] Критическая ошибка при создании бота: ${err.stack}`);
             process.exit(1);
@@ -1356,6 +1485,8 @@ process.on('message', async (message) => {
         sendLog('[System] Получена команда на перезагрузку плагинов...');
         const newConfig = await fetchNewConfig(bot.config.id, prisma);
         if (newConfig) {
+            // Обновляем конфигурацию бота, сохраняя все поля включая прокси
+            bot.config = { ...bot.config, ...newConfig };
             bot.config.plugins = newConfig.installedPlugins;
             bot.commands.clear();
             await loadCommands(bot, newConfig.commands);
@@ -1426,7 +1557,8 @@ process.on('message', async (message) => {
             const players = bot ? Object.keys(bot.players) : [];
 
             const context = {
-                bot: botApi,
+                bot: bot,  // Полный mineflayer bot
+                botApi: botApi,  // API для обратной совместимости
                 players,
                 botState: {
                     health: bot?.health,
@@ -1449,7 +1581,7 @@ process.on('message', async (message) => {
                 eventArgs: eventArgs
             };
 
-            const engine = new GraphExecutionEngine(NodeRegistry, botApi);
+            const engine = new GraphExecutionEngine(NodeRegistry, bot);
 
             await engine.execute(graph, context, eventType);
 

package/backend/src/core/GraphExecutionEngine.js

@@ -172,8 +172,15 @@ class GraphExecutionEngine {
   }
 
   async traverse(node, fromPinId) {
-      const connection = this.activeGraph.connections.find(c => c.sourceNodeId === node.id && c.sourcePinId === fromPinId);
-      if (!connection) return;
+      // Находим соединение к СУЩЕСТВУЮЩЕЙ ноде (пропускаем мусорные соединения к удалённым нодам)
+      const connection = this.activeGraph.connections.find(c => {
+          if (c.sourceNodeId !== node.id || c.sourcePinId !== fromPinId) return false;
+          const targetExists = this.activeGraph.nodes.some(n => n.id === c.targetNodeId);
+          return targetExists;
+      });
+      if (!connection) {
+          return;
+      }
 
       const nextNode = this.activeGraph.nodes.find(n => n.id === connection.targetNodeId);
       if (!nextNode) return;