blockmine 1.24.0 → 1.27.0

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

@@ -1,29 +1,42 @@
 const { LRUCache } = require('lru-cache');
 
+const DEFAULT_MEMORY_THRESHOLD = 500 * 1024 * 1024;
+
 class CacheManager {
     constructor({ commandRepository, permissionRepository, logger } = {}) {
-        // Кеш с TTL и максимальным размером
         this.tokenCache = new LRUCache({
             max: 500,
-            ttl: 1000 * 60 * 5, // 5 минут
+            ttl: 1000 * 60 * 5,
         });
 
         this.playerListCache = new LRUCache({
             max: 100,
-            ttl: 1000 * 2, // 2 секунды
+            ttl: 1000 * 2,
         });
 
         this.botConfigsCache = new Map();
-        
-        // Зависимости для автозагрузки конфигурации
+
         this.commandRepository = commandRepository;
         this.permissionRepository = permissionRepository;
         this.logger = logger;
+
+        this.memoryThreshold = DEFAULT_MEMORY_THRESHOLD;
+
+        this._metrics = {
+            tokenCache: { hits: 0, misses: 0 },
+            playerListCache: { hits: 0, misses: 0 },
+            botConfigsCache: { hits: 0, misses: 0 },
+        };
     }
 
-    // Token cache
     getToken(token) {
-        return this.tokenCache.get(token);
+        const value = this.tokenCache.get(token);
+        if (value !== undefined) {
+            this._metrics.tokenCache.hits++;
+        } else {
+            this._metrics.tokenCache.misses++;
+        }
+        return value;
     }
 
     setToken(token, data) {
@@ -34,18 +47,28 @@ class CacheManager {
         this.tokenCache.delete(token);
     }
 
-    // Player list cache
     getPlayerList(botId) {
-        return this.playerListCache.get(botId);
+        const value = this.playerListCache.get(botId);
+        if (value !== undefined) {
+            this._metrics.playerListCache.hits++;
+        } else {
+            this._metrics.playerListCache.misses++;
+        }
+        return value;
     }
 
     setPlayerList(botId, players) {
         this.playerListCache.set(botId, players);
     }
 
-    // Bot config cache
     getBotConfig(botId) {
-        return this.botConfigsCache.get(botId);
+        const value = this.botConfigsCache.get(botId);
+        if (value !== undefined) {
+            this._metrics.botConfigsCache.hits++;
+        } else {
+            this._metrics.botConfigsCache.misses++;
+        }
+        return value;
     }
 
     setBotConfig(botId, config) {
@@ -56,27 +79,64 @@ class CacheManager {
         this.botConfigsCache.delete(botId);
     }
 
-    // Очистка всего кеша для бота
     clearBotCache(botId) {
         this.deleteBotConfig(botId);
         this.playerListCache.delete(botId);
     }
 
-    /**
-     * Получает конфигурацию бота из кеша или загружает из БД
-     * @param {number} botId - ID бота
-     * @returns {Promise<object>} - Конфигурация бота
-     */
+    getMetrics() {
+        const calc = ({ hits, misses }) => {
+            const total = hits + misses;
+            return {
+                hits,
+                misses,
+                hitRate: total === 0 ? 0 : hits / total,
+            };
+        };
+
+        return {
+            tokenCache: calc(this._metrics.tokenCache),
+            playerListCache: calc(this._metrics.playerListCache),
+            botConfigsCache: calc(this._metrics.botConfigsCache),
+        };
+    }
+
+    resetMetrics() {
+        this._metrics = {
+            tokenCache: { hits: 0, misses: 0 },
+            playerListCache: { hits: 0, misses: 0 },
+            botConfigsCache: { hits: 0, misses: 0 },
+        };
+    }
+
+    checkMemoryUsage() {
+        const { heapUsed } = process.memoryUsage();
+        const threshold = this.memoryThreshold;
+        const exceeded = heapUsed > threshold;
+
+        if (exceeded) {
+            if (this.logger) {
+                this.logger.warn(
+                    { heapUsed, threshold },
+                    'Memory threshold exceeded, clearing playerListCache'
+                );
+            }
+            this.playerListCache.clear();
+        }
+
+        return { heapUsed, threshold, exceeded };
+    }
+
     async getOrLoadBotConfig(botId) {
         let config = this.botConfigsCache.get(botId);
-        
+
         if (!config) {
             if (this.logger) {
-                this.logger.debug({ botId }, 'Кеш конфигурации отсутствует, загрузка из БД');
+                this.logger.debug({ botId }, 'Cache miss, loading from DB');
             }
-            
+
             if (!this.commandRepository || !this.permissionRepository) {
-                throw new Error('CacheManager не имеет доступа к репозиториям для загрузки конфигурации');
+                throw new Error('CacheManager does not have access to repositories for loading configuration');
             }
 
             const [commands, permissions] = await Promise.all([
@@ -98,9 +158,9 @@ class CacheManager {
             }
 
             this.botConfigsCache.set(botId, config);
-            
+
             if (this.logger) {
-                this.logger.debug({ botId }, 'Конфигурация загружена и закеширована');
+                this.logger.debug({ botId }, 'Configuration loaded and cached');
             }
         }
 

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

@@ -0,0 +1,42 @@
+class CrashRestartManager {
+    constructor(maxRestarts = 3, restartWindowMs = 60000) {
+        this.maxRestarts = maxRestarts;
+        this.restartWindowMs = restartWindowMs;
+        this.crashHistory = new Map();
+    }
+
+    handleCrash(botId, botConfig, appendLog) {
+        const history = this.crashHistory.get(botId) || { count: 0, firstCrash: Date.now(), crashes: [] };
+
+        history.count++;
+        history.crashes.push(Date.now());
+
+        history.crashes = history.crashes.filter(t => Date.now() - t < this.restartWindowMs);
+        history.count = history.crashes.length;
+        history.firstCrash = history.crashes[0] || Date.now();
+
+        this.crashHistory.set(botId, history);
+
+        const withinWindow = Date.now() - history.firstCrash < this.restartWindowMs;
+
+        if (history.count > this.maxRestarts && withinWindow) {
+            appendLog(`[CRASH] Бот превысил лимит рестартов (${this.maxRestarts}). Авто-рестарт отключен.`);
+            return { shouldRestart: false, reason: 'max_restarts_exceeded' };
+        }
+
+        const delay = Math.min(1000 * Math.pow(2, history.count - 1), 30000);
+        appendLog(`[CRASH] Перезапуск через ${delay / 1000} сек... (попытка ${history.count}/${this.maxRestarts})`);
+
+        return { shouldRestart: true, delay };
+    }
+
+    resetCounter(botId) {
+        this.crashHistory.delete(botId);
+    }
+
+    getCrashCount(botId) {
+        return this.crashHistory.get(botId)?.count || 0;
+    }
+}
+
+module.exports = CrashRestartManager;

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

@@ -25,6 +25,12 @@ class GraphDebugState {
     // Режим пошагового выполнения (step over)
     this.stepMode = false; // Если true, остановится на следующей ноде
     this.stepFromNodeId = null; // ID ноды, с которой начали step over (чтобы её пропустить)
+
+    this.testMode = false;
+    this.history = [];
+    this.historyLimit = 200;
+    this.rewindTargetIndex = null;
+    this.replayState = null;
   }
 
   /**
@@ -53,7 +59,6 @@ class GraphDebugState {
    * Возвращает Promise, который разрешится когда пользователь нажмет Continue
    */
   async pause(state) {
-    // Генерируем sessionId для этой паузы
     const sessionId = randomUUID();
 
     this.activeExecution = {
@@ -62,10 +67,14 @@ class GraphDebugState {
       pausedAt: Date.now()
     };
 
+    this.pushSnapshot(state);
 
     this.broadcast('debug:paused', {
       sessionId,
-      ...state
+      ...state,
+      historyLength: this.history.length,
+      canStepBack: this.history.length > 1,
+      testMode: this.testMode
     });
 
 
@@ -86,18 +95,18 @@ class GraphDebugState {
    * @param {boolean} stepMode - Если true, остановится на следующей ноде
    */
   resume(overrides = null, stepMode = false) {
+    const effectiveStepMode = this.testMode ? true : stepMode;
+
     if (this.resumeCallback) {
-      // Объединяем pendingOverrides с переданными overrides
       const finalOverrides = {
         ...this.pendingOverrides,
         ...(overrides || {})
       };
 
-      console.log('[GraphDebugState] Resuming with overrides:', finalOverrides, 'stepMode:', stepMode);
+      console.log('[GraphDebugState] Resuming with overrides:', finalOverrides, 'stepMode:', effectiveStepMode, 'testMode:', this.testMode);
 
-      // Устанавливаем флаг stepMode и запоминаем текущую ноду
-      this.stepMode = stepMode;
-      if (stepMode && this.activeExecution) {
+      this.stepMode = effectiveStepMode;
+      if (effectiveStepMode && this.activeExecution) {
         this.stepFromNodeId = this.activeExecution.nodeId;
         console.log('[GraphDebugState] Step mode: will skip current node', this.stepFromNodeId);
       }
@@ -107,15 +116,14 @@ class GraphDebugState {
       this.pausePromise = null;
     }
 
-    // Если не step mode, очищаем состояние полностью
-    if (!stepMode) {
+    if (!effectiveStepMode) {
       this.activeExecution = null;
       this.stepFromNodeId = null;
     }
 
-    this.pendingOverrides = {}; // Очищаем после применения
+    this.pendingOverrides = {};
 
-    this.broadcast('debug:resumed', { stepMode });
+    this.broadcast('debug:resumed', { stepMode: effectiveStepMode, testMode: this.testMode });
   }
 
   /**
@@ -133,6 +141,14 @@ class GraphDebugState {
     this.stepMode = false; // Сбрасываем step mode
     this.stepFromNodeId = null; // Очищаем запомненную ноду
 
+    if (this.testMode) {
+      this.testMode = false;
+      this.history = [];
+      this.rewindTargetIndex = null;
+      this.replayState = null;
+      this.broadcast('debug:test-mode-stopped', {});
+    }
+
     this.broadcast('debug:stopped', {});
   }
 
@@ -217,6 +233,89 @@ class GraphDebugState {
     console.log(`[GraphDebugState] Set override: ${key} =`, value);
   }
 
+  pushSnapshot(state) {
+    if (!state) return;
+    const snapshot = {
+      index: this.history.length,
+      nodeId: state.nodeId,
+      nodeType: state.nodeType,
+      inputs: this._cloneSafely(state.inputs),
+      variables: this._cloneSafely(state.context?.variables),
+      commandArguments: this._cloneSafely(state.context?.commandArguments),
+      executedSteps: this._cloneSafely(state.executedSteps),
+      capturedAt: Date.now()
+    };
+    this.history.push(snapshot);
+    if (this.history.length > this.historyLimit) {
+      this.history.shift();
+      this.history.forEach((s, i) => { s.index = i; });
+    }
+  }
+
+  _cloneSafely(value) {
+    if (value === undefined || value === null) return value;
+    try {
+      return JSON.parse(JSON.stringify(value));
+    } catch (e) {
+      return null;
+    }
+  }
+
+  enableTestMode(initialPayload = {}) {
+    this.testMode = true;
+    this.stepMode = true;
+    this.stepFromNodeId = null;
+    this.history = [];
+    this.rewindTargetIndex = null;
+    this.replayState = null;
+    this.broadcast('debug:test-mode-started', {
+      ...initialPayload,
+      testMode: true
+    });
+  }
+
+  disableTestMode() {
+    this.testMode = false;
+    this.history = [];
+    this.rewindTargetIndex = null;
+    this.replayState = null;
+    this.broadcast('debug:test-mode-stopped', {});
+  }
+
+  consumeRewindTarget(nodeId) {
+    if (this.rewindTargetIndex === null) return false;
+    const target = this.history[this.rewindTargetIndex];
+    if (target && target.nodeId === nodeId) {
+      this.rewindTargetIndex = null;
+      return true;
+    }
+    return false;
+  }
+
+  stepBack() {
+    if (this.history.length < 2) {
+      this.broadcast('debug:rewind-failed', { reason: 'no-history' });
+      return null;
+    }
+    const target = this.history[this.history.length - 2];
+    this.history = this.history.slice(0, this.history.length - 1);
+    this.rewindTargetIndex = this.history.length - 1;
+    this.replayState = {
+      variables: target.variables,
+      commandArguments: target.commandArguments,
+      targetNodeId: target.nodeId
+    };
+    if (this.resumeCallback) {
+      this.resumeCallback({ __rewind: true, target });
+      this.resumeCallback = null;
+      this.pausePromise = null;
+    }
+    this.activeExecution = null;
+    this.pendingOverrides = {};
+    this.broadcast('debug:rewound', { target });
+    return target;
+  }
+
   /**
    * Получить текущее состояние (для отправки новым пользователям)
    */
@@ -224,7 +323,10 @@ class GraphDebugState {
     return {
       breakpoints: Array.from(this.breakpoints.values()),
       activeExecution: this.activeExecution,
-      connectedUsers: Array.from(this.connectedUsers.values())
+      connectedUsers: Array.from(this.connectedUsers.values()),
+      testMode: this.testMode,
+      historyLength: this.history.length,
+      canStepBack: this.history.length > 1
     };
   }
 

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

@@ -0,0 +1,69 @@
+const GraphValidator = require('../domain/services/GraphValidator');
+const { GraphExecutionError, ValidationError } = require('../errors');
+
+const graphValidator = new GraphValidator();
+
+class EventGraphService {
+    constructor({ eventGraphManager, eventGraphRepository, cacheManager, logger } = {}) {
+        this.eventGraphManager = eventGraphManager;
+        this.eventGraphRepository = eventGraphRepository;
+        this.cache = cacheManager;
+        this.logger = logger;
+        this._graphCache = new Map();
+    }
+
+    async loadGraphsForBot(botId) {
+        this.logger.info({ botId }, 'eventGraph.load.start');
+        try {
+            await this.eventGraphManager.loadGraphsForBot(botId);
+            this.logger.info({ botId }, 'eventGraph.load.success');
+        } catch (error) {
+            this.logger.error({ botId, error }, 'eventGraph.load.error');
+            throw new GraphExecutionError('eventGraph.errors.loadFailed', { cause: error, context: { botId } });
+        }
+    }
+
+    unloadGraphsForBot(botId) {
+        this.eventGraphManager.unloadGraphsForBot(botId);
+        this._graphCache.delete(botId);
+        this.logger.info({ botId }, 'eventGraph.unload.success');
+    }
+
+    async handleEvent(botId, eventType, args) {
+        try {
+            await this.eventGraphManager.handleEvent(botId, eventType, args);
+        } catch (error) {
+            this.logger.error({ botId, eventType, error }, 'eventGraph.event.error');
+        }
+    }
+
+    async validateGraph(graphJson) {
+        let graph;
+        try {
+            graph = typeof graphJson === 'string' ? JSON.parse(graphJson) : graphJson;
+        } catch {
+            throw new ValidationError('eventGraph.errors.invalidJson');
+        }
+
+        const result = graphValidator.validate(graph);
+        if (!result.valid) {
+            throw new ValidationError('eventGraph.errors.invalidStructure', { context: { errors: result.errors } });
+        }
+        return true;
+    }
+
+    async getGraphsForBot(botId) {
+        if (this._graphCache.has(botId)) {
+            return this._graphCache.get(botId);
+        }
+        const graphs = await this.eventGraphRepository.findByBotId(botId);
+        this._graphCache.set(botId, graphs);
+        return graphs;
+    }
+
+    invalidateCache(botId) {
+        this._graphCache.delete(botId);
+    }
+}
+
+module.exports = EventGraphService;

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

@@ -88,7 +88,15 @@ class MinecraftBotManager {
         });
 
         bot.on('kicked', (reason) => {
-            this.logger.warn(`[Minecraft] Bot kicked for session ${sessionId}: ${reason}`);
+            let reasonText;
+            if (typeof reason === 'string') {
+                try { reasonText = JSON.parse(reason).text || reason; } catch (e) { reasonText = reason; }
+            } else if (reason && typeof reason === 'object') {
+                reasonText = reason.text || reason.message || reason.reason || JSON.stringify(reason);
+            } else {
+                reasonText = String(reason);
+            }
+            this.logger.warn(`[Minecraft] Bot kicked for session ${sessionId}: ${reasonText}`);
         });
     }
 

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

@@ -0,0 +1,84 @@
+const DependencyResolver = require('../domain/services/DependencyResolver');
+const { validatePluginManifest } = require('../validation/InputValidator');
+const { PluginError, ValidationError } = require('../errors');
+
+const dependencyResolver = new DependencyResolver();
+
+class PluginManagementService {
+    constructor({ pluginManager, pluginRepository, logger } = {}) {
+        this.pluginManager = pluginManager;
+        this.pluginRepository = pluginRepository;
+        this.logger = logger;
+    }
+
+    async installFromGithub(botId, repoUrl, tag = null) {
+        this.logger.info({ botId, repoUrl, tag }, 'plugin.install.github.start');
+        try {
+            const result = await this.pluginManager.installFromGithub(botId, repoUrl, undefined, false, tag);
+            this.logger.info({ botId, pluginName: result.name }, 'plugin.install.github.success');
+            return result;
+        } catch (error) {
+            this.logger.error({ botId, repoUrl, error }, 'plugin.install.github.error');
+            throw new PluginError('plugin.errors.installFailed', { cause: error, context: { repoUrl } });
+        }
+    }
+
+    async installFromLocalPath(botId, directoryPath) {
+        this.logger.info({ botId, directoryPath }, 'plugin.install.local.start');
+        try {
+            const result = await this.pluginManager.installFromLocalPath(botId, directoryPath);
+            this.logger.info({ botId, pluginName: result.name }, 'plugin.install.local.success');
+            return result;
+        } catch (error) {
+            this.logger.error({ botId, directoryPath, error }, 'plugin.install.local.error');
+            throw new PluginError('plugin.errors.installFailed', { cause: error, context: { directoryPath } });
+        }
+    }
+
+    async updatePlugin(pluginId, targetTag = null, targetRepoUrl = null) {
+        this.logger.info({ pluginId, targetTag }, 'plugin.update.start');
+        try {
+            const result = await this.pluginManager.updatePlugin(pluginId, targetTag, targetRepoUrl);
+            this.logger.info({ pluginId, newVersion: result.version }, 'plugin.update.success');
+            return result;
+        } catch (error) {
+            this.logger.error({ pluginId, error }, 'plugin.update.error');
+            throw new PluginError('plugin.errors.updateFailed', { cause: error, context: { pluginId } });
+        }
+    }
+
+    async deletePlugin(pluginId) {
+        this.logger.info({ pluginId }, 'plugin.delete.start');
+        try {
+            await this.pluginManager.deletePlugin(pluginId);
+            this.logger.info({ pluginId }, 'plugin.delete.success');
+        } catch (error) {
+            this.logger.error({ pluginId, error }, 'plugin.delete.error');
+            throw new PluginError('plugin.errors.deleteFailed', { cause: error, context: { pluginId } });
+        }
+    }
+
+    async validateManifest(manifest) {
+        const result = validatePluginManifest(manifest);
+        if (!result.valid) {
+            throw new ValidationError('plugin.errors.invalidManifest', { context: { errors: result.errors } });
+        }
+        return true;
+    }
+
+    async checkDependencies(botId, manifest) {
+        const installedPlugins = await this.pluginRepository.findByBotId(botId);
+        const fakePlugin = { manifest: JSON.stringify(manifest) };
+        return dependencyResolver.checkCompatibility(fakePlugin, installedPlugins);
+    }
+
+    async checkForUpdates(botId, catalog) {
+        return this.pluginManager.checkForUpdates(botId, catalog);
+    }
+
+    async getInstalledPlugins(botId) {
+        return this.pluginRepository.findByBotId(botId);
+    }
+}
+
+module.exports = PluginManagementService;

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

@@ -0,0 +1,65 @@
+function createMockHandler(label) {
+    const handler = {
+        get(target, prop) {
+            if (prop === 'then') return undefined;
+            if (prop === Symbol.toPrimitive) return () => `[mock:${label}]`;
+            if (prop === 'toString') return () => `[mock:${label}]`;
+            if (prop in target) return target[prop];
+            const child = function (...args) {
+                console.log(`[TestMode] mock call: ${label}.${String(prop)}(${args.length} args)`);
+                return undefined;
+            };
+            child.__mock = true;
+            const proxied = new Proxy(child, createMockHandler(`${label}.${String(prop)}`));
+            target[prop] = proxied;
+            return proxied;
+        },
+        apply(target, thisArg, args) {
+            console.log(`[TestMode] mock invoke: ${label}(${args.length} args)`);
+            return undefined;
+        }
+    };
+    return handler;
+}
+
+function createTestBotMock() {
+    const base = function () {};
+    base.username = 'TestBot';
+    base.entity = { position: { x: 0, y: 64, z: 0 }, yaw: 0, pitch: 0 };
+    base.players = {};
+    base.entities = {};
+    base.health = 20;
+    base.food = 20;
+    base.sendMessage = (...args) => {
+        console.log('[TestMode] bot.sendMessage:', ...args);
+    };
+    base.lookAt = () => {};
+    base.chat = (msg) => console.log('[TestMode] bot.chat:', msg);
+    return new Proxy(base, createMockHandler('bot'));
+}
+
+function createTestApiMock() {
+    const base = function () {};
+    return new Proxy(base, createMockHandler('api'));
+}
+
+function buildTestContext({ botId, graphId, eventArgs }) {
+    return {
+        botId,
+        graphId,
+        eventArgs,
+        user: eventArgs?.user || (eventArgs?.username ? { username: eventArgs.username } : { username: 'TestUser' }),
+        commandArguments: eventArgs?.commandArguments || {},
+        bot: createTestBotMock(),
+        api: createTestApiMock(),
+        services: new Proxy({}, createMockHandler('services')),
+        typeChat: 'chat',
+        __testMode: true
+    };
+}
+
+module.exports = {
+    createTestBotMock,
+    createTestApiMock,
+    buildTestContext
+};