blockmine 1.20.0 → 1.22.0

package/backend/src/__tests__/services/ResourceMonitorService.test.js

@@ -0,0 +1,207 @@
+const ResourceMonitorService = require('../../core/services/ResourceMonitorService');
+
+// Mock pidusage
+jest.mock('pidusage', () => jest.fn());
+const pidusage = require('pidusage');
+
+describe('ResourceMonitorService', () => {
+    let resourceMonitor;
+    let mockProcessManager;
+    let mockLogger;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        mockLogger = {
+            error: jest.fn(),
+            info: jest.fn(),
+        };
+
+        mockProcessManager = {
+            getAllProcesses: jest.fn(() => new Map())
+        };
+
+        resourceMonitor = new ResourceMonitorService({
+            botProcessManager: mockProcessManager,
+            logger: mockLogger
+        });
+    });
+
+    describe('startMonitoring', () => {
+        test('должен запустить мониторинг', () => {
+            jest.useFakeTimers();
+
+            resourceMonitor.startMonitoring(1000);
+
+            expect(resourceMonitor.updateInterval).toBeDefined();
+
+            jest.advanceTimersByTime(1000);
+
+            jest.useRealTimers();
+        });
+
+        test('должен очистить предыдущий интервал', () => {
+            jest.useFakeTimers();
+
+            resourceMonitor.startMonitoring(1000);
+            const firstInterval = resourceMonitor.updateInterval;
+
+            resourceMonitor.startMonitoring(2000);
+            const secondInterval = resourceMonitor.updateInterval;
+
+            expect(firstInterval).not.toBe(secondInterval);
+
+            jest.useRealTimers();
+        });
+    });
+
+    describe('stopMonitoring', () => {
+        test('должен остановить мониторинг', () => {
+            jest.useFakeTimers();
+
+            resourceMonitor.startMonitoring(1000);
+            resourceMonitor.stopMonitoring();
+
+            expect(resourceMonitor.updateInterval).toBeNull();
+
+            jest.useRealTimers();
+        });
+    });
+
+    describe('updateAllResourceUsage', () => {
+        test('должен вернуть пустой массив если нет процессов', async () => {
+            mockProcessManager.getAllProcesses.mockReturnValue(new Map());
+
+            const result = await resourceMonitor.updateAllResourceUsage();
+
+            expect(result).toEqual([]);
+            expect(pidusage).not.toHaveBeenCalled();
+        });
+
+        test('должен обновить статистику для запущенных процессов', async () => {
+            const mockChild1 = { pid: 1234, botConfig: { id: 1 } };
+            const mockChild2 = { pid: 5678, botConfig: { id: 2 } };
+
+            const processes = new Map([
+                [1, mockChild1],
+                [2, mockChild2]
+            ]);
+
+            mockProcessManager.getAllProcesses.mockReturnValue(processes);
+
+            // Mock pidusage response
+            pidusage.mockResolvedValue({
+                1234: { cpu: 15.5, memory: 52428800 }, // 50 MB
+                5678: { cpu: 8.2, memory: 31457280 }   // 30 MB
+            });
+
+            const results = await resourceMonitor.updateAllResourceUsage();
+
+            expect(pidusage).toHaveBeenCalledWith([1234, 5678]);
+            expect(results).toHaveLength(2);
+            expect(results[0]).toEqual({
+                botId: 1,
+                cpu: 15.5,
+                memory: 50
+            });
+            expect(results[1]).toEqual({
+                botId: 2,
+                cpu: 8.2,
+                memory: 30
+            });
+        });
+
+        test('должен обработать ошибку при получении статистики', async () => {
+            const mockChild = { pid: 1234 };
+            mockProcessManager.getAllProcesses.mockReturnValue(new Map([[1, mockChild]]));
+
+            pidusage.mockRejectedValue(new Error('Process not found'));
+
+            const results = await resourceMonitor.updateAllResourceUsage();
+
+            expect(results).toEqual([]);
+            expect(mockLogger.error).toHaveBeenCalled();
+        });
+
+        test('должен игнорировать процессы без PID', async () => {
+            const mockChild = { pid: null };
+            mockProcessManager.getAllProcesses.mockReturnValue(new Map([[1, mockChild]]));
+
+            const results = await resourceMonitor.updateAllResourceUsage();
+
+            expect(results).toEqual([]);
+            expect(pidusage).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('getBotIdByPid', () => {
+        test('должен найти botId по PID', () => {
+            const mockChild1 = { pid: 1234 };
+            const mockChild2 = { pid: 5678 };
+
+            mockProcessManager.getAllProcesses.mockReturnValue(new Map([
+                [1, mockChild1],
+                [2, mockChild2]
+            ]));
+
+            const botId = resourceMonitor.getBotIdByPid(5678);
+
+            expect(botId).toBe(2);
+        });
+
+        test('должен вернуть null если PID не найден', () => {
+            mockProcessManager.getAllProcesses.mockReturnValue(new Map());
+
+            const botId = resourceMonitor.getBotIdByPid(9999);
+
+            expect(botId).toBeNull();
+        });
+    });
+
+    describe('getResourceUsage', () => {
+        test('должен вернуть статистику для бота', () => {
+            resourceMonitor.resourceUsage.set(1, {
+                botId: 1,
+                cpu: 10.5,
+                memory: 45
+            });
+
+            const usage = resourceMonitor.getResourceUsage(1);
+
+            expect(usage).toEqual({
+                botId: 1,
+                cpu: 10.5,
+                memory: 45
+            });
+        });
+
+        test('должен вернуть undefined для несуществующего бота', () => {
+            const usage = resourceMonitor.getResourceUsage(999);
+
+            expect(usage).toBeUndefined();
+        });
+    });
+
+    describe('getAllResourceUsage', () => {
+        test('должен вернуть массив всей статистики', () => {
+            resourceMonitor.resourceUsage.set(1, { botId: 1, cpu: 10, memory: 50 });
+            resourceMonitor.resourceUsage.set(2, { botId: 2, cpu: 5, memory: 30 });
+
+            const all = resourceMonitor.getAllResourceUsage();
+
+            expect(all).toHaveLength(2);
+            expect(all).toContainEqual({ botId: 1, cpu: 10, memory: 50 });
+            expect(all).toContainEqual({ botId: 2, cpu: 5, memory: 30 });
+        });
+    });
+
+    describe('clearResourceUsage', () => {
+        test('должен очистить статистику для бота', () => {
+            resourceMonitor.resourceUsage.set(1, { botId: 1, cpu: 10, memory: 50 });
+
+            resourceMonitor.clearResourceUsage(1);
+
+            expect(resourceMonitor.resourceUsage.has(1)).toBe(false);
+        });
+    });
+});

package/backend/src/__tests__/services/TelemetryService.test.js

@@ -0,0 +1,291 @@
+const TelemetryService = require('../../core/services/TelemetryService');
+const fs = require('fs');
+const path = require('path');
+
+// Mock fs
+jest.mock('fs');
+
+// Mock fetch
+global.fetch = jest.fn();
+
+describe('TelemetryService', () => {
+    let telemetryService;
+    let mockConfig;
+    let mockProcessManager;
+    let mockLogger;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        mockConfig = {
+            telemetry: {
+                enabled: true
+            }
+        };
+
+        mockProcessManager = {
+            getAllProcesses: jest.fn(() => new Map())
+        };
+
+        mockLogger = {
+            debug: jest.fn(),
+            error: jest.fn(),
+            info: jest.fn(),
+        };
+
+        fs.existsSync.mockReturnValue(false);
+        fs.mkdirSync.mockReturnValue(undefined);
+        fs.writeFileSync.mockReturnValue(undefined);
+    });
+
+    describe('loadInstanceId', () => {
+        test('должен создать новый instance ID если файл не существует', () => {
+            fs.existsSync.mockReturnValue(false);
+
+            telemetryService = new TelemetryService({
+                config: mockConfig,
+                botProcessManager: mockProcessManager,
+                logger: mockLogger
+            });
+
+            const instanceId = telemetryService.getInstanceId();
+
+            expect(instanceId).toBeDefined();
+            expect(typeof instanceId).toBe('string');
+            expect(instanceId.length).toBeGreaterThan(0);
+            expect(fs.writeFileSync).toHaveBeenCalled();
+        });
+
+        test('должен загрузить существующий instance ID', () => {
+            const existingId = 'test-uuid-123';
+            fs.existsSync.mockReturnValue(true);
+            fs.readFileSync.mockReturnValue(existingId);
+
+            telemetryService = new TelemetryService({
+                config: mockConfig,
+                botProcessManager: mockProcessManager,
+                logger: mockLogger
+            });
+
+            const instanceId = telemetryService.getInstanceId();
+
+            expect(instanceId).toBe(existingId);
+            expect(fs.writeFileSync).not.toHaveBeenCalled();
+        });
+
+        test('должен обработать ошибку при загрузке', () => {
+            fs.existsSync.mockImplementation(() => {
+                throw new Error('Permission denied');
+            });
+
+            telemetryService = new TelemetryService({
+                config: mockConfig,
+                botProcessManager: mockProcessManager,
+                logger: mockLogger
+            });
+
+            const instanceId = telemetryService.getInstanceId();
+
+            expect(instanceId).toBeNull();
+            expect(mockLogger.error).toHaveBeenCalled();
+        });
+    });
+
+    describe('startHeartbeat', () => {
+        beforeEach(() => {
+            fs.existsSync.mockReturnValue(true);
+            fs.readFileSync.mockReturnValue('test-id');
+
+            telemetryService = new TelemetryService({
+                config: mockConfig,
+                botProcessManager: mockProcessManager,
+                logger: mockLogger
+            });
+        });
+
+        test('должен запустить heartbeat если телеметрия включена', () => {
+            jest.useFakeTimers();
+
+            telemetryService.startHeartbeat(1000);
+
+            expect(telemetryService.heartbeatInterval).toBeDefined();
+
+            jest.useRealTimers();
+        });
+
+        test('не должен запускать heartbeat если телеметрия выключена', () => {
+            mockConfig.telemetry.enabled = false;
+
+            telemetryService = new TelemetryService({
+                config: mockConfig,
+                botProcessManager: mockProcessManager,
+                logger: mockLogger
+            });
+
+            telemetryService.startHeartbeat();
+
+            expect(telemetryService.heartbeatInterval).toBeNull();
+        });
+    });
+
+    describe('stopHeartbeat', () => {
+        beforeEach(() => {
+            fs.existsSync.mockReturnValue(true);
+            fs.readFileSync.mockReturnValue('test-id');
+
+            telemetryService = new TelemetryService({
+                config: mockConfig,
+                botProcessManager: mockProcessManager,
+                logger: mockLogger
+            });
+        });
+
+        test('должен остановить heartbeat', () => {
+            jest.useFakeTimers();
+
+            telemetryService.startHeartbeat(1000);
+            telemetryService.stopHeartbeat();
+
+            expect(telemetryService.heartbeatInterval).toBeNull();
+
+            jest.useRealTimers();
+        });
+    });
+
+    describe('triggerHeartbeat', () => {
+        beforeEach(() => {
+            fs.existsSync.mockReturnValue(true);
+            fs.readFileSync.mockReturnValue('test-id');
+
+            telemetryService = new TelemetryService({
+                config: mockConfig,
+                botProcessManager: mockProcessManager,
+                logger: mockLogger
+            });
+        });
+
+        test('должен отложить heartbeat', () => {
+            jest.useFakeTimers();
+
+            telemetryService.triggerHeartbeat();
+
+            expect(telemetryService.heartbeatDebounceTimer).toBeDefined();
+
+            jest.useRealTimers();
+        });
+
+        test('не должен запускаться если телеметрия выключена', () => {
+            mockConfig.telemetry.enabled = false;
+
+            telemetryService = new TelemetryService({
+                config: mockConfig,
+                botProcessManager: mockProcessManager,
+                logger: mockLogger
+            });
+
+            telemetryService.triggerHeartbeat();
+
+            expect(telemetryService.heartbeatDebounceTimer).toBeNull();
+        });
+    });
+
+    describe('sendHeartbeat', () => {
+        beforeEach(() => {
+            fs.existsSync.mockReturnValue(true);
+            fs.readFileSync.mockReturnValue('test-id');
+
+            telemetryService = new TelemetryService({
+                config: mockConfig,
+                botProcessManager: mockProcessManager,
+                logger: mockLogger
+            });
+        });
+
+        test('должен отправить heartbeat с запущенными ботами', async () => {
+            const mockBotProcess = {
+                botConfig: {
+                    username: 'TestBot',
+                    server: {
+                        host: 'mc.example.com',
+                        port: 25565
+                    }
+                }
+            };
+
+            mockProcessManager.getAllProcesses.mockReturnValue(new Map([[1, mockBotProcess]]));
+
+            // Mock fetch responses
+            global.fetch
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        challenge: 'test-challenge',
+                        difficulty: 1,
+                        prefix: 'test'
+                    })
+                })
+                .mockResolvedValueOnce({
+                    ok: true
+                });
+
+            await telemetryService.sendHeartbeat();
+
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+            expect(mockLogger.debug).toHaveBeenCalled();
+        });
+
+        test('не должен отправлять если телеметрия выключена', async () => {
+            mockConfig.telemetry.enabled = false;
+
+            telemetryService = new TelemetryService({
+                config: mockConfig,
+                botProcessManager: mockProcessManager,
+                logger: mockLogger
+            });
+
+            await telemetryService.sendHeartbeat();
+
+            expect(global.fetch).not.toHaveBeenCalled();
+        });
+
+        test('не должен отправлять если нет запущенных ботов', async () => {
+            mockProcessManager.getAllProcesses.mockReturnValue(new Map());
+
+            await telemetryService.sendHeartbeat();
+
+            expect(global.fetch).not.toHaveBeenCalled();
+        });
+
+        test('должен обработать ошибку при отправке', async () => {
+            const mockBotProcess = {
+                botConfig: {
+                    username: 'TestBot',
+                    server: { host: 'mc.example.com', port: 25565 }
+                }
+            };
+
+            mockProcessManager.getAllProcesses.mockReturnValue(new Map([[1, mockBotProcess]]));
+
+            global.fetch.mockRejectedValue(new Error('Network error'));
+
+            await telemetryService.sendHeartbeat();
+
+            expect(mockLogger.error).toHaveBeenCalled();
+        });
+    });
+
+    describe('getInstanceId', () => {
+        test('должен вернуть instance ID', () => {
+            fs.existsSync.mockReturnValue(true);
+            fs.readFileSync.mockReturnValue('test-uuid');
+
+            telemetryService = new TelemetryService({
+                config: mockConfig,
+                botProcessManager: mockProcessManager,
+                logger: mockLogger
+            });
+
+            expect(telemetryService.getInstanceId()).toBe('test-uuid');
+        });
+    });
+});

