blockmine 1.20.0 → 1.22.0

package/backend/src/core/services/BotProcessManager.js

@@ -0,0 +1,163 @@
+const { fork } = require('child_process');
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+
+class BotProcessManager {
+    constructor({ logger }) {
+        this.logger = logger;
+        this.processes = new Map(); // botId -> child process
+        this.pendingPlayerListRequests = new Map();
+        this.pendingCommandRequests = new Map();
+        this.uiSubscriptions = new Map(); // botId -> Map<pluginName -> Set<socket>>
+    }
+
+    isRunning(botId) {
+        const child = this.processes.get(botId);
+        return !!(child && !child.killed);
+    }
+
+    getProcess(botId) {
+        return this.processes.get(botId);
+    }
+
+    getAllProcesses() {
+        return this.processes;
+    }
+
+    async spawn(botConfig, fullBotConfig) {
+        const botProcessPath = path.resolve(__dirname, '../BotProcess.js');
+        const child = fork(botProcessPath, [], {
+            stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+            env: {
+                ...process.env,
+                NODE_PATH: path.resolve(__dirname, '../../../node_modules')
+            }
+        });
+
+        child.botConfig = botConfig;
+        this.processes.set(botConfig.id, child);
+
+        return child;
+    }
+
+    sendMessage(botId, message) {
+        const child = this.processes.get(botId);
+        if (child && !child.killed) {
+            child.send(message);
+            return true;
+        }
+        return false;
+    }
+
+    kill(botId, signal = 'SIGTERM') {
+        const child = this.processes.get(botId);
+        if (child && !child.killed) {
+            child.kill(signal);
+            return true;
+        }
+        return false;
+    }
+
+    remove(botId) {
+        this.processes.delete(botId);
+    }
+
+    // Plugin UI subscriptions
+    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);
+        this.logger.info(`Socket ${socket.id} подписался на ${pluginName} для бота ${botId}. Всего: ${pluginSubscribers.size}`);
+
+        this.sendMessage(botId, { 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);
+        this.logger.info(`Socket ${socket.id} отписался от ${pluginName} для бота ${botId}. Осталось: ${pluginSubscribers.size}`);
+
+        if (pluginSubscribers.size === 0) {
+            this.sendMessage(botId, { 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);
+                }
+            });
+        });
+    }
+
+    getPluginSubscribers(botId, pluginName) {
+        return this.uiSubscriptions.get(botId)?.get(pluginName);
+    }
+
+    // Pending requests
+    addPlayerListRequest(requestId, handler) {
+        this.pendingPlayerListRequests.set(requestId, handler);
+    }
+
+    resolvePlayerListRequest(requestId, players) {
+        const request = this.pendingPlayerListRequests.get(requestId);
+        if (request) {
+            clearTimeout(request.timeout);
+            request.resolve(players);
+            this.pendingPlayerListRequests.delete(requestId);
+        }
+    }
+
+    addNearbyEntitiesRequest(requestId, handler) {
+        if (!this.pendingNearbyEntitiesRequests) {
+            this.pendingNearbyEntitiesRequests = new Map();
+        }
+        this.pendingNearbyEntitiesRequests.set(requestId, handler);
+    }
+
+    resolveNearbyEntitiesRequest(requestId, entities) {
+        if (!this.pendingNearbyEntitiesRequests) {
+            this.pendingNearbyEntitiesRequests = new Map();
+        }
+        const request = this.pendingNearbyEntitiesRequests.get(requestId);
+        if (request) {
+            clearTimeout(request.timeout);
+            request.resolve(entities);
+            this.pendingNearbyEntitiesRequests.delete(requestId);
+        }
+    }
+
+    addCommandRequest(requestId, handler) {
+        this.pendingCommandRequests.set(requestId, handler);
+    }
+
+    resolveCommandRequest(requestId, result, error) {
+        const request = this.pendingCommandRequests.get(requestId);
+        if (request) {
+            if (error) {
+                request.reject(new Error(error));
+            } else {
+                request.resolve(result);
+            }
+            this.pendingCommandRequests.delete(requestId);
+        }
+    }
+}
+
+module.exports = BotProcessManager;

package/backend/src/core/services/CacheManager.js

