blockmine 1.21.0 → 1.23.0

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

@@ -0,0 +1,130 @@
+const express = require('express');
+const router = express.Router();
+const { PrismaClient } = require('@prisma/client');
+const { authenticateUniversal, authorize } = require('../middleware/auth');
+const prisma = new PrismaClient();
+
+router.use(authenticateUniversal);
+
+router.get('/', authorize('proxy:list'), async (req, res) => {
+    try {
+        const proxies = await prisma.proxy.findMany({
+            orderBy: { name: 'asc' },
+            include: {
+                _count: {
+                    select: { bots: true }
+                }
+            }
+        });
+        res.json({
+            items: proxies,
+            total: proxies.length
+        });
+    } catch (error) {
+        console.error("[API /api/proxies] Ошибка получения списка прокси:", error);
+        res.status(500).json({ error: 'Не удалось получить список прокси' });
+    }
+});
+
+router.get('/:id', authorize('proxy:list'), async (req, res) => {
+    try {
+        const proxyId = parseInt(req.params.id, 10);
+        const proxy = await prisma.proxy.findUnique({
+            where: { id: proxyId },
+            include: {
+                _count: {
+                    select: { bots: true }
+                }
+            }
+        });
+        if (!proxy) {
+            return res.status(404).json({ error: 'Прокси не найден' });
+        }
+        res.json(proxy);
+    } catch (error) {
+        console.error("[API /api/proxies/:id] Ошибка получения прокси:", error);
+        res.status(500).json({ error: 'Не удалось получить прокси' });
+    }
+});
+
+router.post('/', authorize('proxy:create'), async (req, res) => {
+    try {
+        const { name, type, host, port, username, password, note } = req.body;
+        if (!name || !host || !port) {
+            return res.status(400).json({ error: 'Имя, хост и порт прокси обязательны' });
+        }
+        if (type && !['socks5', 'http'].includes(type)) {
+            return res.status(400).json({ error: 'Тип прокси должен быть socks5 или http' });
+        }
+        const newProxy = await prisma.proxy.create({
+            data: {
+                name,
+                type: type || 'socks5',
+                host,
+                port: parseInt(port, 10),
+                username: username || null,
+                password: password || null,
+                note: note || null
+            },
+        });
+        res.status(201).json(newProxy);
+    } catch (error) {
+        if (error.code === 'P2002') return res.status(409).json({ error: 'Прокси с таким именем уже существует' });
+        console.error("[API /api/proxies] Ошибка создания прокси:", error);
+        res.status(500).json({ error: 'Не удалось создать прокси' });
+    }
+});
+
+router.put('/:id', authorize('proxy:create'), async (req, res) => {
+    try {
+        const proxyId = parseInt(req.params.id, 10);
+        if (isNaN(proxyId)) return res.status(400).json({ error: 'Некорректный ID прокси' });
+
+        const { name, type, host, port, username, password, note } = req.body;
+
+        if (type && !['socks5', 'http'].includes(type)) {
+            return res.status(400).json({ error: 'Тип прокси должен быть socks5 или http' });
+        }
+
+        const dataToUpdate = {};
+        if (name !== undefined) dataToUpdate.name = name;
+        if (type !== undefined) dataToUpdate.type = type;
+        if (host !== undefined) dataToUpdate.host = host;
+        if (port !== undefined && port !== '') dataToUpdate.port = parseInt(port, 10);
+        if (username !== undefined) dataToUpdate.username = username || null;
+        if (password !== undefined) dataToUpdate.password = password || null;
+        if (note !== undefined) dataToUpdate.note = note || null;
+
+        Object.keys(dataToUpdate).forEach(k => { if (dataToUpdate[k] === undefined) delete dataToUpdate[k]; });
+
+        if (dataToUpdate.name) {
+            const existing = await prisma.proxy.findFirst({ where: { name: dataToUpdate.name, id: { not: proxyId } } });
+            if (existing) return res.status(409).json({ error: 'Прокси с таким именем уже существует' });
+        }
+
+        const updated = await prisma.proxy.update({ where: { id: proxyId }, data: dataToUpdate });
+        res.json(updated);
+    } catch (error) {
+        console.error('[API /api/proxies] Ошибка обновления прокси:', error);
+        res.status(500).json({ error: 'Не удалось обновить прокси' });
+    }
+});
+
+router.delete('/:id', authorize('proxy:delete'), async (req, res) => {
+    try {
+        const proxyId = parseInt(req.params.id, 10);
+
+        const botsUsingProxy = await prisma.bot.count({ where: { proxyId } });
+        if (botsUsingProxy > 0) {
+            return res.status(400).json({ error: `Нельзя удалить прокси, так как он используется ${botsUsingProxy} ботом(ами).` });
+        }
+
+        await prisma.proxy.delete({ where: { id: proxyId } });
+        res.status(204).send();
+    } catch (error) {
+        console.error('[API /api/proxies] Ошибка удаления прокси:', error);
+        res.status(500).json({ error: 'Не удалось удалить прокси' });
+    }
+});
+
+module.exports = router;

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

