blockmine 1.4.3 → 1.4.4

package/backend/src/core/BotManager.js

@@ -5,7 +5,6 @@ const { PrismaClient } = require('@prisma/client');
 const pidusage = require('pidusage');
 const DependencyService = require('./DependencyService');
 const config = require('../config');
-
 const fs = require('fs');
 const os = require('os');
 const { v4: uuidv4 } = require('uuid');
@@ -35,8 +34,6 @@ class BotManager {
         this.botConfigs = new Map();
 
         setInterval(() => this.updateAllResourceUsage(), 5000);
-        
-
         if (config.telemetry?.enabled) {
             setInterval(() => this.sendHeartbeat(), 5 * 60 * 1000);
         }
@@ -49,13 +46,11 @@ class BotManager {
                 prisma.command.findMany({ where: { botId } }),
                 prisma.permission.findMany({ where: { botId } }),
             ]);
-            
             const config = {
                 commands: new Map(commands.map(cmd => [cmd.name, cmd])),
                 permissionsById: new Map(permissions.map(p => [p.id, p])),
                 commandAliases: new Map()
             };
-
             for (const cmd of commands) {
                 const aliases = JSON.parse(cmd.aliases || '[]');
                 for (const alias of aliases) {
@@ -81,7 +76,6 @@ class BotManager {
 
     triggerHeartbeat() {
         if (!config.telemetry?.enabled) return;
-
         if (this.heartbeatDebounceTimer) {
             clearTimeout(this.heartbeatDebounceTimer);
         }
@@ -105,7 +99,6 @@ class BotManager {
 
     async sendHeartbeat() {
         if (!config.telemetry?.enabled) return;
-
         if (!instanceId) return;
 
         try {
@@ -131,7 +124,6 @@ class BotManager {
                 return;
             }
             const { challenge, difficulty, prefix } = await challengeRes.json();
-
             let nonce = 0;
             let hash = '';
             do {
@@ -150,7 +142,6 @@ class BotManager {
                     nonce: nonce
                 })
             });
-
         } catch (error) {
             console.error(`[Telemetry] Не удалось отправить heartbeat: ${error.message}`);
         }
@@ -170,7 +161,6 @@ class BotManager {
           "User": ["user.say"],
           "Admin": ["admin.*", "admin.cooldown.bypass", "user.cooldown.bypass", "user.*"]
         };
-        
         console.log(`[Permission Sync] Синхронизация системных прав для бота ID ${botId}...`);
 
         for (const perm of systemPermissions) {
@@ -218,7 +208,6 @@ class BotManager {
 
         const pids = Array.from(this.bots.values()).map(child => child.pid).filter(Boolean);
         if (pids.length === 0) return;
-        
         try {
             const stats = await pidusage(pids);
             const usageData = [];
@@ -237,7 +226,6 @@ class BotManager {
                 }
             }
             getIO().emit('bots:usage', usageData);
-
         } catch (error) {
         }
     }
@@ -291,18 +279,15 @@ class BotManager {
 
         await this._syncSystemPermissions(botConfig.id);
         await this.loadConfigForBot(botConfig.id);
-
         this.logCache.set(botConfig.id, []);
         this.emitStatusUpdate(botConfig.id, 'starting', '');
 
         const allPluginsForBot = await prisma.installedPlugin.findMany({
             where: { botId: botConfig.id },
         });
-
         const enabledPlugins = allPluginsForBot.filter(p => p.isEnabled);
 
         const { sortedPlugins, pluginInfo, hasCriticalIssues } = DependencyService.resolveDependencies(enabledPlugins, allPluginsForBot);
-
         if (hasCriticalIssues) {
             this.appendLog(botConfig.id, '[DependencyManager] Обнаружены критические проблемы с зависимостями:');
             for (const plugin of Object.values(pluginInfo)) {
@@ -328,20 +313,16 @@ class BotManager {
         }
 
         const fullBotConfig = { ...decryptedConfig, plugins: sortedPlugins };
-        
         const botProcessPath = path.resolve(__dirname, 'BotProcess.js');
         const child = fork(botProcessPath, [], { stdio: ['pipe', 'pipe', 'pipe', 'ipc'] });
 
         child.botConfig = botConfig;
-
         child.on('error', (err) => {
             this.appendLog(botConfig.id, `[PROCESS FATAL] КРИТИЧЕСКАЯ ОШИБКА ПРОЦЕССА: ${err.stack}`);
         });
-
         child.stderr.on('data', (data) => {
             this.appendLog(botConfig.id, `[STDERR] ${data.toString()}`);
         });
-
         child.on('message', async (message) => {
             if (message.type === 'log') {
                 this.appendLog(botConfig.id, message.content);
@@ -351,9 +332,48 @@ class BotManager {
                 await this.handleCommandValidation(botConfig, message);
             } else if (message.type === 'register_command') {
                 await this.handleCommandRegistration(botConfig.id, message.commandConfig);
+            } else if (message.type === 'request_user_action') {
+                const { requestId, payload } = message;
+                const { targetUsername, action, data } = payload;
+                const botId = botConfig.id;
+            
+                try {
+                    const targetUser = await RealUserService.getUser(targetUsername, botId);
+                    let replyPayload = {};
+            
+                    switch (action) {
+                        case 'toggle_blacklist': {
+                            const isCurrentlyBlacklisted = targetUser.isBlacklisted;
+                            await targetUser.setBlacklist(!isCurrentlyBlacklisted);
+                            replyPayload.newStatus = !isCurrentlyBlacklisted; 
+                            break;
+                        }
+            
+                        case 'toggle_group': {
+                            if (!data.groupName) throw new Error('Название группы не указано.');
+                            const hasGroup = targetUser.hasGroup(data.groupName);
+                            if (hasGroup) {
+                                await targetUser.removeGroup(data.groupName);
+                                replyPayload.actionTaken = 'removed'; 
+                            } else {
+                                await targetUser.addGroup(data.groupName);
+                                replyPayload.actionTaken = 'added'; 
+                            }
+                            break;
+                        }
+            
+                        default:
+                            throw new Error(`Неизвестное действие: ${action}`);
+                    }
+            
+                    child.send({ type: 'user_action_response', requestId, payload: replyPayload });
+            
+                } catch (error) {
+                    console.error(`[BotManager] Ошибка выполнения действия '${action}' для пользователя '${targetUsername}':`, error);
+                    child.send({ type: 'user_action_response', requestId, error: error.message });
+                }
             }
         });
-
         child.on('exit', (code, signal) => {
             const botId = botConfig.id;
             this.bots.delete(botId);
@@ -362,7 +382,6 @@ class BotManager {
             this.emitStatusUpdate(botId, 'stopped', `Процесс завершился с кодом ${code} (сигнал: ${signal || 'none'}).`);
             this.updateAllResourceUsage();
         });
-
         this.bots.set(botConfig.id, child);
         child.send({ type: 'start', config: fullBotConfig });
 
@@ -433,7 +452,6 @@ class BotManager {
             }
 
             child.send({ type: 'execute_handler', commandName: dbCommand.name, username, args, typeChat });
-
         } catch (error) {
             console.error(`[BotManager] Command validation error for botId: ${botId}`, {
                 command: commandName,
@@ -477,18 +495,15 @@ class BotManager {
                 allowedChatTypes: JSON.stringify(commandConfig.allowedChatTypes || []),
                 cooldown: commandConfig.cooldown || 0,
             };
-
             const updateData = {
                 description: commandConfig.description,
                 owner: commandConfig.owner,
             };
-
             await prisma.command.upsert({
                 where: { botId_name: { botId, name: commandConfig.name } },
                 update: updateData,
                 create: createData,
             });
-
             this.invalidateConfigCache(botId);
 
         } catch (error) {

package/backend/src/core/BotProcess.js

@@ -1,7 +1,7 @@
-
 const mineflayer = require('mineflayer');
 const { SocksClient } = require('socks');
 const EventEmitter = require('events');
+const { v4: uuidv4 } = require('uuid');
 const { loadCommands } = require('./system/CommandRegistry');
 const { initializePlugins } = require('./PluginLoader');
 const MessageQueue = require('./MessageQueue');
@@ -12,6 +12,7 @@ const UserService = require('./ipc/UserService.stub.js');
 const PermissionManager = require('./ipc/PermissionManager.stub.js');
 
 let bot = null;
+const pendingRequests = new Map(); 
 
 function sendLog(content) {
     if (process.send) {
@@ -29,8 +30,8 @@ function handleIncomingCommand(type, username, message) {
     const commandName = commandParts.shift().toLowerCase();
     const restOfMessage = commandParts.join(' ');
 
-    const commandInstance = bot.commands.get(commandName) || 
-                            Array.from(bot.commands.values()).find(cmd => cmd.aliases.includes(commandName));
+    const commandInstance = bot.commands.get(commandName) ||
+    Array.from(bot.commands.values()).find(cmd => cmd.aliases.includes(commandName));
 
     if (!commandInstance) return;
 
@@ -90,7 +91,17 @@ function handleIncomingCommand(type, username, message) {
 }
 
 process.on('message', async (message) => {
-    if (message.type === 'start') {
+    if (message.type === 'user_action_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 === 'start') {
         const config = message.config;
         sendLog(`[System] Получена команда на запуск бота ${config.username}...`);
         try {
@@ -130,18 +141,17 @@ process.on('message', async (message) => {
                 }
            } else {
                 sendLog(`[System] Прокси не настроен, используется прямое подключение.`);
-           }
+            }
 
             bot = mineflayer.createBot(botOptions);
 
             bot.events = new EventEmitter();
-            bot.events.setMaxListeners(30); 
+            bot.events.setMaxListeners(30);
             bot.config = config;
             bot.sendLog = sendLog;
             bot.messageQueue = new MessageQueue(bot);
 
             const installedPluginNames = config.plugins.map(p => p.name);
-
             bot.api = {
                 Command: Command,
                 events: bot.events,
@@ -172,17 +182,43 @@ process.on('message', async (message) => {
                         });
                     }
                     sendLog(`[API] Команда "${commandInstance.name}" от плагина "${commandInstance.owner}" зарегистрирована в процессе.`);
+                },
+                performUserAction: (username, action, data = {}) => {
+                    return new Promise((resolve, reject) => {
+                        const requestId = uuidv4();
+                        pendingRequests.set(requestId, { resolve, reject });
+        
+                        if (process.send) {
+                            process.send({
+                                type: 'request_user_action',
+                                requestId,
+                                payload: {
+                                    targetUsername: username,
+                                    action,
+                                    data
+                                }
+                            });
+                        } else {
+                            reject(new Error('IPC channel is not available.'));
+                        }
+        
+                        setTimeout(() => {
+                            if (pendingRequests.has(requestId)) {
+                                reject(new Error('Request to main process timed out.'));
+                                pendingRequests.delete(requestId);
+                            }
+                        }, 5000);
+                    });
                 }
             };
 
             bot.commands = await loadCommands();
-
             if (process.send) {
                 for (const cmd of bot.commands.values()) {
                     process.send({
                         type: 'register_command',
                         commandConfig: {
-                            name: cmd.name,
+                             name: cmd.name,
                             description: cmd.description,
                             aliases: cmd.aliases,
                             owner: cmd.owner,
@@ -207,7 +243,6 @@ process.on('message', async (message) => {
                     handleIncomingCommand(type, username, message);
                 }
             });
-            
             bot.on('message', (jsonMsg) => {
                 const ansiMessage = jsonMsg.toAnsi();
                 if (ansiMessage.trim()) {
@@ -218,39 +253,32 @@ process.on('message', async (message) => {
                 const rawMessageText = jsonMsg.toString();
                 bot.events.emit('core:raw_message', rawMessageText, jsonMsg);
             });
-            
             bot.on('chat', (username, message) => {
                 if (messageHandledByCustomParser) {
                     return;
                 }
                 handleIncomingCommand('chat', username, message);
             });
-
             bot.on('login', () => {
                 sendLog('[Event: login] Успешно залогинился!');
                 if (process.send) {
                     process.send({ type: 'status', status: 'running' });
                 }
             });
-
             bot.on('spawn', () => {
                 sendLog('[Event: spawn] Бот заспавнился в мире. Полностью готов к работе!');
             });
-            
             bot.on('kicked', (reason) => {
                 let reasonText;
                 try { reasonText = JSON.parse(reason).text || reason; } catch (e) { reasonText = reason; }
                 sendLog(`[Event: kicked] Меня кикнули. Причина: ${reasonText}.`);
                 process.exit(0);
             });
-
             bot.on('error', (err) => sendLog(`[Event: error] Произошла ошибка: ${err.stack || err.message}`));
-
             bot.on('end', (reason) => {
                 sendLog(`[Event: end] Отключен от сервера. Причина: ${reason}`);
                 process.exit(0);
             });
-
         } catch (err) {
             sendLog(`[CRITICAL] Критическая ошибка при создании бота: ${err.stack}`);
             process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blockmine",
-  "version": "1.4.3",
+  "version": "1.4.4",
   "description": "Мощная панель управления ботами для Майнкрафта.",
   "author": "merka",
   "license": "MIT",