blockmine 1.24.0 → 1.25.0

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

@@ -477,8 +477,21 @@ router.put('/:id', authenticateUniversal, checkBotAccess, authorize('bot:update'
             const proxyIdValue = dataToUpdate.proxyId;
             delete dataToUpdate.proxyId;
             if (proxyIdValue) {
+                // Используем прокси из списка - очищаем кастомные поля
                 dataToUpdate.proxy = { connect: { id: proxyIdValue } };
+                dataToUpdate.proxyHost = null;
+                dataToUpdate.proxyPort = null;
+                dataToUpdate.proxyUsername = null;
+                dataToUpdate.proxyPassword = null;
+            } else if (!dataToUpdate.proxyHost) {
+                // Отключаем прокси только если нет кастомного proxyHost
+                dataToUpdate.proxy = { disconnect: true };
+                dataToUpdate.proxyHost = null;
+                dataToUpdate.proxyPort = null;
+                dataToUpdate.proxyUsername = null;
+                dataToUpdate.proxyPassword = null;
             } else {
+                // Кастомный прокси: отключаем связь с proxy, но сохраняем кастомные поля
                 dataToUpdate.proxy = { disconnect: true };
             }
         }

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

@@ -39,8 +39,14 @@ router.post('/', authorize('server:create'), async (req, res) => {
         if (!name || !host || !version) {
             return res.status(400).json({ error: 'Имя, хост и версия сервера обязательны' });
         }
+
+        const portNumber = port ? parseInt(port, 10) : 25565;
+        if (isNaN(portNumber) || portNumber < 1 || portNumber > 65535) {
+            return res.status(400).json({ error: 'Порт должен быть числом от 1 до 65535 (максимум 5 цифр)' });
+        }
+
         const newServer = await prisma.server.create({
-            data: { name, host, port: port ? parseInt(port, 10) : 25565, version },
+            data: { name, host, port: portNumber, version },
         });
         res.status(201).json(newServer);
     } catch (error) {
@@ -58,7 +64,13 @@ router.put('/:id', authorize('server:create'), async (req, res) => {
         const dataToUpdate = {};
         if (name !== undefined) dataToUpdate.name = name;
         if (host !== undefined) dataToUpdate.host = host;
-        if (port !== undefined && port !== '') dataToUpdate.port = parseInt(port, 10);
+        if (port !== undefined && port !== '') {
+            const portNumber = parseInt(port, 10);
+            if (isNaN(portNumber) || portNumber < 1 || portNumber > 65535) {
+                return res.status(400).json({ error: 'Порт должен быть числом от 1 до 65535 (максимум 5 цифр)' });
+            }
+            dataToUpdate.port = portNumber;
+        }
         if (version !== undefined) dataToUpdate.version = version;
 
         Object.keys(dataToUpdate).forEach(k => { if (dataToUpdate[k] === undefined) delete dataToUpdate[k]; });

package/backend/src/core/BotProcess.js

@@ -6,7 +6,7 @@ const { Vec3 } = require('vec3');
 const { PrismaClient } = require('@prisma/client');
 const { loadCommands } = require('./system/CommandRegistry');
 const { getRuntimeCommandRegistry } = require('./system/RuntimeCommandRegistry');
-const { initializePlugins } = require('./PluginLoader');
+const { initializePlugins, ensurePluginDependencies } = require('./PluginLoader');
 const MessageQueue = require('./MessageQueue');
 const Command = require('./system/Command');
 const { parseArguments } = require('./system/parseArguments');
@@ -179,6 +179,16 @@ process.on('message', async (message) => {
             }
             pendingRequests.delete(message.requestId);
         }
+    } else if (message.type === 'credentials_operation_response') {
+        if (pendingRequests.has(message.requestId)) {
+            const { resolve, reject } = pendingRequests.get(message.requestId);
+            if (message.error) {
+                reject(new Error(message.error));
+            } else {
+                resolve(message.payload);
+            }
+            pendingRequests.delete(message.requestId);
+        }
     } else if (message.type === 'system:get_player_list') {
         const playerList = bot ? Object.keys(bot.players) : [];
         if (process.send) {
@@ -503,6 +513,9 @@ process.on('message', async (message) => {
             bot.sendLog = sendLog;
             bot.messageQueue = new MessageQueue(bot);
 
+            // Plugin Registry для экспорта API между плагинами
+            bot.pluginRegistry = new Map();
+
             const installedPluginNames = config.plugins.map(p => p.name);
             bot.api = {
                 Command: Command,
@@ -783,10 +796,92 @@ process.on('message', async (message) => {
                             payload: newState
                         });
                     }
+                },
+
+                // === Методы для управления credentials ===
+                updateCredentials: async ({ username, password }) => {
+                    return new Promise((resolve, reject) => {
+                        const requestId = uuidv4();
+                        pendingRequests.set(requestId, { resolve, reject });
+
+                        if (process.send) {
+                            process.send({
+                                type: 'update_credentials',
+                                requestId,
+                                payload: {
+                                    botId: bot.config.id,
+                                    username,
+                                    password
+                                }
+                            });
+                        } else {
+                            reject(new Error('IPC channel is not available.'));
+                        }
+
+                        setTimeout(() => {
+                            if (pendingRequests.has(requestId)) {
+                                reject(new Error('Request to update credentials timed out.'));
+                                pendingRequests.delete(requestId);
+                            }
+                        }, 10000);
+                    });
+                },
+
+                restart: async () => {
+                    return new Promise((resolve, reject) => {
+                        const requestId = uuidv4();
+                        pendingRequests.set(requestId, { resolve, reject });
+
+                        if (process.send) {
+                            process.send({
+                                type: 'restart_bot',
+                                requestId,
+                                payload: {
+                                    botId: bot.config.id
+                                }
+                            });
+                        } else {
+                            reject(new Error('IPC channel is not available.'));
+                        }
+
+                        setTimeout(() => {
+                            if (pendingRequests.has(requestId)) {
+                                reject(new Error('Request to restart bot timed out.'));
+                                pendingRequests.delete(requestId);
+                            }
+                        }, 10000);
+                    });
+                },
+
+                changeCredentials: async ({ username, password }) => {
+                    return new Promise((resolve, reject) => {
+                        const requestId = uuidv4();
+                        pendingRequests.set(requestId, { resolve, reject });
+
+                        if (process.send) {
+                            process.send({
+                                type: 'change_credentials',
+                                requestId,
+                                payload: {
+                                    botId: bot.config.id,
+                                    username,
+                                    password
+                                }
+                            });
+                        } else {
+                            reject(new Error('IPC channel is not available.'));
+                        }
+
+                        setTimeout(() => {
+                            if (pendingRequests.has(requestId)) {
+                                reject(new Error('Request to change credentials timed out.'));
+                                pendingRequests.delete(requestId);
+                            }
+                        }, 10000);
+                    });
                 }
             };
 
-            // Упрощенный alias для отправки сообщений (используется в командах и нодах)
             bot.sendMessage = (type, message, username) => {
                 bot.api.sendMessage(type, message, username);
             };
@@ -909,6 +1004,7 @@ process.on('message', async (message) => {
                 }
             }
 
+            await ensurePluginDependencies(config.plugins, sendLog);
             await initializePlugins(bot, config.plugins, prisma);
             sendLog('[System] Все системы инициализированы.');
 

package/backend/src/core/PluginLoader.js

@@ -10,6 +10,61 @@ const { execSync: execSyncRaw } = require('child_process');
 
 const projectRoot = path.resolve(__dirname, '..');
 
+// Проверяет и устанавливает зависимости для всех плагинов
+async function ensurePluginDependencies(installedPlugins = [], sendLog = console.log) {
+    if (!installedPlugins || installedPlugins.length === 0) return;
+
+    sendLog(`[PluginLoader] Проверка зависимостей ${installedPlugins.length} плагинов...`);
+
+    for (const plugin of installedPlugins) {
+        if (!plugin || !plugin.path) continue;
+
+        try {
+            const packageJsonPath = path.join(plugin.path, 'package.json');
+
+            // Проверяем есть ли package.json
+            if (!fssync.existsSync(packageJsonPath)) {
+                continue;
+            }
+
+            const packageJson = JSON.parse(fssync.readFileSync(packageJsonPath, 'utf-8'));
+            const dependencies = packageJson.dependencies || {};
+
+            if (Object.keys(dependencies).length === 0) {
+                continue;
+            }
+
+            // Проверяем есть ли node_modules
+            const nodeModulesPath = path.join(plugin.path, 'node_modules');
+            const needsInstall = !fssync.existsSync(nodeModulesPath);
+
+            if (needsInstall) {
+                sendLog(`[PluginLoader] Установка зависимостей для ${plugin.name}...`);
+
+                try {
+                    execSync('npm install --omit=dev --no-audit --no-fund', {
+                        cwd: plugin.path,
+                        stdio: 'inherit'
+                    });
+                    sendLog(`[PluginLoader] ✓ Зависимости установлены для ${plugin.name}`);
+                } catch (e1) {
+                    sendLog(`[PluginLoader] Повторная попытка с --legacy-peer-deps для ${plugin.name}...`);
+                    execSync('npm install --omit=dev --legacy-peer-deps --no-audit --no-fund', {
+                        cwd: plugin.path,
+                        stdio: 'inherit'
+                    });
+                    sendLog(`[PluginLoader] ✓ Зависимости установлены для ${plugin.name}`);
+                }
+            }
+
+        } catch (error) {
+            sendLog(`[PluginLoader] [WARN] Не удалось проверить зависимости для ${plugin.name}: ${error.message}`);
+        }
+    }
+
+    sendLog(`[PluginLoader] Проверка зависимостей завершена`);
+}
+
 // Создаёт обёрнутый console для перехвата логов плагина
 function createPluginConsole(botId, pluginName, originalConsole) {
     const emitLog = (level, args) => {
@@ -160,6 +215,16 @@ async function initializePlugins(bot, installedPlugins = [], prisma) {
                     } else {
                         sendLog(`[PluginLoader] [ERROR] ${plugin.name} не экспортирует функцию или объект с методом onLoad.`);
                     }
+
+                    if (pluginModule && pluginModule.exports && typeof pluginModule.exports === 'object') {
+                        if (bot.pluginRegistry) {
+                            bot.pluginRegistry.set(plugin.name, pluginModule.exports);
+                        }
+                    } else if (pluginModule && pluginModule.default && pluginModule.default.exports) {
+                        if (bot.pluginRegistry) {
+                            bot.pluginRegistry.set(plugin.name, pluginModule.default.exports);
+                        }
+                    }
                 };
 
                 sendLog(`[PluginLoader] Загрузка: ${plugin.name} (v${plugin.version}) из ${normalizedPath}`);
@@ -184,12 +249,27 @@ async function initializePlugins(bot, installedPlugins = [], prisma) {
                 } catch (error) {
                     let handled = false;
                     let lastError = error;
-                    if (error.message.includes('Cannot find module')) {
+                    // Проверяем не только сообщение ошибки, но и весь стек
+                    const errorString = error.message + '\n' + (error.stack || '');
+                    const isModuleError = errorString.includes('Cannot find module');
+                    if (isModuleError) {
                         const moduleMatch = error.message.match(/Cannot find module '([^']+)'/);
                         const missingModule = moduleMatch ? moduleMatch[1] : null;
                         if (missingModule) {
+                            const isFilePath = missingModule.startsWith('/') ||
+                                               missingModule.startsWith('./') ||
+                                               missingModule.startsWith('../') ||
+                                               missingModule.startsWith('\\') ||
+                                               /^[A-Za-z]:[\\/]/.test(missingModule) || // Windows absolute path
+                                               /\.(js|json|node|ts|mjs|cjs)$/i.test(missingModule);
+
+                            if (isFilePath) {
+                                sendLog(`[PluginLoader] [ERROR] Файл не найден: ${missingModule}`);
+                                sendLog(`[PluginLoader] [ERROR] Плагин ${plugin.name} содержит ошибку — отсутствует файл. Проверьте код плагина.`);
+                                throw error;
+                            }
+
                             try {
-                                // Диагностика текущего состояния резолва
                                 pluginRequire.resolve(missingModule);
                                 sendLog(`[PluginLoader] [DEBUG] ${missingModule} уже резолвится до установки? Это неожиданно.`);
                             } catch {
@@ -300,4 +380,4 @@ async function initializePlugins(bot, installedPlugins = [], prisma) {
     }
 }
 
-module.exports = { initializePlugins };
+module.exports = { initializePlugins, ensurePluginDependencies };

package/backend/src/core/PluginManager.js

@@ -48,6 +48,52 @@ class PluginManager {
         await fse.mkdir(PLUGINS_BASE_DIR, { recursive: true }).catch(console.error);
     }
 
+    /**
+     * Проверяет зависимости плагина из package.json
+     * @param {number} botId - ID бота
+     * @param {object} packageJson - package.json плагина
+     * @returns {Promise<{isValid: boolean, missing: string[], warnings: string[]}>}
+     */
+    async checkPluginDependencies(botId, packageJson) {
+        const result = {
+            isValid: true,
+            missing: [],
+            warnings: []
+        };
+
+        // Проверяем зависимости из botpanel.dependencies
+        const pluginDeps = packageJson.botpanel?.dependencies || {};
+        if (Object.keys(pluginDeps).length === 0) {
+            return result; // Нет зависимостей
+        }
+
+        const installedPlugins = await prisma.installedPlugin.findMany({
+            where: { botId },
+            select: { name: true, version: true }
+        });
+
+        const installedMap = new Map(installedPlugins.map(p => [p.name, p.version]));
+
+        for (const [depName, depVersion] of Object.entries(pluginDeps)) {
+            if (!installedMap.has(depName)) {
+                result.missing.push(`${depName} (требуется ${depVersion})`);
+                result.isValid = false;
+            } else {
+                const installedVersion = installedMap.get(depName);
+                if (depVersion.startsWith('^') || depVersion.startsWith('~')) {
+                    const requiredBase = depVersion.slice(1);
+                    if (!installedVersion.startsWith(requiredBase.split('.')[0])) {
+                        result.warnings.push(
+                            `${depName}: установлена v${installedVersion}, требуется ${depVersion}`
+                        );
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
     async _installDependencies(pluginPath) {
         const packageJsonPath = path.join(pluginPath, 'package.json');
         try {
@@ -108,9 +154,22 @@ class PluginManager {
     }
 
     async installFromLocalPath(botId, directoryPath) {
+        // Проверяем зависимости плагина перед установкой
+        const packageJsonPath = path.join(directoryPath, 'package.json');
+        const packageJson = JSON.parse(await fse.readFile(packageJsonPath, 'utf-8'));
+
+        const depCheck = await this.checkPluginDependencies(botId, packageJson);
+        if (!depCheck.isValid) {
+            const missingList = depCheck.missing.join(', ');
+            console.warn(`[PluginManager] ⚠️ Плагин ${packageJson.name} требует: ${missingList}`);
+            console.warn(`[PluginManager] Плагин будет установлен, но может работать некорректно без зависимостей.`);
+        }
+        if (depCheck.warnings.length > 0) {
+            depCheck.warnings.forEach(w => console.warn(`[PluginManager] ⚠️ ${w}`));
+        }
+
         const newPlugin = await this.registerPlugin(botId, directoryPath, 'LOCAL', directoryPath);
         try {
-            const packageJson = JSON.parse(await fse.readFile(path.join(directoryPath, 'package.json'), 'utf-8'));
             reportPluginDownload(packageJson.name);
         } catch(e) {
             console.error('Не удалось прочитать package.json для отправки статистики локального плагина');
@@ -118,11 +177,11 @@ class PluginManager {
 
         await this._installDependencies(directoryPath);
         await this.loadPluginGraphs(botId, newPlugin.id, directoryPath);
-        
+
         if (this.botManager) {
             await this.botManager.reloadPlugins(botId);
         }
-        
+
         return newPlugin;
     }
 
@@ -193,9 +252,20 @@ class PluginManager {
 
             await this._installDependencies(localPath);
 
-            const newPlugin = await this.registerPlugin(botId, localPath, 'GITHUB', repoUrl, prismaClient);
-            
+
             const packageJson = JSON.parse(await fse.readFile(path.join(localPath, 'package.json'), 'utf-8'));
+            const depCheck = await this.checkPluginDependencies(botId, packageJson);
+            if (!depCheck.isValid) {
+                const missingList = depCheck.missing.join(', ');
+                console.warn(`[PluginManager] ⚠️ Плагин ${packageJson.name} требует: ${missingList}`);
+                console.warn(`[PluginManager] Плагин будет установлен, но может работать некорректно без зависимостей.`);
+            }
+            if (depCheck.warnings.length > 0) {
+                depCheck.warnings.forEach(w => console.warn(`[PluginManager] ⚠️ ${w}`));
+            }
+
+            const newPlugin = await this.registerPlugin(botId, localPath, 'GITHUB', repoUrl, prismaClient);
+
             reportPluginDownload(packageJson.name);
 
             await this.loadPluginGraphs(botId, newPlugin.id, localPath);

package/backend/src/core/services/BotLifecycleService.js

@@ -147,8 +147,8 @@ class BotLifecycleService {
         return this.processManager.getProcess(botId);
     }
 
-    async restartBot(botId) {
-        const botConfig = this.processManager.getProcess(botId)?.botConfig;
+    async restartBot(botId, providedBotConfig = null) {
+        const botConfig = providedBotConfig || this.processManager.getProcess(botId)?.botConfig;
         if (!botConfig) {
             throw new Error('Bot configuration not found');
         }
@@ -229,6 +229,15 @@ class BotLifecycleService {
                     case 'debug:check_step_mode':
                         await this._handleDebugStepModeCheck(botId, child, message);
                         break;
+                    case 'update_credentials':
+                        await this._handleUpdateCredentials(botId, child, message);
+                        break;
+                    case 'restart_bot':
+                        await this._handleRestartBot(botId, child, message);
+                        break;
+                    case 'change_credentials':
+                        await this._handleChangeCredentials(botId, child, message);
+                        break;
                 }
             } catch (error) {
                 this.appendLog(botId, `[SYSTEM-ERROR] Критическая ошибка в обработчике: ${error.stack}`);
@@ -830,6 +839,181 @@ class BotLifecycleService {
             });
         }
     }
+
+    /**
+     * Обработчик обновления credentials в БД (без рестарта)
+     */
+    async _handleUpdateCredentials(botId, child, message) {
+        const { requestId, payload } = message;
+        const { username, password } = payload;
+
+        try {
+            // Валидация входных данных
+            if (!username || username.trim().length === 0) {
+                throw new Error('Username не может быть пустым');
+            }
+
+            const existingBot = await this.botRepository.findByUsername(username);
+            if (existingBot && existingBot.id !== botId) {
+                throw new Error(`Username "${username}" уже используется другим ботом (ID: ${existingBot.id})`);
+            }
+
+            const { encrypt } = require('../utils/crypto');
+            const updateData = { username };
+
+            if (password !== undefined && password !== null) {
+                if (password.trim().length === 0) {
+                    throw new Error('Password не может быть пустым');
+                }
+                updateData.password = encrypt(password);
+            }
+
+            await this.botRepository.update(botId, updateData);
+
+            if (child.botConfig) {
+                child.botConfig.username = username;
+                if (password !== undefined && password !== null) {
+                    child.botConfig.password = updateData.password;
+                }
+            }
+
+            this.logger.info({ botId, username }, 'Credentials обновлены в БД');
+            this.appendLog(botId, `[API] Credentials обновлены: username="${username}"`);
+
+            child.send({
+                type: 'credentials_operation_response',
+                requestId,
+                payload: {
+                    success: true,
+                    message: 'Credentials успешно обновлены в БД'
+                }
+            });
+
+        } catch (error) {
+            this.logger.error({ botId, error }, 'Ошибка обновления credentials');
+            this.appendLog(botId, `[API ERROR] Не удалось обновить credentials: ${error.message}`);
+
+            child.send({
+                type: 'credentials_operation_response',
+                requestId,
+                error: error.message
+            });
+        }
+    }
+
+    /**
+     * Обработчик рестарта бота
+     */
+    async _handleRestartBot(botId, child, message) {
+        const { requestId } = message;
+
+        try {
+            this.logger.info({ botId }, 'Запрос на рестарт бота от плагина');
+            this.appendLog(botId, '[API] Получен запрос на рестарт бота от плагина');
+
+            const savedBotConfig = { ...child.botConfig };
+
+            child.send({
+                type: 'credentials_operation_response',
+                requestId,
+                payload: {
+                    success: true,
+                    message: 'Рестарт инициирован'
+                }
+            });
+
+            setTimeout(async () => {
+                try {
+                    await this.restartBot(botId, savedBotConfig);
+                    this.logger.info({ botId }, 'Бот успешно перезапущен');
+                } catch (error) {
+                    this.logger.error({ botId, error }, 'Ошибка при рестарте бота');
+                    this.appendLog(botId, `[API ERROR] Ошибка при рестарте: ${error.message}`);
+                }
+            }, 3000);
+
+        } catch (error) {
+            this.logger.error({ botId, error }, 'Ошибка инициализации рестарта');
+
+            child.send({
+                type: 'credentials_operation_response',
+                requestId,
+                error: error.message
+            });
+        }
+    }
+
+    /**
+     * Обработчик изменения credentials с автоматическим рестартом
+     */
+    async _handleChangeCredentials(botId, child, message) {
+        const { requestId, payload } = message;
+        const { username, password } = payload;
+
+        try {
+            if (!username || username.trim().length === 0) {
+                throw new Error('Username не может быть пустым');
+            }
+
+            const existingBot = await this.botRepository.findByUsername(username);
+            if (existingBot && existingBot.id !== botId) {
+                throw new Error(`Username "${username}" уже используется другим ботом (ID: ${existingBot.id})`);
+            }
+
+            const { encrypt } = require('../utils/crypto');
+            const updateData = { username };
+
+            if (password !== undefined && password !== null) {
+                if (password.trim().length === 0) {
+                    throw new Error('Password не может быть пустым');
+                }
+                updateData.password = encrypt(password);
+            }
+
+            await this.botRepository.update(botId, updateData);
+
+            if (child.botConfig) {
+                child.botConfig.username = username;
+                if (password !== undefined && password !== null) {
+                    child.botConfig.password = updateData.password;
+                }
+            }
+
+            const savedBotConfig = { ...child.botConfig };
+
+            this.logger.info({ botId, username }, 'Credentials обновлены, инициирован рестарт');
+            this.appendLog(botId, `[API] Credentials изменены: username="${username}". Выполняется рестарт...`);
+
+            child.send({
+                type: 'credentials_operation_response',
+                requestId,
+                payload: {
+                    success: true,
+                    message: 'Credentials обновлены, рестарт инициирован'
+                }
+            });
+
+            setTimeout(async () => {
+                try {
+                    await this.restartBot(botId, savedBotConfig);
+                    this.logger.info({ botId }, 'Бот успешно перезапущен с новыми credentials');
+                } catch (error) {
+                    this.logger.error({ botId, error }, 'Ошибка при рестарте бота после изменения credentials');
+                    this.appendLog(botId, `[API ERROR] Ошибка при рестарте: ${error.message}`);
+                }
+            }, 3000);
+
+        } catch (error) {
+            this.logger.error({ botId, error }, 'Ошибка изменения credentials');
+            this.appendLog(botId, `[API ERROR] Не удалось изменить credentials: ${error.message}`);
+
+            child.send({
+                type: 'credentials_operation_response',
+                requestId,
+                error: error.message
+            });
+        }
+    }
 }
 
 module.exports = BotLifecycleService;

package/backend/src/server.js

@@ -102,6 +102,16 @@ app.get(/^(?!\/api).*/, (req, res) => {
 
 async function runStartupMigrations() {
     try {
+        // Удаляем серверы с невалидными портами напрямую через SQL,
+        // потому что Prisma не может их прочитать если значение не помещается в INT
+        const result = await prisma.$executeRawUnsafe(
+            `DELETE FROM Server WHERE length(CAST(port AS TEXT)) > 5 OR port > 65535 OR port < 1`
+        );
+
+        if (result > 0) {
+            console.log(`[Migration] Удалено ${result} серверов с невалидными портами.`);
+        }
+
         const adminRole = await prisma.panelRole.findUnique({ where: { name: 'Admin' } });
         if (adminRole) {
             const permissions = JSON.parse(adminRole.permissions);
@@ -109,7 +119,7 @@ async function runStartupMigrations() {
                 const newPermissions = ALL_PERMISSIONS
                     .map(p => p.id)
                     .filter(id => id !== '*');
-                
+
                 await prisma.panelRole.update({
                     where: { id: adminRole.id },
                     data: { permissions: JSON.stringify(newPermissions) }