@@ -0,0 +1,111 @@
+const { LRUCache } = require('lru-cache');
+
+class CacheManager {
+    constructor({ commandRepository, permissionRepository, logger } = {}) {
+        // Кеш с TTL и максимальным размером
+        this.tokenCache = new LRUCache({
+            max: 500,
+            ttl: 1000 * 60 * 5, // 5 минут
+        });
+
+        this.playerListCache = new LRUCache({
+            max: 100,
+            ttl: 1000 * 2, // 2 секунды
+        });
+
+        this.botConfigsCache = new Map();
+        
+        // Зависимости для автозагрузки конфигурации
+        this.commandRepository = commandRepository;
+        this.permissionRepository = permissionRepository;
+        this.logger = logger;
+    }
+
+    // Token cache
+    getToken(token) {
+        return this.tokenCache.get(token);
+    }
+
+    setToken(token, data) {
+        this.tokenCache.set(token, data);
+    }
+
+    deleteToken(token) {
+        this.tokenCache.delete(token);
+    }
+
+    // Player list cache
+    getPlayerList(botId) {
+        return this.playerListCache.get(botId);
+    }
+
+    setPlayerList(botId, players) {
+        this.playerListCache.set(botId, players);
+    }
+
+    // Bot config cache
+    getBotConfig(botId) {
+        return this.botConfigsCache.get(botId);
+    }
+
+    setBotConfig(botId, config) {
+        this.botConfigsCache.set(botId, config);
+    }
+
+    deleteBotConfig(botId) {
+        this.botConfigsCache.delete(botId);
+    }
+
+    // Очистка всего кеша для бота
+    clearBotCache(botId) {
+        this.deleteBotConfig(botId);
+        this.playerListCache.delete(botId);
+    }
+
+    /**
+     * Получает конфигурацию бота из кеша или загружает из БД
+     * @param {number} botId - ID бота
+     * @returns {Promise<object>} - Конфигурация бота
+     */
+    async getOrLoadBotConfig(botId) {
+        let config = this.botConfigsCache.get(botId);
+        
+        if (!config) {
+            if (this.logger) {
+                this.logger.debug({ botId }, 'Кеш конфигурации отсутствует, загрузка из БД');
+            }
+            
+            if (!this.commandRepository || !this.permissionRepository) {
+                throw new Error('CacheManager не имеет доступа к репозиториям для загрузки конфигурации');
+            }
+
+            const [commands, permissions] = await Promise.all([
+                this.commandRepository.findByBotId(botId),
+                this.permissionRepository.findByBotId(botId),
+            ]);
+
+            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) {
+                    config.commandAliases.set(alias, cmd.name);
+                }
+            }
+
+            this.botConfigsCache.set(botId, config);
+            
+            if (this.logger) {
+                this.logger.debug({ botId }, 'Конфигурация загружена и закеширована');
+            }
+        }
+
+        return config;
+    }
+}
+
+module.exports = CacheManager;

package/backend/src/core/services/CommandExecutionService.js