package/backend/src/__tests__/setup.js

@@ -0,0 +1,25 @@
+/**
+ * Jest Setup - выполняется перед всеми тестами
+ */
+
+// Мокируем логгер чтобы тесты были тихими
+global.console = {
+    ...console,
+    log: jest.fn(),
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+};
+
+// Устанавливаем переменные окружения для тестов
+process.env.NODE_ENV = 'test';
+process.env.DEBUG = 'false';
+
+// Mock для Prisma (если нужно)
+jest.mock('../lib/prisma', () => ({
+    bot: {},
+    command: {},
+    permission: {},
+    // ... другие модели при необходимости
+}));

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

@@ -0,0 +1,181 @@
+const express = require('express');
+const prisma = require('../../lib/prisma');
+const bcrypt = require('bcryptjs');
+const crypto = require('crypto');
+const { authenticate, authorize } = require('../middleware/auth');
+const { checkBotAccess } = require('../middleware/botAccess');
+
+const router = express.Router({ mergeParams: true });
+
+// Middleware для проверки доступа к боту
+router.use(authenticate, checkBotAccess);
+
+// GET /api/bots/:botId/api-keys/connected - Получить количество подключенных клиентов (ДОЛЖЕН БЫТЬ ПЕРЕД /:keyId)
+router.get('/connected', authorize('bot:update'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+
+        const { getIO } = require('../../real-time/socketHandler');
+        const { getConnectedClientsCount } = require('../../real-time/botApi/utils');
+
+        const io = getIO();
+        const count = getConnectedClientsCount(io, botId);
+
+        res.json({ success: true, count });
+    } catch (error) {
+        console.error('[API Keys] Ошибка получения количества клиентов:', error);
+        res.status(500).json({ success: false, message: 'Ошибка при получении количества клиентов' });
+    }
+});
+
+// GET /api/bots/:botId/api-keys/logs - Получить логи подключений (ДОЛЖЕН БЫТЬ ПЕРЕД /:keyId)
+router.get('/logs', authorize('bot:update'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const limit = parseInt(req.query.limit, 10) || 50;
+
+        const logs = await prisma.apiConnectionLog.findMany({
+            where: { botId },
+            orderBy: { createdAt: 'desc' },
+            take: Math.min(limit, 200),
+        });
+
+        res.json({ success: true, logs });
+    } catch (error) {
+        console.error('[API Keys] Ошибка получения логов:', error);
+        res.status(500).json({ success: false, message: 'Ошибка при получении логов' });
+    }
+});
+
+// GET /api/bots/:botId/api-keys - Получить список всех API ключей
+router.get('/', authorize('bot:update'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+
+        const keys = await prisma.botApiKey.findMany({
+            where: { botId },
+            select: {
+                id: true,
+                name: true,
+                keyPrefix: true,
+                permissions: true,
+                createdAt: true,
+                lastUsedAt: true,
+            },
+            orderBy: { createdAt: 'desc' },
+        });
+
+        res.json({ success: true, keys });
+    } catch (error) {
+        console.error('[API Keys] Ошибка получения списка ключей:', error);
+        res.status(500).json({ success: false, message: 'Ошибка при получении ключей' });
+    }
+});
+
+// POST /api/bots/:botId/api-keys - Создать новый API ключ
+router.post('/', authorize('bot:update'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const { name, permissions = 'ReadWrite' } = req.body;
+
+        if (!name || name.trim().length === 0) {
+            return res.status(400).json({ success: false, message: 'Название ключа обязательно' });
+        }
+
+        if (!['Read', 'Write', 'ReadWrite'].includes(permissions)) {
+            return res.status(400).json({ success: false, message: 'Недопустимое значение permissions' });
+        }
+
+        // Генерируем уникальный ключ: bk_<32 байта hex>
+        const rawKey = `bk_${crypto.randomBytes(32).toString('hex')}`;
+        const keyPrefix = rawKey.substring(0, 11); // "bk_" + 8 символов
+        const keyHash = await bcrypt.hash(rawKey, 10);
+
+        const apiKey = await prisma.botApiKey.create({
+            data: {
+                botId,
+                name: name.trim(),
+                keyHash,
+                keyPrefix,
+                permissions,
+            },
+        });
+
+        // Возвращаем полный ключ ТОЛЬКО ОДИН РАЗ
+        res.json({
+            success: true,
+            key: rawKey, // Полный ключ
+            apiKey: {
+                id: apiKey.id,
+                name: apiKey.name,
+                keyPrefix: apiKey.keyPrefix,
+                permissions: apiKey.permissions,
+                createdAt: apiKey.createdAt,
+            },
+        });
+    } catch (error) {
+        console.error('[API Keys] Ошибка создания ключа:', error);
+        res.status(500).json({ success: false, message: 'Ошибка при создании ключа' });
+    }
+});
+
+// PUT /api/bots/:botId/api-keys/:keyId - Обновить имя или права ключа
+router.put('/:keyId', authorize('bot:update'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const keyId = parseInt(req.params.keyId, 10);
+        const { name, permissions } = req.body;
+
+        const updateData = {};
+        if (name !== undefined && name.trim().length > 0) {
+            updateData.name = name.trim();
+        }
+        if (permissions !== undefined) {
+            if (!['Read', 'Write', 'ReadWrite'].includes(permissions)) {
+                return res.status(400).json({ success: false, message: 'Недопустимое значение permissions' });
+            }
+            updateData.permissions = permissions;
+        }
+
+        if (Object.keys(updateData).length === 0) {
+            return res.status(400).json({ success: false, message: 'Нечего обновлять' });
+        }
+
+        const apiKey = await prisma.botApiKey.updateMany({
+            where: { id: keyId, botId },
+            data: updateData,
+        });
+
+        if (apiKey.count === 0) {
+            return res.status(404).json({ success: false, message: 'Ключ не найден' });
+        }
+
+        res.json({ success: true, message: 'Ключ обновлен' });
+    } catch (error) {
+        console.error('[API Keys] Ошибка обновления ключа:', error);
+        res.status(500).json({ success: false, message: 'Ошибка при обновлении ключа' });
+    }
+});
+
+// DELETE /api/bots/:botId/api-keys/:keyId - Удалить (отозвать) API ключ
+router.delete('/:keyId', authorize('bot:update'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId, 10);
+        const keyId = parseInt(req.params.keyId, 10);
+
+        const result = await prisma.botApiKey.deleteMany({
+            where: { id: keyId, botId },
+        });
+
+        if (result.count === 0) {
+            return res.status(404).json({ success: false, message: 'Ключ не найден' });
+        }
+
+        res.json({ success: true, message: 'Ключ удален' });
+    } catch (error) {
+        console.error('[API Keys] Ошибка удаления ключа:', error);
+        res.status(500).json({ success: false, message: 'Ошибка при удалении ключа' });
+    }
+});
+
+module.exports = router;