blockmine 1.13.1 → 1.14.1

package/CHANGELOG.md

@@ -1,6 +1,23 @@
 # История версий
 
 
+### [1.14.1](https://github.com/blockmineJS/blockmine/compare/v1.14.0...v1.14.1) (2025-07-19)
+
+## [1.14.0](https://github.com/blockmineJS/blockmine/compare/v1.13.1...v1.14.0) (2025-07-19)
+
+
+### ✨ Новые возможности
+
+* [PluginUiPage] Если бот не запущен, то на этой странице попросит запустить бота ([fda603e](https://github.com/blockmineJS/blockmine/commit/fda603ee4162b32d3bac481307dc6aca2d671d07))
+
+
+### 🐛 Исправления
+
+* импорт/экспорт починен ([bad135f](https://github.com/blockmineJS/blockmine/commit/bad135fe04c7e1dc5bb0cfc67a326a3a60e3b040))
+* обновлен интерфейс отображения установленных плагинов и улучшена логика обновления плагинов ([ba50a0a](https://github.com/blockmineJS/blockmine/commit/ba50a0aec6bf656e73fb46dc575668dbc617d5ce))
+* теперь бот будет принудительно убит если не сможет остановится ([7770af5](https://github.com/blockmineJS/blockmine/commit/7770af5999abf108ec38ab416d8aab3fd5c804ab))
+* улучшен интерфейс переключателя темы и исправлена логика инициализации темы при монтировании компонента ([2ed06d8](https://github.com/blockmineJS/blockmine/commit/2ed06d8ed26263521741b62318cab34cf561248e))
+
 ### [1.13.1](https://github.com/blockmineJS/blockmine/compare/v1.13.0...v1.13.1) (2025-07-18)
 
 

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

@@ -15,6 +15,7 @@ const pluginIdeRouter = require('./pluginIde');
 const multer = require('multer');
 const archiver = require('archiver');
 const AdmZip = require('adm-zip');
+const os = require('os');
 
 const upload = multer({ storage: multer.memoryStorage() });
 
@@ -127,15 +128,22 @@ router.put('/:id', authorize('bot:update'), async (req, res) => {
             dataToUpdate.proxyPassword = encrypt(proxyPassword);
         }
 
-        if (serverId) {
+        if (serverId !== undefined && serverId !== '') {
             dataToUpdate.serverId = parseInt(serverId, 10);
         }
         
+        Object.keys(dataToUpdate).forEach(key => {
+            if (dataToUpdate[key] === undefined) {
+                delete dataToUpdate[key];
+            }
+        });
+        
         if (dataToUpdate.serverId) {
-             const { serverId: sId, ...rest } = dataToUpdate;
-             dataToUpdate = { ...rest, server: { connect: { id: sId } } };
+            const serverIdValue = dataToUpdate.serverId;
+            delete dataToUpdate.serverId;
+            dataToUpdate.server = { connect: { id: serverIdValue } };
         }
-
+        
         const botId = parseInt(req.params.id, 10);
         if (isNaN(botId)) {
             return res.status(400).json({ message: 'Неверный ID бота.' });
@@ -1011,16 +1019,22 @@ router.post('/:botId/event-graphs', authorize('management:edit'), async (req, re
         const botId = parseInt(req.params.botId, 10);
         const { name } = req.body;
 
-        if (!name) {
-            return res.status(400).json({ error: 'Имя графа обязательно' });
+        if (!name || typeof name !== 'string' || name.trim() === '') {
+            return res.status(400).json({ error: 'Имя графа обязательно и должно быть непустой строкой' });
         }
 
+        const initialGraph = {
+            nodes: [],
+            connections: []
+        };
+
         const newEventGraph = await prisma.eventGraph.create({
             data: {
                 botId,
-                name,
+                name: name.trim(),
                 isEnabled: true,
-                graphJson: 'null',
+                graphJson: JSON.stringify(initialGraph),
+                variables: '[]'
             },
         });
 
@@ -1052,10 +1066,10 @@ router.delete('/:botId/event-graphs/:graphId', authorize('management:edit'), asy
 
 router.put('/:botId/event-graphs/:graphId', authorize('management:edit'), async (req, res) => {
     const { botId, graphId } = req.params;
-    const { name, isEnabled, graphJson, eventType } = req.body;
+    const { name, isEnabled, graphJson, variables } = req.body;
 
-    if (!name || !eventType || !graphJson) {
-        return res.status(400).json({ error: 'Поля name, eventType и graphJson обязательны.' });
+    if (!name || typeof name !== 'string' || name.trim() === '') {
+        return res.status(400).json({ error: 'Поле name обязательно и должно быть непустой строкой.' });
     }
 
     if (typeof isEnabled !== 'boolean') {
@@ -1063,18 +1077,24 @@ router.put('/:botId/event-graphs/:graphId', authorize('management:edit'), async
     }
 
     try {
+        const dataToUpdate = {
+            name: name.trim(),
+            isEnabled,
+        };
+
+        if (graphJson !== undefined) {
+            dataToUpdate.graphJson = graphJson;
+        }
+
+        if (variables !== undefined) {
+            dataToUpdate.variables = Array.isArray(variables) ? JSON.stringify(variables) : variables;
+        }
+
         const updatedGraph = await prisma.eventGraph.update({
             where: { id: parseInt(graphId), botId: parseInt(botId) },
-            data: {
-                name,
-                isEnabled,
-                graphJson,
-                eventType,
-            }
+            data: dataToUpdate
         });
         
-        botManager.eventGraphManager.updateGraph(parseInt(botId), updatedGraph);
-        
         res.json(updatedGraph);
     } catch (error) {
         console.error(`[API Error] /event-graphs/:graphId PUT:`, error);
@@ -1261,4 +1281,229 @@ router.post('/:botId/plugins/:pluginName/action', authorize('plugin:list'), asyn
 });
 
 
+router.get('/:botId/export', authorize('bot:export'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const {
+            includeCommands,
+            includePermissions,
+            includePluginFiles,
+            includePluginDataStore,
+            includeEventGraphs,
+        } = req.query;
+
+        const bot = await prisma.bot.findUnique({ where: { id: botId } });
+        if (!bot) {
+            return res.status(404).json({ error: 'Bot not found' });
+        }
+
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        res.attachment(`bot_${bot.username}_export_${new Date().toISOString()}.zip`);
+        archive.pipe(res);
+
+        const botData = { ...bot };
+        delete botData.password;
+        delete botData.proxyPassword;
+        archive.append(JSON.stringify(botData, null, 2), { name: 'bot.json' });
+
+        if (includeCommands === 'true') {
+            const commands = await prisma.command.findMany({ where: { botId } });
+            archive.append(JSON.stringify(commands, null, 2), { name: 'commands.json' });
+        }
+
+        if (includePermissions === 'true') {
+            const users = await prisma.user.findMany({ where: { botId }, include: { groups: { include: { group: true } } } });
+            const groups = await prisma.group.findMany({ where: { botId }, include: { permissions: { include: { permission: true } } } });
+            const permissions = await prisma.permission.findMany({ where: { botId } });
+            const permissionsData = { users, groups, permissions };
+            archive.append(JSON.stringify(permissionsData, null, 2), { name: 'permissions.json' });
+        }
+        
+        if (includeEventGraphs === 'true') {
+            const eventGraphs = await prisma.eventGraph.findMany({ where: { botId } });
+            archive.append(JSON.stringify(eventGraphs, null, 2), { name: 'event_graphs.json' });
+        }
+
+        if (includePluginFiles === 'true' || includePluginDataStore === 'true') {
+            const installedPlugins = await prisma.installedPlugin.findMany({ where: { botId } });
+            archive.append(JSON.stringify(installedPlugins, null, 2), { name: 'plugins.json' });
+
+            if (includePluginFiles === 'true') {
+                for (const plugin of installedPlugins) {
+                    const pluginPath = plugin.path;
+                    if (await fs.stat(pluginPath).then(s => s.isDirectory()).catch(() => false)) {
+                        archive.directory(pluginPath, `plugins/${plugin.name}`);
+                    }
+                }
+            }
+            if (includePluginDataStore === 'true') {
+                console.log(`[Export] Экспорт PluginDataStore для бота ${botId}`);
+                const pluginDataStore = await prisma.pluginDataStore.findMany({ 
+                    where: { botId: parseInt(botId) } 
+                });
+                console.log(`[Export] Найдено записей PluginDataStore: ${pluginDataStore.length}`);
+                if (pluginDataStore.length > 0) {
+                    archive.append(JSON.stringify(pluginDataStore, null, 2), { name: 'plugin_data_store.json' });
+                    console.log(`[Export] Данные PluginDataStore добавлены в архив`);
+                } else {
+                    console.log(`[Export] Нет данных PluginDataStore для экспорта`);
+                }
+            }
+        }
+
+        await archive.finalize();
+
+    } catch (error) {
+        console.error('Failed to export bot:', error);
+        res.status(500).json({ error: `Failed to export bot: ${error.message}` });
+    }
+});
+
+router.post('/import', authorize('bot:create'), upload.single('file'), async (req, res) => {
+    if (!req.file) {
+        return res.status(400).json({ error: 'No file uploaded.' });
+    }
+
+    const botIdMap = new Map();
+
+    try {
+        const zip = new AdmZip(req.file.buffer);
+        const zipEntries = zip.getEntries();
+
+        const botDataEntry = zipEntries.find(e => e.entryName === 'bot.json');
+        if (!botDataEntry) {
+            return res.status(400).json({ error: 'Archive missing bot.json' });
+        }
+        const botData = JSON.parse(botDataEntry.getData().toString('utf8'));
+
+        const server = await prisma.server.findFirst();
+        if (!server) {
+            return res.status(500).json({ error: 'No servers configured in the target system.' });
+        }
+
+        let newBotName = botData.username;
+        let counter = 1;
+        while (await prisma.bot.findFirst({ where: { username: newBotName } })) {
+            newBotName = `${botData.username}_imported_${counter}`;
+            counter++;
+        }
+
+        const newBot = await prisma.bot.create({
+            data: {
+                ...botData,
+                id: undefined, 
+                username: newBotName,
+                serverId: server.id, 
+                password: null, 
+                proxyPassword: null
+            },
+            include: { server: true }
+        });
+        
+        botIdMap.set(botData.id, newBot.id);
+
+        const commandsEntry = zipEntries.find(e => e.entryName === 'commands.json');
+        if (commandsEntry) {
+            const commands = JSON.parse(commandsEntry.getData().toString('utf8'));
+            for (let command of commands) {
+                delete command.id;
+                command.botId = newBot.id;
+                await prisma.command.create({ data: command });
+            }
+        }
+
+        const permissionsEntry = zipEntries.find(e => e.entryName === 'permissions.json');
+        if (permissionsEntry) {
+            const { users, groups, permissions } = JSON.parse(permissionsEntry.getData().toString('utf8'));
+            
+            await setupDefaultPermissionsForBot(newBot.id, prisma);
+            
+            const pMap = new Map();
+            for(let p of permissions.filter(p=>p.owner !== 'system')) {
+                const newP = await prisma.permission.create({ data: { ...p, id: undefined, botId: newBot.id }});
+                pMap.set(p.id, newP.id);
+            }
+
+            const gMap = new Map();
+            for(let g of groups.filter(g=>g.owner !== 'system')) {
+                const newG = await prisma.group.create({ data: { ...g, id: undefined, botId: newBot.id, permissions: {
+                    create: g.permissions.map(gp => ({ permissionId: pMap.get(gp.permissionId) })).filter(p=>p.permissionId)
+                }}});
+                gMap.set(g.id, newG.id);
+            }
+            
+            for(let u of users) {
+                await prisma.user.create({ data: { ...u, id: undefined, botId: newBot.id, groups: {
+                    create: u.groups.map(ug => ({ groupId: gMap.get(ug.groupId) })).filter(g=>g.groupId)
+                }}});
+            }
+        }
+        
+        const eventGraphsEntry = zipEntries.find(e => e.entryName === 'event_graphs.json');
+        if (eventGraphsEntry) {
+            const eventGraphs = JSON.parse(eventGraphsEntry.getData().toString('utf8'));
+            for (let graph of eventGraphs) {
+                delete graph.id;
+                graph.botId = newBot.id;
+                await prisma.eventGraph.create({ data: graph });
+            }
+        }
+
+        const pluginDataStoreEntry = zipEntries.find(e => e.entryName === 'plugin_data_store.json');
+        if (pluginDataStoreEntry) {
+            console.log(`[Import] Импорт PluginDataStore для бота ${newBot.id}`);
+            const pluginDataStore = JSON.parse(pluginDataStoreEntry.getData().toString('utf8'));
+            console.log(`[Import] Найдено записей PluginDataStore: ${pluginDataStore.length}`);
+            
+            for (let dataRecord of pluginDataStore) {
+                delete dataRecord.id;
+                dataRecord.botId = newBot.id;
+                await prisma.pluginDataStore.create({ data: dataRecord });
+            }
+            console.log(`[Import] PluginDataStore успешно импортирован`);
+        }
+
+        const pluginsEntry = zipEntries.find(e => e.entryName === 'plugins.json');
+        if (pluginsEntry) {
+            const plugins = JSON.parse(pluginsEntry.getData().toString('utf8'));
+            const pluginsDir = path.join(os.homedir(), '.blockmine', 'storage', 'plugins');
+            const botPluginsDir = path.join(pluginsDir, newBot.username);
+            await fs.mkdir(botPluginsDir, { recursive: true });
+
+            for (let pluginData of plugins) {
+                const oldPath = pluginData.path;
+                const pluginName = pluginData.name;
+                const newPluginPath = path.join(botPluginsDir, pluginName);
+
+                delete pluginData.id;
+                pluginData.botId = newBot.id;
+                pluginData.path = path.resolve(newPluginPath);
+                
+                for (const entry of zipEntries) {
+                    if (entry.entryName.startsWith(`plugins/${pluginName}/`)) {
+                        const relativePath = entry.entryName.replace(`plugins/${pluginName}/`, '');
+                        if (relativePath) {
+                            const destPath = path.join(newPluginPath, relativePath);
+                            const destDir = path.dirname(destPath);
+                            await fs.mkdir(destDir, { recursive: true });
+                            
+                            if (!entry.isDirectory) {
+                                await fs.writeFile(destPath, entry.getData());
+                            }
+                        }
+                    }
+                }
+                
+                await prisma.installedPlugin.create({ data: pluginData });
+            }
+        }
+        
+        res.status(201).json(newBot);
+
+    } catch (error) {
+        console.error('Failed to import bot:', error);
+        res.status(500).json({ error: `Failed to import bot: ${error.message}` });
+    }
+});
+
 module.exports = router;

package/backend/src/core/BotManager.js

@@ -727,7 +727,20 @@ class BotManager {
         const child = this.bots.get(botId);
         if (child) {
             this.eventGraphManager.unloadGraphsForBot(botId);
+            
             child.send({ type: 'stop' });
+            
+            setTimeout(() => {
+                if (!child.killed) {
+                    console.log(`[BotManager] Принудительное завершение процесса бота ${botId}`);
+                    try {
+                        child.kill('SIGKILL');
+                    } catch (error) {
+                        console.error(`[BotManager] Ошибка при принудительном завершении бота ${botId}:`, error);
+                    }
+                }
+            }, 5000);
+            
             this.botConfigs.delete(botId);
             return { success: true };
         }

package/backend/src/core/BotProcess.js

@@ -20,6 +20,7 @@ const prisma = new PrismaClient();
 const pluginUiState = new Map();
 const pendingRequests = new Map();
 const entityMoveThrottles = new Map();
+let connectionTimeout = null;
 
 function sendLog(content) {
     if (process.send) {
@@ -202,6 +203,13 @@ process.on('message', async (message) => {
 
             bot = mineflayer.createBot(botOptions);
 
+            connectionTimeout = setTimeout(() => {
+                if (bot && !bot.player) {
+                    sendLog('[System] Таймаут подключения к серверу (30 секунд). Завершение работы...');
+                    process.exit(1);
+                }
+            }, 30000);
+
             bot.pluginUiState = pluginUiState;
 
             let isReady = false;
@@ -489,6 +497,10 @@ process.on('message', async (message) => {
             });
             
             bot.on('login', () => {
+                if (connectionTimeout) {
+                    clearTimeout(connectionTimeout);
+                    connectionTimeout = null;
+                }
                 sendLog('[Event: login] Успешно залогинился!');
                 if (process.send) {
                     process.send({ type: 'bot_ready' });
@@ -507,9 +519,19 @@ process.on('message', async (message) => {
                 process.exit(0);
             });
 
-            bot.on('error', (err) => sendLog(`[Event: error] Произошла ошибка: ${err.stack || err.message}`));
+            bot.on('error', (err) => {
+                if (connectionTimeout) {
+                    clearTimeout(connectionTimeout);
+                    connectionTimeout = null;
+                }
+                sendLog(`[Event: error] Произошла ошибка: ${err.stack || err.message}`);
+            });
             
             bot.on('end', (reason) => {
+                if (connectionTimeout) {
+                    clearTimeout(connectionTimeout);
+                    connectionTimeout = null;
+                }
                 sendLog(`[Event: end] Отключен от сервера. Причина: ${reason}`);
                 process.exit(0);
             });
@@ -575,6 +597,10 @@ process.on('message', async (message) => {
             sendLog(`[System] Error reloading configuration: ${error.message}`);
         }
     } else if (message.type === 'stop') {
+        if (connectionTimeout) {
+            clearTimeout(connectionTimeout);
+            connectionTimeout = null;
+        }
         if (bot) bot.quit();
         else process.exit(0);
     } else if (message.type === 'chat') {
@@ -653,6 +679,23 @@ process.on('unhandledRejection', (reason, promise) => {
     process.exit(1);
 });
 
+process.on('SIGTERM', () => {
+    sendLog('[System] Получен сигнал SIGTERM. Завершение работы...');
+    if (bot) {
+        try {
+            bot.quit();
+        } catch (error) {
+            sendLog(`[System] Ошибка при корректном завершении бота: ${error.message}`);
+        }
+    }
+    process.exit(0);
+});
+
+process.on('SIGKILL', () => {
+    sendLog('[System] Получен сигнал SIGKILL. Принудительное завершение...');
+    process.exit(0);
+});
+
 function serializeEntity(entity) {
     if (!entity) return null;
     return {

package/backend/src/core/PluginLoader.js

@@ -14,10 +14,12 @@ async function ensurePluginDependencies(pluginPath, pluginName) {
             const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
             if (packageJson.dependencies && Object.keys(packageJson.dependencies).length > 0) {
                 console.log(`[PluginLoader] У плагина ${pluginName} есть зависимости, устанавливаем их...`);
+                const shell = process.platform === 'win32' ? process.env.ComSpec : '/bin/sh';
                 try {
-                    execSync('npm install', { 
-                        cwd: pluginPath, 
-                        stdio: 'pipe' 
+                    execSync('npm install', {
+                        cwd: pluginPath,
+                        stdio: 'pipe',
+                        shell: shell
                     });
                     console.log(`[PluginLoader] Зависимости для плагина ${pluginName} установлены`);
                 } catch (installError) {
@@ -92,10 +94,12 @@ async function initializePlugins(bot, installedPlugins = [], prisma) {
                         if (moduleMatch) {
                             const missingModule = moduleMatch[1];
                             sendLog(`[PluginLoader] Попытка установки недостающего модуля ${missingModule} в папку плагина ${plugin.name}`);
+                            const shell = process.platform === 'win32' ? process.env.ComSpec : '/bin/sh';
                             try {
-                                execSync(`npm install ${missingModule}`, { 
-                                    cwd: plugin.path, 
-                                    stdio: 'pipe' 
+                                execSync(`npm install ${missingModule}`, {
+                                    cwd: plugin.path,
+                                    stdio: 'pipe',
+                                    shell: shell
                                 });
                                 sendLog(`[PluginLoader] Модуль ${missingModule} успешно установлен в папку плагина ${plugin.name}, повторная попытка загрузки`);
                                 

package/commitlint.config.js

@@ -1,3 +1,6 @@
 module.exports = {
-  extends: ['@commitlint/config-conventional']
+  extends: ['@commitlint/config-conventional'],
+  rules: {
+    'header-max-length': [2, 'always', 120]
+  }
 };