blockmine 1.14.1 → 1.15.1

package/backend/src/api/routes/eventGraphs.js

@@ -4,6 +4,8 @@ const { PrismaClient } = require('@prisma/client');
 const { authorize } = require('../middleware/auth');
 const logger = require('../../lib/logger');
 const crypto = require('crypto');
+const fse = require('fs-extra');
+const path = require('path');
 
 const prisma = new PrismaClient();
 const router = express.Router({ mergeParams: true });
@@ -14,7 +16,17 @@ router.get('/',
     const { botId } = req.params;
     const eventGraphs = await prisma.eventGraph.findMany({ 
       where: { botId: parseInt(botId) },
-      include: { triggers: true },
+      include: { 
+        triggers: true,
+        pluginOwner: {
+          select: {
+            id: true,
+            name: true,
+            version: true,
+            sourceType: true
+          }
+        }
+      },
       orderBy: { createdAt: 'desc' }
     });
 
@@ -46,21 +58,49 @@ router.post('/',
     }
 
     const { botId } = req.params;
-    const { name } = req.body;
-
-    const initialGraph = {
+    const { name, graphJson, variables, isEnabled = true } = req.body;
+
+    let graphJsonString;
+    if (graphJson) {
+      if (typeof graphJson === 'string') {
+        graphJsonString = graphJson;
+      } else {
+        graphJsonString = JSON.stringify(graphJson);
+      }
+    } else {
+      graphJsonString = JSON.stringify({
         nodes: [],
         connections: []
-    };
+      });
+    }
 
     try {
+        let eventTypes = [];
+        try {
+            const parsedGraph = JSON.parse(graphJsonString);
+            if (parsedGraph.nodes && Array.isArray(parsedGraph.nodes)) {
+                const eventNodes = parsedGraph.nodes.filter(node => node.type && node.type.startsWith('event:'));
+                eventTypes = [...new Set(eventNodes.map(node => node.type.split(':')[1]))];
+            }
+        } catch (error) {
+            console.warn('[API] Не удалось извлечь типы событий из графа:', error.message);
+        }
+
         const newGraph = await prisma.eventGraph.create({
             data: {
                 botId: parseInt(botId),
-                name,
-                graphJson: JSON.stringify(initialGraph)
-            }
+                name: name.trim(),
+                isEnabled: isEnabled,
+                graphJson: graphJsonString,
+                variables: variables || '[]',
+                pluginOwnerId: req.body.pluginOwnerId || null,
+                triggers: {
+                    create: eventTypes.map(eventType => ({ eventType }))
+                }
+            },
+            include: { triggers: true }
         });
+        
         res.status(201).json(newGraph);
     } catch (error) {
         if (error.code === 'P2002') {
@@ -84,8 +124,20 @@ router.get('/:graphId',
     const { graphId } = req.params;
     const eventGraph = await prisma.eventGraph.findUnique({ 
       where: { id: parseInt(graphId) },
-      include: { triggers: true } 
+      include: { 
+        triggers: true,
+        pluginOwner: {
+          select: {
+            id: true,
+            name: true,
+            version: true,
+            sourceType: true
+          }
+        }
+      } 
     });
+    
+
     if (!eventGraph) {
       return res.status(404).json({ error: 'Event graph not found' });
     }
@@ -109,12 +161,15 @@ router.put('/:graphId',
     }
 
     const { graphId } = req.params;
-    const { name, isEnabled, graphJson, variables } = req.body;
+    const { name, isEnabled, graphJson, variables, pluginOwnerId } = req.body;
+    
+
 
     try {
       const dataToUpdate = {};
       if (name !== undefined) dataToUpdate.name = name;
       if (isEnabled !== undefined) dataToUpdate.isEnabled = isEnabled;
+      if (pluginOwnerId !== undefined) dataToUpdate.pluginOwnerId = pluginOwnerId;
       
       if (graphJson !== undefined) {
           dataToUpdate.graphJson = graphJson;
@@ -149,6 +204,25 @@ router.put('/:graphId',
         include: { triggers: true },
       });
 
+      if (graphJson && updatedGraph.pluginOwnerId) {
+        try {
+          const plugin = await prisma.installedPlugin.findUnique({
+            where: { id: updatedGraph.pluginOwnerId }
+          });
+          
+          if (plugin) {
+            const graphDir = path.join(plugin.path, 'graph');
+            await fse.mkdir(graphDir, { recursive: true });
+            
+            const graphFile = path.join(graphDir, `${updatedGraph.name}.json`);
+            await fse.writeJson(graphFile, JSON.parse(graphJson), { spaces: 2 });
+            console.log(`[API] Граф события ${updatedGraph.name} сохранен в ${graphFile}`);
+          }
+        } catch (error) {
+          console.error(`[API] Ошибка сохранения графа события в папку плагина:`, error);
+        }
+      }
+
       res.json(updatedGraph);
     } catch (error) {
         logger.error(error, "--- ERROR CAUGHT IN EVENT GRAPH UPDATE ---");

package/backend/src/api/routes/plugins.js

@@ -64,6 +64,89 @@ router.post('/:id/clear-data', authenticate, authorize('plugin:settings:edit'),
     }
 });
 
+router.get('/:id/info', authenticate, authorize('plugin:list'), async (req, res) => {
+    try {
+        const pluginId = parseInt(req.params.id);
+        
+        const plugin = await prisma.installedPlugin.findUnique({
+            where: { id: pluginId },
+            include: {
+                commands: {
+                    select: {
+                        id: true,
+                        name: true,
+                        description: true,
+                        isEnabled: true,
+                        isVisual: true,
+                        owner: true
+                    }
+                },
+                eventGraphs: {
+                    select: {
+                        id: true,
+                        name: true,
+                        isEnabled: true,
+                        createdAt: true,
+                        updatedAt: true
+                    }
+                }
+            }
+        });
+
+        if (!plugin) {
+            return res.status(404).json({ error: 'Плагин не найден.' });
+        }
+
+        res.json(plugin);
+    } catch (error) {
+        console.error(`[API Error] /plugins/:id/info:`, error);
+        res.status(500).json({ error: 'Не удалось получить информацию о плагине.' });
+    }
+});
+
+router.get('/bot/:botId', authenticate, authorize('plugin:list'), async (req, res) => {
+    try {
+        const botId = parseInt(req.params.botId);
+        
+        const plugins = await prisma.installedPlugin.findMany({
+            where: { botId },
+            select: {
+                id: true,
+                name: true,
+                version: true,
+                description: true,
+                sourceType: true,
+                isEnabled: true,
+                commands: {
+                    select: {
+                        id: true,
+                        name: true,
+                        description: true,
+                        isEnabled: true,
+                        isVisual: true,
+                        owner: true
+                    }
+                },
+                eventGraphs: {
+                    select: {
+                        id: true,
+                        name: true,
+                        isEnabled: true,
+                        createdAt: true,
+                        updatedAt: true
+                    }
+                }
+            },
+            orderBy: { name: 'asc' }
+        });
+
+        res.json(plugins);
+    } catch (error) {
+        console.error(`[API Error] /plugins/bot/:botId:`, error);
+        res.status(500).json({ error: 'Не удалось получить список плагинов.' });
+    }
+});
+
 router.get('/catalog/:name', async (req, res) => {
     try {
         const pluginName = req.params.name;

package/backend/src/core/BotProcess.js

@@ -253,6 +253,20 @@ process.on('message', async (message) => {
                             }
                         }
 
+                        let pluginOwnerId = null;
+                        if (command.owner && command.owner.startsWith('plugin:')) {
+                            const pluginName = command.owner.replace('plugin:', '');
+                            const plugin = await prisma.installedPlugin.findFirst({
+                                where: {
+                                    botId: bot.config.id,
+                                    name: pluginName
+                                }
+                            });
+                            if (plugin) {
+                                pluginOwnerId = plugin.id;
+                            }
+                        }
+
                         const commandData = {
                             botId: bot.config.id,
                             name: command.name,
@@ -264,6 +278,7 @@ process.on('message', async (message) => {
                             aliases: JSON.stringify(command.aliases || []),
                             allowedChatTypes: JSON.stringify(command.allowedChatTypes || ['chat', 'private']),
                             argumentsJson: JSON.stringify(command.args || []),
+                            pluginOwnerId: pluginOwnerId,
                         };
 
                         await prisma.command.upsert({
@@ -339,6 +354,69 @@ process.on('message', async (message) => {
                         }, 10000);
                     });
                 },
+                registerEventGraph: async (graphData) => {
+                    try {
+                        let pluginOwnerId = null;
+                        if (graphData.owner && graphData.owner.startsWith('plugin:')) {
+                            const pluginName = graphData.owner.replace('plugin:', '');
+                            const plugin = await prisma.installedPlugin.findFirst({
+                                where: {
+                                    botId: bot.config.id,
+                                    name: pluginName
+                                }
+                            });
+                            if (plugin) {
+                                pluginOwnerId = plugin.id;
+                            }
+                        }
+
+                        const graphDataToSave = {
+                            botId: bot.config.id,
+                            name: graphData.name,
+                            isEnabled: graphData.isEnabled !== undefined ? graphData.isEnabled : true,
+                            graphJson: graphData.graphJson || JSON.stringify({ nodes: [], connections: [] }),
+                            variables: JSON.stringify(graphData.variables || []),
+                            pluginOwnerId: pluginOwnerId,
+                        };
+
+                        const eventGraph = await prisma.eventGraph.upsert({
+                            where: {
+                                botId_name: {
+                                    botId: bot.config.id,
+                                    name: graphData.name
+                                }
+                            },
+                            update: {
+                                isEnabled: graphDataToSave.isEnabled,
+                                graphJson: graphDataToSave.graphJson,
+                                variables: graphDataToSave.variables,
+                                pluginOwnerId: graphDataToSave.pluginOwnerId,
+                            },
+                            create: graphDataToSave,
+                        });
+
+                        if (graphData.triggers && Array.isArray(graphData.triggers)) {
+                            await prisma.eventTrigger.deleteMany({
+                                where: { graphId: eventGraph.id }
+                            });
+
+                            if (graphData.triggers.length > 0) {
+                                await prisma.eventTrigger.createMany({
+                                    data: graphData.triggers.map(eventType => ({
+                                        graphId: eventGraph.id,
+                                        eventType
+                                    }))
+                                });
+                            }
+                        }
+
+                        sendLog(`[API] Граф события "${graphData.name}" от плагина "${graphData.owner}" зарегистрирован.`);
+                        return eventGraph;
+                    } catch (error) {
+                        sendLog(`[API] Ошибка при регистрации графа события: ${error.message}`);
+                        throw error;
+                    }
+                },
                 executeCommand: (command) => {
                     sendLog(`[Graph] Выполнение серверной команды: ${command}`);
                     bot.chat(command);
@@ -676,7 +754,13 @@ process.on('message', async (message) => {
 process.on('unhandledRejection', (reason, promise) => {
     const errorMsg = `[FATAL] Необработанная ошибка процесса: ${reason?.stack || reason}`;
     sendLog(errorMsg);
-    process.exit(1);
+    setTimeout(() => process.exit(1), 100);
+});
+
+process.on('uncaughtException', (error) => {
+    const errorMsg = `[FATAL] Необработанное исключение: ${error.stack || error.message}`;
+    sendLog(errorMsg);
+    setTimeout(() => process.exit(1), 100);
 });
 
 process.on('SIGTERM', () => {
@@ -688,14 +772,26 @@ process.on('SIGTERM', () => {
             sendLog(`[System] Ошибка при корректном завершении бота: ${error.message}`);
         }
     }
-    process.exit(0);
+    setTimeout(() => process.exit(0), 100);
 });
 
-process.on('SIGKILL', () => {
-    sendLog('[System] Получен сигнал SIGKILL. Принудительное завершение...');
-    process.exit(0);
+process.on('SIGINT', () => {
+    sendLog('[System] Получен сигнал SIGINT. Завершение работы...');
+    if (bot) {
+        try {
+            bot.quit();
+        } catch (error) {
+            sendLog(`[System] Ошибка при корректном завершении бота: ${error.message}`);
+        }
+    }
+    setTimeout(() => process.exit(0), 100);
 });
 
+// process.on('SIGKILL', () => {
+//     sendLog('[System] Получен сигнал SIGKILL. Принудительное завершение...');
+//     process.exit(0);
+// });
+
 function serializeEntity(entity) {
     if (!entity) return null;
     return {

package/backend/src/core/GraphExecutionEngine.js

@@ -266,6 +266,41 @@ class GraphExecutionEngine {
               await this.traverse(node, 'exec');
               break;
           }
+          case 'array:get_random_element': {
+              await this.traverse(node, 'element');
+              break;
+          }
+          case 'array:add_element':
+          case 'array:remove_by_index':
+          case 'array:get_by_index':
+          case 'array:find_index':
+          case 'array:contains': {
+              await this.traverse(node, 'result');
+              break;
+          }
+          case 'data:array_literal':
+          case 'data:make_object':
+          case 'data:get_variable':
+          case 'data:get_argument':
+          case 'data:length':
+          case 'data:get_entity_field':
+          case 'data:cast':
+          case 'data:string_literal':
+          case 'data:get_user_field':
+          case 'data:get_server_players':
+          case 'data:get_bot_look':
+          case 'math:operation':
+          case 'math:random_number':
+          case 'logic:operation':
+          case 'string:concat':
+          case 'object:create':
+          case 'object:get':
+          case 'object:set':
+          case 'object:delete':
+          case 'object:has_key': {
+              await this.traverse(node, 'value');
+              break;
+          }
       }
   }
 
@@ -535,7 +570,10 @@ class GraphExecutionEngine {
             const numPins = node.data?.pinCount || 0;
             const items = [];
             for (let i = 0; i < numPins; i++) {
-                items.push(await this.resolvePinValue(node, `pin_${i}`));
+                const value = await this.resolvePinValue(node, `pin_${i}`) || 
+                             node.data?.[`item_${i}`] || 
+                             node.data?.[`value_${i}`];
+                items.push(value);
             }
             result = items;
             break;