blockmine 1.21.0 → 1.23.0

package/backend/src/core/nodes/actions/create_command.js

@@ -0,0 +1,189 @@
+const prismaService = require('../../PrismaService');
+const prisma = prismaService.getClient();
+const { getRuntimeCommandRegistry } = require('../../system/RuntimeCommandRegistry');
+const Command = require('../../system/Command');
+
+/**
+ * Создает новую команду (временную или постоянную)
+ * @param {object} node - Экземпляр узла из графа
+ * @param {object} context - Контекст выполнения графа
+ * @param {object} helpers - Вспомогательные функции движка
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse, memo } = helpers;
+    const { botId, botManager } = context;
+
+    try {
+        const name = await resolvePinValue(node, 'name');
+        const description = await resolvePinValue(node, 'description', '');
+        let aliases = await resolvePinValue(node, 'aliases', []);
+        const cooldown = await resolvePinValue(node, 'cooldown', 0);
+        let allowedChatTypes = await resolvePinValue(node, 'allowedChatTypes', ['chat', 'private']);
+        const permissionName = await resolvePinValue(node, 'permissionName', null);
+        const temporary = await resolvePinValue(node, 'temporary', false);
+
+        if (typeof aliases === 'string') {
+            try {
+                const normalizedString = aliases.replace(/'/g, '"');
+                aliases = JSON.parse(normalizedString);
+            } catch (e) {
+                console.warn('[create_command] Не удалось распарсить aliases:', e);
+                aliases = [];
+            }
+        }
+
+        if (typeof allowedChatTypes === 'string') {
+            try {
+                const normalizedString = allowedChatTypes.replace(/'/g, '"');
+                allowedChatTypes = JSON.parse(normalizedString);
+            } catch (e) {
+                console.warn('[create_command] Не удалось распарсить allowedChatTypes:', e);
+                allowedChatTypes = ['chat', 'private'];
+            }
+        }
+
+        if (!name) {
+            console.error('[create_command] Имя команды обязательно');
+            memo.set(`${node.id}:success`, false);
+            memo.set(`${node.id}:commandId`, null);
+            await traverse(node, 'exec');
+            return;
+        }
+
+        let commandId = null;
+
+        if (temporary) {
+            commandId = `temp_${Date.now()}`;
+
+            let permissionId = null;
+
+            if (permissionName) {
+                const permission = await prisma.permission.findFirst({
+                    where: {
+                        botId,
+                        name: permissionName
+                    }
+                });
+
+                if (permission) {
+                    permissionId = permission.id;
+                }
+            }
+
+            const tempCommand = new Command({
+                name,
+                description: description || '',
+                aliases: Array.isArray(aliases) ? aliases : [],
+                cooldown: cooldown || 0,
+                allowedChatTypes: Array.isArray(allowedChatTypes) ? allowedChatTypes : ['chat', 'private'],
+                args: [],
+                owner: 'runtime',
+            });
+
+            tempCommand.permissionId = permissionId;
+            tempCommand.isTemporary = true;
+            tempCommand.tempId = commandId;
+            tempCommand.isVisual = false;
+
+            tempCommand.handler = () => {
+                // Handler будет вызван через validate_and_run_command в BotProcess
+            };
+
+            // Регистрируем в runtime registry (для главного процесса)
+            const runtimeRegistry = getRuntimeCommandRegistry();
+            runtimeRegistry.register(botId, name, tempCommand);
+
+            // Также регистрируем алиасы в runtime registry
+            if (Array.isArray(aliases)) {
+                for (const alias of aliases) {
+                    runtimeRegistry.register(botId, alias, tempCommand);
+                }
+            }
+
+            // Отправляем IPC сообщение в child process для регистрации команды
+            if (botManager && botManager.processManager) {
+                botManager.processManager.sendMessage(botId, {
+                    type: 'register_temp_command',
+                    commandData: {
+                        name,
+                        description: description || '',
+                        aliases: Array.isArray(aliases) ? aliases : [],
+                        cooldown: cooldown || 0,
+                        allowedChatTypes: Array.isArray(allowedChatTypes) ? allowedChatTypes : ['chat', 'private'],
+                        permissionId,
+                        tempId: commandId,
+                    }
+                });
+            }
+
+            console.log(`[create_command] Временная команда "${name}" создана с ID ${commandId}`);
+        } else {
+            const existingCommand = await prisma.command.findFirst({
+                where: { botId, name }
+            });
+
+            if (existingCommand) {
+                console.error(`[create_command] Команда "${name}" уже существует`);
+                memo.set(`${node.id}:success`, false);
+                memo.set(`${node.id}:commandId`, null);
+                await traverse(node, 'exec');
+                return;
+            }
+
+            let permissionId = null;
+            if (permissionName) {
+                const permission = await prisma.permission.findFirst({
+                    where: {
+                        botId,
+                        name: permissionName
+                    }
+                });
+
+                if (permission) {
+                    permissionId = permission.id;
+                } else {
+                    console.warn(`[create_command] Право "${permissionName}" не найдено, команда будет создана без права`);
+                }
+            }
+
+            const newCommand = await prisma.command.create({
+                data: {
+                    botId,
+                    name,
+                    description: description || '',
+                    aliases: JSON.stringify(Array.isArray(aliases) ? aliases : []),
+                    permissionId: permissionId || null,
+                    cooldown: cooldown || 0,
+                    allowedChatTypes: JSON.stringify(Array.isArray(allowedChatTypes) ? allowedChatTypes : ['chat', 'private']),
+                    isVisual: true,
+                    argumentsJson: '[]',
+                    graphJson: JSON.stringify({
+                        nodes: [],
+                        edges: []
+                    }),
+                    pluginOwnerId: null
+                }
+            });
+
+            commandId = newCommand.id;
+            console.log(`[create_command] Постоянная команда "${name}" создана с ID ${commandId}`);
+
+            if (botManager && botManager.reloadBotConfigInRealTime) {
+                botManager.reloadBotConfigInRealTime(botId);
+            }
+        }
+
+        memo.set(`${node.id}:commandId`, commandId);
+        memo.set(`${node.id}:success`, true);
+    } catch (error) {
+        console.error('[create_command] Ошибка создания команды:', error);
+        memo.set(`${node.id}:success`, false);
+        memo.set(`${node.id}:commandId`, null);
+    }
+
+    await traverse(node, 'exec');
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/actions/delete_command.js

@@ -0,0 +1,92 @@
+const prismaService = require('../../PrismaService');
+const prisma = prismaService.getClient();
+const { getRuntimeCommandRegistry } = require('../../system/RuntimeCommandRegistry');
+
+/**
+ * Удаляет существующую команду
+ * @param {object} node - Экземпляр узла из графа
+ * @param {object} context - Контекст выполнения графа
+ * @param {object} helpers - Вспомогательные функции движка
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse, memo } = helpers;
+    const { botId, botManager } = context;
+
+    try {
+        const commandName = await resolvePinValue(node, 'commandName');
+
+        if (!commandName) {
+            console.error('[delete_command] Имя команды обязательно');
+            memo.set(`${node.id}:success`, false);
+            await traverse(node, 'exec');
+            return;
+        }
+
+        const runtimeRegistry = getRuntimeCommandRegistry();
+
+        if (runtimeRegistry.has(botId, commandName)) {
+            const tempCommand = runtimeRegistry.get(botId, commandName);
+            const aliases = tempCommand && tempCommand.aliases ? tempCommand.aliases : [];
+
+            runtimeRegistry.unregister(botId, commandName);
+
+            if (Array.isArray(aliases)) {
+                for (const alias of aliases) {
+                    runtimeRegistry.unregister(botId, alias);
+                }
+            }
+
+            if (botManager && botManager.processManager) {
+                botManager.processManager.sendMessage(botId, {
+                    type: 'unregister_temp_command',
+                    commandName,
+                    aliases
+                });
+            }
+
+            console.log(`[delete_command] Временная команда "${commandName}" успешно удалена`);
+            memo.set(`${node.id}:success`, true);
+            await traverse(node, 'exec');
+            return;
+        }
+
+        const existingCommand = await prisma.command.findFirst({
+            where: { name: commandName, botId }
+        });
+
+        if (!existingCommand) {
+            console.error(`[delete_command] Команда "${commandName}" не найдена`);
+            memo.set(`${node.id}:success`, false);
+            await traverse(node, 'exec');
+            return;
+        }
+
+        if (!existingCommand.isVisual) {
+            console.error(`[delete_command] Команда "${commandName}" является системной и не может быть удалена`);
+            memo.set(`${node.id}:success`, false);
+            await traverse(node, 'exec');
+            return;
+        }
+
+        await prisma.command.delete({
+            where: { id: existingCommand.id }
+        });
+
+        console.log(`[delete_command] Команда "${commandName}" успешно удалена`);
+
+        if (botManager && botManager.reloadBotConfigInRealTime) {
+            botManager.reloadBotConfigInRealTime(botId);
+        }
+
+        memo.set(`${node.id}:success`, true);
+    } catch (error) {
+        console.error('[delete_command] Ошибка удаления команды:', error);
+        memo.set(`${node.id}:success`, false);
+    }
+
+    await traverse(node, 'exec');
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/{action_send_log.js → actions/send_log.js}

@@ -1,23 +1,28 @@
-/**
- * @param {object} node - Экземпляр узла из графа.
- * @param {object} context - Контекст выполнения графа.
- * @param {object} helpers - Вспомогательные функции движка.
- * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
- * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
- */
-async function execute(node, context, helpers) {
-    const message = await helpers.resolvePinValue(node, 'message', '');
-    
-    // this.botManager - это экземпляр botManager из GraphExecutionEngine
-    if (this.botManager?.appendLog && context?.botId) {
-        this.botManager.appendLog(context.botId, `[Graph] ${message}`);
-    } else {
-        console.log(`[Graph Log] ${message}`);
-    }
-
-    await helpers.traverse(node, 'exec');
-}
-
-module.exports = {
-    execute,
-};
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    let message = await helpers.resolvePinValue(node, 'message', '');
+
+    // Если сообщение - это объект или массив, форматируем как JSON
+    if (typeof message === 'object' && message !== null) {
+        message = JSON.stringify(message, null, 2);
+    }
+
+    if (context?.bot?.sendLog) {
+        context.bot.sendLog(`[Graph] ${message}`);
+    } else {
+        // Fallback - консоль терминала
+        console.log(`[Graph Log] ${message}`);
+    }
+
+    await helpers.traverse(node, 'exec');
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/{action_send_message.js → actions/send_message.js}

