blockmine 1.22.0 → 1.23.0

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

@@ -1,6 +1,7 @@
 const DependencyService = require('../DependencyService');
 const { decrypt } = require('../utils/crypto');
 const UserService = require('../UserService');
+const PermissionManager = require('../PermissionManager');
 
 class BotLifecycleService {
     constructor({
@@ -72,6 +73,14 @@ class BotLifecycleService {
         }
 
         const decryptedConfig = { ...botConfig };
+
+        if (decryptedConfig.proxy) {
+            decryptedConfig.proxyHost = decryptedConfig.proxy.host;
+            decryptedConfig.proxyPort = decryptedConfig.proxy.port;
+            decryptedConfig.proxyUsername = decryptedConfig.proxy.username;
+            decryptedConfig.proxyPassword = decryptedConfig.proxy.password;
+        }
+
         if (decryptedConfig.password) decryptedConfig.password = decrypt(decryptedConfig.password);
         if (decryptedConfig.proxyPassword) decryptedConfig.proxyPassword = decrypt(decryptedConfig.proxyPassword);
         if (decryptedConfig.proxyUsername) decryptedConfig.proxyUsername = decryptedConfig.proxyUsername.trim();
@@ -109,6 +118,11 @@ class BotLifecycleService {
         if (child) {
             this.eventGraphManager.unloadGraphsForBot(botId);
 
+            // Очищаем traces для этого бота
+            const { getTraceCollector } = require('./TraceCollectorService');
+            const traceCollector = getTraceCollector();
+            traceCollector.clearForBot(botId);
+
             child.send({ type: 'stop' });
 
             // Принудительное завершение через 5 секунд
@@ -129,6 +143,10 @@ class BotLifecycleService {
         return { success: false, message: 'Бот не найден или уже остановлен' };
     }
 
+    getChildProcess(botId) {
+        return this.processManager.getProcess(botId);
+    }
+
     async restartBot(botId) {
         const botConfig = this.processManager.getProcess(botId)?.botConfig;
         if (!botConfig) {
@@ -161,6 +179,9 @@ class BotLifecycleService {
                     case 'log':
                         this.appendLog(botId, message.content);
                         break;
+                    case 'plugin-log':
+                        this._handlePluginLog(message.log);
+                        break;
                     case 'status':
                         this.emitStatusUpdate(botId, message.status);
                         break;
@@ -190,6 +211,24 @@ class BotLifecycleService {
                     case 'register_command':
                         await this._handleCommandRegistration(botId, message.commandConfig);
                         break;
+                    case 'register_permissions':
+                        await this._handlePermissionsRegistration(botId, message);
+                        break;
+                    case 'register_group':
+                        await this._handleGroupRegistration(botId, message);
+                        break;
+                    case 'add_permissions_to_group':
+                        await this._handleAddPermissionsToGroup(botId, message);
+                        break;
+                    case 'trace:completed':
+                        await this._handleTraceCompleted(botId, message.trace);
+                        break;
+                    case 'debug:check_breakpoint':
+                        await this._handleDebugBreakpointCheck(botId, child, message);
+                        break;
+                    case 'debug:check_step_mode':
+                        await this._handleDebugStepModeCheck(botId, child, message);
+                        break;
                 }
             } catch (error) {
                 this.appendLog(botId, `[SYSTEM-ERROR] Критическая ошибка в обработчике: ${error.stack}`);
@@ -209,15 +248,25 @@ class BotLifecycleService {
     async _handleEventMessage(botId, message) {
         if (message.eventType === 'raw_message') {
             try {
-                const { getIO } = require('../../real-time/socketHandler');
+                const { getIOSafe } = require('../../real-time/socketHandler');
                 const { broadcastToApiClients } = require('../../real-time/botApi');
-                broadcastToApiClients(getIO(), botId, 'chat:raw_message', {
+                broadcastToApiClients(getIOSafe(), botId, 'chat:raw_message', {
                     raw_message: message.args.rawText || message.args.raw_message,
                     json: message.args.json
                 });
             } catch (e) { /* Socket.IO может быть не инициализирован */ }
         }
 
+        try {
+            const { broadcastToPanelNamespace } = require('../../real-time/panelNamespace');
+            broadcastToPanelNamespace(botId, 'bot:event', {
+                botId,
+                eventType: message.eventType,
+                data: message.args || {},
+                timestamp: new Date().toISOString()
+            });
+        } catch (e) { /* Socket.IO может быть не инициализирован */ }
+
         if (this.eventGraphManager) {
             this.eventGraphManager.handleEvent(botId, message.eventType, message.args);
         }
@@ -234,10 +283,25 @@ class BotLifecycleService {
         }
     }
 
+    _handlePluginLog(logData) {
+        const { getIOSafe, addPluginLogToBuffer } = require('../../real-time/socketHandler');
+        const { botId, pluginName } = logData;
+
+        // Добавляем лог в буфер
+        addPluginLogToBuffer(botId, pluginName, logData);
+
+        // Отправляем через Socket.IO в комнату плагина
+        const io = getIOSafe();
+        if (io) {
+            const room = `plugin-logs:${botId}:${pluginName}`;
+            io.to(room).emit('plugin-log', logData);
+        }
+    }
+
     _handleWebSocketMessage(message) {
-        const { getIO } = require('../../real-time/socketHandler');
+        const { getIOSafe } = require('../../real-time/socketHandler');
         const { botId, message: msg } = message.payload;
-        getIO().to(`bot_${botId}`).emit('bot:message', { message: msg });
+        getIOSafe().to(`bot_${botId}`).emit('bot:message', { message: msg });
     }
 
     _handleBotReady(botId) {
@@ -245,10 +309,15 @@ class BotLifecycleService {
         this.crashCounters.delete(botId);
 
         try {
-            const { getIO } = require('../../real-time/socketHandler');
+            const { getIOSafe } = require('../../real-time/socketHandler');
             const { broadcastBotStatus } = require('../../real-time/botApi');
-            broadcastBotStatus(getIO(), botId, true);
+            broadcastBotStatus(getIOSafe(), botId, true);
         } catch (e) { /* Socket.IO может быть не инициализирован */ }
+
+        // Триггерим событие запуска бота
+        if (this.eventGraphManager) {
+            this.eventGraphManager.handleEvent(botId, 'botStartup', {});
+        }
     }
 
     async _handleCommandRegistration(botId, commandConfig) {
@@ -260,6 +329,33 @@ class BotLifecycleService {
         }
     }
 
+    async _handlePermissionsRegistration(botId, message) {
+        try {
+            await PermissionManager.registerPermissions(botId, message.permissions);
+            this.logger.debug({ botId, count: message.permissions.length }, 'Права зарегистрированы');
+        } catch (error) {
+            this.logger.error({ botId, error }, 'Ошибка регистрации прав');
+        }
+    }
+
+    async _handleGroupRegistration(botId, message) {
+        try {
+            await PermissionManager.registerGroup(botId, message.groupConfig);
+            this.logger.debug({ botId, groupName: message.groupConfig.name }, 'Группа зарегистрирована');
+        } catch (error) {
+            this.logger.error({ botId, error }, 'Ошибка регистрации группы');
+        }
+    }
+
+    async _handleAddPermissionsToGroup(botId, message) {
+        try {
+            await PermissionManager.addPermissionsToGroup(botId, message.groupName, message.permissionNames);
+            this.logger.debug({ botId, groupName: message.groupName, count: message.permissionNames.length }, 'Права добавлены в группу');
+        } catch (error) {
+            this.logger.error({ botId, error }, 'Ошибка добавления прав в группу');
+        }
+    }
+
     async _handleUserAction(botId, child, message) {
         const { requestId, payload } = message;
         const { targetUsername, action, data } = payload;
@@ -309,9 +405,9 @@ class BotLifecycleService {
         this.emitStatusUpdate(botId, 'stopped', `Процесс завершился с кодом ${code} (сигнал: ${signal || 'none'}).`);
 
         try {
-            const { getIO } = require('../../real-time/socketHandler');
+            const { getIOSafe } = require('../../real-time/socketHandler');
             const { broadcastBotStatus } = require('../../real-time/botApi');
-            broadcastBotStatus(getIO(), botId, false);
+            broadcastBotStatus(getIOSafe(), botId, false);
         } catch (e) { /* Socket.IO может быть не инициализирован */ }
 
         // Автоперезапуск при критических ошибках
@@ -391,12 +487,12 @@ class BotLifecycleService {
     }
 
     reloadBotConfigInRealTime(botId) {
-        const { getIO } = require('../../real-time/socketHandler');
+        const { getIOSafe } = require('../../real-time/socketHandler');
         this.invalidateConfigCache(botId);
 
         if (this.processManager.sendMessage(botId, { type: 'config:reload' })) {
             this.logger.info({ botId }, 'Отправлен config:reload');
-            getIO().emit('bot:config_reloaded', { botId });
+            getIOSafe().emit('bot:config_reloaded', { botId });
         }
     }
 
@@ -438,7 +534,7 @@ class BotLifecycleService {
     }
 
     appendLog(botId, logContent) {
-        const { getIO } = require('../../real-time/socketHandler');
+        const { getIOSafe } = require('../../real-time/socketHandler');
         const logEntry = {
             id: Date.now() + Math.random(),
             content: logContent,
@@ -448,7 +544,7 @@ class BotLifecycleService {
         const newLogs = [...currentLogs.slice(-199), logEntry];
         this.logCache.set(botId, newLogs);
 
-        getIO().emit('bot:log', { botId, log: logEntry });
+        getIOSafe().emit('bot:log', { botId, log: logEntry });
     }
 
     getBotLogs(botId) {
@@ -456,9 +552,17 @@ class BotLifecycleService {
     }
 
     emitStatusUpdate(botId, status, message = null) {
-        const { getIO } = require('../../real-time/socketHandler');
+        const { getIOSafe, broadcastToPanelNamespace } = require('../../real-time/socketHandler');
         if (message) this.appendLog(botId, `[SYSTEM] ${message}`);
-        getIO().emit('bot:status', { botId, status, message });
+
+        getIOSafe().emit('bot:status', { botId, status, message });
+
+        broadcastToPanelNamespace(getIOSafe(), 'bots:status', {
+            botId,
+            status,
+            message,
+            timestamp: new Date().toISOString()
+        });
     }
 
     getFullState() {
@@ -500,8 +604,8 @@ class BotLifecycleService {
     async reloadPlugins(botId) {
         if (this.processManager.sendMessage(botId, { type: 'plugins:reload' })) {
             this.logger.info({ botId }, 'Отправлен plugins:reload');
-            const { getIO } = require('../../real-time/socketHandler');
-            getIO().emit('bot:plugins_reloaded', { botId });
+            const { getIOSafe } = require('../../real-time/socketHandler');
+            getIOSafe().emit('bot:plugins_reloaded', { botId });
             return { success: true, message: 'Команда на перезагрузку плагинов отправлена.' };
         }
         return { success: false, message: 'Бот не запущен.' };
@@ -591,6 +695,141 @@ class BotLifecycleService {
 
         return { success: true };
     }
+
+    async _handleTraceCompleted(botId, trace) {
+        try {
+            const { getTraceCollector } = require('../services/TraceCollectorService');
+            const traceCollector = getTraceCollector();
+
+            // Сохраняем трассировку в главном TraceCollectorService
+            await traceCollector._storeCompletedTrace(trace);
+        } catch (error) {
+            this.logger.error({ botId, error }, 'Ошибка обработки завершённой трассировки');
+        }
+    }
+
+    async _handleDebugBreakpointCheck(botId, child, message) {
+        const { requestId, payload } = message;
+        const { graphId, nodeId, nodeType, inputs, executedSteps, context } = payload;
+
+        try {
+            const { getGlobalDebugManager } = require('../services/DebugSessionManager');
+            const debugManager = getGlobalDebugManager();
+
+            const debugState = debugManager.get(graphId);
+            if (!debugState) {
+                // Нет debug сессии для этого графа - просто продолжаем выполнение
+                child.send({
+                    type: 'debug:breakpoint_response',
+                    requestId,
+                    overrides: null
+                });
+                return;
+            }
+
+            const breakpoint = debugState.breakpoints.get(nodeId);
+            if (!breakpoint || !breakpoint.enabled) {
+                // Нет брейкпоинта для этой ноды или он отключен
+                child.send({
+                    type: 'debug:breakpoint_response',
+                    requestId,
+                    overrides: null
+                });
+                return;
+            }
+
+            // Проверяем условие брейкпоинта (пока всегда срабатывает)
+            // TODO: добавить evaluateBreakpointCondition
+
+            breakpoint.hitCount++;
+
+            // Приостанавливаем выполнение и ждём действий от пользователя
+            const overrides = await debugState.pause({
+                nodeId,
+                nodeType,
+                inputs,
+                executedSteps,
+                context,
+                breakpoint: {
+                    condition: breakpoint.condition,
+                    hitCount: breakpoint.hitCount
+                }
+            });
+
+            // Отправляем результат обратно в дочерний процесс
+            child.send({
+                type: 'debug:breakpoint_response',
+                requestId,
+                overrides: overrides || null
+            });
+
+        } catch (error) {
+            this.logger.error({ botId, error }, 'Ошибка обработки debug breakpoint check');
+            // В случае ошибки отправляем null чтобы продолжить выполнение
+            child.send({
+                type: 'debug:breakpoint_response',
+                requestId,
+                overrides: null
+            });
+        }
+    }
+
+    async _handleDebugStepModeCheck(botId, child, message) {
+        const { requestId, payload } = message;
+        const { graphId, nodeId, nodeType, inputs, executedSteps, context } = payload;
+
+        try {
+            const { getGlobalDebugManager } = require('../services/DebugSessionManager');
+            const debugManager = getGlobalDebugManager();
+
+            const debugState = debugManager.get(graphId);
+            if (!debugState) {
+                // Нет debug сессии - продолжаем выполнение
+                child.send({
+                    type: 'debug:breakpoint_response', // Используем тот же тип ответа
+                    requestId,
+                    overrides: null
+                });
+                return;
+            }
+
+            // Проверяем, нужно ли остановиться в step mode
+            if (!debugState.shouldStepPause(nodeId)) {
+                // Step mode не активен или не нужно останавливаться на этой ноде
+                child.send({
+                    type: 'debug:breakpoint_response',
+                    requestId,
+                    overrides: null
+                });
+                return;
+            }
+
+            // Приостанавливаем выполнение и ждём действий от пользователя
+            const overrides = await debugState.pause({
+                nodeId,
+                nodeType,
+                inputs,
+                executedSteps,
+                context
+            });
+
+            // Отправляем результат обратно в дочерний процесс
+            child.send({
+                type: 'debug:breakpoint_response',
+                requestId,
+                overrides: overrides || null
+            });
+
+        } catch (error) {
+            this.logger.error({ botId, error }, 'Ошибка обработки debug step mode check');
+            // В случае ошибки отправляем null чтобы продолжить выполнение
+            child.send({
+                type: 'debug:breakpoint_response',
+                requestId,
+                overrides: null
+            });
+        }
+    }
 }
 
 module.exports = BotLifecycleService;