@@ -1,8 +1,12 @@
 const express = require('express');
+const { authenticate } = require('../middleware/auth');
 const router = express.Router();
 const { PrismaClient } = require('@prisma/client');
 const prisma = new PrismaClient();
 
+// Все роуты требуют аутентификации
+router.use(authenticate);
+
 router.get('/', async (req, res) => {
   const { query } = req.query;
 

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

@@ -1,21 +1,38 @@
 const express = require('express');
 const router = express.Router();
 const { PrismaClient } = require('@prisma/client');
-const { authenticate, authorize } = require('../middleware/auth');
+const { authenticateUniversal, authorize } = require('../middleware/auth');
 const prisma = new PrismaClient();
 
-router.use(authenticate);
+router.use(authenticateUniversal);
 
 router.get('/', authorize('server:list'), async (req, res) => {
     try {
         const servers = await prisma.server.findMany({ orderBy: { name: 'asc' } });
-        res.json(servers);
+        res.json({
+            items: servers,
+            total: servers.length
+        });
     } catch (error) {
         console.error("[API /api/servers] Ошибка получения списка серверов:", error);
         res.status(500).json({ error: 'Не удалось получить список серверов' });
     }
 });
 
+router.get('/:id', authorize('server:list'), async (req, res) => {
+    try {
+        const serverId = parseInt(req.params.id, 10);
+        const server = await prisma.server.findUnique({ where: { id: serverId } });
+        if (!server) {
+            return res.status(404).json({ error: 'Сервер не найден' });
+        }
+        res.json(server);
+    } catch (error) {
+        console.error("[API /api/servers/:id] Ошибка получения сервера:", error);
+        res.status(500).json({ error: 'Не удалось получить сервер' });
+    }
+});
+
 router.post('/', authorize('server:create'), async (req, res) => {
     try {
         const { name, host, port, version } = req.body;

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

@@ -1,10 +1,15 @@
 const express = require('express');
+const { authenticate, authorize } = require('../middleware/auth');
 const router = express.Router();
 const { PrismaClient } = require('@prisma/client');
 const PluginService = require('../../core/PluginService');
 
 const prisma = new PrismaClient();
 
+// Все роуты требуют аутентификации и прав администратора
+router.use(authenticate);
+router.use(authorize('system:settings'));
+
 router.get('/plugin-directories', async (req, res) => {
     try {
         const setting = await prisma.setting.findUnique({

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

@@ -0,0 +1,174 @@
+const express = require('express');
+const { authenticate, authenticateUniversal } = 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', authenticateUniversal, 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', authenticateUniversal, 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/api/routes/traces.js

@@ -0,0 +1,131 @@
+const express = require('express');
+const { authenticate, authorize } = require('../middleware/auth');
+const router = express.Router();
+const { getTraceCollector } = require('../../core/services/TraceCollectorService');
+
+router.use(authenticate);
+
+/**
+ * GET /api/traces/:botId
+ * Получить трассировки для бота
+ */
+router.get('/:botId', authorize('management:view'), async (req, res) => {
+  try {
+    const botId = parseInt(req.params.botId);
+    const { limit, status, graphId } = req.query;
+
+    const options = {
+      limit: limit ? parseInt(limit) : 150,
+      status: status || null,
+      graphId: graphId ? parseInt(graphId) : null,
+    };
+
+    const traceCollector = getTraceCollector();
+    const traces = traceCollector.getTracesForBot(botId, options);
+
+    res.json({
+      success: true,
+      traces,
+    });
+  } catch (error) {
+    console.error('[API /traces/:botId] Ошибка:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message,
+    });
+  }
+});
+
+/**
+ * GET /api/traces/:botId/:traceId
+ * Получить конкретную трассировку по ID
+ */
+router.get('/:botId/:traceId', authorize('management:view'), async (req, res) => {
+  try {
+    const { traceId } = req.params;
+
+    const traceCollector = getTraceCollector();
+    let trace = traceCollector.getTrace(traceId);
+
+    // Если не нашли в памяти, пытаемся загрузить из БД
+    if (!trace) {
+      trace = await traceCollector.loadTraceFromDb(traceId);
+    }
+
+    if (!trace) {
+      return res.status(404).json({
+        success: false,
+        error: 'Трассировка не найдена',
+      });
+    }
+
+    res.json({
+      success: true,
+      trace,
+    });
+  } catch (error) {
+    console.error('[API /traces/:botId/:traceId] Ошибка:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message,
+    });
+  }
+});
+
+/**
+ * GET /api/traces/:botId/graph/:graphId/last
+ * Получить последнюю трассировку для графа
+ * Query params: eventType (опционально) - фильтр по типу события
+ */
+router.get('/:botId/graph/:graphId/last', authorize('management:view'), async (req, res) => {
+  try {
+    const botId = parseInt(req.params.botId);
+    const graphId = parseInt(req.params.graphId);
+    const { eventType } = req.query;
+
+    const traceCollector = getTraceCollector();
+    const trace = await traceCollector.getLastTraceForGraph(botId, graphId, eventType);
+
+    if (!trace) {
+      return res.status(404).json({
+        success: false,
+        error: 'Трассировка не найдена',
+      });
+    }
+
+    res.json({
+      success: true,
+      trace,
+    });
+  } catch (error) {
+    console.error('[API /traces/:botId/graph/:graphId/last] Ошибка:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message,
+    });
+  }
+});
+
+/**
+ * GET /api/traces/stats
+ * Получить статистику трассировок
+ */
+router.get('/stats', authorize('management:view'), async (req, res) => {
+  try {
+    const traceCollector = getTraceCollector();
+    const stats = traceCollector.getStats();
+
+    res.json({
+      success: true,
+      stats,
+    });
+  } catch (error) {
+    console.error('[API /traces/stats] Ошибка:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message,
+    });
+  }
+});
+
+module.exports = router;

package/backend/src/config/debug.config.js

@@ -0,0 +1,36 @@
+/**
+ * Конфигурация для Live Debug системы
+ */
+
+module.exports = {
+    // Таймауты (в миллисекундах)
+    BREAKPOINT_TIMEOUT: 30000,        // 30 секунд - максимальное время ожидания breakpoint response
+    STEP_MODE_TIMEOUT: 30000,         // 30 секунд - максимальное время ожидания step mode response
+    TRACE_CLEANUP_DELAY: 5000,        // 5 секунд - задержка перед удалением completed trace
+
+    // Лимиты
+    MAX_TRACE_STEPS: 10000,           // Максимальное количество шагов в одном trace
+    MAX_COMPLETED_TRACES: 100,        // Максимальное количество хранимых completed traces
+    MAX_OUTPUT_LENGTH: 30000,         // Максимальная длина output при передаче через IPC
+
+    // IPC Message Types (для type safety)
+    IPC_TYPES: {
+        EXECUTE_EVENT_GRAPH: 'execute_event_graph',
+        EXECUTE_HANDLER: 'execute_handler',
+        EXECUTE_COMMAND_REQUEST: 'execute_command_request',
+
+        DEBUG_CHECK_BREAKPOINT: 'debug:check_breakpoint',
+        DEBUG_CHECK_STEP_MODE: 'debug:check_step_mode',
+        DEBUG_BREAKPOINT_RESPONSE: 'debug:breakpoint_response',
+
+        TRACE_COMPLETED: 'trace:completed',
+        TRACE_ERROR: 'trace:error',
+    },
+
+    // Debug Session
+    DEBUG_SESSION_IDLE_TIMEOUT: 300000, // 5 минут - таймаут неактивной debug сессии
+
+    // Trace Storage
+    TRACE_RETENTION_TIME: 3600000,    // 1 час - время хранения completed traces
+    ACTIVE_TRACE_MAX_AGE: 600000,     // 10 минут - максимальный возраст active trace
+};

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;