@@ -1,32 +1,32 @@
-/**
- * @param {object} node - Экземпляр узла из графа.
- * @param {object} context - Контекст выполнения графа.
- * @param {object} helpers - Вспомогательные функции движка.
- * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
- * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
- */
-async function execute(node, context, helpers) {
-    const { resolvePinValue, traverse } = helpers;
-
-    let message = String(await resolvePinValue(node, 'message', ''));
-    const chatType = await resolvePinValue(node, 'chat_type', context.typeChat);
-    const recipient = await resolvePinValue(node, 'recipient', context.user?.username);
-
-    // Парсим и заменяем переменные в формате {varName}
-    const variablePattern = /\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
-    const matches = [...message.matchAll(variablePattern)];
-
-    for (const match of matches) {
-        const varName = match[1];
-        // Для динамических пинов, созданных на фронтенде, значение нужно будет получить, используя resolvePinValue
-        const varValue = await resolvePinValue(node, `var_${varName}`, '');
-        message = message.replace(match[0], String(varValue));
-    }
-
-    context.bot.sendMessage(chatType, message, recipient);
-    await traverse(node, 'exec');
-}
-
-module.exports = {
-    execute,
-};
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse } = helpers;
+
+    let message = String(await resolvePinValue(node, 'message', ''));
+    const chatType = await resolvePinValue(node, 'chat_type', context.typeChat);
+    const recipient = await resolvePinValue(node, 'recipient', context.user?.username);
+
+    // Парсим и заменяем переменные в формате {varName}
+    const variablePattern = /\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
+    const matches = [...message.matchAll(variablePattern)];
+
+    for (const match of matches) {
+        const varName = match[1];
+        // Для динамических пинов, созданных на фронтенде, значение нужно будет получить, используя resolvePinValue
+        const varValue = await resolvePinValue(node, `var_${varName}`, '');
+        message = message.replace(match[0], String(varValue));
+    }
+
+    context.bot.sendMessage(chatType, message, recipient);
+    await traverse(node, 'exec');
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/actions/send_websocket_response.js

