blockmine 1.23.4 → 1.24.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');
@@ -793,21 +794,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 +822,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 +853,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 +868,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 +1205,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 +1237,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/core/BotProcess.js

@@ -68,6 +68,7 @@ async function fetchNewConfig(botId, prisma) {
             where: { id: botId },
             include: {
                 server: true,
+                proxy: true,
                 installedPlugins: {
                     where: { isEnabled: true }
                 },
@@ -317,6 +318,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 +411,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 +428,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);
 
 
@@ -841,7 +850,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,
@@ -1108,6 +1118,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 +1389,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 +1461,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 +1485,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;

package/backend/src/core/PluginHooks.js

@@ -0,0 +1,221 @@
+const path = require('path');
+const fse = require('fs-extra');
+const { createRequire } = require('module');
+const { pathToFileURL } = require('url');
+const PluginStore = require('../plugins/PluginStore');
+
+/**
+ * Сервис для вызова хуков плагинов
+ * Поддерживаемые хуки:
+ * - onLoad(bot, options) - при загрузке плагина
+ * - onUnload({ botId, prisma }) - при удалении плагина
+ * - onEnable({ botId, settings, store, prisma }) - при включении плагина
+ * - onDisable({ botId, settings, store, prisma }) - при выключении плагина
+ * - onUpdate({ botId, oldVersion, newVersion, settings, store, prisma }) - при обновлении плагина
+ */
+class PluginHooks {
+    constructor({ prisma }) {
+        this.prisma = prisma;
+    }
+
+    /**
+     * Загружает модуль плагина
+     * @private
+     */
+    async _loadPluginModule(pluginPath, mainFile = 'index.js') {
+        const entryPointPath = path.join(pluginPath, mainFile);
+
+        if (!await fse.pathExists(entryPointPath)) {
+            return null;
+        }
+
+        const pluginRequire = createRequire(entryPointPath);
+
+        // Очищаем кэш для актуальной версии модуля
+        try {
+            const resolvedPath = require.resolve(entryPointPath);
+            if (require.cache[resolvedPath]) {
+                delete require.cache[resolvedPath];
+            }
+        } catch (e) {
+            // Игнорируем ошибки очистки кэша
+        }
+
+        try {
+            // Пробуем CommonJS
+            return pluginRequire(entryPointPath);
+        } catch (e) {
+            if (e.code === 'ERR_REQUIRE_ESM' || /Cannot use import statement|Unexpected token 'export'/.test(e.message)) {
+                // Пробуем ESM
+                const moduleUrl = pathToFileURL(entryPointPath).href;
+                const esmModule = await import(moduleUrl);
+                return esmModule && esmModule.default ? esmModule.default : esmModule;
+            }
+            throw e;
+        }
+    }
+
+    /**
+     * Подготавливает настройки плагина
+     * @private
+     */
+    _prepareSettings(plugin) {
+        try {
+            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];
+                    try {
+                        defaultSettings[key] = JSON.parse(config.default || 'null');
+                    } catch {
+                        defaultSettings[key] = config.default;
+                    }
+                }
+            }
+
+            // Мержим дефолтные с сохранёнными
+            return { ...defaultSettings, ...savedSettings };
+        } catch (e) {
+            console.error(`[PluginHooks] Ошибка подготовки настроек:`, e);
+            return {};
+        }
+    }
+
+    /**
+     * Вызывает хук onEnable при включении плагина
+     * @param {number} pluginId - ID плагина
+     * @returns {Promise<boolean>} - true если хук успешно выполнен
+     */
+    async callOnEnable(pluginId) {
+        const plugin = await this.prisma.installedPlugin.findUnique({ where: { id: pluginId } });
+        if (!plugin) {
+            console.error(`[PluginHooks] Плагин ${pluginId} не найден`);
+            return false;
+        }
+
+        try {
+            const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
+            const mainFile = manifest.main || 'index.js';
+            const pluginModule = await this._loadPluginModule(plugin.path, mainFile);
+
+            if (!pluginModule || typeof pluginModule.onEnable !== 'function') {
+                // Хук не определён - это нормально
+                console.log(`[PluginHooks] Плагин ${plugin.name} не имеет хука onEnable`);
+                return true;
+            }
+
+            const settings = this._prepareSettings(plugin);
+            const store = new PluginStore(this.prisma, plugin.botId, plugin.name);
+
+            console.log(`[PluginHooks] Вызов onEnable для плагина ${plugin.name}...`);
+
+            await pluginModule.onEnable({
+                botId: plugin.botId,
+                settings,
+                store,
+                prisma: this.prisma
+            });
+
+            console.log(`[PluginHooks] Хук onEnable для ${plugin.name} успешно выполнен`);
+            return true;
+        } catch (error) {
+            console.error(`[PluginHooks] Ошибка выполнения onEnable для ${plugin.name}:`, error);
+            return false;
+        }
+    }
+
+    /**
+     * Вызывает хук onDisable при выключении плагина
+     * @param {number} pluginId - ID плагина
+     * @returns {Promise<boolean>} - true если хук успешно выполнен
+     */
+    async callOnDisable(pluginId) {
+        const plugin = await this.prisma.installedPlugin.findUnique({ where: { id: pluginId } });
+        if (!plugin) {
+            console.error(`[PluginHooks] Плагин ${pluginId} не найден`);
+            return false;
+        }
+
+        try {
+            const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
+            const mainFile = manifest.main || 'index.js';
+            const pluginModule = await this._loadPluginModule(plugin.path, mainFile);
+
+            if (!pluginModule || typeof pluginModule.onDisable !== 'function') {
+                // Хук не определён - это нормально
+                console.log(`[PluginHooks] Плагин ${plugin.name} не имеет хука onDisable`);
+                return true;
+            }
+
+            const settings = this._prepareSettings(plugin);
+            const store = new PluginStore(this.prisma, plugin.botId, plugin.name);
+
+            console.log(`[PluginHooks] Вызов onDisable для плагина ${plugin.name}...`);
+
+            await pluginModule.onDisable({
+                botId: plugin.botId,
+                settings,
+                store,
+                prisma: this.prisma
+            });
+
+            console.log(`[PluginHooks] Хук onDisable для ${plugin.name} успешно выполнен`);
+            return true;
+        } catch (error) {
+            console.error(`[PluginHooks] Ошибка выполнения onDisable для ${plugin.name}:`, error);
+            return false;
+        }
+    }
+
+    /**
+     * Вызывает хук onUpdate при обновлении плагина
+     * @param {number} pluginId - ID нового плагина
+     * @param {string} oldVersion - старая версия
+     * @param {string} newVersion - новая версия
+     * @returns {Promise<boolean>} - true если хук успешно выполнен
+     */
+    async callOnUpdate(pluginId, oldVersion, newVersion) {
+        const plugin = await this.prisma.installedPlugin.findUnique({ where: { id: pluginId } });
+        if (!plugin) {
+            console.error(`[PluginHooks] Плагин ${pluginId} не найден`);
+            return false;
+        }
+
+        try {
+            const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
+            const mainFile = manifest.main || 'index.js';
+            const pluginModule = await this._loadPluginModule(plugin.path, mainFile);
+
+            if (!pluginModule || typeof pluginModule.onUpdate !== 'function') {
+                // Хук не определён - это нормально
+                console.log(`[PluginHooks] Плагин ${plugin.name} не имеет хука onUpdate`);
+                return true;
+            }
+
+            const settings = this._prepareSettings(plugin);
+            const store = new PluginStore(this.prisma, plugin.botId, plugin.name);
+
+            console.log(`[PluginHooks] Вызов onUpdate для плагина ${plugin.name} (${oldVersion} → ${newVersion})...`);
+
+            await pluginModule.onUpdate({
+                botId: plugin.botId,
+                oldVersion,
+                newVersion,
+                settings,
+                store,
+                prisma: this.prisma
+            });
+
+            console.log(`[PluginHooks] Хук onUpdate для ${plugin.name} успешно выполнен`);
+            return true;
+        } catch (error) {
+            console.error(`[PluginHooks] Ошибка выполнения onUpdate для ${plugin.name}:`, error);
+            return false;
+        }
+    }
+}
+
+module.exports = PluginHooks;

package/backend/src/core/PluginManager.js

@@ -5,6 +5,7 @@ const { execSync } = require('child_process');
 const { PrismaClient } = require('@prisma/client');
 const AdmZip = require('adm-zip');
 const semver = require('semver');
+const PluginHooks = require('./PluginHooks');
 
 const prisma = new PrismaClient();
 
@@ -402,6 +403,15 @@ class PluginManager {
             }
         }
 
+        // Вызываем хук onUpdate для миграции данных плагина
+        try {
+            const pluginHooks = new PluginHooks({ prisma });
+            await pluginHooks.callOnUpdate(newPlugin.id, oldVersion, newPlugin.version);
+        } catch (hookError) {
+            console.error(`[PluginManager] Ошибка выполнения хука onUpdate для ${plugin.name}:`, hookError);
+            // Не прерываем обновление из-за ошибки в хуке
+        }
+
         return newPlugin;
     }