blockmine 1.20.0 → 1.22.0

package/backend/src/core/services/ResourceMonitorService.js

@@ -0,0 +1,90 @@
+const pidusage = require('pidusage');
+
+class ResourceMonitorService {
+    constructor({ botProcessManager, logger }) {
+        this.processManager = botProcessManager;
+        this.logger = logger;
+        this.resourceUsage = new Map();
+        this.updateInterval = null;
+    }
+
+    startMonitoring(intervalMs = 5000) {
+        if (this.updateInterval) {
+            clearInterval(this.updateInterval);
+        }
+        this.updateInterval = setInterval(() => this.updateAllResourceUsage(), intervalMs);
+    }
+
+    stopMonitoring() {
+        if (this.updateInterval) {
+            clearInterval(this.updateInterval);
+            this.updateInterval = null;
+        }
+    }
+
+    async updateAllResourceUsage() {
+        const processes = this.processManager.getAllProcesses();
+
+        if (processes.size === 0) {
+            if (this.resourceUsage.size > 0) {
+                this.resourceUsage.clear();
+            }
+            return [];
+        }
+
+        const pids = Array.from(processes.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);
+                }
+            }
+
+            return usageData;
+        } catch (error) {
+            this.logger.error({ error }, 'Ошибка обновления ресурсов');
+            return [];
+        }
+    }
+
+    getBotIdByPid(pid) {
+        const processes = this.processManager.getAllProcesses();
+        for (const [botId, child] of processes.entries()) {
+            if (child.pid === pid) {
+                return botId;
+            }
+        }
+        return null;
+    }
+
+    getResourceUsage(botId) {
+        return this.resourceUsage.get(botId);
+    }
+
+    getAllResourceUsage() {
+        return Array.from(this.resourceUsage.values());
+    }
+
+    clearResourceUsage(botId) {
+        this.resourceUsage.delete(botId);
+    }
+}
+
+module.exports = ResourceMonitorService;

package/backend/src/core/services/TelemetryService.js

@@ -0,0 +1,124 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+
+class TelemetryService {
+    constructor({ config, botProcessManager, logger }) {
+        this.config = config;
+        this.processManager = botProcessManager;
+        this.logger = logger;
+        this.instanceId = null;
+        this.heartbeatDebounceTimer = null;
+        this.heartbeatInterval = null;
+
+        this.STATS_SERVER_URL = 'http://185.65.200.184:3000';
+        this.DATA_DIR = path.join(os.homedir(), '.blockmine');
+        this.INSTANCE_ID_PATH = path.join(this.DATA_DIR, '.instance_id');
+
+        this.loadInstanceId();
+    }
+
+    loadInstanceId() {
+        if (this.instanceId) return this.instanceId;
+
+        try {
+            if (fs.existsSync(this.INSTANCE_ID_PATH)) {
+                this.instanceId = fs.readFileSync(this.INSTANCE_ID_PATH, 'utf-8');
+            } else {
+                this.instanceId = uuidv4();
+                if (!fs.existsSync(this.DATA_DIR)) {
+                    fs.mkdirSync(this.DATA_DIR, { recursive: true });
+                }
+                fs.writeFileSync(this.INSTANCE_ID_PATH, this.instanceId, 'utf-8');
+            }
+        } catch (error) {
+            this.logger.error({ error }, 'Ошибка загрузки Instance ID');
+            return null;
+        }
+
+        return this.instanceId;
+    }
+
+    getInstanceId() {
+        return this.instanceId;
+    }
+
+    startHeartbeat(intervalMs = 5 * 60 * 1000) {
+        if (!this.config.telemetry?.enabled) return;
+
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+
+        this.heartbeatInterval = setInterval(() => this.sendHeartbeat(), intervalMs);
+    }
+
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+
+    triggerHeartbeat() {
+        if (!this.config.telemetry?.enabled) return;
+
+        if (this.heartbeatDebounceTimer) {
+            clearTimeout(this.heartbeatDebounceTimer);
+        }
+
+        this.heartbeatDebounceTimer = setTimeout(() => {
+            this.sendHeartbeat();
+        }, 3000);
+    }
+
+    async sendHeartbeat() {
+        if (!this.config.telemetry?.enabled || !this.instanceId) return;
+
+        try {
+            const processes = this.processManager.getAllProcesses();
+            const runningBots = Array.from(processes.values())
+                .filter(p => p.botConfig)
+                .map(p => ({
+                    username: p.botConfig.username,
+                    serverHost: p.botConfig.server.host,
+                    serverPort: p.botConfig.server.port
+                }));
+
+            if (runningBots.length === 0) return;
+
+            const challengeRes = await fetch(`${this.STATS_SERVER_URL}/api/challenge?uuid=${this.instanceId}`);
+            if (!challengeRes.ok) throw new Error(`Challenge server error: ${challengeRes.statusText}`);
+
+            const { challenge, difficulty, prefix } = await challengeRes.json();
+
+            // Proof of work
+            let nonce = 0;
+            let hash = '';
+            do {
+                nonce++;
+                hash = crypto.createHash('sha256').update(prefix + challenge + nonce).digest('hex');
+            } while (!hash.startsWith('0'.repeat(difficulty)));
+
+            const packageJson = require('../../../../package.json');
+            await fetch(`${this.STATS_SERVER_URL}/api/heartbeat`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    instanceUuid: this.instanceId,
+                    appVersion: packageJson.version,
+                    bots: runningBots,
+                    nonce: nonce
+                })
+            });
+
+            this.logger.debug('Heartbeat отправлен успешно');
+        } catch (error) {
+            this.logger.error({ error }, 'Не удалось отправить heartbeat');
+        }
+    }
+}
+
+module.exports = TelemetryService;

