blockmine 1.6.2 → 1.12.1

package/backend/src/core/EventGraphManager.js

@@ -1,13 +1,14 @@
 const { PrismaClient } = require('@prisma/client');
+const GraphExecutionEngine = require('./GraphExecutionEngine');
+const nodeRegistry = require('./NodeRegistry');
 
 const prisma = new PrismaClient();
 
 class EventGraphManager {
     constructor(botManager) {
         this.botManager = botManager;
-        this.graphEngine = botManager.graphEngine;
+        this.graphEngine = new GraphExecutionEngine(nodeRegistry, botManager);
         this.activeGraphs = new Map();
-        // Хранилище для состояний (переменных) каждого графа
         this.graphStates = new Map();
     }
 
@@ -26,7 +27,6 @@ class EventGraphManager {
                 const parsedGraph = JSON.parse(graph.graphJson);
                 if (!parsedGraph.nodes) continue;
 
-                // Инициализация начального состояния переменных для этого графа
                 const initialState = {};
                 if (graph.variables) {
                     try {
@@ -56,6 +56,7 @@ class EventGraphManager {
                         name: graph.name,
                         nodes: parsedGraph.nodes,
                         connections: parsedGraph.connections,
+                        variables: parsedGraph.variables || [],
                     });
                 }
             } catch (e) {
@@ -69,7 +70,6 @@ class EventGraphManager {
 
     unloadGraphsForBot(botId) {
         this.activeGraphs.delete(botId);
-        // Также очищаем состояния при выгрузке
         for (const key of this.graphStates.keys()) {
             if (key.startsWith(`${botId}-`)) {
                 this.graphStates.delete(key);
@@ -120,7 +120,25 @@ class EventGraphManager {
         initialContext.botId = botId;
         initialContext.players = players;
         initialContext.botState = eventArgs.botState || {};
-        initialContext.variables = { ...(this.graphStates.get(stateKey) || {}) };
+        
+        const savedVariables = { ...(this.graphStates.get(stateKey) || {}) };
+        
+        if (graph.variables && Array.isArray(graph.variables)) {
+            for (const v of graph.variables) {
+                if (!savedVariables.hasOwnProperty(v.name)) {
+                    let val;
+                    switch (v.type) {
+                        case 'number': val = Number(v.value) || 0; break;
+                        case 'boolean': val = v.value === 'true'; break;
+                        case 'array': try { val = Array.isArray(JSON.parse(v.value)) ? JSON.parse(v.value) : []; } catch { val = []; } break;
+                        default: val = v.value;
+                    }
+                    savedVariables[v.name] = val;
+                }
+            }
+        }
+        
+        initialContext.variables = savedVariables;
 
         try {
             const finalContext = await this.graphEngine.execute(graph, initialContext, eventType);
@@ -162,6 +180,12 @@ class EventGraphManager {
             case 'entityGone':
                 context.entity = args.entity;
                 break;
+            case 'command':
+                context.command_name = args.commandName;
+                context.user = args.user;
+                context.args = args.args;
+                context.chat_type = args.typeChat;
+                break;
         }
         return context;
     }

package/backend/src/core/GraphExecutionEngine.js

@@ -219,6 +219,34 @@ class GraphExecutionEngine {
             await this.traverse(node, 'completed');
             break;
           }
+          case 'flow:while': {
+            let iteration = 0;
+            const maxIterations = 1000;
+            
+            try {
+                while (iteration < maxIterations) {
+                    const condition = await this.resolvePinValue(node, 'condition', false);
+                    if (!condition) break;
+                    
+                    this.memo.set(`${node.id}:iteration`, iteration);
+                    this.clearLoopBodyMemo(node);
+                    await this.traverse(node, 'loop_body');
+                    iteration++;
+                }
+                
+                if (iteration >= maxIterations) {
+                    console.warn(`[GraphExecutionEngine] Цикл while достиг максимального количества итераций (${maxIterations})`);
+                }
+            } catch (e) {
+                if (e instanceof BreakLoopSignal) {
+                } else {
+                    throw e;
+                }
+            }
+            
+            await this.traverse(node, 'completed');
+            break;
+          }
           case 'flow:sequence': {
               const pinCount = node.data?.pinCount || 2;
               for (let i = 0; i < pinCount; i++) {
@@ -375,7 +403,7 @@ class GraphExecutionEngine {
           case 'event:command':
               if (pinId === 'args') result = this.context.args || {};
               else if (pinId === 'user') result = this.context.user || {};
-              else if (pinId === 'chat_type') result = this.context.typeChat || 'local';
+              else if (pinId === 'chat_type') result = this.context.typeChat || 'chat';
               else result = this.context[pinId];
               break;
           case 'event:chat':
@@ -399,8 +427,13 @@ class GraphExecutionEngine {
               break;
           
           case 'data:get_variable':
-              const varName = node.data?.variableName || '';
-              result = this.context.variables.hasOwnProperty(varName) ? this.context.variables[varName] : null;
+              const varName = node.data?.variableName || node.data?.selectedVariable || '';
+              if (!varName) {
+                  console.warn('[GraphExecutionEngine] data:get_variable: не указано имя переменной', node.data);
+                  result = null;
+              } else {
+                  result = this.context.variables.hasOwnProperty(varName) ? this.context.variables[varName] : null;
+              }
               break;
           
 
@@ -471,17 +504,13 @@ class GraphExecutionEngine {
           case 'logic:operation': {
             const op = node.data?.operation || 'AND';
             const inputs = [];
-            for (const key in node.data) {
-                if (key.startsWith('pin_')) {
-                    inputs.push(await this.resolvePinValue(node, key, false));
-                }
-            }
-            if (inputs.length === 0) {
-                inputs.push(await this.resolvePinValue(node, 'a', false));
-                inputs.push(await this.resolvePinValue(node, 'b', false));
+            const pinCount = node.data?.pinCount || 2;
+            
+            for (let i = 0; i < pinCount; i++) {
+                const value = await this.resolvePinValue(node, `pin_${i}`, false);
+                inputs.push(value);
             }
 
-
             switch (op) {
                 case 'AND': result = inputs.every(Boolean); break;
                 case 'OR': result = inputs.some(Boolean); break;
@@ -738,6 +767,12 @@ class GraphExecutionEngine {
             }
             break;
           }
+          case 'flow:while': {
+            if (pinId === 'iteration') {
+                result = this.memo.get(`${node.id}:iteration`);
+            }
+            break;
+          }
           
           case 'string:equals': {
               const strA = String(await this.resolvePinValue(node, 'a', ''));
@@ -798,6 +833,13 @@ class GraphExecutionEngine {
 
     return false;
   }
+
+  hasConnection(node, pinId) {
+      if (!this.activeGraph || !this.activeGraph.connections) return false;
+      return this.activeGraph.connections.some(conn => 
+          conn.targetNodeId === node.id && conn.targetPinId === pinId
+      );
+  }
 }
 
 module.exports = GraphExecutionEngine;

package/backend/src/core/MessageQueue.js

@@ -33,7 +33,16 @@ class MessageQueue {
     enqueue(chatType, message, username = null) {
         const typeConfig = this.chatTypes[chatType];
         if (!typeConfig) return;
-        this._enqueue({ type: 'simple', chatType, ...typeConfig, message, username });
+
+        if (Array.isArray(message)) {
+            for (const msg of message) {
+                if (typeof msg === 'string' && msg.trim().length > 0) {
+                    this._enqueue({ type: 'simple', chatType, ...typeConfig, message: msg, username });
+                }
+            }
+        } else if (typeof message === 'string') {
+            this._enqueue({ type: 'simple', chatType, ...typeConfig, message, username });
+        }
     }
 
     enqueueAndWait(command, patterns, timeout) {

package/backend/src/core/NodeRegistry.js

@@ -102,11 +102,12 @@ class NodeRegistry {
       label: '▶️ При выполнении команды',
       category: 'События',
       description: 'Стартовая точка для графа команды.',
-      graphType: command,
+      graphType: 'all',
       pins: {
         inputs: [],
         outputs: [
           { id: 'exec', name: 'Выполнить', type: 'Exec' },
+          { id: 'command_name', name: 'Имя команды', type: 'String' },
           { id: 'user', name: 'Пользователь', type: 'User' },
           { id: 'args', name: 'Аргументы', type: 'Object' },
           { id: 'chat_type', name: 'Тип чата', type: 'String' }

package/backend/src/core/PluginLoader.js

@@ -1,8 +1,36 @@
 
 const path = require('path');
 const fs = require('fs/promises');
+const { execSync } = require('child_process');
+const fssync = require('fs');
+const PluginStore = require('../plugins/PluginStore');
 
-async function initializePlugins(bot, installedPlugins = []) {
+const projectRoot = path.resolve(__dirname, '..');
+
+async function ensurePluginDependencies(pluginPath, pluginName) {
+    const packageJsonPath = path.join(pluginPath, 'package.json');
+    try {
+        if (fssync.existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+            if (packageJson.dependencies && Object.keys(packageJson.dependencies).length > 0) {
+                console.log(`[PluginLoader] У плагина ${pluginName} есть зависимости, устанавливаем их...`);
+                try {
+                    execSync('npm install', { 
+                        cwd: pluginPath, 
+                        stdio: 'pipe' 
+                    });
+                    console.log(`[PluginLoader] Зависимости для плагина ${pluginName} установлены`);
+                } catch (installError) {
+                    console.error(`[PluginLoader] Ошибка установки зависимостей для ${pluginName}:`, installError.message);
+                }
+            }
+        }
+    } catch (error) {
+        console.error(`[PluginLoader] Ошибка чтения package.json для ${pluginName}:`, error.message);
+    }
+}
+
+async function initializePlugins(bot, installedPlugins = [], prisma) {
     if (!installedPlugins || installedPlugins.length === 0) return;
     
     const sendLog = bot.sendLog || console.log;
@@ -11,6 +39,8 @@ async function initializePlugins(bot, installedPlugins = []) {
     for (const plugin of installedPlugins) {
         if (plugin && plugin.path) {
             try {
+                await ensurePluginDependencies(plugin.path, plugin.name);
+
                 const manifest = plugin.manifest ? JSON.parse(plugin.manifest) : {};
                 const savedSettings = plugin.settings ? JSON.parse(plugin.settings) : {};
                 const defaultSettings = {};
@@ -38,20 +68,54 @@ async function initializePlugins(bot, installedPlugins = []) {
                 }
                 
                 const finalSettings = { ...defaultSettings, ...savedSettings };
+                const store = new PluginStore(prisma, bot.config.id, plugin.name);
                 
                 const mainFile = manifest.main || 'index.js';
                 const entryPointPath = path.join(plugin.path, mainFile);
                 const normalizedPath = entryPointPath.replace(/\\/g, '/');
                 
                 sendLog(`[PluginLoader] Загрузка: ${plugin.name} (v${plugin.version}) из ${normalizedPath}`);
-                const pluginModule = require(normalizedPath);
                 
-                if (typeof pluginModule === 'function') {
-                    pluginModule(bot, { settings: finalSettings });
-                } else if (pluginModule && typeof pluginModule.onLoad === 'function') {
-                    pluginModule.onLoad(bot, { settings: finalSettings });
-                } else {
-                    sendLog(`[PluginLoader] [ERROR] ${plugin.name} не экспортирует функцию или объект с методом onLoad.`);
+                try {
+                    const pluginModule = require(normalizedPath);
+                    
+                    if (typeof pluginModule === 'function') {
+                        pluginModule(bot, { settings: finalSettings, store });
+                    } else if (pluginModule && typeof pluginModule.onLoad === 'function') {
+                        pluginModule.onLoad(bot, { settings: finalSettings, store });
+                    } else {
+                        sendLog(`[PluginLoader] [ERROR] ${plugin.name} не экспортирует функцию или объект с методом onLoad.`);
+                    }
+                } catch (error) {
+                    if (error.message.includes('Cannot find module')) {
+                        const moduleMatch = error.message.match(/Cannot find module '([^']+)'/);
+                        if (moduleMatch) {
+                            const missingModule = moduleMatch[1];
+                            sendLog(`[PluginLoader] Попытка установки недостающего модуля ${missingModule} в папку плагина ${plugin.name}`);
+                            try {
+                                execSync(`npm install ${missingModule}`, { 
+                                    cwd: plugin.path, 
+                                    stdio: 'pipe' 
+                                });
+                                sendLog(`[PluginLoader] Модуль ${missingModule} успешно установлен в папку плагина ${plugin.name}, повторная попытка загрузки`);
+                                
+                                // Повторная попытка загрузки
+                                const pluginModule = require(normalizedPath);
+                                if (typeof pluginModule === 'function') {
+                                    pluginModule(bot, { settings: finalSettings, store });
+                                } else if (pluginModule && typeof pluginModule.onLoad === 'function') {
+                                    pluginModule.onLoad(bot, { settings: finalSettings, store });
+                                }
+                            } catch (installError) {
+                                sendLog(`[PluginLoader] Не удалось установить модуль ${missingModule} в папку плагина ${plugin.name}: ${installError.message}`);
+                                throw error; // Пробрасываем оригинальную ошибку
+                            }
+                        } else {
+                            throw error;
+                        }
+                    } else {
+                        throw error;
+                    }
                 }
 
             } catch (error) {

package/backend/src/core/PluginManager.js

@@ -277,6 +277,25 @@ class PluginManager {
         
         return await this.installFromGithub(botId, repoUrl, prisma, true);
     }
+
+    async clearPluginData(pluginId) {
+        const plugin = await prisma.installedPlugin.findUnique({ where: { id: pluginId } });
+        if (!plugin) {
+            throw new Error('Плагин не найден.');
+        }
+
+        console.log(`[PluginManager] Очистка данных для плагина ${plugin.name} (Bot ID: ${plugin.botId})`);
+
+        const { count } = await prisma.pluginDataStore.deleteMany({
+            where: {
+                pluginName: plugin.name,
+                botId: plugin.botId,
+            },
+        });
+
+        console.log(`[PluginManager] Удалено ${count} записей из хранилища.`);
+        return { count };
+    }
 }
 
 module.exports = PluginManager;

package/backend/src/plugins/PluginStore.js

@@ -0,0 +1,87 @@
+class PluginStore {
+    constructor(prisma, botId, pluginName) {
+        this.prisma = prisma;
+        this.botId = botId;
+        this.pluginName = pluginName;
+    }
+
+    async set(key, value) {
+        const jsonValue = JSON.stringify(value);
+        await this.prisma.pluginDataStore.upsert({
+            where: {
+                pluginName_botId_key: {
+                    pluginName: this.pluginName,
+                    botId: this.botId,
+                    key: key
+                }
+            },
+            update: {
+                value: jsonValue
+            },
+            create: {
+                pluginName: this.pluginName,
+                botId: this.botId,
+                key: key,
+                value: jsonValue
+            }
+        });
+    }
+
+    async get(key) {
+        const data = await this.prisma.pluginDataStore.findUnique({
+            where: {
+                pluginName_botId_key: {
+                    pluginName: this.pluginName,
+                    botId: this.botId,
+                    key: key
+                }
+            }
+        });
+        return data ? JSON.parse(data.value) : null;
+    }
+
+    async delete(key) {
+        try {
+            await this.prisma.pluginDataStore.delete({
+                where: {
+                    pluginName_botId_key: {
+                        pluginName: this.pluginName,
+                        botId: this.botId,
+                        key: key
+                    }
+                }
+            });
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async has(key) {
+        const count = await this.prisma.pluginDataStore.count({
+            where: {
+                pluginName: this.pluginName,
+                botId: this.botId,
+                key: key
+            }
+        });
+        return count > 0;
+    }
+
+    async getAll() {
+        const allData = await this.prisma.pluginDataStore.findMany({
+            where: {
+                pluginName: this.pluginName,
+                botId: this.botId
+            }
+        });
+        const map = new Map();
+        for (const item of allData) {
+            map.set(item.key, JSON.parse(item.value));
+        }
+        return map;
+    }
+}
+
+module.exports = PluginStore;
+

package/backend/src/real-time/socketHandler.js

@@ -1,6 +1,8 @@
 const { Server } = require('socket.io');
 const config = require('../config');
 
+const { botManager } = require('../core/services');
+
 let io;
 
 function initializeSocket(httpServer) {
@@ -16,14 +18,20 @@ function initializeSocket(httpServer) {
     });
 
     io.on('connection', (socket) => {
-        // console.log(`[Socket.IO] Пользователь подключен: ${socket.id}. Всего клиентов: ${io.engine.clientsCount}`);
         
         socket.on('disconnect', () => {
-            // console.log(`[Socket.IO] Пользователь отключен: ${socket.id}. Всего клиентов: ${io.engine.clientsCount}`);
+            botManager.handleSocketDisconnect(socket);
+        });
+
+        socket.on('plugin:ui:subscribe', ({ botId, pluginName }) => {
+            botManager.subscribeToPluginUi(botId, pluginName, socket);
+        });
+
+        socket.on('plugin:ui:unsubscribe', ({ botId, pluginName }) => {
+            botManager.unsubscribeFromPluginUi(botId, pluginName, socket);
         });
     });
     
-    // console.log('Socket.IO инициализирован с динамическим CORS.');
     return io;
 }
 

package/backend/src/server.js

@@ -19,6 +19,7 @@ const searchRoutes = require('./api/routes/search');
 const eventGraphsRouter = require('./api/routes/eventGraphs');
 const TaskScheduler = require('./core/TaskScheduler');
 const panelRoutes = require('./api/routes/panel');
+const changelogRoutes = require('./api/routes/changelog');
 
 const app = express();
 const server = http.createServer(app);
@@ -59,6 +60,7 @@ app.use('/api/servers', serverRoutes);
 app.use('/api/permissions', permissionsRoutes);
 app.use('/api/search', searchRoutes);
 app.use('/api/panel', panelRoutes);
+app.use('/api/changelog', changelogRoutes);
 
 app.use(express.static(frontendPath));
 

package/commitlint.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  extends: ['@commitlint/config-conventional']
+};