blockmine 1.6.0 → 1.6.2

package/README.md

@@ -131,6 +131,7 @@
 git clone https://github.com/blockmineJS/blockmine.git
 cd blockmine
 npm install
+npm run build
 ```
 
 ### 2. Запуск в режиме разработки

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

@@ -21,18 +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);
-
-        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: 'Директория плагина не найдена в файловой системе.' });
         }
         
         req.pluginPath = pluginPath;
+        req.pluginData = plugin;
         next();
     } catch (error) {
         console.error('[Plugin IDE Middleware Error]', error);
@@ -297,19 +304,48 @@ router.post('/:pluginName/file', resolvePluginPath, async (req, res) => {
         if (relativePath === 'package.json' || relativePath.endsWith('/package.json')) {
             try {
                 const packageJson = JSON.parse(content);
-                await prisma.installedPlugin.updateMany({
+                
+                const existingPlugin = await prisma.installedPlugin.findFirst({
                     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`);
+                
+                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);
             }
@@ -366,6 +402,33 @@ router.post('/:pluginName/fs', resolvePluginPath, async (req, res) => {
                 res.status(200).json({ message: 'Renamed successfully.' });
                 break;
 
+            case 'move':
+                if (!newPath) return res.status(400).json({ error: 'New path is required for move operation.' });
+                const safeMoveNewPath = path.resolve(req.pluginPath, newPath);
+                if (!safeMoveNewPath.startsWith(req.pluginPath)) return res.status(403).json({ error: 'Access denied: New path is outside of plugin directory.' });
+                if (!await fse.pathExists(safePath)) return res.status(404).json({ error: 'Source file or folder not found.' });
+                
+                if (safeMoveNewPath.startsWith(safePath + path.sep)) {
+                    return res.status(400).json({ error: 'Cannot move folder into itself.' });
+                }
+
+                let finalPath = safeMoveNewPath;
+                let counter = 1;
+                while (await fse.pathExists(finalPath)) {
+                    const ext = path.extname(safeMoveNewPath);
+                    const base = path.basename(safeMoveNewPath, ext);
+                    const dir = path.dirname(safeMoveNewPath);
+                    finalPath = path.join(dir, `${base} (${counter})${ext}`);
+                    counter++;
+                }
+                
+                await fse.move(safePath, finalPath);
+                res.status(200).json({ 
+                    message: 'Moved successfully.',
+                    newPath: path.relative(req.pluginPath, finalPath)
+                });
+                break;
+
             default:
                 res.status(400).json({ error: 'Invalid operation specified.' });
         }
@@ -412,23 +475,50 @@ router.post('/:pluginName/manifest', resolvePluginPath, async (req, res) => {
         
         await fse.writeJson(manifestPath, newManifest, { spaces: 2 });
         
-        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,
-                manifest: JSON.stringify(newManifest.botpanel || {}),
             }
         });
+        
+        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 обновлен (возможны проблемы с синхронизацией БД).' });
     }
 });
 
@@ -543,7 +633,26 @@ router.post('/:pluginName/create-pr', resolvePluginPath, async (req, res) => {
             
             process.chdir(tempDir);
             
-            cp.execSync(`git checkout -b ${branch}`);
+            let branchExists = false;
+            try {
+                cp.execSync(`git checkout -b ${branch}`, { stdio: 'pipe' });
+                console.log(`[Plugin IDE] Создана новая ветка ${branch}`);
+            } catch (e) {
+                try {
+                    cp.execSync(`git checkout ${branch}`, { stdio: 'pipe' });
+                    console.log(`[Plugin IDE] Переключились на существующую ветку ${branch}`);
+                } catch (e2) {
+                    try {
+                        cp.execSync(`git fetch origin ${branch}`, { stdio: 'pipe' });
+                        cp.execSync(`git checkout -b ${branch} origin/${branch}`, { stdio: 'pipe' });
+                        branchExists = true;
+                        console.log(`[Plugin IDE] Создана ветка ${branch} из удаленной`);
+                    } catch (e3) {
+                        cp.execSync(`git checkout -B ${branch}`, { stdio: 'pipe' });
+                        console.log(`[Plugin IDE] Принудительно создана ветка ${branch}`);
+                    }
+                }
+            }
             
             const files = await fse.readdir(req.pluginPath);
             for (const file of files) {
@@ -564,11 +673,26 @@ router.post('/:pluginName/create-pr', resolvePluginPath, async (req, res) => {
                 throw e;
             }
 
-            cp.execSync(`git push -u origin ${branch}`);
+
+            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}`;
 
-            res.json({ success: true, prUrl });
+            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 {

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,51 +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;
-
-                    const permissions = userData.permissionsSet ? Array.from(userData.permissionsSet) : [];
-
-                    return {
-                        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 }),
-                        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),
@@ -464,6 +420,10 @@ process.on('message', async (message) => {
                 messageHandledByCustomParser = false;
                 const rawMessageText = jsonMsg.toString();
                 bot.events.emit('core:raw_message', rawMessageText, jsonMsg);
+                
+                sendEvent('raw_message', {
+                    rawText: rawMessageText
+                });
             });
 
             bot.events.on('chat:message', (data) => {

package/backend/src/core/EventGraphManager.js

@@ -145,6 +145,9 @@ class EventGraphManager {
                 context.message = args.message;
                 context.chat_type = args.chatType;
                 break;
+            case 'raw_message':
+                context.rawText = args.rawText;
+                break;
             case 'playerJoined':
             case 'playerLeft':
                 context.user = args.user;

package/backend/src/core/GraphExecutionEngine.js

@@ -379,7 +379,13 @@ class GraphExecutionEngine {
               else result = this.context[pinId];
               break;
           case 'event:chat':
-              if (pinId === 'user') result = { username: this.context.username };
+              if (pinId === 'username') result = this.context.username;
+              else if (pinId === 'message') result = this.context.message;
+              else if (pinId === 'chatType') result = this.context.chat_type;
+              else result = this.context[pinId];
+              break;
+          case 'event:raw_message':
+              if (pinId === 'rawText') result = this.context.rawText;
               else result = this.context[pinId];
               break;
           case 'event:playerJoined':

package/backend/src/core/NodeRegistry.js

@@ -129,7 +129,23 @@ class NodeRegistry {
                 { id: 'username', type: 'String', name: 'Игрок' },
                 { id: 'message', type: 'String', name: 'Сообщение' },
                 { id: 'chatType', type: 'String', name: 'Тип чата' },
-                { id: 'raw', type: 'String', name: 'Raw JSON' },
+            ]
+        }
+    });
+
+    this.registerNodeType({
+        type: 'event:raw_message',
+        name: 'Событие: Сырое сообщение',
+        label: '📝 Сырое сообщение',
+        description: 'Срабатывает при получении любого сообщения в сыром виде (до парсинга).',
+        category: 'События',
+        graphType: event,
+        isEvent: true,
+        pins: {
+            inputs: [],
+            outputs: [
+                { id: 'exec', type: 'Exec', name: 'Выполнить' },
+                { id: 'rawText', type: 'String', name: 'Сырой текст' },
             ]
         }
     });