package/backend/src/core/services/ValidationService.js

@@ -0,0 +1,132 @@
+const { validateGraph, validateNodeConfig } = require('../validation/nodeSchemas');
+const { safeJsonParse } = require('../utils/jsonParser');
+const { VALIDATION_ENABLED, VALIDATION_STRICT_MODE } = require('../config/validation');
+
+/**
+ * Сервис для централизованной валидации графов и нод
+ *
+ * Предоставляет единую точку входа для валидации с учетом конфигурации окружения.
+ * В строгом режиме (dev/test) выбрасывает исключения, в production логирует и возвращает результат.
+ */
+class ValidationService {
+    constructor() {
+        this.validationEnabled = VALIDATION_ENABLED;
+        this.strictMode = VALIDATION_STRICT_MODE;
+    }
+
+    /**
+     * Парсит JSON строку графа с безопасной обработкой ошибок
+     * @param {string|object} graph - Граф в виде строки или объекта
+     * @param {string} contextName - Имя контекста для логирования
+     * @returns {object|null} - Распарсенный граф или null при ошибке
+     */
+    parseGraph(graph, contextName = 'unknown context') {
+        if (typeof graph === 'string') {
+            return safeJsonParse(graph, null, contextName);
+        }
+        return graph;
+    }
+
+    /**
+     * Валидирует конфигурацию графа
+     * @param {object} graph - Объект графа для валидации
+     * @param {string} contextName - Имя контекста для логирования (например, 'GraphExecutionEngine')
+     * @returns {{success: boolean, error?: any, shouldSkip: boolean}} - Результат валидации
+     */
+    validateGraphStructure(graph, contextName = 'unknown context') {
+        if (!this.validationEnabled) {
+            return { success: true, shouldSkip: false };
+        }
+
+        // Сначала проверяем базовую структуру
+        if (!graph || !Array.isArray(graph.nodes) || !Array.isArray(graph.connections)) {
+            console.error(`[${contextName}] Graph validation failed: missing or invalid nodes/connections arrays`);
+
+            if (this.strictMode) {
+                throw new Error('Invalid graph structure: missing nodes or connections');
+            }
+
+            console.warn(`[${contextName}] Skipping graph execution due to missing basic structure in production mode`);
+            return { success: false, error: 'Missing nodes or connections', shouldSkip: true };
+        }
+
+        // Затем выполняем полную валидацию схемы
+        const validation = validateGraph(graph);
+
+        if (!validation.success) {
+            console.error(`[${contextName}] Graph validation failed:`, {
+                errors: validation.error
+            });
+
+            if (this.strictMode) {
+                throw new Error('Invalid graph structure');
+            }
+
+            // В production логируем и пропускаем выполнение
+            console.warn(`[${contextName}] Skipping graph execution due to validation errors in production mode`);
+            return { success: false, error: validation.error, shouldSkip: true };
+        }
+
+        return { success: true, shouldSkip: false };
+    }
+
+    /**
+     * Валидирует конфигурацию ноды
+     * @param {object} nodeConfig - Конфигурация ноды для валидации
+     * @param {string} contextName - Имя контекста для логирования (например, 'NodeRegistry')
+     * @returns {{success: boolean, error?: any, shouldSkip: boolean}} - Результат валидации
+     */
+    validateNode(nodeConfig, contextName = 'unknown context') {
+        if (!this.validationEnabled) {
+            return { success: true, shouldSkip: false };
+        }
+
+        const validation = validateNodeConfig(nodeConfig);
+
+        if (!validation.success) {
+            console.error(`[${contextName}] Validation failed for node type '${nodeConfig.type}':`, {
+                type: nodeConfig.type,
+                errors: validation.error
+            });
+
+            if (this.strictMode) {
+                throw new Error(`Invalid node configuration for '${nodeConfig.type}'`);
+            }
+
+            // В production пропускаем невалидную ноду
+            console.warn(`[${contextName}] Skipping registration of invalid node '${nodeConfig.type}' in production mode`);
+            return { success: false, error: validation.error, shouldSkip: true };
+        }
+
+        return { success: true, shouldSkip: false };
+    }
+
+    /**
+     * Проверяет базовую структуру графа (nodes и connections)
+     * @param {object} graph - Объект графа
+     * @returns {boolean} - true если структура валидна
+     */
+    hasValidBasicStructure(graph) {
+        return !!(graph && Array.isArray(graph.nodes) && Array.isArray(graph.connections));
+    }
+
+    /**
+     * Проверяет, включена ли валидация
+     * @returns {boolean}
+     */
+    isValidationEnabled() {
+        return this.validationEnabled;
+    }
+
+    /**
+     * Проверяет, включен ли строгий режим
+     * @returns {boolean}
+     */
+    isStrictMode() {
+        return this.strictMode;
+    }
+}
+
+// Экспортируем singleton instance
+const validationServiceInstance = new ValidationService();
+module.exports = validationServiceInstance;

