blockmine 1.22.0 → 1.23.0

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/core/BotHistoryStore.js

@@ -0,0 +1,180 @@
+/**
+ * In-memory хранилище истории чатов и команд ботов
+ * Хранит последние N сообщений/команд для каждого бота
+ */
+
+class BotHistoryStore {
+    constructor() {
+        this.chatHistory = new Map();
+        this.commandLogs = new Map();
+
+        this.MAX_CHAT_MESSAGES = 1000;
+        this.MAX_COMMAND_LOGS = 500;
+    }
+
+    /**
+     * Добавить сообщение чата
+     */
+    addChatMessage(botId, data) {
+        if (!this.chatHistory.has(botId)) {
+            this.chatHistory.set(botId, []);
+        }
+
+        const messages = this.chatHistory.get(botId);
+
+        const entry = {
+            type: data.type || 'chat',
+            username: data.username,
+            message: data.message,
+            timestamp: data.timestamp || new Date().toISOString()
+        };
+
+        messages.push(entry);
+
+        if (messages.length > this.MAX_CHAT_MESSAGES) {
+            messages.shift();
+        }
+    }
+
+    /**
+     * Получить историю чата с фильтрами
+     */
+    getChatHistory(botId, filters = {}) {
+        const messages = this.chatHistory.get(botId) || [];
+
+        let filtered = [...messages];
+
+        if (filters.type) {
+            filtered = filtered.filter(m => m.type === filters.type);
+        }
+
+        if (filters.username) {
+            filtered = filtered.filter(m => m.username.toLowerCase() === filters.username.toLowerCase());
+        }
+
+        if (filters.search) {
+            const searchLower = filters.search.toLowerCase();
+            filtered = filtered.filter(m => m.message.toLowerCase().includes(searchLower));
+        }
+
+        if (filters.from) {
+            const fromDate = new Date(filters.from);
+            filtered = filtered.filter(m => new Date(m.timestamp) >= fromDate);
+        }
+
+        if (filters.to) {
+            const toDate = new Date(filters.to);
+            filtered = filtered.filter(m => new Date(m.timestamp) <= toDate);
+        }
+
+        const limit = parseInt(filters.limit) || 100;
+        const offset = parseInt(filters.offset) || 0;
+
+        return {
+            messages: filtered.slice(offset, offset + limit).reverse(),
+            total: filtered.length
+        };
+    }
+
+    /**
+     * Добавить лог команды
+     */
+    addCommandLog(botId, data) {
+        if (!this.commandLogs.has(botId)) {
+            this.commandLogs.set(botId, []);
+        }
+
+        const logs = this.commandLogs.get(botId);
+
+        const entry = {
+            username: data.username,
+            command: data.command,
+            args: data.args || [],
+            success: data.success !== undefined ? data.success : true,
+            error: data.error || null,
+            timestamp: data.timestamp || new Date().toISOString()
+        };
+
+        logs.push(entry);
+
+        if (logs.length > this.MAX_COMMAND_LOGS) {
+            logs.shift();
+        }
+    }
+
+    /**
+     * Получить логи команд с фильтрами
+     */
+    getCommandLogs(botId, filters = {}) {
+        const logs = this.commandLogs.get(botId) || [];
+
+        let filtered = [...logs];
+
+        if (filters.username) {
+            filtered = filtered.filter(l => l.username.toLowerCase() === filters.username.toLowerCase());
+        }
+
+        if (filters.command) {
+            filtered = filtered.filter(l => l.command === filters.command);
+        }
+
+        if (filters.success !== undefined) {
+            const successValue = filters.success === 'true' || filters.success === true;
+            filtered = filtered.filter(l => l.success === successValue);
+        }
+
+        if (filters.from) {
+            const fromDate = new Date(filters.from);
+            filtered = filtered.filter(l => new Date(l.timestamp) >= fromDate);
+        }
+
+        if (filters.to) {
+            const toDate = new Date(filters.to);
+            filtered = filtered.filter(l => new Date(l.timestamp) <= toDate);
+        }
+
+        const limit = parseInt(filters.limit) || 100;
+        const offset = parseInt(filters.offset) || 0;
+
+        return {
+            logs: filtered.slice(offset, offset + limit).reverse(),
+            total: filtered.length
+        };
+    }
+
+    /**
+     * Очистить историю бота
+     */
+    clearBot(botId) {
+        this.chatHistory.delete(botId);
+        this.commandLogs.delete(botId);
+    }
+
+    /**
+     * Получить статистику
+     */
+    getStats(botId) {
+        const chatMessages = this.chatHistory.get(botId) || [];
+        const commandLogs = this.commandLogs.get(botId) || [];
+
+        const byType = {};
+        chatMessages.forEach(msg => {
+            const type = msg.type || 'unknown';
+            byType[type] = (byType[type] || 0) + 1;
+        });
+
+        return {
+            chat: {
+                total: chatMessages.length,
+                byType
+            },
+            commands: {
+                total: commandLogs.length,
+                successful: commandLogs.filter(l => l.success).length,
+                failed: commandLogs.filter(l => !l.success).length
+            }
+        };
+    }
+}
+
+module.exports = new BotHistoryStore();

package/backend/src/core/BotManager.js

@@ -159,8 +159,11 @@ class BotManager {
     // === Resource monitoring ===
     async updateAllResourceUsage() {
         const usageData = await this.resourceMonitor.updateAllResourceUsage();
-        const { getIO } = require('../real-time/socketHandler');
-        getIO().emit('bots:usage', usageData);
+        const { getIOSafe } = require('../real-time/socketHandler');
+        const io = getIOSafe();
+        if (io) {
+            io.emit('bots:usage', usageData);
+        }
     }
 
     getBotIdByPid(pid) {
@@ -195,11 +198,14 @@ class BotManager {
 
     syncBotStatuses() {
         const processes = this.processManager.getAllProcesses();
-        const { getIO } = require('../real-time/socketHandler');
+        const { getIOSafe } = require('../real-time/socketHandler');
+        const io = getIOSafe();
+
+        if (!io) return;
 
         for (const [botId, child] of processes.entries()) {
             const actualStatus = child.killed ? 'stopped' : 'running';
-            getIO().emit('bot:status', { botId, status: actualStatus });
+            io.emit('bot:status', { botId, status: actualStatus });
         }
     }
 
@@ -209,6 +215,10 @@ class BotManager {
         this.lifecycleService.eventGraphManager = manager;
     }
 
+    getChildProcess(botId) {
+        return this.lifecycleService.getChildProcess(botId);
+    }
+
     // === Legacy async methods для migration ===
     async _syncSystemPermissions(botId) {
         return this.lifecycleService._syncSystemPermissions(botId);