blockmine 1.21.0 → 1.23.0

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

@@ -0,0 +1,347 @@
+const { randomUUID } = require('crypto');
+
+/**
+ * Состояние отладки для конкретного графа
+ * Shared state между всеми подключенными пользователями
+ */
+class GraphDebugState {
+  constructor(botId, graphId, io) {
+    this.botId = botId;
+    this.graphId = graphId;
+    this.io = io;
+
+    this.breakpoints = new Map(); // Map<nodeId, Breakpoint>
+
+    this.activeExecution = null;
+
+    this.connectedUsers = new Map(); // Map<socketId, {userId, username}>
+
+    this.pausePromise = null;
+    this.resumeCallback = null;
+
+    // Измененные значения во время паузы (what-if)
+    this.pendingOverrides = {}; // Object<key, value>
+
+    // Режим пошагового выполнения (step over)
+    this.stepMode = false; // Если true, остановится на следующей ноде
+    this.stepFromNodeId = null; // ID ноды, с которой начали step over (чтобы её пропустить)
+  }
+
+  /**
+   * Получить имя комнаты для этого графа
+   */
+  getRoomName() {
+    return `graph:${this.graphId}:debug`;
+  }
+
+  /**
+   * Broadcast событие всем подключенным пользователям
+   */
+  broadcast(event, data) {
+    const room = this.getRoomName();
+    console.log(`[GraphDebugState] Broadcasting ${event} to room ${room}`);
+    console.log(`[GraphDebugState] Connected users in this debug state:`, this.connectedUsers.size);
+
+    const socketsInRoom = this.io.sockets.adapter.rooms.get(room);
+    console.log(`[GraphDebugState] Sockets in room ${room}:`, socketsInRoom ? socketsInRoom.size : 0);
+
+    this.io.to(room).emit(event, data);
+  }
+
+  /**
+   * Приостановить выполнение графа
+   * Возвращает Promise, который разрешится когда пользователь нажмет Continue
+   */
+  async pause(state) {
+    // Генерируем sessionId для этой паузы
+    const sessionId = randomUUID();
+
+    this.activeExecution = {
+      sessionId,
+      ...state,
+      pausedAt: Date.now()
+    };
+
+
+    this.broadcast('debug:paused', {
+      sessionId,
+      ...state
+    });
+
+
+    // Создаем Promise, который будет ждать resume
+    this.pausePromise = new Promise((resolve) => {
+      this.resumeCallback = resolve;
+    });
+
+    // Ждем пока кто-то не вызовет resume
+    const overrides = await this.pausePromise;
+
+    return overrides;
+  }
+
+  /**
+   * Возобновить выполнение
+   * @param {object} overrides - Изменения значений
+   * @param {boolean} stepMode - Если true, остановится на следующей ноде
+   */
+  resume(overrides = null, stepMode = false) {
+    if (this.resumeCallback) {
+      // Объединяем pendingOverrides с переданными overrides
+      const finalOverrides = {
+        ...this.pendingOverrides,
+        ...(overrides || {})
+      };
+
+      console.log('[GraphDebugState] Resuming with overrides:', finalOverrides, 'stepMode:', stepMode);
+
+      // Устанавливаем флаг stepMode и запоминаем текущую ноду
+      this.stepMode = stepMode;
+      if (stepMode && this.activeExecution) {
+        this.stepFromNodeId = this.activeExecution.nodeId;
+        console.log('[GraphDebugState] Step mode: will skip current node', this.stepFromNodeId);
+      }
+
+      this.resumeCallback(Object.keys(finalOverrides).length > 0 ? finalOverrides : null);
+      this.resumeCallback = null;
+      this.pausePromise = null;
+    }
+
+    // Если не step mode, очищаем состояние полностью
+    if (!stepMode) {
+      this.activeExecution = null;
+      this.stepFromNodeId = null;
+    }
+
+    this.pendingOverrides = {}; // Очищаем после применения
+
+    this.broadcast('debug:resumed', { stepMode });
+  }
+
+  /**
+   * Остановить выполнение (форсированно)
+   */
+  stop() {
+    if (this.resumeCallback) {
+      this.resumeCallback({ __stopped: true });
+      this.resumeCallback = null;
+      this.pausePromise = null;
+    }
+
+    this.activeExecution = null;
+    this.pendingOverrides = {}; // Очищаем при остановке
+    this.stepMode = false; // Сбрасываем step mode
+    this.stepFromNodeId = null; // Очищаем запомненную ноду
+
+    this.broadcast('debug:stopped', {});
+  }
+
+  /**
+   * Добавить брейкпоинт
+   */
+  addBreakpoint(nodeId, condition, createdBy) {
+    const breakpoint = {
+      id: randomUUID(),
+      nodeId,
+      condition: condition || null,
+      enabled: true,
+      hitCount: 0,
+      createdBy,
+      createdAt: Date.now()
+    };
+
+    this.breakpoints.set(nodeId, breakpoint);
+
+    this.broadcast('debug:breakpoint-added', { breakpoint });
+
+    return breakpoint;
+  }
+
+  /**
+   * Удалить брейкпоинт
+   */
+  removeBreakpoint(nodeId) {
+    this.breakpoints.delete(nodeId);
+    this.broadcast('debug:breakpoint-removed', { nodeId });
+  }
+
+  /**
+   * Переключить enabled для брейкпоинта
+   */
+  toggleBreakpoint(nodeId, enabled) {
+    const bp = this.breakpoints.get(nodeId);
+    if (bp) {
+      bp.enabled = enabled;
+      this.broadcast('debug:breakpoint-toggled', { nodeId, enabled });
+    }
+  }
+
+  /**
+   * Очистить все брейкпоинты
+   */
+  clearAllBreakpoints() {
+    const nodeIds = Array.from(this.breakpoints.keys());
+    this.breakpoints.clear();
+
+    // Уведомляем о каждом удаленном брейкпоинте
+    nodeIds.forEach(nodeId => {
+      this.broadcast('debug:breakpoint-removed', { nodeId });
+    });
+  }
+
+  /**
+   * Проверить, нужно ли остановиться в step mode
+   * @param {string} nodeId - ID текущей ноды
+   * @returns {boolean}
+   */
+  shouldStepPause(nodeId) {
+    if (this.stepMode) {
+      // Пропускаем ноду, с которой начали step
+      if (nodeId === this.stepFromNodeId) {
+        return false;
+      }
+
+      // Останавливаемся на следующей ноде
+      this.stepMode = false; // Сбрасываем после остановки
+      this.stepFromNodeId = null;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Установить измененное значение (what-if)
+   */
+  setValue(key, value) {
+    this.pendingOverrides[key] = value;
+    console.log(`[GraphDebugState] Set override: ${key} =`, value);
+  }
+
+  /**
+   * Получить текущее состояние (для отправки новым пользователям)
+   */
+  getState() {
+    return {
+      breakpoints: Array.from(this.breakpoints.values()),
+      activeExecution: this.activeExecution,
+      connectedUsers: Array.from(this.connectedUsers.values())
+    };
+  }
+
+  /**
+   * Добавить пользователя
+   */
+  addUser(socketId, userInfo) {
+    this.connectedUsers.set(socketId, userInfo);
+  }
+
+  /**
+   * Удалить пользователя
+   */
+  removeUser(socketId) {
+    this.connectedUsers.delete(socketId);
+  }
+}
+
+/**
+ * Менеджер отладочных сессий
+ * Управляет состоянием отладки для всех графов (в памяти)
+ */
+class DebugSessionManager {
+  constructor(io) {
+    this.io = io;
+
+    // Map<graphId, GraphDebugState>
+    this.graphDebugStates = new Map();
+
+    console.log('[DebugSessionManager] Initialized');
+  }
+
+  /**
+   * Получить или создать состояние отладки для графа
+   */
+  getOrCreate(botId, graphId) {
+    if (!this.graphDebugStates.has(graphId)) {
+      const state = new GraphDebugState(botId, graphId, this.io);
+      this.graphDebugStates.set(graphId, state);
+      console.log(`[DebugSessionManager] Created debug state for graph ${graphId}`);
+    }
+
+    return this.graphDebugStates.get(graphId);
+  }
+
+  /**
+   * Получить состояние отладки для графа (если существует)
+   */
+  get(graphId) {
+    return this.graphDebugStates.get(graphId);
+  }
+
+  /**
+   * Найти состояние по sessionId
+   */
+  getBySessionId(sessionId) {
+    for (const state of this.graphDebugStates.values()) {
+      if (state.activeExecution && state.activeExecution.sessionId === sessionId) {
+        return state;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Удалить состояние графа (при необходимости)
+   */
+  remove(graphId) {
+    this.graphDebugStates.delete(graphId);
+    console.log(`[DebugSessionManager] Removed debug state for graph ${graphId}`);
+  }
+
+  /**
+   * Очистить все состояния (при перезапуске бота)
+   */
+  clearAll() {
+    this.graphDebugStates.clear();
+    console.log('[DebugSessionManager] Cleared all debug states');
+  }
+
+  /**
+   * Очистить состояния для конкретного бота
+   */
+  clearForBot(botId) {
+    for (const [graphId, state] of this.graphDebugStates.entries()) {
+      if (state.botId === botId) {
+        this.graphDebugStates.delete(graphId);
+      }
+    }
+    console.log(`[DebugSessionManager] Cleared debug states for bot ${botId}`);
+  }
+}
+
+// Глобальный инстанс для предотвращения циклических зависимостей
+let globalDebugManager = null;
+
+/**
+ * Инициализировать глобальный инстанс DebugSessionManager
+ */
+function initializeDebugManager(io) {
+  if (!globalDebugManager) {
+    globalDebugManager = new DebugSessionManager(io);
+    console.log('[DebugSessionManager] Global instance initialized');
+  }
+  return globalDebugManager;
+}
+
+/**
+ * Получить глобальный инстанс DebugSessionManager
+ */
+function getGlobalDebugManager() {
+  if (!globalDebugManager) {
+    throw new Error('DebugSessionManager not initialized! Call initializeDebugManager(io) first.');
+  }
+  return globalDebugManager;
+}
+
+module.exports = DebugSessionManager;
+module.exports.initializeDebugManager = initializeDebugManager;
+module.exports.getGlobalDebugManager = getGlobalDebugManager;