blockmine 1.21.0 → 1.22.0

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

@@ -12,8 +12,10 @@ const { encrypt } = require('../../core/utils/crypto');
 const { randomUUID } = require('crypto');
 const eventGraphsRouter = require('./eventGraphs');
 const pluginIdeRouter = require('./pluginIde');
+const apiKeysRouter = require('./apiKeys');
 const { deepMergeSettings } = require('../../core/utils/settingsMerger');
 const { checkBotAccess } = require('../middleware/botAccess');
+const { filterSecretSettings, prepareSettingsForSave, isGroupedSettings } = require('../../core/utils/secretsFilter');
 
 const multer = require('multer');
 const archiver = require('archiver');
@@ -328,6 +330,7 @@ router.get('/:id/logs', conditionalListAuth, authenticate, checkBotAccess, (req,
 router.use(authenticate);
 router.use('/:botId/event-graphs', eventGraphsRouter);
 router.use('/:botId/plugins/ide', pluginIdeRouter);
+router.use('/:botId/api-keys', apiKeysRouter);
 
 async function setupDefaultPermissionsForBot(botId, prismaClient = prisma) {
     const initialData = {
@@ -601,9 +604,8 @@ router.get('/:botId/plugins/:pluginId/settings', authenticate, checkBotAccess, a
 		const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
 		const manifestSettings = manifest.settings || {};
 
-
-		const firstSettingValue = Object.values(manifestSettings)[0];
-		const isGrouped = firstSettingValue && typeof firstSettingValue === 'object' && !firstSettingValue.type && firstSettingValue.label;
+		// Определяем тип настроек (обычные или группированные)
+		const isGrouped = isGroupedSettings(manifestSettings);
 
 		const processSetting = async (settingKey, config) => {
 			if (!config || !config.type) return;
@@ -641,7 +643,11 @@ router.get('/:botId/plugins/:pluginId/settings', authenticate, checkBotAccess, a
 		}
 
 		const finalSettings = deepMergeSettings(defaultSettings, savedSettings);
-		res.json(finalSettings);
+		
+		// Фильтруем секретные значения перед отправкой на фронтенд
+		const filteredSettings = filterSecretSettings(finalSettings, manifestSettings, isGrouped);
+		
+		res.json(filteredSettings);
 	} catch (error) {
 		console.error("[API Error] /settings GET:", error);
 		res.status(500).json({ error: 'Не удалось получить настройки плагина' });
@@ -740,12 +746,40 @@ router.put('/:botId/plugins/:pluginId', authenticate, checkBotAccess, authorize(
         const pluginId = parseInt(req.params.pluginId);
         const { isEnabled, settings } = req.body;
         const dataToUpdate = {};
+        
         if (typeof isEnabled === 'boolean') dataToUpdate.isEnabled = isEnabled;
-        if (settings) dataToUpdate.settings = JSON.stringify(settings);
+        
+        if (settings) {
+            // Получаем существующий плагин для обработки секретных значений
+            const plugin = await prisma.installedPlugin.findUnique({ where: { id: pluginId } });
+            if (!plugin) return res.status(404).json({ error: 'Плагин не найден' });
+            
+            const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
+            const existingSettings = plugin.settings ? JSON.parse(plugin.settings) : {};
+            const manifestSettings = manifest.settings || {};
+            
+            // Определяем тип настроек (обычные или группированные)
+            const isGrouped = isGroupedSettings(manifestSettings);
+            
+            // Подготавливаем настройки для сохранения (сохраняем существующие значения для замаскированных секретов)
+            const settingsToSave = prepareSettingsForSave(settings, existingSettings, manifestSettings, isGrouped);
+
+            // Валидация структуры settingsToSave
+            if (!settingsToSave || typeof settingsToSave !== 'object' || Array.isArray(settingsToSave)) {
+                console.error("[Validation Error] prepareSettingsForSave вернул некорректную структуру:", settingsToSave);
+                return res.status(400).json({ error: "Некорректная структура настроек для сохранения" });
+            }
+
+            dataToUpdate.settings = JSON.stringify(settingsToSave);
+        }
+        
         if (Object.keys(dataToUpdate).length === 0) return res.status(400).json({ error: "Нет данных для обновления" });
         const updated = await prisma.installedPlugin.update({ where: { id: pluginId }, data: dataToUpdate });
         res.json(updated);
-    } catch (error) { res.status(500).json({ error: 'Не удалось обновить плагин' }); }
+    } catch (error) { 
+        console.error("[API Error] /plugins/:pluginId PUT:", error);
+        res.status(500).json({ error: 'Не удалось обновить плагин' }); 
+    }
 });
 
 router.get('/:botId/management-data', authenticate, checkBotAccess, authorize('management:view'), async (req, res) => {
@@ -1168,13 +1202,21 @@ router.get('/:id/settings/all', authenticate, checkBotAccess, authorize('bot:upd
                 }
             }
 
+            const mergedSettings = deepMergeSettings(defaultSettings, savedSettings);
+            
+            // Определяем тип настроек (обычные или группированные)
+            const isGrouped = isGroupedSettings(manifest.settings);
+            
+            // Фильтруем секретные значения
+            const filteredSettings = filterSecretSettings(mergedSettings, manifest.settings, isGrouped);
+            
             return {
                 id: plugin.id,
                 name: plugin.name,
                 description: plugin.description,
                 isEnabled: plugin.isEnabled,
                 manifest: manifest,
-                settings: deepMergeSettings(defaultSettings, savedSettings)
+                settings: filteredSettings
             };
         });
 

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

@@ -46,7 +46,8 @@ router.post('/check-updates/:botId', authenticate, authorize('plugin:update'), a
 router.post('/update/:pluginId', authenticate, authorize('plugin:update'), async (req, res) => {
     try {
         const pluginId = parseInt(req.params.pluginId);
-        const updatedPlugin = await pluginManager.updatePlugin(pluginId);
+        const { targetTag } = req.body; // Получаем тег из тела запроса (если указан)
+        const updatedPlugin = await pluginManager.updatePlugin(pluginId, targetTag);
         res.json(updatedPlugin);
     } catch (error) {
         res.status(500).json({ error: error.message });

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

@@ -0,0 +1,174 @@
+const express = require('express');
+const { authenticate } = require('../middleware/auth');
+const os = require('os');
+const pidusage = require('pidusage');
+const rateLimit = require('express-rate-limit');
+
+const router = express.Router();
+
+
+const serverStartTime = Date.now();
+
+/**
+ * Вычисляет системное использование CPU на основе средней загрузки
+ * Избегает состояния гонки, не используя глобальное состояние
+ */
+function getSystemCpuUsage() {
+    // Используем среднюю загрузку системы за 1 минуту
+    const loadAvg = os.loadavg()[0]; // 1-минутное среднее
+    const cpuCount = os.cpus().length;
+    // Конвертируем в процент (loadAvg / cpuCount * 100)
+    const cpuPercentage = Math.round((loadAvg / cpuCount) * 100);
+    return Math.max(0, Math.min(100, cpuPercentage));
+}
+
+/**
+ * @route GET /api/system/health
+ * @desc Получить информацию о здоровье системы
+ * @access Требуется авторизация
+ */
+router.get('/health', authenticate, async (req, res) => {
+    try {
+        const uptime = process.uptime();
+        const serverUptime = (Date.now() - serverStartTime) / 1000;
+        
+        const totalMemory = os.totalmem();
+        const freeMemory = os.freemem();
+        const usedMemory = totalMemory - freeMemory;
+        
+        const cpus = os.cpus();
+        
+        const systemCpuUsage = getSystemCpuUsage();
+        
+        let panelCpu = 0;
+        let panelMemory = 0;
+        try {
+            const stats = await pidusage(process.pid);
+            panelCpu = parseFloat(stats.cpu.toFixed(1));
+            panelMemory = parseFloat((stats.memory / 1024 / 1024).toFixed(1)); // MB
+        } catch (error) {
+            console.error('Ошибка получения статистики процесса:', error);
+        }
+        
+        const platform = process.platform;
+        const arch = process.arch;
+        
+        const platformName = {
+            'win32': 'Windows',
+            'linux': 'Linux',
+            'darwin': 'macOS',
+            'freebsd': 'FreeBSD',
+            'openbsd': 'OpenBSD',
+            'aix': 'AIX'
+        }[platform] || platform;
+        
+        // Форматируем uptime
+        const formatUptime = (seconds) => {
+            const days = Math.floor(seconds / 86400);
+            const hours = Math.floor((seconds % 86400) / 3600);
+            const minutes = Math.floor((seconds % 3600) / 60);
+            
+            if (days > 0) return `${days}д ${hours}ч`;
+            if (hours > 0) return `${hours}ч ${minutes}м`;
+            return `${minutes}м`;
+        };
+
+        let websocketStatus = true;
+        let databaseStatus = true;
+        
+        try {
+            const prisma = req.app.get('prisma') || require('../../lib/prisma');
+            await prisma.$queryRaw`SELECT 1`;
+        } catch (error) {
+            databaseStatus = false;
+        }
+        
+        try {
+            const botManager = req.app.get('botManager');
+            websocketStatus = botManager !== null && botManager !== undefined;
+        } catch (error) {
+            websocketStatus = false;
+        }
+
+        res.json({
+            status: 'ok',
+            uptime: formatUptime(serverUptime),
+            uptimeSeconds: Math.floor(serverUptime),
+            processUptime: formatUptime(uptime),
+            memory: {
+                total: Math.round(totalMemory / 1024 / 1024), // MB
+                free: Math.round(freeMemory / 1024 / 1024), // MB
+                used: Math.round(usedMemory / 1024 / 1024), // MB
+                usedPercent: Math.round((usedMemory / totalMemory) * 100),
+                panel: panelMemory // Память используемая панелью
+            },
+            cpu: {
+                cores: cpus.length,
+                model: cpus[0]?.model || 'Unknown',
+                usage: systemCpuUsage,
+                panelUsage: panelCpu,
+                loadAverage: os.loadavg()
+            },
+            platform: platformName,
+            platformRaw: platform,
+            arch: arch,
+            osRelease: os.release(),
+            hostname: os.hostname(),
+            nodeVersion: process.version,
+            services: {
+                panel: true,
+                websocket: websocketStatus,
+                database: databaseStatus
+            }
+        });
+    } catch (error) {
+        console.error('Error getting system health:', error);
+        res.status(500).json({ 
+            error: 'Failed to get system health',
+            message: error.message 
+        });
+    }
+});
+
+/**
+ * @route GET /api/system/stats
+ * @desc Получить статистику системы
+ * @access Требуется авторизация
+ */
+router.get('/stats', authenticate, async (req, res) => {
+    try {
+        const prisma = req.app.get('prisma') || require('../../lib/prisma');
+        
+        const totalBots = await prisma.bot.count();
+        const totalServers = await prisma.server.count();
+        const totalUsers = await prisma.panelUser.count();
+        
+        const botManager = req.app.get('botManager');
+        let runningBots = 0;
+        
+        if (botManager && botManager.bots) {
+            runningBots = Array.from(botManager.bots.values())
+                .filter(bot => typeof bot.isRunning === 'function' && bot.isRunning())
+                .length;
+        }
+        
+        res.json({
+            bots: {
+                total: totalBots,
+                running: runningBots,
+                stopped: totalBots - runningBots
+            },
+            servers: totalServers,
+            users: totalUsers
+        });
+    } catch (error) {
+        console.error('Error getting system stats:', error);
+        res.status(500).json({ 
+            error: 'Failed to get system stats',
+            message: error.message 
+        });
+    }
+});
+
+module.exports = router;
+

package/backend/src/container.js

@@ -0,0 +1,82 @@
+const { createContainer, asClass, asValue, asFunction } = require('awilix');
+const prisma = require('./lib/prisma');
+const config = require('./config');
+
+// Repositories
+const BotRepository = require('./repositories/BotRepository');
+const CommandRepository = require('./repositories/CommandRepository');
+const EventGraphRepository = require('./repositories/EventGraphRepository');
+const ServerRepository = require('./repositories/ServerRepository');
+const UserRepository = require('./repositories/UserRepository');
+const PluginRepository = require('./repositories/PluginRepository');
+const PermissionRepository = require('./repositories/PermissionRepository');
+const GroupRepository = require('./repositories/GroupRepository');
+
+// Services
+const CacheManager = require('./core/services/CacheManager');
+const BotProcessManager = require('./core/services/BotProcessManager');
+const ResourceMonitorService = require('./core/services/ResourceMonitorService');
+const TelemetryService = require('./core/services/TelemetryService');
+const BotLifecycleService = require('./core/services/BotLifecycleService');
+const CommandExecutionService = require('./core/services/CommandExecutionService');
+
+// Core
+const EventGraphManager = require('./core/EventGraphManager');
+const PluginManager = require('./core/PluginManager');
+
+function createLogger() {
+    return {
+        debug: (...args) => console.log('[DEBUG]', ...args),
+        info: (...args) => console.log('[INFO]', ...args),
+        warn: (...args) => console.warn('[WARN]', ...args),
+        error: (...args) => console.error('[ERROR]', ...args),
+    };
+}
+
+function configureContainer() {
+    const container = createContainer();
+
+    // Infrastructure
+    container.register({
+        prisma: asValue(prisma),
+        config: asValue(config),
+        logger: asFunction(createLogger).singleton(),
+    });
+
+    // Repositories
+    container.register({
+        botRepository: asClass(BotRepository).singleton(),
+        commandRepository: asClass(CommandRepository).singleton(),
+        eventGraphRepository: asClass(EventGraphRepository).singleton(),
+        serverRepository: asClass(ServerRepository).singleton(),
+        userRepository: asClass(UserRepository).singleton(),
+        pluginRepository: asClass(PluginRepository).singleton(),
+        permissionRepository: asClass(PermissionRepository).singleton(),
+        groupRepository: asClass(GroupRepository).singleton(),
+    });
+
+    // Core Services
+    container.register({
+        cacheManager: asClass(CacheManager).singleton(),
+        botProcessManager: asClass(BotProcessManager).singleton(),
+        resourceMonitorService: asClass(ResourceMonitorService).singleton(),
+        telemetryService: asClass(TelemetryService).singleton(),
+    });
+
+    // Managers
+    container.register({
+        pluginManager: asClass(PluginManager).singleton(),
+        // EventGraphManager создаётся без зависимости - botManager передаётся через setter
+        eventGraphManager: asClass(EventGraphManager).singleton(),
+    });
+
+    // High-level Services (зависят от managers)
+    container.register({
+        botLifecycleService: asClass(BotLifecycleService).singleton(),
+        commandExecutionService: asClass(CommandExecutionService).singleton(),
+    });
+
+    return container;
+}
+
+module.exports = configureContainer;