blockmine 1.5.9 → 1.6.0

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;
@@ -26,7 +24,6 @@ const resolvePluginPath = async (req, res, next) => {
         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: 'Доступ запрещен: попытка доступа за пределы директории плагина.' });
         }
@@ -35,7 +32,6 @@ const resolvePluginPath = async (req, res, next) => {
             return res.status(404).json({ error: 'Директория плагина не найдена.' });
         }
         
-        // Attach the safe path to the request object
         req.pluginPath = pluginPath;
         next();
     } catch (error) {
@@ -52,7 +48,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 +293,28 @@ 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);
+                await prisma.installedPlugin.updateMany({
+                    where: {
+                        botId: parseInt(req.params.botId),
+                        path: req.pluginPath,
+                    },
+                    data: {
+                        name: packageJson.name || req.params.pluginName,
+                        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 +393,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,10 +402,16 @@ 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({
             where: {
                 botId: parseInt(req.params.botId),
@@ -397,6 +421,7 @@ router.post('/:pluginName/manifest', resolvePluginPath, async (req, res) => {
                 name: newManifest.name,
                 version: newManifest.version,
                 description: newManifest.description,
+                manifest: JSON.stringify(newManifest.botpanel || {}),
             }
         });
 
@@ -436,6 +461,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 +479,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 +491,98 @@ 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);
+            
+            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;
+            }
+
+            cp.execSync(`git push -u origin ${branch}`);
+
+            const prUrl = `https://github.com/${repoInfo.owner}/${repoInfo.repo}/pull/new/${branch}`;
+
+            res.json({ success: true, prUrl });
+            
+        } 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

@@ -211,8 +211,39 @@ process.on('message', async (message) => {
                     const userData = await UserService.getUser(username, bot.config.id, bot.config);
                     if (!userData) return null;
 
+                    const permissions = userData.permissionsSet ? Array.from(userData.permissionsSet) : [];
+
                     return {
-                        ...userData,
+                        id: userData.id,
+                        username: userData.username,
+                        isOwner: userData.isOwner,
+                        isBlacklisted: userData.isBlacklisted,
+                        permissions: permissions,
+                        groups: userData.groups,
+                        hasPermission: (permissionName) => {
+                            if (userData.isOwner) return true;
+                            if (!permissionName) return false;
+
+                            if (permissions.includes(permissionName)) {
+                                return true;
+                            }
+
+                            const permissionParts = permissionName.split('.');
+                            if (permissionParts.length > 1) {
+                                const domain = permissionParts[0];
+                                const wildcard = `${domain}.*`;
+                                if (permissions.includes(wildcard)) {
+                                    return true;
+                                }
+                            }
+                            
+                            if (permissions.includes('*')) {
+                                return true;
+                            }
+
+                            return false;
+                        },
+                        hasGroup: (groupName) => userData.hasGroup(groupName),
                         addGroup: (group) => bot.api.performUserAction(username, 'addGroup', { group }),
                         removeGroup: (group) => bot.api.performUserAction(username, 'removeGroup', { group }),
                         addPermission: (permission) => bot.api.performUserAction(username, 'addPermission', { permission }),
@@ -514,11 +545,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 +561,7 @@ process.on('message', async (message) => {
             });
 
             bot.on('entityGone', (entity) => {
+                if (!isReady) return;
                 sendEvent('entityGone', { entity: serializeEntity(entity) });
                 entityMoveThrottles.delete(entity.id);
             });
@@ -536,7 +570,7 @@ process.on('message', async (message) => {
                 sendLog('[Event: spawn] Бот заспавнился в мире.');
                 setTimeout(() => {
                     isReady = true;
-                    sendLog('[BotProcess] Бот готов к приему событий playerJoined/playerLeft.');
+                    sendLog('[BotProcess] Бот готов к приему событий.');
                 }, 3000);
             });
         } catch (err) {