@@ -0,0 +1,351 @@
+const { v4: uuidv4 } = require('uuid');
+const UserService = require('../UserService');
+
+// Кулдауны и предупреждения - глобальные для всех инстансов
+const cooldowns = new Map();
+const warningCache = new Map();
+const WARNING_COOLDOWN = 10 * 1000;
+
+class CommandExecutionService {
+    constructor({
+        botProcessManager,
+        cacheManager,
+        eventGraphManager,
+        commandRepository,
+        permissionRepository,
+        groupRepository,
+        logger
+    }) {
+        this.processManager = botProcessManager;
+        this.cache = cacheManager;
+        this.eventGraphManager = eventGraphManager;
+        this.commandRepository = commandRepository;
+        this.permissionRepository = permissionRepository;
+        this.groupRepository = groupRepository;
+        this.logger = logger;
+    }
+
+    async handleCommandValidation(botConfig, message) {
+        const { commandName, username, args, typeChat } = message;
+        const botId = botConfig.id;
+
+        try {
+            // Получаем конфигурацию из кеша или загружаем из БД
+            const botConfigCache = await this.cache.getOrLoadBotConfig(botId);
+
+            const user = await UserService.getUser(username, botId, botConfig);
+
+            const child = this.processManager.getProcess(botId);
+            if (!child) return;
+
+            if (user.isBlacklisted) {
+                child.send({
+                    type: 'handle_blacklist',
+                    commandName,
+                    username,
+                    typeChat
+                });
+                return;
+            }
+
+            const mainCommandName = botConfigCache.commandAliases.get(commandName) || commandName;
+            const dbCommand = botConfigCache.commands.get(mainCommandName);
+
+            if (!dbCommand || (!dbCommand.isEnabled && !user.isOwner)) {
+                return;
+            }
+
+            const allowedTypes = JSON.parse(dbCommand.allowedChatTypes || '[]');
+            if (!allowedTypes.includes(typeChat) && !user.isOwner) {
+                if (typeChat === 'global') return;
+                child.send({
+                    type: 'handle_wrong_chat',
+                    commandName: dbCommand.name,
+                    username,
+                    typeChat
+                });
+                return;
+            }
+
+            const permission = dbCommand.permissionId ? botConfigCache.permissionsById.get(dbCommand.permissionId) : null;
+            if (permission && !user.hasPermission(permission.name) && !user.isOwner) {
+                child.send({
+                    type: 'handle_permission_error',
+                    commandName: dbCommand.name,
+                    username,
+                    typeChat
+                });
+                return;
+            }
+
+            const domain = (permission?.name || '').split('.')[0] || 'user';
+            const bypassCooldownPermission = `${domain}.cooldown.bypass`;
+
+            if (dbCommand.cooldown > 0 && !user.isOwner && !user.hasPermission(bypassCooldownPermission)) {
+                const cooldownKey = `${botId}:${dbCommand.name}:${user.id}`;
+                const now = Date.now();
+                const lastUsed = cooldowns.get(cooldownKey);
+
+                if (lastUsed && (now - lastUsed < dbCommand.cooldown * 1000)) {
+                    const timeLeft = Math.ceil((dbCommand.cooldown * 1000 - (now - lastUsed)) / 1000);
+                    child.send({
+                        type: 'handle_cooldown',
+                        commandName: dbCommand.name,
+                        username,
+                        typeChat,
+                        timeLeft
+                    });
+                    return;
+                }
+                cooldowns.set(cooldownKey, now);
+            }
+
+            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) {
+            this.logger.error({ botId, command: commandName, username, error }, 'Ошибка валидации команды');
+            this.sendMessageToBot(botId, `Произошла внутренняя ошибка при выполнении команды.`, 'private', username);
+        }
+    }
+
+    async validateAndExecuteCommandForApi(botId, username, commandName, args) {
+        const botConfig = this.processManager.getProcess(botId)?.botConfig;
+        if (!botConfig) {
+            throw new Error('Bot configuration not found.');
+        }
+
+        const typeChat = 'websocket';
+
+        let botConfigCache = this.cache.getBotConfig(botId);
+        if (!botConfigCache) {
+            throw new Error('Bot configuration cache not loaded.');
+        }
+
+        const user = await UserService.getUser(username, botId, botConfig);
+
+        if (user.isBlacklisted) {
+            throw new Error(`User '${username}' is blacklisted.`);
+        }
+
+        const mainCommandName = botConfigCache.commandAliases.get(commandName) || commandName;
+        const dbCommand = botConfigCache.commands.get(mainCommandName);
+
+        if (!dbCommand || (!dbCommand.isEnabled && !user.isOwner)) {
+            throw new Error(`Command '${commandName}' not found or is disabled.`);
+        }
+
+        // WebSocket - универсальный транспорт
+        if (typeChat !== 'websocket') {
+            const allowedTypes = JSON.parse(dbCommand.allowedChatTypes || '[]');
+            if (!allowedTypes.includes(typeChat) && !user.isOwner) {
+                throw new Error(`Command '${commandName}' cannot be used in this chat type.`);
+            }
+        }
+
+        const permission = dbCommand.permissionId ? botConfigCache.permissionsById.get(dbCommand.permissionId) : null;
+        if (permission && !user.hasPermission(permission.name) && !user.isOwner) {
+            throw new Error(`User '${username}' has insufficient permissions.`);
+        }
+
+        const domain = (permission?.name || '').split('.')[0] || 'user';
+        const bypassCooldownPermission = `${domain}.cooldown.bypass`;
+
+        if (dbCommand.cooldown > 0 && !user.isOwner && !user.hasPermission(bypassCooldownPermission)) {
+            const cooldownKey = `${botId}:${dbCommand.name}:${user.id}`;
+            const now = Date.now();
+            const lastUsed = cooldowns.get(cooldownKey);
+
+            if (lastUsed && (now - lastUsed < dbCommand.cooldown * 1000)) {
+                const timeLeft = Math.ceil((dbCommand.cooldown * 1000 - (now - lastUsed)) / 1000);
+                throw new Error(`Command on cooldown for user '${username}'. Please wait ${timeLeft} seconds.`);
+            }
+            cooldowns.set(cooldownKey, now);
+        }
+
+        return this._executeCommandInProcess(botId, dbCommand.name, args, user, typeChat);
+    }
+
+    async _executeCommandInProcess(botId, commandName, args, user, typeChat) {
+        return new Promise((resolve, reject) => {
+            const child = this.processManager.getProcess(botId);
+            if (!child || child.killed) {
+                return reject(new Error('Bot is not running'));
+            }
+
+            const requestId = uuidv4();
+
+            // Таймаут на выполнение команды
+            const timeout = setTimeout(() => {
+                reject(new Error('Command execution timed out.'));
+            }, 10000);
+
+            this.processManager.addCommandRequest(requestId, {
+                resolve: (result) => {
+                    clearTimeout(timeout);
+                    resolve(result);
+                },
+                reject: (error) => {
+                    clearTimeout(timeout);
+                    reject(error);
+                }
+            });
+
+            child.send({
+                type: 'execute_command_request',
+                requestId,
+                payload: {
+                    commandName,
+                    args: args || {},
+                    username: user.username,
+                    typeChat
+                }
+            });
+        });
+    }
+
+    sendMessageToBot(botId, message, chatType = 'command', username = null) {
+        const child = this.processManager.getProcess(botId);
+        if (child && child.api) {
+            child.api.sendMessage(chatType, message, username);
+            return { success: true };
+        }
+        return { success: false, message: 'Бот не найден или не запущен' };
+    }
+
+    async handleCommandRegistration(botId, commandConfig) {
+        try {
+            let permissionId = null;
+
+            if (commandConfig.permissions) {
+                let permission = await this.permissionRepository.findByName(botId, commandConfig.permissions);
+
+                if (!permission) {
+                    permission = await this.permissionRepository.create({
+                        botId,
+                        name: commandConfig.permissions,
+                        description: `Автоматически создано для команды ${commandConfig.name}`,
+                        owner: commandConfig.owner,
+                    });
+                }
+                permissionId = permission.id;
+            }
+
+            const createData = {
+                botId,
+                name: commandConfig.name,
+                description: commandConfig.description,
+                aliases: JSON.stringify(commandConfig.aliases || []),
+                owner: commandConfig.owner,
+                permissionId: permissionId,
+                allowedChatTypes: JSON.stringify(commandConfig.allowedChatTypes || []),
+                cooldown: commandConfig.cooldown || 0,
+            };
+
+            const updateData = {
+                description: commandConfig.description,
+                owner: commandConfig.owner,
+                permissionId: permissionId,
+                aliases: JSON.stringify(commandConfig.aliases || []),
+                allowedChatTypes: JSON.stringify(commandConfig.allowedChatTypes || []),
+                cooldown: commandConfig.cooldown || 0,
+            };
+
+            const existingCommand = await this.commandRepository.findByName(botId, commandConfig.name);
+            if (existingCommand) {
+                await this.commandRepository.update(existingCommand.id, updateData);
+            } else {
+                await this.commandRepository.create(createData);
+            }
+
+            this.cache.deleteBotConfig(botId);
+        } catch (error) {
+            this.logger.error({ botId, commandName: commandConfig.name, error }, 'Ошибка регистрации команды');
+        }
+    }
+
+    async handleGroupRegistration(botId, groupConfig) {
+        try {
+            if (!groupConfig.name || !groupConfig.owner) {
+                this.logger.warn({ botId, groupConfig }, 'Пропущена группа без имени или владельца');
+                return;
+            }
+
+            await this.groupRepository.upsertGroup(botId, groupConfig.name, {
+                owner: groupConfig.owner,
+                description: groupConfig.description || ''
+            });
+
+            this.logger.debug({ botId, groupName: groupConfig.name }, 'Группа зарегистрирована');
+            this.cache.deleteBotConfig(botId);
+        } catch (error) {
+            this.logger.error({ botId, groupName: groupConfig.name, error }, 'Ошибка регистрации группы');
+        }
+    }
+
+    async handlePermissionsRegistration(botId, permissions) {
+        try {
+            for (const perm of permissions) {
+                if (!perm.name || !perm.owner) {
+                    this.logger.warn({ botId, perm }, 'Пропущено право без имени или владельца');
+                    continue;
+                }
+
+                const existing = await this.permissionRepository.findByName(botId, perm.name);
+                if (existing) {
+                    await this.permissionRepository.update(existing.id, { description: perm.description });
+                } else {
+                    await this.permissionRepository.create({
+                        botId,
+                        name: perm.name,
+                        description: perm.description || '',
+                        owner: perm.owner,
+                    });
+                }
+            }
+
+            this.cache.deleteBotConfig(botId);
+        } catch (error) {
+            this.logger.error({ botId, error }, 'Ошибка регистрации прав');
+        }
+    }
+
+    async handleAddPermissionsToGroup(botId, message) {
+        try {
+            const { groupName, permissionNames } = message;
+
+            // Находим группу
+            const group = await this.groupRepository.findByName(botId, groupName);
+            if (!group) {
+                this.logger.warn({ botId, groupName }, 'Группа не найдена');
+                return;
+            }
+
+            // Добавляем каждое право в группу
+            for (const permName of permissionNames) {
+                const permission = await this.permissionRepository.findByName(botId, permName);
+                if (!permission) {
+                    this.logger.warn({ botId, groupName, permName }, 'Право не найдено');
+                    continue;
+                }
+
+                await this.groupRepository.addPermissionToGroup(group.id, permission.id, this.permissionRepository.prisma);
+                this.logger.debug({ botId, groupName, permName }, 'Право добавлено в группу');
+            }
+
+            this.cache.deleteBotConfig(botId);
+        } catch (error) {
+            this.logger.error({ botId, groupName: message.groupName, error }, 'Ошибка добавления прав в группу');
+        }
+    }
+}
+
+module.exports = CommandExecutionService;