blockmine 1.22.0 → 1.23.0

package/backend/src/core/MessageQueue.js

@@ -109,15 +109,21 @@ class MessageQueue {
                 await this._handleWaitableTask(task);
             } else {
                 let fullMessage;
-                if (task.chatType === 'private' && task.username) {
+                const typeConfig = this.chatTypes[task.chatType];
+
+                // Для private/whisper добавляем username
+                if ((task.chatType === 'private' || task.chatType === 'whisper') && task.username) {
                     fullMessage = `/msg ${task.username} ${task.message}`;
-                } else if (task.chatType === 'clan') {
-                    fullMessage = `/cc ${task.message}`;
-                } else if (task.chatType === 'global') {
-                    fullMessage = `!${task.message}`;
-                } else {
+                }
+                // Для остальных типов используем prefix из конфига
+                else if (typeConfig && typeConfig.prefix) {
+                    fullMessage = `${typeConfig.prefix}${task.message}`;
+                }
+                // Если нет prefix (command, chat) - отправляем как есть
+                else {
                     fullMessage = task.message;
                 }
+
                 this.bot.chat(fullMessage);
             }
         } catch (error) {

package/backend/src/core/PluginLoader.js

@@ -10,7 +10,72 @@ const { execSync: execSyncRaw } = require('child_process');
 
 const projectRoot = path.resolve(__dirname, '..');
 
+// Создаёт обёрнутый console для перехвата логов плагина
+function createPluginConsole(botId, pluginName, originalConsole) {
+    const emitLog = (level, args) => {
+        try {
+            const message = args.map(arg =>
+                typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
+            ).join(' ');
 
+            // Фильтруем системные логи (не отправляем в IDE)
+            const systemLogPatterns = [
+                /^\[Config\]/,           // [Config] сообщения
+                /^\[System\]/,           // [System] сообщения
+                /^\[Internal\]/,         // [Internal] сообщения
+                /^\[Graph\]/,            // [Graph] логи от визуальных графов
+                /\[Graph Log\]/,         // [Graph Log] логи от нод графов
+            ];
+
+            const isSystemLog = systemLogPatterns.some(pattern => pattern.test(message));
+            if (isSystemLog) {
+                return; // Не отправляем системные логи в IDE
+            }
+
+            const logData = {
+                botId,
+                pluginName,
+                level,
+                message,
+                source: 'plugin',
+                timestamp: Date.now()
+            };
+
+            // Отправляем лог в parent process через IPC
+            if (process.send) {
+                process.send({
+                    type: 'plugin-log',
+                    log: logData
+                });
+            }
+        } catch (error) {
+            originalConsole.error(`[PluginLog] Error emitting log:`, error);
+        }
+    };
+
+    return {
+        log: (...args) => {
+            originalConsole.log(`[${pluginName}]`, ...args);
+            emitLog('info', args);
+        },
+        info: (...args) => {
+            originalConsole.info(`[${pluginName}]`, ...args);
+            emitLog('info', args);
+        },
+        warn: (...args) => {
+            originalConsole.warn(`[${pluginName}]`, ...args);
+            emitLog('warn', args);
+        },
+        error: (...args) => {
+            originalConsole.error(`[${pluginName}]`, ...args);
+            emitLog('error', args);
+        },
+        debug: (...args) => {
+            originalConsole.debug(`[${pluginName}]`, ...args);
+            emitLog('debug', args);
+        }
+    };
+}
 
 async function initializePlugins(bot, installedPlugins = [], prisma) {
     if (!installedPlugins || installedPlugins.length === 0) return;
@@ -70,23 +135,52 @@ async function initializePlugins(bot, installedPlugins = [], prisma) {
                         }
                     }
 
+                    // Создаём обёрнутый console для перехвата логов плагина
+                    const originalConsole = global.console;
+                    const pluginConsole = createPluginConsole(bot.config.id, plugin.name, originalConsole);
+
+                    // Добавляем кастомный console в bot объект для использования плагинами
+                    bot.console = pluginConsole;
+
+                    // Опции плагина с кастомным console
+                    const pluginOptions = {
+                        settings: finalSettings,
+                        store,
+                        console: pluginConsole  // Передаём обёрнутый console в опциях
+                    };
+
                     if (typeof pluginModule === 'function') {
-                        pluginModule(bot, { settings: finalSettings, store });
+                        pluginModule(bot, pluginOptions);
                     } else if (pluginModule && typeof pluginModule.onLoad === 'function') {
-                        pluginModule.onLoad(bot, { settings: finalSettings, store });
+                        pluginModule.onLoad(bot, pluginOptions);
                     } else if (pluginModule && pluginModule.default && typeof pluginModule.default === 'function') {
-                        pluginModule.default(bot, { settings: finalSettings, store });
+                        pluginModule.default(bot, pluginOptions);
                     } else if (pluginModule && pluginModule.default && typeof pluginModule.default.onLoad === 'function') {
-                        pluginModule.default.onLoad(bot, { settings: finalSettings, store });
+                        pluginModule.default.onLoad(bot, pluginOptions);
                     } else {
                         sendLog(`[PluginLoader] [ERROR] ${plugin.name} не экспортирует функцию или объект с методом onLoad.`);
                     }
                 };
 
                 sendLog(`[PluginLoader] Загрузка: ${plugin.name} (v${plugin.version}) из ${normalizedPath}`);
