blockmine 1.0.0

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

@@ -0,0 +1,79 @@
+const express = require('express');
+const router = express.Router();
+const { PrismaClient } = require('@prisma/client');
+const prisma = new PrismaClient();
+
+
+router.get('/groups', async (req, res) => {
+    const groups = await prisma.group.findMany({ include: { permissions: { include: { permission: true } } } });
+    res.json(groups);
+});
+
+router.post('/groups', async (req, res) => {
+    const { name, permissionIds } = req.body;
+    const newGroup = await prisma.group.create({
+        data: {
+            name,
+            permissions: {
+                create: permissionIds.map(id => ({ permissionId: id }))
+            }
+        }
+    });
+    res.status(201).json(newGroup);
+});
+
+
+
+router.put('/groups/:id', async (req, res) => {
+    const groupId = parseInt(req.params.id);
+    const { name, permissionIds } = req.body;
+    try {
+        await prisma.$transaction(async (tx) => {
+            await tx.group.update({ where: { id: groupId }, data: { name } });
+            await tx.groupPermission.deleteMany({ where: { groupId } });
+            if (permissionIds && permissionIds.length > 0) {
+                await tx.groupPermission.createMany({
+                    data: permissionIds.map(pid => ({ groupId, permissionId: pid })),
+                });
+            }
+        });
+        res.status(200).send();
+    } catch (error) { res.status(500).json({ error: 'Не удалось обновить группу' }); }
+});
+router.delete('/groups/:id', async (req, res) => {
+    try {
+        await prisma.group.delete({ where: { id: parseInt(req.params.id) } });
+        res.status(204).send();
+    } catch (error) { res.status(500).json({ error: 'Не удалось удалить группу' }); }
+});
+
+router.get('/all', async (req, res) => {
+    const permissions = await prisma.permission.findMany({ orderBy: { name: 'asc' } });
+    res.json(permissions);
+});
+
+
+router.get('/users/:username', async (req, res) => {
+    const user = await prisma.user.findUnique({
+        where: { username: req.params.username },
+        include: { groups: { include: { group: true } } }
+    });
+    if (!user) return res.status(404).json({ error: 'Пользователь не найден' });
+    res.json(user);
+});
+
+router.post('/users/:username/groups', async (req, res) => {
+    const { groupId } = req.body;
+    const user = await prisma.user.upsert({
+        where: { username: req.params.username },
+        update: {},
+        create: { username: req.params.username }
+    });
+    await prisma.userGroup.create({
+        data: { userId: user.id, groupId: parseInt(groupId) }
+    });
+    res.status(201).send();
+});
+
+
+module.exports = router;

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

