blockmine 1.21.0 → 1.23.0

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

@@ -38,7 +38,7 @@ function reportPluginDownload(pluginName) {
 
 
 class PluginManager {
-    constructor(botManager) {
+    constructor({ botManager } = {}) {
         this.botManager = botManager;
         this.ensureBaseDirExists();
     }
@@ -125,7 +125,7 @@ class PluginManager {
         return newPlugin;
     }
 
-    async installFromGithub(botId, repoUrl, prismaClient = prisma, isUpdate = false) {
+    async installFromGithub(botId, repoUrl, prismaClient = prisma, isUpdate = false, tag = null) {
         const botPluginsDir = path.join(PLUGINS_BASE_DIR, `bot_${botId}`);
         await fse.mkdir(botPluginsDir, { recursive: true });
 
@@ -137,17 +137,36 @@ class PluginManager {
         try {
             const url = new URL(repoUrl);
             const repoPath = url.pathname.replace(/^\/|\.git$/g, '');
-            const archiveUrlMain = `https://github.com/${repoPath}/archive/refs/heads/main.zip`;
-            const archiveUrlMaster = `https://github.com/${repoPath}/archive/refs/heads/master.zip`;
+            
+            let response;
+            
+            // Если указан тег - скачиваем конкретный релиз
+            if (tag) {
+                const archiveUrlTag = `https://github.com/${repoPath}/archive/refs/tags/${encodeURIComponent(tag)}.zip`;
+                console.log(`[PluginManager] Скачиваем релиз ${tag} из ${repoUrl}...`);
+                try {
+                    response = await fetch(archiveUrlTag);
+                } catch (err) {
+                    throw new Error(`Ошибка сети при скачивании релиза ${tag}: ${err.message || err}`);
+                }
+                if (!response.ok) {
+                    throw new Error(`Не удалось скачать релиз ${tag}. Статус: ${response.status}. Возможно, тег не существует.`);
+                }
+            } else {
+                // Если тег не указан - скачиваем последний коммит из main/master (старое поведение)
+                const archiveUrlMain = `https://github.com/${repoPath}/archive/refs/heads/main.zip`;
+                const archiveUrlMaster = `https://github.com/${repoPath}/archive/refs/heads/master.zip`;
 
-            let response = await fetch(archiveUrlMain);
-            if (!response.ok) {
-                console.log(`[PluginManager] Ветка 'main' не найдена для ${repoUrl}, пробую 'master'...`);
-                response = await fetch(archiveUrlMaster);
+                response = await fetch(archiveUrlMain);
                 if (!response.ok) {
-                    throw new Error(`Не удалось скачать архив плагина. Статус: ${response.status}`);
+                    console.log(`[PluginManager] Ветка 'main' не найдена для ${repoUrl}, пробую 'master'...`);
+                    response = await fetch(archiveUrlMaster);
+                    if (!response.ok) {
+                        throw new Error(`Не удалось скачать архив плагина. Статус: ${response.status}`);
+                    }
                 }
             }
+            
             const buffer = await response.arrayBuffer();
 
             const zip = new AdmZip(Buffer.from(buffer));
@@ -324,6 +343,7 @@ class PluginManager {
                         sourceUri: plugin.sourceUri,
                         currentVersion: localVersion,
                         recommendedVersion: recommendedVersion,
+                        latestTag: catalogInfo.latestTag, // 🏷️ Добавляем тег для использования при обновлении
                     });
                 }
             } catch (error) {
@@ -333,21 +353,56 @@ class PluginManager {
         return updatesAvailable;
     }
 
-    async updatePlugin(pluginId) {
+    async updatePlugin(pluginId, targetTag = null) {
         const plugin = await prisma.installedPlugin.findUnique({ where: { id: pluginId } });
         if (!plugin || plugin.sourceType !== 'GITHUB') {
             throw new Error('Плагин не найден или не является GitHub-плагином.');
         }
 
-        console.log(`[PluginManager] Начало обновления плагина ${plugin.name}...`);
-        
+        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,
+        };
+        console.log(`[PluginManager] Настройки плагина ${plugin.name} сохранены для миграции.`);
+
         await this.deletePlugin(pluginId);
         console.log(`[PluginManager] Старая версия ${plugin.name} удалена, устанавливаем новую...`);
-        
-        return await this.installFromGithub(botId, repoUrl, prisma, true);
+
+        const newPlugin = await this.installFromGithub(botId, repoUrl, prisma, true, targetTag);
+
+        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 },
+                    data: {
+                        settings: backupData.settings,
+                        isEnabled: backupData.isEnabled,
+                    },
+                });
+                console.log(`[PluginManager] Настройки успешно восстановлены для ${plugin.name}`);
+            } catch (settingsError) {
+                console.error(`[PluginManager] Не удалось восстановить настройки для ${plugin.name}:`, settingsError);
+            }
+        }
+
+        return newPlugin;
     }
 
     async loadPluginGraphs(botId, pluginId, pluginPath) {
@@ -461,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/PrismaService.js

@@ -0,0 +1,32 @@
+const { PrismaClient } = require('@prisma/client');
+
+/**
+ * Singleton service для PrismaClient
+ * Предотвращает утечки памяти используя одно соединение с БД
+ * Благодаря кешированию require в Node.js это фактический singleton
+ */
+class PrismaService {
+    constructor() {
+        this.prisma = new PrismaClient({
+            log: ['error', 'warn'],
+        });
+    }
+
+    /**
+     * Получить экземпляр Prisma client
+     * @returns {PrismaClient}
+     */
+    getClient() {
+        return this.prisma;
+    }
+
+    /**
+     * Отключиться от БД (вызывать при выключении приложения)
+     */
+    async disconnect() {
+        await this.prisma.$disconnect();
+    }
+}
+
+const prismaService = new PrismaService();
+module.exports = prismaService;

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/UserService.js

@@ -10,15 +10,15 @@ class User {
     constructor(userInstance, botConfig = {}) {
         this.user = userInstance;
         this.botConfig = botConfig;
-        
+
         const globalOwners = ["merka", "akrem"];
         const keksikServers = ["mc.mineblaze.net", "mc.masedworld.net", "mc.cheatmine.net", "mc.dexland.org"];
-        
+
         const botOwners = (this.botConfig.owners || '').toLowerCase().split(',').map(s => s.trim()).filter(Boolean);
         const usernameLower = this.user.username.toLowerCase();
 
         this.isOwner = botOwners.includes(usernameLower) || (keksikServers.includes(this.botConfig.server?.host) && globalOwners.includes(usernameLower));
-        
+
         this.permissionsSet = new Set();
         if (this.user.groups) {
             this.user.groups.forEach(userGroup => {

package/backend/src/core/__tests__/PrismaService.test.js

@@ -0,0 +1,24 @@
+const prismaService = require('../PrismaService');
+
+describe('PrismaService', () => {
+    it('should return singleton instance', () => {
+        const service1 = require('../PrismaService');
+        const service2 = require('../PrismaService');
+
+        expect(service1).toBe(service2);
+    });
+
+    it('should provide getClient method', () => {
+        const client = prismaService.getClient();
+
+        expect(client).toBeDefined();
+        expect(typeof client.$connect).toBe('function');
+    });
+
+    it('should reuse same client instance', () => {
+        const client1 = prismaService.getClient();
+        const client2 = prismaService.getClient();
+
+        expect(client1).toBe(client2);
+    });
+});