-                
+
                 try {
                     await loadAndInit();
+
+                    // Отправляем сообщение об успешной загрузке в IDE console
+                    const { getIOSafe } = require('../real-time/socketHandler');
+                    const io = getIOSafe();
+                    if (io) {
+                        const room = `plugin-logs:${bot.config.id}:${plugin.name}`;
+                        io.to(room).emit('plugin-log', {
+                            botId: bot.config.id,
+                            pluginName: plugin.name,
+                            level: 'success',
+                            message: `✓ Плагин ${plugin.name} v${plugin.version} успешно загружен`,
+                            source: 'system',
+                            timestamp: Date.now()
+                        });
+                    }
                 } catch (error) {
                     let handled = false;
                     let lastError = error;

package/backend/src/core/PluginManager.js

@@ -360,28 +360,34 @@ class PluginManager {
         }
 
         console.log(`[PluginManager] Начало обновления плагина ${plugin.name}${targetTag ? ` до версии ${targetTag}` : ''}...`);
-        
+
         const repoUrl = plugin.sourceUri;
         const botId = plugin.botId;
-        
-        // Сохраняем настройки и важные данные перед удалением
+        const oldVersion = plugin.version;
+
         const backupData = {
             name: plugin.name,
             settings: plugin.settings,
             isEnabled: plugin.isEnabled,
-            // PluginDataStore сохранятся автоматически (привязаны к pluginName + botId)
         };
         console.log(`[PluginManager] Настройки плагина ${plugin.name} сохранены для миграции.`);
-        
-        // Удаляем старую версию
+
         await this.deletePlugin(pluginId);
         console.log(`[PluginManager] Старая версия ${plugin.name} удалена, устанавливаем новую...`);
-        
-        // Устанавливаем новую версию с конкретным тегом (если указан)
+
         const newPlugin = await this.installFromGithub(botId, repoUrl, prisma, true, targetTag);
-        
-        // Восстанавливаем настройки
-        if (backupData.settings && newPlugin) {
+
+        const oldMajor = semver.major(semver.coerce(oldVersion) || '0.0.0');
+        const newMajor = semver.major(semver.coerce(newPlugin.version) || '0.0.0');
+        const isMajorUpdate = newMajor > oldMajor;
+
+        if (isMajorUpdate) {
+            console.log(`[PluginManager] Мажорное обновление ${oldVersion} → ${newPlugin.version}. Настройки сброшены к дефолтным.`);
+            await prisma.installedPlugin.update({
+                where: { id: newPlugin.id },
+                data: { isEnabled: backupData.isEnabled },
+            });
+        } else if (backupData.settings && newPlugin) {
             try {
                 await prisma.installedPlugin.update({
                     where: { id: newPlugin.id },
@@ -393,10 +399,9 @@ class PluginManager {
                 console.log(`[PluginManager] Настройки успешно восстановлены для ${plugin.name}`);
             } catch (settingsError) {
                 console.error(`[PluginManager] Не удалось восстановить настройки для ${plugin.name}:`, settingsError);
-                // Не бросаем ошибку, т.к. плагин уже установлен
             }
         }
-        
+
         return newPlugin;
     }
 
@@ -511,6 +516,62 @@ class PluginManager {
         console.log(`[PluginManager] Удалено ${count} записей из хранилища.`);
         return { count };
     }
+
+    async reloadLocalPlugin(pluginId) {
+        const plugin = await prisma.installedPlugin.findUnique({ where: { id: pluginId } });
+        if (!plugin) {
+            throw new Error('Плагин не найден.');
+        }
+
+        if (plugin.sourceType !== 'LOCAL' && plugin.sourceType !== 'LOCAL_IDE') {
+            throw new Error('Перезагрузка доступна только для локальных плагинов.');
+        }
+
+        const pluginPath = plugin.path;
+        const packageJsonPath = path.join(pluginPath, 'package.json');
+
+        if (!await fse.pathExists(packageJsonPath)) {
+            throw new Error(`package.json не найден: ${packageJsonPath}`);
+        }
+
+        console.log(`[PluginManager] Перезагрузка локального плагина ${plugin.name} из ${pluginPath}`);
+
+        let packageJson;
+        try {
+            packageJson = JSON.parse(await fse.readFile(packageJsonPath, 'utf-8'));
+        } catch (e) {
+            throw new Error(`Не удалось прочитать package.json: ${e.message}`);
+        }
+
+        const manifest = packageJson.botpanel || {};
+        const defaultSettings = {};
+
+        if (manifest.settings) {
+            for (const [key, config] of Object.entries(manifest.settings)) {
+                if (config.default !== undefined) {
+                    defaultSettings[key] = config.default;
+                }
+            }
+        }
+
+        const updatedPlugin = await prisma.installedPlugin.update({
+            where: { id: pluginId },
+            data: {
+                version: packageJson.version,
+                description: packageJson.description || '',
+                manifest: JSON.stringify(manifest),
+                settings: JSON.stringify(defaultSettings),
+            },
+        });
+
+        console.log(`[PluginManager] Плагин ${plugin.name} перезагружен. Версия: ${packageJson.version}, настройки сброшены.`);
+
+        if (this.botManager) {
+            await this.botManager.reloadPlugins(plugin.botId);
+        }
+
+        return updatedPlugin;
+    }
 }
 
 module.exports = PluginManager;

package/backend/src/core/TaskScheduler.js

@@ -51,7 +51,7 @@ class TaskScheduler {
 
             for (const botId of botIds) {
                 try {
-                    const botConfig = await prisma.bot.findUnique({ where: { id: botId }, include: { server: true } });
+                    const botConfig = await prisma.bot.findUnique({ where: { id: botId }, include: { server: true, proxy: true } });
                     if (!botConfig) continue;
 
                     switch (task.action) {

package/backend/src/core/commands/whois.js

@@ -33,7 +33,7 @@ class WhoisCommand extends Command {
                 .join(', ') || 'Нет групп';
 
             // Статус
-            const status = targetUser.isBlacklisted ? '⛔ В черном списке' : '✅ Активен';
+            const status = targetUser.isBlacklisted ? '⛔ В черном списке' : '✅ Не в чс';
 
             // Форматируем вывод в зависимости от транспорта
             let message;

package/backend/src/core/node-registries/actions.js

@@ -127,6 +127,76 @@ function registerNodes(registry) {
       ]
     }
   });
+
+  registry.registerNodeType({
+    type: 'action:create_command',
+    label: '➕ Создать команду',
+    category: 'Действия',
+    description: 'Создает новую команду (временную или постоянную)',
+    graphType: GRAPH_TYPES.ALL,
+    executor: require('../nodes/actions/create_command').execute,
+    pins: {
+      inputs: [
+        { id: 'exec', name: 'Выполнить', type: 'Exec', required: true },
+        { id: 'name', name: 'Имя команды', type: 'String', required: true },
+        { id: 'description', name: 'Описание', type: 'String', required: false },
+        { id: 'aliases', name: 'Алиасы', type: 'Array', required: false },
+        { id: 'cooldown', name: 'Кулдаун (сек)', type: 'Number', required: false },
+        { id: 'allowedChatTypes', name: 'Типы чата', type: 'Array', required: false },
+        { id: 'permissionName', name: 'Название права', type: 'String', required: false },
+        { id: 'temporary', name: 'Временная?', type: 'Boolean', required: false }
+      ],
+      outputs: [
+        { id: 'exec', name: 'Выполнено', type: 'Exec' },
+        { id: 'commandId', name: 'ID команды', type: 'Number' },
+        { id: 'success', name: 'Успешно', type: 'Boolean' }
+      ]
+    }
+  });
+
+  registry.registerNodeType({
+    type: 'action:update_command',
+    label: '✏️ Редактировать команду',
+    category: 'Действия',
+    description: 'Изменяет параметры существующей команды',
+    graphType: GRAPH_TYPES.ALL,
+    executor: require('../nodes/actions/update_command').execute,
+    pins: {
+      inputs: [
+        { id: 'exec', name: 'Выполнить', type: 'Exec', required: true },
+        { id: 'commandName', name: 'Имя команды', type: 'String', required: true },
+        { id: 'newName', name: 'Новое имя', type: 'String', required: false },
+        { id: 'description', name: 'Описание', type: 'String', required: false },
+        { id: 'aliases', name: 'Алиасы', type: 'Array', required: false },
+        { id: 'cooldown', name: 'Кулдаун (сек)', type: 'Number', required: false },
+        { id: 'allowedChatTypes', name: 'Типы чата', type: 'Array', required: false },
+        { id: 'permissionName', name: 'Название права', type: 'String', required: false }
+      ],
+      outputs: [
+        { id: 'exec', name: 'Выполнено', type: 'Exec' },
+        { id: 'success', name: 'Успешно', type: 'Boolean' }
+      ]
+    }
+  });
+
+  registry.registerNodeType({
+    type: 'action:delete_command',
+    label: '🗑️ Удалить команду',
+    category: 'Действия',
+    description: 'Удаляет существующую команду бота',
+    graphType: GRAPH_TYPES.ALL,
+    executor: require('../nodes/actions/delete_command').execute,
+    pins: {
+      inputs: [
+        { id: 'exec', name: 'Выполнить', type: 'Exec', required: true },
+        { id: 'commandName', name: 'Имя команды', type: 'String', required: true }
+      ],
+      outputs: [
+        { id: 'exec', name: 'Выполнено', type: 'Exec' },
+        { id: 'success', name: 'Успешно', type: 'Boolean' }
+      ]
+    }
+  });
 }
 
 module.exports = { registerNodes };

package/backend/src/core/node-registries/arrays.js

@@ -132,6 +132,24 @@ function registerNodes(registry) {
       ]
     }
   });
+
+  registry.registerNodeType({
+    type: 'array:join',
+    label: '🔗 Объединить в строку',
+    category: 'Массив',
+    description: 'Объединяет элементы массива в строку с разделителем.',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../nodes/arrays/join').evaluate,
+    pins: {
+      inputs: [
+        { id: 'array', name: 'Массив', type: 'Array', required: false },
+        { id: 'separator', name: 'Разделитель', type: 'String', required: false }
+      ],
+      outputs: [
+        { id: 'result', name: 'Result', type: 'String' }
+      ]
+    }
+  });
 }
 
 module.exports = { registerNodes };

