blockmine 1.5.9 → 1.6.1

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

@@ -12,10 +12,8 @@ const router = express.Router({ mergeParams: true });
 const DATA_DIR = path.join(os.homedir(), '.blockmine');
 const PLUGINS_BASE_DIR = path.join(DATA_DIR, 'storage', 'plugins');
 
-// All routes in this file require plugin development permission
 router.use(authenticate, authorize('plugin:develop'));
 
-// Middleware to resolve plugin path and ensure it's safe
 const resolvePluginPath = async (req, res, next) => {
     try {
         const { botId, pluginName } = req.params;
@@ -23,20 +21,25 @@ const resolvePluginPath = async (req, res, next) => {
             return res.status(400).json({ error: 'Имя плагина обязательно в пути.' });
         }
         
-        const botPluginsDir = path.join(PLUGINS_BASE_DIR, `bot_${botId}`);
-        const pluginPath = path.resolve(botPluginsDir, pluginName);
-
-        // Security check: ensure the resolved path is still within the bot's plugins directory
-        if (!pluginPath.startsWith(botPluginsDir)) {
-            return res.status(403).json({ error: 'Доступ запрещен: попытка доступа за пределы директории плагина.' });
+        const plugin = await prisma.installedPlugin.findFirst({
+            where: { 
+                botId: parseInt(botId), 
+                name: pluginName 
+            }
+        });
+        
+        if (!plugin) {
+            return res.status(404).json({ error: 'Плагин не найден в базе данных.' });
         }
         
+        const pluginPath = plugin.path;
+        
         if (!await fse.pathExists(pluginPath)) {
-            return res.status(404).json({ error: 'Директория плагина не найдена.' });
+            return res.status(404).json({ error: 'Директория плагина не найдена в файловой системе.' });
         }
         
-        // Attach the safe path to the request object
         req.pluginPath = pluginPath;
+        req.pluginData = plugin;
         next();
     } catch (error) {
         console.error('[Plugin IDE Middleware Error]', error);
@@ -52,7 +55,7 @@ router.post('/create', async (req, res) => {
             version = '1.0.0',
             description = '',
             author = '',
-            template = 'empty' // 'empty' or 'command'
+            template = 'empty'
         } = req.body;
 
         if (!name) {
@@ -297,6 +300,57 @@ router.post('/:pluginName/file', resolvePluginPath, async (req, res) => {
         }
         
         await fse.writeFile(safePath, content, 'utf-8');
+        
+        if (relativePath === 'package.json' || relativePath.endsWith('/package.json')) {
+            try {
+                const packageJson = JSON.parse(content);
+                
+                const existingPlugin = await prisma.installedPlugin.findFirst({
+                    where: {
+                        botId: parseInt(req.params.botId),
+                        path: req.pluginPath,
+                    }
+                });
+                
+                if (existingPlugin) {
+                    const newName = packageJson.name || req.params.pluginName;
+                    
+                    const conflictingPlugin = await prisma.installedPlugin.findFirst({
+                        where: {
+                            botId: parseInt(req.params.botId),
+                            name: newName,
+                            id: { not: existingPlugin.id }
+                        }
+                    });
+                    
+                    if (conflictingPlugin) {
+                        console.warn(`[Plugin IDE] Конфликт имени плагина: ${newName} уже существует для бота ${req.params.botId}`);
+                        await prisma.installedPlugin.update({
+                            where: { id: existingPlugin.id },
+                            data: {
+                                version: packageJson.version || '1.0.0',
+                                description: packageJson.description || '',
+                                manifest: JSON.stringify(packageJson.botpanel || {}),
+                            }
+                        });
+                    } else {
+                        await prisma.installedPlugin.update({
+                            where: { id: existingPlugin.id },
+                            data: {
+                                name: newName,
+                                version: packageJson.version || '1.0.0',
+                                description: packageJson.description || '',
+                                manifest: JSON.stringify(packageJson.botpanel || {}),
+                            }
+                        });
+                    }
+                    console.log(`[Plugin IDE] Manifest обновлен для плагина ${req.params.pluginName} после сохранения package.json`);
+                }
+            } catch (manifestError) {
+                console.error(`[Plugin IDE] Ошибка обновления manifest для ${req.params.pluginName}:`, manifestError);
+            }
+        }
+        
         res.status(200).json({ message: 'Файл успешно сохранен.' });
         
     } catch (error) {
@@ -375,7 +429,7 @@ router.post('/:pluginName/manifest', resolvePluginPath, async (req, res) => {
         }
 
         const currentManifest = await fse.readJson(manifestPath);
-        const { name, version, description, author } = req.body;
+        const { name, version, description, author, repositoryUrl } = req.body;
 
         const newManifest = {
             ...currentManifest,
@@ -384,26 +438,60 @@ router.post('/:pluginName/manifest', resolvePluginPath, async (req, res) => {
             description: description,
             author: author,
         };
+
+        if (repositoryUrl) {
+            newManifest.repository = {
+                type: 'git',
+                url: repositoryUrl
+            };
+        }
         
         await fse.writeJson(manifestPath, newManifest, { spaces: 2 });
         
-        // Also update the DB record
-        await prisma.installedPlugin.updateMany({
+        const existingPlugin = await prisma.installedPlugin.findFirst({
             where: {
                 botId: parseInt(req.params.botId),
                 path: req.pluginPath,
-            },
-            data: {
-                name: newManifest.name,
-                version: newManifest.version,
-                description: newManifest.description,
             }
         });
+        
+        if (existingPlugin) {
+            const conflictingPlugin = await prisma.installedPlugin.findFirst({
+                where: {
+                    botId: parseInt(req.params.botId),
+                    name: newManifest.name,
+                    id: { not: existingPlugin.id }
+                }
+            });
+            
+            if (conflictingPlugin) {
+                console.warn(`[Plugin IDE] Конфликт имени плагина: ${newManifest.name} уже существует для бота ${req.params.botId}`);
+                await prisma.installedPlugin.update({
+                    where: { id: existingPlugin.id },
+                    data: {
+                        version: newManifest.version,
+                        description: newManifest.description,
+                        manifest: JSON.stringify(newManifest.botpanel || {}),
+                    }
+                });
+            } else {
+                await prisma.installedPlugin.update({
+                    where: { id: existingPlugin.id },
+                    data: {
+                        name: newManifest.name,
+                        version: newManifest.version,
+                        description: newManifest.description,
+                        manifest: JSON.stringify(newManifest.botpanel || {}),
+                    }
+                });
+            }
+        }
 
         res.status(200).json({ message: 'package.json успешно обновлен.' });
     } catch (error) {
         console.error(`[Plugin IDE Error] /manifest POST for ${req.params.pluginName}:`, error);
-        res.status(500).json({ error: 'Не удалось обновить package.json.' });
+        // Файл уже сохранен, поэтому возвращаем успех даже если есть ошибка с БД
+        res.status(200).json({ message: 'package.json обновлен (возможны проблемы с синхронизацией БД).' });
     }
 });
 
@@ -436,6 +524,12 @@ router.post('/:pluginName/fork', resolvePluginPath, async (req, res) => {
         
         packageJson.name = newName;
         packageJson.description = `(Forked from ${pluginName}) ${packageJson.description || ''}`;
+        
+        packageJson.repository = {
+            type: 'git',
+            url: currentPlugin.sourceUri
+        };
+        
         await fse.writeJson(packageJsonPath, packageJson, { spaces: 2 });
         
         const forkedPlugin = await prisma.installedPlugin.create({
@@ -448,7 +542,7 @@ router.post('/:pluginName/fork', resolvePluginPath, async (req, res) => {
                 sourceType: 'LOCAL_IDE',
                 sourceUri: newPath,
                 manifest: JSON.stringify(packageJson.botpanel || {}),
-                isEnabled: false // Forked plugins are disabled by default
+                isEnabled: false
             }
         });
 
@@ -460,4 +554,127 @@ router.post('/:pluginName/fork', resolvePluginPath, async (req, res) => {
     }
 });
 
+router.post('/:pluginName/create-pr', resolvePluginPath, async (req, res) => {
+    const cp = require('child_process');
+    const { branch = 'main', commitMessage = 'Changes from local edit', repositoryUrl } = req.body;
+
+    if (!branch) {
+        return res.status(400).json({ error: 'Название ветки обязательно.' });
+    }
+
+    try {
+        cp.execSync('git --version');
+    } catch (e) {
+        return res.status(400).json({ error: 'Git не установлен на этой системе. Пожалуйста, установите Git для создания PR.' });
+    }
+
+    try {
+        const manifestPath = path.join(req.pluginPath, 'package.json');
+        const packageJson = await fse.readJson(manifestPath);
+        let originalRepo = packageJson.repository?.url;
+
+        if (repositoryUrl) {
+            originalRepo = repositoryUrl;
+            
+            packageJson.repository = {
+                type: 'git',
+                url: repositoryUrl
+            };
+            await fse.writeJson(manifestPath, packageJson, { spaces: 2 });
+        }
+
+        if (!originalRepo) {
+            return res.status(400).json({ error: 'URL репозитория не указан.' });
+        }
+        const cleanRepoUrl = originalRepo.replace(/^git\+/, '');
+
+        const parseRepo = (url) => {
+            const match = url.match(/(?:git\+)?https?:\/\/github\.com\/([^\/]+)\/([^\/]+)(?:\.git)?/);
+            return match ? { owner: match[1], repo: match[2].replace(/\.git$/, '') } : null;
+        };
+
+        const repoInfo = parseRepo(cleanRepoUrl);
+        if (!repoInfo) {
+            return res.status(400).json({ error: 'Неверный формат URL репозитория.' });
+        }
+
+        const cwd = req.pluginPath;
+        const tempDir = path.join(cwd, '..', `temp-${Date.now()}`);
+
+        try {
+            cp.execSync(`git clone ${cleanRepoUrl} "${tempDir}"`, { stdio: 'inherit' });
+            
+            process.chdir(tempDir);
+            
+            let branchExists = false;
+            try {
+                cp.execSync(`git ls-remote --heads origin ${branch}`, { stdio: 'pipe' });
+                branchExists = true;
+                console.log(`[Plugin IDE] Ветка ${branch} уже существует, переключаемся на неё`);
+            } catch (e) {
+                console.log(`[Plugin IDE] Ветка ${branch} не существует, создаём новую`);
+            }
+            
+            if (branchExists) {
+                cp.execSync(`git checkout -b ${branch} origin/${branch}`);
+                cp.execSync(`git pull origin ${branch}`);
+            } else {
+                cp.execSync(`git checkout -b ${branch}`);
+            }
+            
+            const files = await fse.readdir(req.pluginPath);
+            for (const file of files) {
+                if (file !== '.git') {
+                    const sourcePath = path.join(req.pluginPath, file);
+                    const destPath = path.join(tempDir, file);
+                    await fse.copy(sourcePath, destPath, { overwrite: true });
+                }
+            }
+            
+            cp.execSync('git add .');
+            try {
+                cp.execSync(`git commit -m "${commitMessage}"`);
+            } catch (e) {
+                if (e.message.includes('nothing to commit')) {
+                    return res.status(400).json({ error: 'Нет изменений для коммита.' });
+                }
+                throw e;
+            }
+
+
+            if (branchExists) {
+                cp.execSync(`git push origin ${branch} --force`);
+                console.log(`[Plugin IDE] Ветка ${branch} обновлена`);
+            } else {
+                cp.execSync(`git push -u origin ${branch}`);
+                console.log(`[Plugin IDE] Новая ветка ${branch} создана`);
+            }
+
+            const prUrl = `https://github.com/${repoInfo.owner}/${repoInfo.repo}/pull/new/${branch}`;
+
+            const responseData = { 
+                success: true, 
+                prUrl: prUrl,
+                isUpdate: branchExists,
+                message: branchExists ? 'Существующий PR обновлен' : 'Новый PR создан'
+            };
+            
+            console.log(`[Plugin IDE] PR ${branchExists ? 'обновлен' : 'создан'} для плагина ${req.params.pluginName}:`, responseData);
+            res.json(responseData);
+            
+        } finally {
+            try {
+                process.chdir(req.pluginPath);
+                await fse.remove(tempDir);
+            } catch (cleanupError) {
+                console.error('Cleanup error:', cleanupError);
+            }
+        }
+
+    } catch (error) {
+        console.error('[Plugin IDE Error] /create-pr:', error);
+        res.status(500).json({ error: 'Не удалось создать PR: ' + error.message });
+    }
+});
+
 module.exports = router; 

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

@@ -31,9 +31,19 @@ router.get('/', authorize('task:list'), async (req, res) => {
 
 router.post('/', authorize('task:create'), async (req, res) => {
     try {
-        const taskData = { ...req.body, cronPattern: normalizeCronPattern(req.body.cronPattern) };
+        const { runOnStartup, cronPattern, ...restOfBody } = req.body;
+        const taskData = { ...restOfBody, runOnStartup: !!runOnStartup };
+
+        if (runOnStartup) {
+            taskData.cronPattern = null; 
+        } else {
+            taskData.cronPattern = normalizeCronPattern(cronPattern);
+        }
+
         const newTask = await prisma.scheduledTask.create({ data: taskData });
-        TaskScheduler.scheduleTask(newTask);
+        if (!runOnStartup) {
+            TaskScheduler.scheduleTask(newTask);
+        }
         res.status(201).json(newTask);
     } catch (error) {
         console.error("[API /tasks] Ошибка создания задачи:", error);
@@ -46,6 +56,13 @@ router.put('/:id', authorize('task:edit'), async (req, res) => {
     try {
         const { id, createdAt, updatedAt, lastRun, ...dataToUpdate } = req.body;
         
+        if (typeof dataToUpdate.runOnStartup !== 'undefined') {
+            dataToUpdate.runOnStartup = !!dataToUpdate.runOnStartup;
+            if (dataToUpdate.runOnStartup) {
+                dataToUpdate.cronPattern = null;
+            }
+        }
+
         if (dataToUpdate.cronPattern) {
             dataToUpdate.cronPattern = normalizeCronPattern(dataToUpdate.cronPattern);
         }

package/backend/src/core/BotManager.js

@@ -253,9 +253,19 @@ class BotManager {
     }
 
     getFullState() {
+        const statuses = {};
+        for (const [id, child] of this.bots.entries()) {
+            statuses[id] = child.killed ? 'stopped' : 'running';
+        }
+
+        const logs = {};
+        for (const [botId, logArray] of this.logCache.entries()) {
+            logs[botId] = logArray;
+        }
+
         return {
-            statuses: Object.fromEntries(Array.from(this.bots.entries()).map(([id, child]) => [id, child.killed ? 'stopped' : 'running'])),
-            logs: Object.fromEntries(this.logCache)
+            statuses,
+            logs,
         };
     }
 
@@ -265,11 +275,15 @@ class BotManager {
         getIO().emit('bot:status', { botId, status, message });
     }
     
-    appendLog(botId, log) {
+    appendLog(botId, logContent) {
+        const logEntry = {
+            id: Date.now() + Math.random(),
+            content: logContent,
+        };
         const currentLogs = this.logCache.get(botId) || [];
-        const newLogs = [...currentLogs.slice(-499), log];
+        const newLogs = [...currentLogs.slice(-499), logEntry];
         this.logCache.set(botId, newLogs);
-        getIO().emit('bot:log', { botId, log });
+        getIO().emit('bot:log', { botId, log: logEntry });
     }
 
     async startBot(botConfig) {
@@ -343,6 +357,12 @@ class BotManager {
                     case 'register_group':
                         await this.handleGroupRegistration(botId, message.groupConfig);
                         break;
+                    case 'register_permissions':
+                        await this.handlePermissionsRegistration(botId, message);
+                        break;
+                    case 'add_permissions_to_group':
+                        await this.handleAddPermissionsToGroup(botId, message);
+                        break;
                     case 'request_user_action':
                         const { requestId, payload } = message;
                         const { targetUsername, action, data } = payload;
@@ -406,6 +426,7 @@ class BotManager {
         });
 
         child.on('error', (err) => this.appendLog(botConfig.id, `[PROCESS FATAL] ${err.stack}`));
+        child.stdout.on('data', (data) => console.log(data.toString()));
         child.stderr.on('data', (data) => this.appendLog(botConfig.id, `[STDERR] ${data.toString()}`));
         
         child.on('exit', (code, signal) => {
@@ -590,6 +611,66 @@ class BotManager {
         }
     }
 
+    async handlePermissionsRegistration(botId, message) {
+        try {
+            const { permissions } = message;
+            for (const perm of permissions) {
+                if (!perm.name || !perm.owner) {
+                    console.warn(`[BotManager] Пропущено право без имени или владельца для бота ${botId}:`, perm);
+                    continue;
+                }
+                await prisma.permission.upsert({
+                    where: { botId_name: { botId, name: perm.name } },
+                    update: { description: perm.description },
+                    create: {
+                        botId,
+                        name: perm.name,
+                        description: perm.description || '',
+                        owner: perm.owner,
+                    },
+                });
+            }
+            this.invalidateConfigCache(botId);
+        } catch (error) {
+            console.error(`[BotManager] Ошибка при регистрации прав для бота ${botId}:`, error);
+        }
+    }
+
+    async handleAddPermissionsToGroup(botId, message) {
+        try {
+            const { groupName, permissionNames } = message;
+            
+            const group = await prisma.group.findUnique({
+                where: { botId_name: { botId, name: groupName } }
+            });
+
+            if (!group) {
+                console.warn(`[BotManager] Попытка добавить права в несуществующую группу "${groupName}" для бота ID ${botId}.`);
+                return;
+            }
+
+            for (const permName of permissionNames) {
+                const permission = await prisma.permission.findUnique({
+                    where: { botId_name: { botId, name: permName } }
+                });
+
+                if (permission) {
+                    await prisma.groupPermission.upsert({
+                        where: { groupId_permissionId: { groupId: group.id, permissionId: permission.id } },
+                        update: {},
+                        create: { groupId: group.id, permissionId: permission.id },
+                    });
+                } else {
+                    console.warn(`[BotManager] Право "${permName}" не найдено для бота ID ${botId} при добавлении в группу "${groupName}".`);
+                }
+            }
+            
+            this.invalidateConfigCache(botId);
+        } catch (error) {
+            console.error(`[BotManager] Ошибка при добавлении прав в группу "${message.groupName}" для бота ${botId}:`, error);
+        }
+    }
+
     stopBot(botId) {
         const child = this.bots.get(botId);
         if (child) {
@@ -705,4 +786,4 @@ class BotManager {
     }
 }
 
-module.exports = BotManager;
+module.exports = new BotManager();

package/backend/src/core/BotProcess.js

@@ -12,7 +12,7 @@ const { parseArguments } = require('./system/parseArguments');
 const GraphExecutionEngine = require('./GraphExecutionEngine');
 const NodeRegistry = require('./NodeRegistry');
 
-const UserService = require('./ipc/UserService.stub.js');
+const UserService = require('./UserService');
 const PermissionManager = require('./ipc/PermissionManager.stub.js');
 
 let bot = null;
@@ -208,20 +208,7 @@ process.on('message', async (message) => {
                 sendMessage: (type, message, username) => bot.messageQueue.enqueue(type, message, username),
                 sendMessageAndWaitForReply: (command, patterns, timeout) => bot.messageQueue.enqueueAndWait(command, patterns, timeout),
                 getUser: async (username) => {
-                    const userData = await UserService.getUser(username, bot.config.id, bot.config);
-                    if (!userData) return null;
-
-                    return {
-                        ...userData,
-                        addGroup: (group) => bot.api.performUserAction(username, 'addGroup', { group }),
-                        removeGroup: (group) => bot.api.performUserAction(username, 'removeGroup', { group }),
-                        addPermission: (permission) => bot.api.performUserAction(username, 'addPermission', { permission }),
-                        removePermission: (permission) => bot.api.performUserAction(username, 'removePermission', { permission }),
-                        getGroups: () => bot.api.performUserAction(username, 'getGroups'),
-                        getPermissions: () => bot.api.performUserAction(username, 'getPermissions'),
-                        isBlacklisted: () => bot.api.performUserAction(username, 'isBlacklisted'),
-                        setBlacklisted: (value) => bot.api.performUserAction(username, 'setBlacklisted', { value }),
-                    };
+                    return await UserService.getUser(username, bot.config.id, bot.config);
                 },
                 registerPermissions: (permissions) => PermissionManager.registerPermissions(bot.config.id, permissions),
                 registerGroup: (groupConfig) => PermissionManager.registerGroup(bot.config.id, groupConfig),
@@ -514,11 +501,13 @@ process.on('message', async (message) => {
             });
 
             bot.on('entitySpawn', (entity) => {
+                if (!isReady) return;
                 const serialized = serializeEntity(entity);
                 sendEvent('entitySpawn', { entity: serialized });
             });
 
             bot.on('entityMoved', (entity) => {
+                if (!isReady) return;
                 const now = Date.now();
                 const lastSent = entityMoveThrottles.get(entity.id);
                 if (!lastSent || now - lastSent > 500) {
@@ -528,6 +517,7 @@ process.on('message', async (message) => {
             });
 
             bot.on('entityGone', (entity) => {
+                if (!isReady) return;
                 sendEvent('entityGone', { entity: serializeEntity(entity) });
                 entityMoveThrottles.delete(entity.id);
             });
@@ -536,7 +526,7 @@ process.on('message', async (message) => {
                 sendLog('[Event: spawn] Бот заспавнился в мире.');
                 setTimeout(() => {
                     isReady = true;
-                    sendLog('[BotProcess] Бот готов к приему событий playerJoined/playerLeft.');
+                    sendLog('[BotProcess] Бот готов к приему событий.');
                 }, 3000);
             });
         } catch (err) {