blockmine 1.22.0 → 1.23.1

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/actions/http_request.js

@@ -9,16 +9,35 @@
 async function execute(node, context, helpers) {
     const { resolvePinValue, traverse, memo } = helpers;
 
-    const url = await resolvePinValue(node, 'url', '');
+    let url = await resolvePinValue(node, 'url', '');
     const method = await resolvePinValue(node, 'method', node.data?.method || 'GET');
-    const headersStr = await resolvePinValue(node, 'headers', '');
+    const headersInput = await resolvePinValue(node, 'headers', null);
+    const queryParamsInput = await resolvePinValue(node, 'queryParams', null);
     const body = await resolvePinValue(node, 'body', '');
     const timeout = await resolvePinValue(node, 'timeout', 5000);
 
+    if (queryParamsInput) {
+        try {
+            const params = typeof queryParamsInput === 'string'
+                ? JSON.parse(queryParamsInput)
+                : queryParamsInput;
+
+            const urlObj = new URL(url);
+            Object.entries(params).forEach(([key, value]) => {
+                urlObj.searchParams.append(key, value);
+            });
+            url = urlObj.toString();
+        } catch (e) {
+            console.error('[HTTP Request] Ошибка обработки query params:', e);
+        }
+    }
+
     let headers = {};
-    if (headersStr) {
+    if (headersInput) {
         try {
-            headers = JSON.parse(headersStr);
+            headers = typeof headersInput === 'string'
+                ? JSON.parse(headersInput)
+                : headersInput;
         } catch (e) {
             console.error('[HTTP Request] Ошибка парсинга headers:', e);
             headers = {};

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

@@ -8,21 +8,11 @@
 async function execute(node, context, helpers) {
     const { resolvePinValue, traverse } = helpers;
 
-    let message = String(await resolvePinValue(node, 'message', ''));
+    // resolvePinValue теперь автоматически заменяет {varName} на значения
+    const 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');
 }

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/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

@@ -9,7 +9,8 @@
 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';
 

package/backend/src/core/nodes/data/string_literal.js

@@ -10,19 +10,8 @@ async function evaluate(node, pinId, context, helpers) {
     const { resolvePinValue } = helpers;
 
     if (pinId === 'value') {
-        let text = String(node.data?.value || '');
-
-        // Парсим и заменяем переменные в формате {varName}
-        const variablePattern = /\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
-        const matches = [...text.matchAll(variablePattern)];
-
-        for (const match of matches) {
-            const varName = match[1];
-            // Получаем значение из динамического пина
-            const varValue = await resolvePinValue(node, `var_${varName}`, '');
-            text = text.replace(match[0], String(varValue));
-        }
-
+        // resolvePinValue автоматически заменит переменные {varName}
+        const text = String(await resolvePinValue(node, 'value', ''));
         return text;
     }
 

package/backend/src/core/nodes/logic/not.js

@@ -0,0 +1,22 @@
+/**
+ * @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 value = await resolvePinValue(node, 'value', false);
+        return !value;
+    }
+
+    return false;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/strings/starts_with.js

@@ -23,7 +23,7 @@ async function evaluate(node, pinId, context, helpers) {
     const { resolvePinValue } = helpers;
 
     if (pinId === 'result') {
-        const str = String(await resolvePinValue(node, 'string', ''));
+        const str = String(await resolvePinValue(node, 'text', ''));
         const prefix = String(await resolvePinValue(node, 'prefix', ''));
         const caseSensitive = await resolvePinValue(node, 'case_sensitive', false);
 

package/backend/src/core/nodes/strings/to_lower.js

@@ -0,0 +1,22 @@
+/**
+ * @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 text = String(await resolvePinValue(node, 'text', ''));
+        return text.toLowerCase();
+    }
+
+    return '';
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/strings/to_upper.js

@@ -0,0 +1,22 @@
+/**
+ * @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 text = String(await resolvePinValue(node, 'text', ''));
+        return text.toUpperCase();
+    }
+
+    return '';
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/type/to_string.js

@@ -0,0 +1,32 @@
+/**
+ * @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 value = await resolvePinValue(node, 'value', '');
+
+        // Преобразуем в строку
+        if (value === null || value === undefined) {
+            return '';
+        }
+
+        if (typeof value === 'object') {
+            return JSON.stringify(value);
+        }
+
+        return String(value);
+    }
+
+    return '';
+}
+
+module.exports = {
+    evaluate,
+};