package/backend/src/core/node-registries/data.js

@@ -139,7 +139,7 @@ function registerNodes(registry) {
         { id: 'value', name: 'Значение', type: 'Wildcard', required: true }
       ],
       outputs: [
-        { id: 'value', name: 'Значение', type: 'Wildcard' }
+        { id: 'result', name: 'Результат', type: 'Wildcard' }
       ]
     }
   });

package/backend/src/core/node-registries/events.js

@@ -148,6 +148,20 @@ function registerNodes(registry) {
     }
   });
 
+  registry.registerNodeType({
+    type: 'event:botStartup',
+    label: '🚀 При запуске бота',
+    category: 'События',
+    description: 'Срабатывает один раз при запуске бота.',
+    graphType: GRAPH_TYPES.EVENT,
+    pins: {
+      inputs: [],
+      outputs: [
+        { id: 'exec', name: 'Выполнить', type: 'Exec' },
+      ]
+    }
+  });
+
   registry.registerNodeType({
     type: 'event:health',
     label: '❤️ Здоровье/Голод изменилось',

package/backend/src/core/node-registries/logic.js

@@ -40,6 +40,23 @@ function registerNodes(registry) {
       ]
     }
   });
+
+  registry.registerNodeType({
+    type: 'logic:not',
+    label: '! НЕ',
+    category: 'Логика',
+    description: 'Инвертирует boolean значение (NOT).',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../nodes/logic/not').evaluate,
+    pins: {
+      inputs: [
+        { id: 'value', name: 'Значение', type: 'Boolean', required: false }
+      ],
+      outputs: [
+        { id: 'result', name: 'Результат', type: 'Boolean' }
+      ]
+    }
+  });
 }
 
 module.exports = { registerNodes };