@@ -0,0 +1,33 @@
+/**
+ * Нода: Отправить ответ в WebSocket
+ * Отправляет данные обратно клиенту, вызвавшему граф через WebSocket API
+ *
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const data = await helpers.resolvePinValue(node, 'data', null);
+
+    // Проверяем, что граф был вызван через WebSocket API
+    if (!context.sendResponse || typeof context.sendResponse !== 'function') {
+        console.warn('[WebSocket Response] Нода может использоваться только в графах, вызванных через WebSocket API');
+        await helpers.traverse(node, 'exec');
+        return;
+    }
+
+    // Отправляем ответ клиенту
+    try {
+        context.sendResponse(data);
+        console.log('[WebSocket Response] Ответ отправлен клиенту:', data);
+    } catch (error) {
+        console.error('[WebSocket Response] Ошибка отправки ответа:', error);
+    }
+
+    // Продолжаем выполнение графа
+    await helpers.traverse(node, 'exec');
+}
+
+module.exports = { execute };

package/backend/src/core/nodes/actions/update_command.js

@@ -0,0 +1,133 @@
+const prismaService = require('../../PrismaService');
+const prisma = prismaService.getClient();
+
+/**
+ * Обновляет существующую команду
+ * @param {object} node - Экземпляр узла из графа
+ * @param {object} context - Контекст выполнения графа
+ * @param {object} helpers - Вспомогательные функции движка
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse, memo } = helpers;
+    const { botId, botManager } = context;
+
+    try {
+        const commandName = await resolvePinValue(node, 'commandName');
+        const newName = await resolvePinValue(node, 'newName', null);
+        const description = await resolvePinValue(node, 'description', null);
+        let aliases = await resolvePinValue(node, 'aliases', null);
+        const cooldown = await resolvePinValue(node, 'cooldown', null);
+        let allowedChatTypes = await resolvePinValue(node, 'allowedChatTypes', null);
+        const permissionName = await resolvePinValue(node, 'permissionName', null);
+
+        if (aliases !== null && typeof aliases === 'string') {
+            try {
+                const normalizedString = aliases.replace(/'/g, '"');
+                aliases = JSON.parse(normalizedString);
+            } catch (e) {
+                console.warn('[update_command] Не удалось распарсить aliases:', e);
+                aliases = null; 
+            }
+        }
+
+        if (allowedChatTypes !== null && typeof allowedChatTypes === 'string') {
+            try {
+                const normalizedString = allowedChatTypes.replace(/'/g, '"');
+                allowedChatTypes = JSON.parse(normalizedString);
+            } catch (e) {
+                console.warn('[update_command] Не удалось распарсить allowedChatTypes:', e);
+                allowedChatTypes = null; 
+            }
+        }
+
+        if (!commandName) {
+            console.error('[update_command] Имя команды обязательно');
+            memo.set(`${node.id}:success`, false);
+            await traverse(node, 'exec');
+            return;
+        }
+
+        const existingCommand = await prisma.command.findFirst({
+            where: { name: commandName, botId }
+        });
+
+        if (!existingCommand) {
+            console.error(`[update_command] Команда "${commandName}" не найдена`);
+            memo.set(`${node.id}:success`, false);
+            await traverse(node, 'exec');
+            return;
+        }
+
+        if (newName && newName !== existingCommand.name) {
+            const duplicateCommand = await prisma.command.findFirst({
+                where: {
+                    botId,
+                    name: newName,
+                    id: { not: existingCommand.id }
+                }
+            });
+
+            if (duplicateCommand) {
+                console.error(`[update_command] Команда с именем "${newName}" уже существует`);
+                memo.set(`${node.id}:success`, false);
+                await traverse(node, 'exec');
+                return;
+            }
+        }
+
+        const updateData = {};
+
+        if (newName !== null) updateData.name = newName;
+        if (description !== null) updateData.description = description;
+        if (aliases !== null) {
+            updateData.aliases = JSON.stringify(Array.isArray(aliases) ? aliases : []);
+        }
+        if (cooldown !== null) updateData.cooldown = cooldown;
+        if (allowedChatTypes !== null) {
+            updateData.allowedChatTypes = JSON.stringify(
+                Array.isArray(allowedChatTypes) ? allowedChatTypes : ['chat', 'private']
+            );
+        }
+
+        if (permissionName !== null) {
+            if (permissionName === '') {
+                updateData.permissionId = null;
+            } else {
+                const permission = await prisma.permission.findFirst({
+                    where: {
+                        botId,
+                        name: permissionName
+                    }
+                });
+
+                if (permission) {
+                    updateData.permissionId = permission.id;
+                } else {
+                    console.warn(`[update_command] Право "${permissionName}" не найдено, поле не будет обновлено`);
+                }
+            }
+        }
+
+        await prisma.command.update({
+            where: { id: existingCommand.id },
+            data: updateData
+        });
+
+        console.log(`[update_command] Команда "${commandName}" успешно обновлена`);
+
+        if (botManager && botManager.reloadBotConfigInRealTime) {
+            botManager.reloadBotConfigInRealTime(botId);
+        }
+
+        memo.set(`${node.id}:success`, true);
+    } catch (error) {
+        console.error('[update_command] Ошибка обновления команды:', error);
+        memo.set(`${node.id}:success`, false);
+    }
+
+    await traverse(node, 'exec');
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/arrays/get_next.js

@@ -0,0 +1,35 @@
+/**
+ * Получает следующий элемент массива по текущему индексу
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+    const arr = await resolvePinValue(node, 'array', []);
+    const currentIndex = await resolvePinValue(node, 'current_index', -1);
+    
+    const nextIndex = currentIndex + 1;
+    const hasNext = Array.isArray(arr) && nextIndex >= 0 && nextIndex < arr.length;
+
+    switch (pinId) {
+        case 'next_element':
+            return hasNext ? arr[nextIndex] : null;
+        
+        case 'next_index':
+            return nextIndex;
+        
+        case 'has_next':
+            return hasNext;
+        
+        default:
+            return null;
+    }
+}
+
+module.exports = {
+    evaluate,
+};
+
+
+
+
+
+

package/backend/src/core/nodes/arrays/join.js

@@ -0,0 +1,28 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const array = await resolvePinValue(node, 'array', []);
+        const separator = String(await resolvePinValue(node, 'separator', ', '));
+
+        if (!Array.isArray(array)) {
+            return '';
+        }
+
+        return array.join(separator);
+    }
+
+    return '';
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/{data_cast.js → data/cast.js}

@@ -9,12 +9,21 @@
 async function evaluate(node, pinId, context, helpers) {
     const { resolvePinValue } = helpers;
 
-    if (pinId === 'value') {
+    // Поддерживаем оба варианта: 'result' (новая версия) и 'value' (старая версия для обратной совместимости)
+    if (pinId === 'result' || pinId === 'value') {
         const value = await resolvePinValue(node, 'value');
         const targetType = node.data?.targetType || 'String';
 
         switch (targetType) {
             case 'String':
+                // Для объектов и массивов используем JSON.stringify
+                if (typeof value === 'object' && value !== null) {
+                    try {
+                        return JSON.stringify(value);
+                    } catch (e) {
+                        return String(value ?? '');
+                    }
+                }
                 return String(value ?? '');
             case 'Number':
                 const num = Number(value);