blockmine 1.5.7 → 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);
         }