package/backend/src/core/node-registries/strings.js

@@ -148,6 +148,40 @@ function registerNodes(registry) {
       ]
     }
   });
+
+  registry.registerNodeType({
+    type: 'string:to_upper',
+    label: '⬆️ В верхний регистр',
+    category: 'Строки',
+    description: 'Преобразует строку в верхний регистр (UPPERCASE).',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../nodes/strings/to_upper').evaluate,
+    pins: {
+      inputs: [
+        { id: 'text', name: 'Текст', type: 'String', required: false }
+      ],
+      outputs: [
+        { id: 'result', name: 'Result', type: 'String' }
+      ]
+    }
+  });
+
+  registry.registerNodeType({
+    type: 'string:to_lower',
+    label: '⬇️ В нижний регистр',
+    category: 'Строки',
+    description: 'Преобразует строку в нижний регистр (lowercase).',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../nodes/strings/to_lower').evaluate,
+    pins: {
+      inputs: [
+        { id: 'text', name: 'Текст', type: 'String', required: false }
+      ],
+      outputs: [
+        { id: 'result', name: 'Result', type: 'String' }
+      ]
+    }
+  });
 }
 
 module.exports = { registerNodes };

package/backend/src/core/node-registries/type.js

@@ -0,0 +1,25 @@
+const { GRAPH_TYPES } = require('../constants/graphTypes');
+
+/**
+ * Регистрация нод категории "Преобразование типов"
+ */
+function registerNodes(registry) {
+  registry.registerNodeType({
+    type: 'type:to_string',
+    label: '📝 В строку',
+    category: 'Типы',
+    description: 'Преобразует любое значение в строку (toString).',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../nodes/type/to_string').evaluate,
+    pins: {
+      inputs: [
+        { id: 'value', name: 'Значение', type: 'Wildcard', required: false }
+      ],
+      outputs: [
+        { id: 'result', name: 'Result', type: 'String' }
+      ]
+    }
+  });
+}
+
+module.exports = { registerNodes };

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

@@ -24,7 +24,7 @@ async function execute(node, context, helpers) {
 
         if (finalPosition) {
             finalPosition.y += Number(yOffset || 0);
-            context.bot.lookAt(finalPosition);
+            await context.bot.lookAt(finalPosition.x, finalPosition.y, finalPosition.z);
         }
     }