package/backend/src/core/services/__tests__/ValidationService.test.js

@@ -0,0 +1,148 @@
+const validationService = require('../ValidationService');
+const { GRAPH_TYPES } = require('../../constants/graphTypes');
+
+describe('ValidationService', () => {
+    describe('parseGraph', () => {
+        it('should parse JSON string graph', () => {
+            const graphJson = JSON.stringify({ nodes: [], connections: [] });
+            const result = validationService.parseGraph(graphJson, 'test');
+
+            expect(result).toEqual({ nodes: [], connections: [] });
+        });
+
+        it('should return graph object as-is', () => {
+            const graphObj = { nodes: [], connections: [] };
+            const result = validationService.parseGraph(graphObj, 'test');
+
+            expect(result).toBe(graphObj);
+        });
+
+        it('should return null for invalid JSON', () => {
+            const result = validationService.parseGraph('invalid json', 'test');
+
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('hasValidBasicStructure', () => {
+        it('should return true for valid graph structure', () => {
+            const graph = { nodes: [], connections: [] };
+
+            expect(validationService.hasValidBasicStructure(graph)).toBe(true);
+        });
+
+        it('should return false for graph without nodes', () => {
+            const graph = { connections: [] };
+
+            expect(validationService.hasValidBasicStructure(graph)).toBe(false);
+        });
+
+        it('should return false for graph without connections', () => {
+            const graph = { nodes: [] };
+
+            expect(validationService.hasValidBasicStructure(graph)).toBe(false);
+        });
+
+        it('should return false for null graph', () => {
+            expect(validationService.hasValidBasicStructure(null)).toBe(false);
+        });
+
+        it('should return false for undefined graph', () => {
+            expect(validationService.hasValidBasicStructure(undefined)).toBe(false);
+        });
+    });
+
+    describe('validateGraphStructure', () => {
+        it('should validate correct graph structure', () => {
+            const graph = {
+                nodes: [
+                    {
+                        id: '1',
+                        type: 'event:command',
+                        position: { x: 0, y: 0 },
+                        data: {}
+                    }
+                ],
+                connections: [],
+                variables: []
+            };
+
+            const result = validationService.validateGraphStructure(graph, 'test');
+
+            expect(result.success).toBe(true);
+            expect(result.shouldSkip).toBe(false);
+        });
+
+        it('should fail validation for invalid graph', () => {
+            const graph = {
+                nodes: 'not an array',
+                connections: []
+            };
+
+            // В production mode не выбрасывает исключение, а возвращает shouldSkip: true
+            if (process.env.NODE_ENV === 'production') {
+                const result = validationService.validateGraphStructure(graph, 'test');
+
+                expect(result.success).toBe(false);
+                expect(result.shouldSkip).toBe(true);
+                expect(result.error).toBeDefined();
+            } else {
+                // В dev/test mode выбрасывает исключение
+                expect(() => {
+                    validationService.validateGraphStructure(graph, 'test');
+                }).toThrow('Invalid graph structure');
+            }
+        });
+    });
+
+    describe('validateNode', () => {
+        it('should validate correct node configuration', () => {
+            const nodeConfig = {
+                type: 'test:node',
+                label: 'Test Node',
+                category: 'Test',
+                description: 'Test description',
+                inputs: [],
+                outputs: [],
+                graphType: GRAPH_TYPES.ALL
+            };
+
+            const result = validationService.validateNode(nodeConfig, 'test');
+
+            expect(result.success).toBe(true);
+            expect(result.shouldSkip).toBe(false);
+        });
+
+        it('should fail validation for invalid node', () => {
+            const nodeConfig = {
+                type: 'test:node',
+                // Missing required fields
+            };
+
+            // В production mode не выбрасывает исключение, а возвращает shouldSkip: true
+            if (process.env.NODE_ENV === 'production') {
+                const result = validationService.validateNode(nodeConfig, 'test');
+
+                expect(result.success).toBe(false);
+                expect(result.shouldSkip).toBe(true);
+                expect(result.error).toBeDefined();
+            } else {
+                // В dev/test mode выбрасывает исключение
+                expect(() => {
+                    validationService.validateNode(nodeConfig, 'test');
+                }).toThrow();
+            }
+        });
+    });
+
+    describe('utility methods', () => {
+        it('isValidationEnabled should return true', () => {
+            expect(validationService.isValidationEnabled()).toBe(true);
+        });
+
+        it('isStrictMode should reflect environment', () => {
+            const expected = process.env.NODE_ENV !== 'production';
+            expect(validationService.isStrictMode()).toBe(expected);
+        });
+    });
+});

package/backend/src/core/services.js

@@ -1,11 +1,26 @@
-const botManager = require('./BotManager');
-const PluginManager = require('./PluginManager');
+const { asValue } = require('awilix');
+const configureContainer = require('../container');
 
-const pluginManager = new PluginManager(botManager);
+const container = configureContainer();
+
+const BotManager = require('./BotManager');
+const botManager = new BotManager(container.cradle);
+
+// Регистрируем botManager в контейнере для PluginManager
+container.register({
+    botManager: asValue(botManager)
+});
+
+const pluginManager = container.resolve('pluginManager');
+const eventGraphManager = container.resolve('eventGraphManager');
+
+// EventGraphManager требует botManager через setter из-за циклической зависимости
+eventGraphManager.setBotManager(botManager);
 
 botManager.initialize();
 
 module.exports = {
     botManager,
-    pluginManager
-}; 
+    pluginManager,
+    container
+};

package/backend/src/core/system/CommandContext.js

@@ -0,0 +1,84 @@
+const Transport = require('./Transport');
+const UserService = require('../UserService');
+
+/**
+ * CommandContext - контекст выполнения команды
+ * Предоставляет единый интерфейс для команд независимо от источника (Minecraft, WebSocket, Telegram)
+ */
+class CommandContext {
+    /**
+     * @param {object} bot - Экземпляр бота
+     * @param {object} user - User объект с методами
+     * @param {object} args - Аргументы команды
+     * @param {Transport} transport - Transport объект
+     */
+    constructor(bot, user, args, transport) {
+        this.bot = bot;
+        this.user = user;
+        this.args = args;
+        this.transport = transport;
+
+        // Для обратной совместимости
+        this.typeChat = transport.type;
+        
+        // Добавляем информацию о позиции бота
+        this.botEntity = bot.entity ? {
+            position: bot.entity.position,
+            yaw: bot.entity.yaw,
+            pitch: bot.entity.pitch
+        } : null;
+    }
+
+    /**
+     * Отправить ответ пользователю
+     * @param {string} message - Текст сообщения
+     * @returns {string|void} - Для websocket возвращает message, для остальных void
+     */
+    reply(message) {
+        return this.transport.send(message, this.user.username);
+    }
+
+    /**
+     * Отправить сообщение в определенный чат
+     * @param {string} chatType - Тип чата ('chat', 'clan', 'private', etc)
+     * @param {string} message - Текст сообщения
+     * @param {string} recipient - Получатель (для private)
+     */
+    sendTo(chatType, message, recipient = null) {
+        if (this.bot.api) {
+            this.bot.api.sendMessage(chatType, message, recipient);
+        }
+    }
+
+    /**
+     * Получить User объект с методами
+     * @param {string} username - Имя пользователя
+     * @returns {Promise<User>} - User объект с методами
+     */
+    async getUser(username) {
+        return await UserService.getUser(username, this.bot.config.id, this.bot.config);
+    }
+
+    /**
+     * Проверка, выполняется ли команда через WebSocket API
+     */
+    isWebSocket() {
+        return this.transport.type === 'websocket';
+    }
+
+    /**
+     * Проверка, выполняется ли команда из Minecraft
+     */
+    isMinecraft() {
+        return this.transport.isMinecraftTransport();
+    }
+
+    /**
+     * Получить название транспорта
+     */
+    getTransportName() {
+        return this.transport.getDisplayName();
+    }
+}
+
+module.exports = CommandContext;

package/backend/src/core/system/Transport.js

@@ -0,0 +1,78 @@
+/**
+ * Transport - абстракция для различных способов доставки сообщений
+ * Поддерживает: websocket, minecraft (chat/clan/private/command), telegram (будущее)
+ */
+class Transport {
+    constructor(type, bot = null) {
+        this.type = type; // 'websocket' | 'chat' | 'clan' | 'private' | 'command' | 'telegram'
+        this.bot = bot;
+    }
+
+    /**
+     * Отправить сообщение через этот транспорт
+     * @param {string} message - Текст сообщения
+     * @param {string} recipient - Получатель (для private/telegram)
+     * @returns {string|void} - Для websocket возвращает message, для остальных void
+     */
+    send(message, recipient = null) {
+        if (this.type === 'websocket') {
+            // WebSocket - возвращаем результат как есть
+            return message;
+        } else if (this.isMinecraftTransport()) {
+            // Minecraft - отправляем через бота
+            if (this.bot && this.bot.api) {
+                this.bot.api.sendMessage(this.type, message, recipient);
+            }
+        } else if (this.type === 'telegram') {
+            // Telegram - будущая интеграция
+            // TODO: Implement telegram sending
+            console.warn('[Transport] Telegram transport not implemented yet');
+        }
+    }
+
+    /**
+     * Проверка, является ли этот транспорт Minecraft-транспортом
+     */
+    isMinecraftTransport() {
+        return ['chat', 'local', 'clan', 'private', 'command'].includes(this.type);
+    }
+
+    /**
+     * Проверка, является ли этот транспорт универсальным (не требует проверки allowedChatTypes)
+     */
+    isUniversal() {
+        return this.type === 'websocket';
+    }
+
+    /**
+     * Проверка, может ли команда быть выполнена через этот транспорт
+     * @param {Array<string>} allowedTypes - Список разрешенных типов чата из команды
+     */
+    isAllowedFor(allowedTypes) {
+        // Универсальные транспорты всегда разрешены
+        if (this.isUniversal()) {
+            return true;
+        }
+
+        // Для остальных проверяем список разрешенных типов
+        return allowedTypes.includes(this.type);
+    }
+
+    /**
+     * Получить читаемое название транспорта
+     */
+    getDisplayName() {
+        const names = {
+            websocket: 'WebSocket API',
+            chat: 'Общий чат',
+            local: 'Локальный чат',
+            clan: 'Клан',
+            private: 'Личное сообщение',
+            command: 'Команда',
+            telegram: 'Telegram'
+        };
+        return names[this.type] || this.type;
+    }
+}
+
+module.exports = Transport;