@@ -0,0 +1,110 @@
+
+const express = require('express');
+const router = express.Router();
+const PluginManager = require('../../core/PluginManager');
+
+const OFFICIAL_CATALOG_URL = "https://raw.githubusercontent.com/blockmineJS/official-plugins-list/main/index.json";
+
+
+const getCacheBustedUrl = (url) => `${url}?t=${new Date().getTime()}`;
+
+
+router.get('/catalog', async (req, res) => {
+    try {
+        const response = await fetch(getCacheBustedUrl(OFFICIAL_CATALOG_URL));
+        
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`[API Error] Failed to fetch catalog from GitHub. Status: ${response.status}, Response: ${errorText}`);
+            throw new Error(`GitHub returned status ${response.status}`);
+        }
+        
+        res.json(await response.json());
+    } catch (error) {
+        console.error(`[API Error] Could not fetch catalog URL. Reason: ${error.message}`);
+        res.status(500).json({ error: 'Не удалось загрузить каталог плагинов.' });
+    }
+});
+
+router.post('/check-updates/:botId', async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId);
+        
+        const catalogResponse = await fetch(getCacheBustedUrl(OFFICIAL_CATALOG_URL));
+        if (!catalogResponse.ok) throw new Error('Не удалось загрузить каталог для проверки обновлений.');
+        const catalog = await catalogResponse.json();
+
+        const updates = await PluginManager.checkForUpdates(botId, catalog);
+        res.json(updates);
+    } catch (error) {
+        console.error("[API Error] /check-updates:", error);
+        res.status(500).json({ error: 'Не удалось проверить обновления.' });
+    }
+});
+
+router.post('/update/:pluginId', async (req, res) => {
+    try {
+        const pluginId = parseInt(req.params.pluginId);
+        const updatedPlugin = await PluginManager.updatePlugin(pluginId);
+        res.json(updatedPlugin);
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+router.get('/catalog/:name', async (req, res) => {
+    try {
+        const pluginName = req.params.name;
+        
+        const catalogResponse = await fetch(getCacheBustedUrl(OFFICIAL_CATALOG_URL));
+        if (!catalogResponse.ok) throw new Error(`Failed to fetch catalog, status: ${catalogResponse.status}`);
+        
+        const catalog = await catalogResponse.json();
+        const pluginInfo = catalog.find(p => p.name === pluginName);
+        
+        if (!pluginInfo) {
+            return res.status(404).json({ error: 'Плагин с таким именем не найден в каталоге.' });
+        }
+
+        let readmeContent = pluginInfo.description || 'Описание для этого плагина не предоставлено.';
+        
+        try {
+            const urlParts = new URL(pluginInfo.repoUrl);
+            const pathParts = urlParts.pathname.split('/').filter(p => p);
+            
+            if (pathParts.length >= 2) {
+                const owner = pathParts[0];
+                const repo = pathParts[1].replace('.git', '');
+
+                const readmeUrls = [
+                    `https://raw.githubusercontent.com/${owner}/${repo}/main/README.md`,
+                    `https://raw.githubusercontent.com/${owner}/${repo}/master/README.md`,
+                    `https://raw.githubusercontent.com/${owner}/${repo}/main/readme.md`,
+                    `https://raw.githubusercontent.com/${owner}/${repo}/master/readme.md`,
+                ];
+
+                for (const url of readmeUrls) {
+                    const readmeResponse = await fetch(getCacheBustedUrl(url));
+                    if (readmeResponse.ok) {
+                        readmeContent = await readmeResponse.text();
+                        break;
+                    }
+                }
+            }
+        } catch (readmeError) {
+            console.error(`[API] Не удалось загрузить README для ${pluginName}:`, readmeError.message);
+        }
+        
+        const finalPluginData = {
+            ...pluginInfo,
+            fullDescription: readmeContent 
+        };
+
+        res.json(finalPluginData);
+    } catch (error) {
+        console.error(`[API Error] /catalog/:name :`, error);
+        res.status(500).json({ error: 'Не удалось загрузить данные плагина.' });
+    }
+});
+
+module.exports = router;

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

@@ -0,0 +1,50 @@
+const express = require('express');
+const router = express.Router();
+const { PrismaClient } = require('@prisma/client');
+const prisma = new PrismaClient();
+
+router.get('/', async (req, res) => {
+    try {
+        const servers = await prisma.server.findMany({ orderBy: { name: 'asc' } });
+        res.json(servers);
+    } catch (error) {
+        res.status(500).json({ error: 'Не удалось получить список серверов' });
+    }
+});
+
+router.post('/', async (req, res) => {
+    try {
+        const { name, host, port, version } = req.body;
+        if (!name || !host || !version) {
+            return res.status(400).json({ error: 'Имя, хост и версия сервера обязательны' });
+        }
+        const newServer = await prisma.server.create({
+            data: { name, host, port: port ? parseInt(port, 10) : 25565, version },
+        });
+        res.status(201).json(newServer);
+    } catch (error) {
+        if (error.code === 'P2002') return res.status(409).json({ error: 'Сервер с таким именем уже существует' });
+        res.status(500).json({ error: 'Не удалось создать сервер' });
+    }
+});
+
+
+
+
+router.delete('/:id', async (req, res) => {
+    try {
+        const serverId = parseInt(req.params.id, 10);
+        
+        const botsOnServer = await prisma.bot.count({ where: { serverId } });
+        if (botsOnServer > 0) {
+            return res.status(400).json({ error: `Нельзя удалить сервер, так как он используется ${botsOnServer} ботом(ами).` });
+        }
+
+        await prisma.server.delete({ where: { id: serverId } });
+        res.status(204).send();
+    } catch (error) {
+        res.status(500).json({ error: 'Не удалось удалить сервер' });
+    }
+});
+
+module.exports = router;

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

@@ -0,0 +1,40 @@
+const express = require('express');
+const router = express.Router();
+const { PrismaClient } = require('@prisma/client');
+const PluginService = require('../../core/PluginService');
+
+const prisma = new PrismaClient();
+
+router.get('/plugin-directories', async (req, res) => {
+    try {
+        const setting = await prisma.setting.findUnique({
+            where: { key: 'plugin_directories' },
+        });
+        res.json(setting?.value || []);
+    } catch (error) {
+        res.status(500).json({ error: 'Не удалось получить настройки директорий' });
+    }
+});
+
+router.post('/plugin-directories', async (req, res) => {
+    try {
+        const { directories } = req.body;
+        if (!Array.isArray(directories)) {
+            return res.status(400).json({ error: 'Ожидался массив директорий' });
+        }
+
+        const updatedSetting = await prisma.setting.upsert({
+            where: { key: 'plugin_directories' },
+            update: { value: directories },
+            create: { key: 'plugin_directories', value: directories },
+        });
+        
+        await PluginService.syncPluginsWithDb();
+
+        res.json(updatedSetting);
+    } catch (error) {
+        res.status(500).json({ error: 'Не удалось сохранить настройки директорий' });
+    }
+});
+
+module.exports = router;

package/backend/src/core/BotManager.js

@@ -0,0 +1,264 @@
+
+const { fork } = require('child_process');
+const path = require('path');
+const { getIO } = require('../real-time/socketHandler');
+const { PrismaClient } = require('@prisma/client');
+const pidusage = require('pidusage');
+const DependencyService = require('./DependencyService');
+
+const RealPermissionManager = require('./PermissionManager');
+const RealUserService = require('./UserService');
+
+const prisma = new PrismaClient();
+const cooldowns = new Map();
+
+class BotManager {
+    constructor() {
+        this.bots = new Map();
+        this.logCache = new Map();
+        this.resourceUsage = new Map();
+        
+        setInterval(() => this.updateAllResourceUsage(), 5000);
+    }
+
+    async updateAllResourceUsage() {
+        if (this.bots.size === 0) {
+            if (this.resourceUsage.size > 0) {
+                this.resourceUsage.clear();
+                getIO().emit('bots:usage', []);
+            }
+            return;
+        }
+
+        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 = [];
+
+            for (const pid in stats) {
+                if (!stats[pid]) continue;
+                const botId = this.getBotIdByPid(parseInt(pid, 10));
+                if (botId) {
+                    const usage = {
+                        botId: botId,
+                        cpu: parseFloat(stats[pid].cpu.toFixed(1)),
+                        memory: parseFloat((stats[pid].memory / 1024 / 1024).toFixed(1)),
+                    };
+                    this.resourceUsage.set(botId, usage);
+                    usageData.push(usage);
+                }
+            }
+            getIO().emit('bots:usage', usageData);
+
+        } catch (error) {
+        }
+    }
+
+    getBotIdByPid(pid) {
+        for (const [botId, child] of this.bots.entries()) {
+            if (child.pid === pid) {
+                return botId;
+            }
+        }
+        return null;
+    }
+
+    getFullState() {
+        const statuses = {};
+        this.bots.forEach((childProcess, botId) => {
+             if (childProcess && !childProcess.killed) {
+                 statuses[botId] = 'running';
+             }
+        });
+        const logs = {};
+        this.logCache.forEach((logArray, botId) => {
+            logs[botId] = logArray;
+        });
+        return { statuses, logs };
+    }
+
+    emitStatusUpdate(botId, status, message = null) {
+        if (message) {
+            this.appendLog(botId, `[SYSTEM] ${message}`);
+        }
+        getIO().emit('bot:status', { botId, status, message });
+    }
+    
+    appendLog(botId, log) {
+        const currentLogs = this.logCache.get(botId) || [];
+        const newLogs = [log, ...currentLogs.slice(0, 499)];
+        this.logCache.set(botId, newLogs);
+        getIO().emit('bot:log', { botId, log });
+    }
+
+    async startBot(botConfig) {
+        if (this.bots.has(botConfig.id)) {
+            const existingProcess = this.bots.get(botConfig.id);
+            if (existingProcess && !existingProcess.killed) {
+                 console.error(`[BotManager] Попытка повторного запуска уже работающего бота ID: ${botConfig.id}. Запуск отменен.`);
+                 this.appendLog(botConfig.id, `[SYSTEM-ERROR] Попытка повторного запуска. Запуск отменен.`);
+                 return { success: false, message: 'Бот уже запущен или запускается.' };
+            }
+        }
+        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 } = DependencyService.resolveDependencies(enabledPlugins, allPluginsForBot);
+
+        let canStart = true;
+        if (Object.values(pluginInfo).some(info => info.issues.length > 0)) {
+            this.appendLog(botConfig.id, '[DependencyManager] Обнаружены проблемы с зависимостями:');
+            for (const plugin of Object.values(pluginInfo)) {
+                if (plugin.issues.length > 0) {
+                    this.appendLog(botConfig.id, `  - Плагин "${plugin.name}":`);
+                    for (const issue of plugin.issues) {
+                        const logMessage = `    - [${issue.type.toUpperCase()}] ${issue.message}`;
+                        this.appendLog(botConfig.id, logMessage);
+                        if (['missing_dependency', 'version_mismatch', 'circular_dependency'].includes(issue.type)) {
+                            canStart = false;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (!canStart) {
+            this.appendLog(botConfig.id, '[DependencyManager] [FATAL] Запуск отменен из-за критических ошибок в зависимостях.');
+            this.emitStatusUpdate(botConfig.id, 'stopped', 'Ошибка зависимостей плагинов.');
+            return { success: false, message: 'Критические ошибки в зависимостях плагинов.' };
+        }
+        
+        const fullBotConfig = { ...botConfig, plugins: sortedPlugins };
+        
+        const botProcessPath = path.resolve(__dirname, 'BotProcess.js');
+        const child = fork(botProcessPath, [], { stdio: ['pipe', 'pipe', 'pipe', 'ipc'] });
+
+        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);
+            } else if (message.type === 'status') {
+                this.emitStatusUpdate(botConfig.id, message.status); 
+            } else if (message.type === 'validate_and_run_command') {
+                await this.handleCommandValidation(botConfig, message);
+            }
+        });
+
+        child.on('exit', (code, signal) => {
+            const botId = botConfig.id;
+            this.bots.delete(botId);
+            this.resourceUsage.delete(botId);
+            this.emitStatusUpdate(botId, 'stopped', `Процесс завершился с кодом ${code} (сигнал: ${signal || 'none'}).`);
+            this.updateAllResourceUsage();
+        });
+
+        this.bots.set(botConfig.id, child);
+        child.send({ type: 'start', config: fullBotConfig });
+        
+        this.appendLog(botConfig.id, '[SYSTEM] Проверка зависимостей пройдена. Запускаем процесс бота...');
+        return { success: true, message: 'Бот запускается' };
+    }
+
+    async handleCommandValidation(botConfig, message) {
+        const { commandName, username, args, typeChat } = message;
+        
+        try {
+            const user = await RealUserService.getUser(username, botConfig.id, botConfig);
+    
+            if (user.isBlacklisted) {
+                return;
+            }
+            
+            const dbCommand = await prisma.command.findUnique({ where: { botId_name: { botId: botConfig.id, name: commandName } } });
+            
+            if (!dbCommand || (!dbCommand.isEnabled && !user.isOwner)) {
+                return;
+            }
+    
+            const allowedTypes = JSON.parse(dbCommand.allowedChatTypes || '[]');
+            if (!allowedTypes.includes(typeChat) && !user.isOwner) {
+                const replyMessage = `Команду ${commandName} нельзя использовать в этом типе чата.`;
+                this.sendMessageToBot(botConfig.id, replyMessage, 'private', username);
+                return;
+            }
+            
+            const permission = dbCommand.permissionId ? await prisma.permission.findUnique({ where: { id: dbCommand.permissionId } }) : null;
+            if (permission && !user.hasPermission(permission.name)) {
+                const replyMessage = `У вас нет прав для выполнения команды ${commandName}.`;
+                this.sendMessageToBot(botConfig.id, replyMessage, typeChat, username);
+                return;
+            }
+    
+            const domain = (permission?.name || '').split('.')[0] || 'user';
+            const bypassCooldownPermission = `${domain}.cooldown.bypass`;
+            if (dbCommand.cooldown > 0 && !user.isOwner && !user.hasPermission(bypassCooldownPermission)) {
+                const cooldownKey = `${botConfig.id}:${commandName}:${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);
+                    const replyMessage = `Команду ${commandName} можно будет использовать через ${timeLeft} сек.`;
+                    this.sendMessageToBot(botConfig.id, replyMessage, typeChat, username);
+                    return;
+                }
+                cooldowns.set(cooldownKey, now);
+            }
+
+            const child = this.bots.get(botConfig.id);
+            if (child) {
+                child.send({ type: 'execute_handler', commandName, username, args, typeChat });
+            }
+
+        } catch (error) {
+            console.error(`[BotManager] Ошибка валидации команды ${commandName}:`, error);
+            const replyMessage = `Произошла внутренняя ошибка при выполнении команды.`;
+            this.sendMessageToBot(botConfig.id, replyMessage, 'private', username);
+        }
+    }
+
+    stopBot(botId) {
+        const child = this.bots.get(botId);
+        if (child) {
+            child.send({ type: 'stop' });
+            return { success: true };
+        }
+        return { success: false, message: 'Бот не найден или уже остановлен' };
+    }
+    
+    sendMessageToBot(botId, message, chatType = 'command', username = null) {
+        const child = this.bots.get(botId);
+        if (child) {
+            // Отправляем объект с полной информацией
+            child.send({ type: 'chat', payload: { message, chatType, username } });
+            return { success: true };
+        }
+        return { success: false, message: 'Бот не найден или не запущен' };
+    }
+
+    invalidateUserCache(botId, username) {
+        RealUserService.clearCache(username, botId);
+        const child = this.bots.get(botId);
+        if (child) {
+            child.send({ type: 'invalidate_user_cache', username });
+        }
+        return { success: true };
+    }
+}
+
+module.exports = new BotManager();