blockmine 1.0.0

package/backend/src/core/BotProcess.js

@@ -0,0 +1,233 @@
+
+const mineflayer = require('mineflayer');
+const { SocksClient } = require('socks');
+const EventEmitter = require('events');
+const { loadCommands } = require('./system/CommandRegistry');
+const { initializePlugins } = require('./PluginLoader');
+const MessageQueue = require('./MessageQueue');
+const Command = require('./system/Command');
+const { parseArguments } = require('./system/parseArguments');
+
+const UserService = require('./ipc/UserService.stub.js');
+const PermissionManager = require('./ipc/PermissionManager.stub.js');
+
+let bot = null;
+
+function sendLog(content) {
+    if (process.send) {
+        process.send({ type: 'log', content });
+    } else {
+        console.log(`[ChildProcess Log] ${content}`);
+    }
+}
+
+/**
+ * Анализирует входящее сообщение и отправляет запрос на валидацию команды в главный процесс.
+ */
+async function handleIncomingChat(type, username, message) {
+    if (!message.startsWith(bot.config.prefix || '@')) return;
+
+    const rawMessage = message.slice((bot.config.prefix || '@').length).trim();
+    const commandParts = rawMessage.split(/ +/);
+    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));
+
+    if (!commandInstance) return;
+
+    try {
+        const args = parseArguments(restOfMessage);
+        if (process.send) {
+            process.send({
+                type: 'validate_and_run_command',
+                commandName: commandInstance.name,
+                username,
+                args,
+                typeChat: type
+            });
+        }
+    } catch (e) {
+        sendLog(`[BotProcess] Ошибка парсинга аргументов: ${e.message}`);
+    }
+}
+
+process.on('message', async (message) => {
+    if (message.type === 'start') {
+        const config = message.config;
+        sendLog(`[System] Получена команда на запуск бота ${config.username}...`);
+        try {
+            const botOptions = {
+                host: config.server.host,
+                port: config.server.port,
+                username: config.username,
+                password: config.password,
+                version: config.server.version,
+                auth: 'offline',
+                hideErrors: false,
+            };
+
+            if (config.proxyHost && config.proxyPort) {
+                sendLog(`[System] Используется прокси: ${config.proxyHost}:${config.proxyPort}`);
+                botOptions.connect = (client) => {
+                   SocksClient.createConnection({
+                       proxy: {
+                           host: config.proxyHost,
+                           port: config.proxyPort,
+                           type: 5,
+                           userId: config.proxyUsername,
+                           password: config.proxyPassword
+                       },
+                       command: 'connect',
+                       destination: {
+                           host: config.server.host,
+                           port: config.server.port
+                       }
+                   }).then(info => {
+                       client.setSocket(info.socket);
+                       client.emit('connect');
+                   }).catch(err => {
+                       sendLog(`[Proxy Error] ${err.message}`);
+                       client.emit('error', err);
+                   });
+                }
+           } else {
+                sendLog(`[System] Прокси не настроен, используется прямое подключение.`);
+           }
+
+            bot = mineflayer.createBot(botOptions);
+
+            bot.events = new EventEmitter();
+            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,
+                sendMessage: (type, message, username) => bot.messageQueue.enqueue(type, message, username),
+                sendMessageAndWaitForReply: (command, patterns, timeout) => bot.messageQueue.enqueueAndWait(command, patterns, timeout),
+                getUser: (username) => UserService.getUser(username, bot.config.id, bot.config),
+                registerPermissions: (permissions) => PermissionManager.registerPermissions(bot.config.id, permissions),
+                registerGroup: (groupConfig) => PermissionManager.registerGroup(bot.config.id, groupConfig),
+                addPermissionsToGroup: (groupName, permissionNames) => PermissionManager.addPermissionsToGroup(bot.config.id, groupName, permissionNames),
+                installedPlugins: installedPluginNames,
+                registerCommand: (commandInstance) => {
+                    if (!(commandInstance instanceof Command)) {
+                        throw new Error('registerCommand ожидает экземпляр класса Command.');
+                    }
+                    bot.commands.set(commandInstance.name, commandInstance);
+                    if (process.send) {
+                        process.send({
+                            type: 'register_command',
+                            commandConfig: {
+                                name: commandInstance.name,
+                                description: commandInstance.description,
+                                aliases: commandInstance.aliases,
+                                owner: commandInstance.owner,
+                                permissions: commandInstance.permissions,
+                                cooldown: commandInstance.cooldown,
+                                allowedChatTypes: commandInstance.allowedChatTypes,
+                            }
+                        });
+                    }
+                    sendLog(`[API] Команда "${commandInstance.name}" от плагина "${commandInstance.owner}" зарегистрирована в процессе.`);
+                }
+            };
+
+            bot.commands = await loadCommands();
+            await initializePlugins(bot, config.plugins);
+            sendLog('[System] Все системы инициализированы.');
+
+
+            let messageHandledByCustomParser = false;
+
+            bot.events.on('chat:message', (data) => {
+                if (data && data.username && data.message) {
+                    messageHandledByCustomParser = true;
+                    handleIncomingChat(data.type, data.username, data.message);
+                }
+            });
+
+            bot.on('message', (jsonMsg) => {
+                const ansiMessage = jsonMsg.toAnsi();
+                if (ansiMessage.trim()) {
+                    sendLog(ansiMessage);
+                }
+                
+                messageHandledByCustomParser = false;
+                const rawMessageText = jsonMsg.toString();
+                bot.events.emit('core:raw_message', rawMessageText, jsonMsg);
+            });
+            
+            bot.on('chat', (username, message) => {
+                if (messageHandledByCustomParser) {
+                    return;
+                }
+                
+                handleIncomingChat('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);
+        }
+    } else if (message.type === 'stop') {
+        if (bot) bot.quit();
+        else process.exit(0);
+    } else if (message.type === 'chat') {
+    if (bot && bot.entity) {
+        const { message: msg, chatType, username } = message.payload;
+        bot.messageQueue.enqueue(chatType, msg, username);
+    }
+} else if (message.type === 'execute_handler') {
+        const { commandName, username, args, typeChat } = message;
+        const commandInstance = bot.commands.get(commandName);
+        if (commandInstance) {
+            const fakeUser = { username };
+            commandInstance.handler(bot, typeChat, fakeUser, args).catch(e => {
+                sendLog(`[Handler Error] Ошибка в handler-е команды ${commandName}: ${e.message}`);
+            });
+        }
+    } else if (message.type === 'invalidate_user_cache') {
+        if (message.username && bot && bot.config) {
+            UserService.clearCache(message.username, bot.config.id);
+        }
+    }
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+    const errorMsg = `[FATAL] Необработанная ошибка процесса: ${reason?.stack || reason}`;
+    sendLog(errorMsg);
+    console.error(errorMsg, promise);
+    process.exit(1);
+});

package/backend/src/core/DependencyService.js

@@ -0,0 +1,93 @@
+
+const semver = require('semver');
+
+class DependencyService {
+    /**
+     * Анализирует плагины, разрешает зависимости и возвращает отсортированный список и информацию о проблемах.
+     * @param {Array} enabledPlugins - Массив включенных плагинов (записи из БД).
+     * @param {Array} allBotPlugins - Массив всех плагинов, установленных для бота.
+     * @returns {{sortedPlugins: Array, pluginInfo: Object, hasCriticalIssues: boolean}}
+     */
+    resolveDependencies(enabledPlugins, allBotPlugins) {
+        const pluginMap = new Map(allBotPlugins.map(p => [p.name, p]));
+        const enabledPluginSet = new Set(enabledPlugins.map(p => p.name));
+        const pluginInfo = {};
+        let hasCriticalIssues = false;
+
+        for (const plugin of allBotPlugins) {
+            const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
+            pluginInfo[plugin.id] = {
+                ...plugin,
+                isEnabled: enabledPluginSet.has(plugin.name),
+                issues: [],
+                dependencies: manifest.dependencies ? Object.entries(manifest.dependencies) : [],
+            };
+        }
+
+        for (const plugin of enabledPlugins) {
+            const info = pluginInfo[plugin.id];
+            
+            for (const [depName, depVersion] of info.dependencies) {
+                const dependency = pluginMap.get(depName);
+                let issue = null;
+
+                if (!dependency) {
+                    issue = { type: 'missing_dependency', message: `Требуемый плагин "${depName}" не найден.` };
+                    hasCriticalIssues = true;
+                } else if (!enabledPluginSet.has(depName)) {
+                    issue = { type: 'disabled_dependency', message: `Требуемый плагин "${depName}" отключен.` };
+                } else if (!semver.satisfies(dependency.version, depVersion)) {
+                    issue = { type: 'version_mismatch', message: `Требуется версия "${depVersion}" для "${depName}", но найдена v${dependency.version}.` };
+                    hasCriticalIssues = true;
+                }
+                if (issue) info.issues.push(issue);
+            }
+        }
+        
+        const sorted = [];
+        const visited = new Set();
+        const visiting = new Set();
+
+        function visit(pluginName) {
+            if (visited.has(pluginName)) return;
+            if (visiting.has(pluginName)) {
+                hasCriticalIssues = true;
+                const cyclePath = Array.from(visiting).join(' -> ') + ` -> ${pluginName}`;
+                for (const p of enabledPlugins) {
+                    if (visiting.has(p.name)) {
+                        pluginInfo[p.id].issues.push({ type: 'circular_dependency', message: `Обнаружена циклическая зависимость: ${cyclePath}` });
+                    }
+                }
+                return;
+            }
+            
+            visiting.add(pluginName);
+
+            const plugin = pluginMap.get(pluginName);
+            if (plugin) {
+                const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
+                if (manifest.dependencies) {
+                    for (const depName in manifest.dependencies) {
+                        if (enabledPluginSet.has(depName)) {
+                            visit(depName);
+                        }
+                    }
+                }
+            }
+            
+            visiting.delete(pluginName);
+            visited.add(pluginName);
+            if (plugin) {
+                sorted.push(plugin);
+            }
+        }
+
+        for (const plugin of enabledPlugins) {
+            visit(plugin.name);
+        }
+
+        return { sortedPlugins: sorted, pluginInfo, hasCriticalIssues };
+    }
+}
+
+module.exports = new DependencyService();

package/backend/src/core/MessageQueue.js

@@ -0,0 +1,126 @@
+class MessageQueue {
+    constructor(bot) {
+        this.bot = bot;
+        this.queue = [];
+        this.isProcessing = false;
+
+        this.lastGlobalSendTime = 0;
+        this.minGlobalDelay = 350; 
+
+        this.lastSendTimes = {};
+        this.chatTypes = {
+            command: { prefix: '', delay: 400 },
+            chat: { prefix: '', delay: 1000 },
+            private: { prefix: '/msg ', delay: 1000 },
+        };
+        Object.keys(this.chatTypes).forEach(type => {
+            this.lastSendTimes[type] = 0;
+        });
+    }
+
+    registerChatType(typeName, config) {
+        this.chatTypes[typeName] = config;
+        this.lastSendTimes[typeName] = 0;
+    }
+
+    _enqueue(task) {
+        this.queue.push(task);
+        if (!this.isProcessing) {
+            this._processNext();
+        }
+    }
+
+    enqueue(chatType, message, username = null) {
+        const typeConfig = this.chatTypes[chatType];
+        if (!typeConfig) return;
+        this._enqueue({ type: 'simple', chatType, ...typeConfig, message, username });
+    }
+
+    enqueueAndWait(command, patterns, timeout) {
+        return new Promise((resolve, reject) => {
+            const typeConfig = this.chatTypes['command'];
+            this._enqueue({
+                type: 'waitable', chatType: 'command', ...typeConfig,
+                message: command, patterns, timeout, resolve, reject,
+            });
+        });
+    }
+
+    async _processNext() {
+        if (this.queue.length === 0) {
+            this.isProcessing = false;
+            return;
+        }
+
+        this.isProcessing = true;
+        const task = this.queue.shift();
+
+        try {
+            const now = Date.now();
+
+            const timeSinceGlobal = now - this.lastGlobalSendTime;
+            const globalDelayNeeded = this.minGlobalDelay - timeSinceGlobal;
+
+            const lastSent = this.lastSendTimes[task.chatType] || 0;
+            const timeSinceType = now - lastSent;
+            const typeDelayNeeded = (task.delay || 0) - timeSinceType;
+
+            const finalDelay = Math.max(globalDelayNeeded, typeDelayNeeded);
+
+            if (finalDelay > 0) {
+                await new Promise(resolve => setTimeout(resolve, finalDelay));
+            }
+
+            const sendTime = Date.now();
+            this.lastGlobalSendTime = sendTime;
+            this.lastSendTimes[task.chatType] = sendTime;
+
+            if (task.type === 'waitable') {
+                await this._handleWaitableTask(task);
+            } else {
+                let fullMessage;
+                if (task.chatType === 'private' && task.username) {
+                    fullMessage = `/msg ${task.username} ${task.message}`;
+                } else if (task.chatType === 'clan') {
+                    fullMessage = `/cc ${task.message}`;
+                } else if (task.chatType === 'global') {
+                    fullMessage = `!${task.message}`;
+                } else {
+                    fullMessage = task.message;
+                }
+                this.bot.chat(fullMessage);
+            }
+        } catch (error) {
+            if (task.type === 'waitable' && task.reject) task.reject(error);
+        } finally {
+            this._processNext();
+        }
+    }
+
+    _handleWaitableTask(task) {
+        return new Promise((resolve, reject) => {
+            let timeoutId;
+            const listener = (rawMessageText) => {
+                for (const pattern of task.patterns) {
+                    const match = rawMessageText.match(pattern);
+                    if (match) {
+                        this.bot.events.removeListener('core:raw_message', listener);
+                        clearTimeout(timeoutId);
+                        task.resolve(match);
+                        resolve();
+                        return;
+                    }
+                }
+            };
+            this.bot.events.on('core:raw_message', listener);
+            this.bot.chat(task.message);
+            timeoutId = setTimeout(() => {
+                this.bot.events.removeListener('core:raw_message', listener);
+                task.reject(new Error(`Timeout`));
+                resolve();
+            }, task.timeout);
+        });
+    }
+}
+
+module.exports = MessageQueue;

package/backend/src/core/PermissionManager.js

@@ -0,0 +1,97 @@
+const { PrismaClient } = require('@prisma/client');
+const prisma = new PrismaClient();
+
+class PermissionManager {
+    /**
+     * Регистрирует одно или несколько прав для КОНКРЕТНОГО бота.
+     * @param {number} botId - ID бота, для которого регистрируются права.
+     * @param {Array<object>} permissions - Массив объектов прав.
+     */
+    async registerPermissions(botId, permissions) {
+        for (const perm of permissions) {
+            if (!perm.name || !perm.owner) {
+                console.warn('[PermissionManager] Пропущено право без имени или владельца:', perm);
+                continue;
+            }
+            await prisma.permission.upsert({
+                where: { botId_name: { botId, name: perm.name } },
+                update: { description: perm.description },
+                create: {
+                    botId,
+                    name: perm.name,
+                    description: perm.description || '',
+                    owner: perm.owner,
+                },
+            });
+        }
+    }
+
+
+    /**
+     * Добавляет права к уже существующей группе.
+     * @param {number} botId - ID бота.
+     * @param {string} groupName - Имя группы, которую нужно обновить.
+     * @param {Array<string>} permissionNames - Массив имен прав для добавления.
+     */
+    async addPermissionsToGroup(botId, groupName, permissionNames) {
+        const group = await prisma.group.findUnique({
+            where: { botId_name: { botId, name: groupName } }
+        });
+
+        if (!group) {
+            console.warn(`[PermissionManager] Попытка добавить права в несуществующую группу "${groupName}" для бота ID ${botId}.`);
+            return;
+        }
+
+        for (const permName of permissionNames) {
+            const permission = await prisma.permission.findUnique({
+                where: { botId_name: { botId, name: permName } }
+            });
+
+            if (permission) {
+                await prisma.groupPermission.upsert({
+                    where: { groupId_permissionId: { groupId: group.id, permissionId: permission.id } },
+                    update: {},
+                    create: { groupId: group.id, permissionId: permission.id },
+                });
+            } else {
+                console.warn(`[PermissionManager] Право "${permName}" не найдено для бота ID ${botId} при добавлении в группу "${groupName}".`);
+            }
+        }
+    }
+
+    /**
+     * Регистрирует группу для КОНКРЕТНОГО бота и привязывает к ней права.
+     * @param {number} botId - ID бота, для которого регистрируется группа.
+     * @param {object} groupConfig - Конфигурация группы.
+     */
+    async registerGroup(botId, groupConfig) {
+        if (!groupConfig.name || !groupConfig.owner) {
+            console.warn('[PermissionManager] Пропущена группа без имени или владельца:', groupConfig);
+            return;
+        }
+
+        const group = await prisma.group.upsert({
+            where: { botId_name: { botId, name: groupConfig.name } },
+            update: {},
+            create: { botId, name: groupConfig.name, owner: groupConfig.owner },
+        });
+
+        if (groupConfig.permissions && groupConfig.permissions.length > 0) {
+            for (const permName of groupConfig.permissions) {
+                const permission = await prisma.permission.findUnique({ where: { botId_name: { botId, name: permName } } });
+                if (permission) {
+                    await prisma.groupPermission.upsert({
+                        where: { groupId_permissionId: { groupId: group.id, permissionId: permission.id } },
+                        update: {},
+                        create: { groupId: group.id, permissionId: permission.id },
+                    });
+                } else {
+                    console.warn(`[PermissionManager] Право "${permName}" не найдено для бота ID ${botId} при привязке к группе "${groupConfig.name}".`);
+                }
+            }
+        }
+    }
+}
+
+module.exports = new PermissionManager();

package/backend/src/core/PluginLoader.js

@@ -0,0 +1,64 @@
+
+const path = require('path');
+const fs = require('fs/promises');
+
+async function initializePlugins(bot, installedPlugins = []) {
+    if (!installedPlugins || installedPlugins.length === 0) return;
+    
+    const sendLog = bot.sendLog || console.log;
+    sendLog(`[PluginLoader] Загрузка ${installedPlugins.length} плагинов...`);
+
+    for (const plugin of installedPlugins) {
+        if (plugin && plugin.path) {
+            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];
+                        if (config.type === 'json_file' && config.defaultPath) {
+                            const configFilePath = path.join(plugin.path, config.defaultPath);
+                            try {
+                                const fileContent = await fs.readFile(configFilePath, 'utf-8');
+                                defaultSettings[key] = JSON.parse(fileContent);
+                            } catch (e) {
+                                sendLog(`[PluginLoader] WARN: Не удалось прочитать defaultPath '${config.defaultPath}' для плагина ${plugin.name}.`);
+                                defaultSettings[key] = (config.type === 'string[]' || config.type === 'json_file') ? [] : {};
+                            }
+                        } else {
+                            try {
+                                defaultSettings[key] = JSON.parse(config.default || 'null');
+                            } catch {
+                                defaultSettings[key] = config.default;
+                            }
+                        }
+                    }
+                }
+                
+                const finalSettings = { ...defaultSettings, ...savedSettings };
+                
+                const mainFile = manifest.main || 'index.js';
+                const entryPointPath = path.join(plugin.path, mainFile);
+                const normalizedPath = entryPointPath.replace(/\\/g, '/');
+                
+                sendLog(`[PluginLoader] Загрузка: ${plugin.name} (v${plugin.version}) из ${normalizedPath}`);
+                const pluginModule = require(normalizedPath);
+                
+                if (typeof pluginModule === 'function') {
+                    pluginModule(bot, { settings: finalSettings });
+                } else if (pluginModule && typeof pluginModule.onLoad === 'function') {
+                    pluginModule.onLoad(bot, { settings: finalSettings });
+                } else {
+                    sendLog(`[PluginLoader] [ERROR] ${plugin.name} не экспортирует функцию или объект с методом onLoad.`);
+                }
+
+            } catch (error) {
+                sendLog(`[PluginLoader] [FATAL] Не удалось загрузить плагин ${plugin.name}: ${error.stack}`);
+            }
+        }
+    }
+}
+
+module.exports = { initializePlugins };