blockmine 1.25.0 → 1.27.0

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

@@ -0,0 +1,63 @@
+const express = require('express');
+const router = express.Router();
+const nodeRegistry = require('../../core/NodeRegistry');
+
+router.get('/nodes', (req, res) => {
+  try {
+    const graphType = req.query.graphType || null;
+    const flat = nodeRegistry.getAllNodes().map(node => {
+      const json = node.toJSON ? node.toJSON() : node;
+      return json;
+    });
+
+    if (graphType) {
+      const filtered = flat.filter(node =>
+        node.graphType === graphType || node.graphType === 'ALL'
+      );
+      return res.json({ nodes: filtered, count: filtered.length });
+    }
+
+    res.json({ nodes: flat, count: flat.length });
+  } catch (error) {
+    console.error('[API] Error getting nodes:', error);
+    res.status(500).json({ error: 'Failed to get nodes', message: error.message });
+  }
+});
+
+router.get('/nodes/categories', (req, res) => {
+  try {
+    const graphType = req.query.graphType || null;
+    const byCategory = nodeRegistry.getNodesByCategory(graphType);
+
+    const result = {};
+    for (const [category, nodes] of Object.entries(byCategory)) {
+      result[category] = nodes.map(node => {
+        return node.toJSON ? node.toJSON() : node;
+      });
+    }
+
+    res.json({ categories: result, count: Object.keys(result).length });
+  } catch (error) {
+    console.error('[API] Error getting nodes by category:', error);
+    res.status(500).json({ error: 'Failed to get nodes', message: error.message });
+  }
+});
+
+router.get('/nodes/:type', (req, res) => {
+  try {
+    const { type } = req.params;
+    const node = nodeRegistry.getNodeConfig(type);
+
+    if (!node) {
+      return res.status(404).json({ error: 'Node type not found', type });
+    }
+
+    const json = node.toJSON ? node.toJSON() : node;
+    res.json({ node: json });
+  } catch (error) {
+    console.error('[API] Error getting node:', error);
+    res.status(500).json({ error: 'Failed to get node', message: error.message });
+  }
+});
+
+module.exports = router;

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

@@ -6,23 +6,224 @@ const { pluginManager } = require('../../core/services');
 
 const prisma = new PrismaClient();
 const OFFICIAL_CATALOG_URL = "https://raw.githubusercontent.com/blockmineJS/official-plugins-list/main/index.json";
+const CATALOG_TTL_MS = 5 * 60 * 1000;
+const PLUGIN_DETAIL_TTL_MS = 10 * 60 * 1000;
+const PLUGIN_CHANGELOG_TTL_MS = 10 * 60 * 1000;
+
+let catalogCache = {
+    data: null,
+    expiresAt: 0,
+    pending: null,
+};
+
+const pluginDetailCache = new Map();
+const pluginChangelogCache = new Map();
+const GITHUB_REQUEST_TIMEOUT_MS = 10000;
+
+function getGithubHeaders(extra = {}) {
+    const headers = {
+        'Accept': 'application/vnd.github+json',
+        'User-Agent': 'BlockMine',
+        ...extra
+    };
+
+    if (process.env.GITHUB_TOKEN) {
+        headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
+    }
 
-const getCacheBustedUrl = (url) => `${url}?t=${new Date().getTime()}`;
-
+    return headers;
+}
 
-router.get('/catalog', async (req, res) => {
+async function fetchWithTimeout(url, options = {}) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), GITHUB_REQUEST_TIMEOUT_MS);
     try {
-        const response = await fetch(getCacheBustedUrl(OFFICIAL_CATALOG_URL));
-        
+        return await fetch(url, { ...options, signal: controller.signal });
+    } finally {
+        clearTimeout(timeoutId);
+    }
+}
+
+async function fetchOfficialCatalog(force = false) {
+    const now = Date.now();
+
+    if (!force && catalogCache.data && catalogCache.expiresAt > now) {
+        return catalogCache.data;
+    }
+
+    if (catalogCache.pending) {
+        return catalogCache.pending;
+    }
+
+    catalogCache.pending = (async () => {
+        const response = await fetchWithTimeout(OFFICIAL_CATALOG_URL);
+
         if (!response.ok) {
             const errorText = await response.text();
             console.error(`[API Error] Failed to fetch catalog from GitHub. Status: ${response.status}, Response: ${errorText}`);
             throw new Error(`GitHub returned status ${response.status}`);
         }
-        
-        res.json(await response.json());
+
+        const data = await response.json();
+        catalogCache.data = data;
+        catalogCache.expiresAt = Date.now() + CATALOG_TTL_MS;
+        return data;
+    })();
+
+    try {
+        return await catalogCache.pending;
+    } catch (error) {
+        catalogCache.data = null;
+        catalogCache.expiresAt = 0;
+        throw error;
+    } finally {
+        catalogCache.pending = null;
+    }
+}
+
+function getCachedTimedValue(cache, key) {
+    const cached = cache.get(key);
+    if (!cached) return null;
+    if (cached.expiresAt <= Date.now()) {
+        cache.delete(key);
+        return null;
+    }
+    return cached.data;
+}
+
+function setCachedTimedValue(cache, key, data, ttlMs) {
+    cache.set(key, {
+        data,
+        expiresAt: Date.now() + ttlMs,
+    });
+}
+
+function getCachedPluginDetail(pluginName) {
+    return getCachedTimedValue(pluginDetailCache, pluginName);
+}
+
+function setCachedPluginDetail(pluginName, data) {
+    setCachedTimedValue(pluginDetailCache, pluginName, data, PLUGIN_DETAIL_TTL_MS);
+}
+
+function getCachedPluginChangelog(pluginName) {
+    return getCachedTimedValue(pluginChangelogCache, pluginName);
+}
+
+function setCachedPluginChangelog(pluginName, data) {
+    setCachedTimedValue(pluginChangelogCache, pluginName, data, PLUGIN_CHANGELOG_TTL_MS);
+}
+
+function parseGithubRepoInfo(repoUrl) {
+    if (typeof repoUrl !== 'string') {
+        return null;
+    }
+
+    try {
+        const parsedUrl = new URL(repoUrl);
+        const hostname = parsedUrl.hostname.toLowerCase();
+        if (!['github.com', 'www.github.com'].includes(hostname)) {
+            return null;
+        }
+
+        const pathParts = parsedUrl.pathname.split('/').filter(Boolean);
+        if (pathParts.length < 2) {
+            return null;
+        }
+
+        return {
+            owner: pathParts[0],
+            repo: pathParts[1].replace(/\.git$/i, '')
+        };
+    } catch {
+        return null;
+    }
+}
+
+async function fetchGithubReadme(owner, repo) {
+    const response = await fetchWithTimeout(
+        `https://api.github.com/repos/${owner}/${repo}/readme`,
+        { headers: getGithubHeaders({ 'Accept': 'application/vnd.github.raw+json' }) }
+    );
+
+    if (!response.ok) {
+        if (response.status === 403) {
+            const remaining = response.headers.get('x-ratelimit-remaining');
+            if (remaining === '0') {
+                console.warn(`[GitHub README] Rate limit reached while loading README for ${owner}/${repo}.`);
+            }
+        }
+        return null;
+    }
+
+    return response.text();
+}
+
+async function renderGithubMarkdown(markdown, owner, repo) {
+    if (!markdown) {
+        return null;
+    }
+
+    const response = await fetchWithTimeout('https://api.github.com/markdown', {
+        method: 'POST',
+        headers: getGithubHeaders({
+            'Accept': 'text/html',
+            'Content-Type': 'application/json'
+        }),
+        body: JSON.stringify({
+            text: markdown,
+            mode: 'gfm',
+            context: `${owner}/${repo}`
+        })
+    });
+
+    if (!response.ok) {
+        if (response.status === 403) {
+            const remaining = response.headers.get('x-ratelimit-remaining');
+            if (remaining === '0') {
+                console.warn(`[GitHub Markdown] Rate limit reached while rendering ${owner}/${repo}.`);
+            }
+        }
+        return null;
+    }
+
+    return response.text();
+}
+
+async function fetchLatestGithubReleaseBody(repoUrl) {
+    const repoInfo = parseGithubRepoInfo(repoUrl);
+    if (!repoInfo) {
+        return null;
+    }
+
+    const response = await fetchWithTimeout(
+        `https://api.github.com/repos/${repoInfo.owner}/${repoInfo.repo}/releases/latest`,
+        { headers: getGithubHeaders() }
+    );
+
+    if (!response.ok) {
+        if (response.status === 403) {
+            const remaining = response.headers.get('x-ratelimit-remaining');
+            if (remaining === '0') {
+                console.warn(`[GitHub Releases] Rate limit reached while loading changelog for ${repoInfo.owner}/${repoInfo.repo}.`);
+            }
+        }
+        return null;
+    }
+
+    const release = await response.json();
+    return typeof release?.body === 'string' ? release.body : null;
+}
+
+
+router.get('/catalog', async (req, res) => {
+    try {
+        res.json(await fetchOfficialCatalog());
     } catch (error) {
         console.error(`[API Error] Could not fetch catalog URL. Reason: ${error.message}`);
+        if (error.name === 'AbortError' || error.message.includes('aborted') || error.message.includes('timed out')) {
+            return res.json([]);
+        }
         res.status(500).json({ error: 'Не удалось загрузить каталог плагинов.' });
     }
 });
@@ -31,9 +232,7 @@ router.post('/check-updates/:botId', authenticateUniversal, authorize('plugin:up
     try {
         const botId = parseInt(req.params.botId);
         
-        const catalogResponse = await fetch(getCacheBustedUrl(OFFICIAL_CATALOG_URL));
-        if (!catalogResponse.ok) throw new Error('Не удалось загрузить каталог для проверки обновлений.');
-        const catalog = await catalogResponse.json();
+        const catalog = await fetchOfficialCatalog();
 
         const updates = await pluginManager.checkForUpdates(botId, catalog);
         res.json(updates);
@@ -47,7 +246,7 @@ router.post('/update/:pluginId', authenticateUniversal, authorize('plugin:update
     try {
         const pluginId = parseInt(req.params.pluginId);
         const { targetTag } = req.body; // Получаем тег из тела запроса (если указан)
-        const updatedPlugin = await pluginManager.updatePlugin(pluginId, targetTag);
+        const updatedPlugin = await pluginManager.updatePlugin(pluginId, targetTag, req.body?.targetRepoUrl);
         res.json(updatedPlugin);
     } catch (error) {
         res.status(500).json({ error: error.message });
@@ -92,6 +291,8 @@ router.get('/:id/info', authenticateUniversal, authorize('plugin:list'), async (
                 description: true,
                 sourceType: true,
                 sourceUri: true,
+                sourceRefType: true,
+                sourceRef: true,
                 isEnabled: true,
                 manifest: true,
                 settings: true,
@@ -142,6 +343,8 @@ router.get('/bot/:botId', authenticateUniversal, authorize('plugin:list'), async
                 description: true,
                 sourceType: true,
                 sourceUri: true,
+                sourceRefType: true,
+                sourceRef: true,
                 isEnabled: true,
                 manifest: true,
                 settings: true,
@@ -176,14 +379,42 @@ router.get('/bot/:botId', authenticateUniversal, authorize('plugin:list'), async
     }
 });
 
+router.get('/catalog/:name/changelog', async (req, res) => {
+    try {
+        const pluginName = req.params.name;
+        const cachedChangelog = getCachedPluginChangelog(pluginName);
+
+        if (cachedChangelog !== null) {
+            return res.json({ body: cachedChangelog });
+        }
+
+        const catalog = await fetchOfficialCatalog();
+        const pluginInfo = catalog.find((plugin) => plugin.name === pluginName);
+
+        if (!pluginInfo) {
+            return res.status(404).json({ error: 'Plugin not found in catalog.' });
+        }
+
+        const changelogBody = (await fetchLatestGithubReleaseBody(pluginInfo.repoUrl)) || '';
+        setCachedPluginChangelog(pluginName, changelogBody);
+
+        return res.json({ body: changelogBody });
+    } catch (error) {
+        console.error(`[API Error] /catalog/:name/changelog:`, error);
+        return res.status(500).json({ error: 'Failed to load plugin changelog.' });
+    }
+});
+
 router.get('/catalog/:name', async (req, res) => {
     try {
         const pluginName = req.params.name;
+        const cachedDetail = getCachedPluginDetail(pluginName);
 
-        const catalogResponse = await fetch(getCacheBustedUrl(OFFICIAL_CATALOG_URL));
-        if (!catalogResponse.ok) throw new Error(`Failed to fetch catalog, status: ${catalogResponse.status}`);
+        if (cachedDetail) {
+            return res.json(cachedDetail);
+        }
 
-        const catalog = await catalogResponse.json();
+        const catalog = await fetchOfficialCatalog();
         const pluginInfo = catalog.find(p => p.name === pluginName);
 
         if (!pluginInfo) {
@@ -191,6 +422,7 @@ router.get('/catalog/:name', async (req, res) => {
         }
 
         let readmeContent = pluginInfo.description || 'Описание для этого плагина не предоставлено.';
+        let readmeHtml = null;
 
         try {
             const urlParts = new URL(pluginInfo.repoUrl);
@@ -200,19 +432,10 @@ router.get('/catalog/:name', async (req, res) => {
                 const owner = pathParts[0];
                 const repo = pathParts[1].replace('.git', '');
 
-                const readmeUrls = [
-                    `https://raw.githubusercontent.com/${owner}/${repo}/main/README.md`,
-                    `https://raw.githubusercontent.com/${owner}/${repo}/master/README.md`,
-                    `https://raw.githubusercontent.com/${owner}/${repo}/main/readme.md`,
-                    `https://raw.githubusercontent.com/${owner}/${repo}/master/readme.md`,
-                ];
-
-                for (const url of readmeUrls) {
-                    const readmeResponse = await fetch(getCacheBustedUrl(url));
-                    if (readmeResponse.ok) {
-                        readmeContent = await readmeResponse.text();
-                        break;
-                    }
+                const fetchedReadme = await fetchGithubReadme(owner, repo);
+                if (fetchedReadme) {
+                    readmeContent = fetchedReadme;
+                    readmeHtml = await renderGithubMarkdown(fetchedReadme, owner, repo);
                 }
             }
         } catch (readmeError) {
@@ -221,9 +444,11 @@ router.get('/catalog/:name', async (req, res) => {
 
         const finalPluginData = {
             ...pluginInfo,
-            fullDescription: readmeContent
+            fullDescription: readmeContent,
+            readmeHtml
         };
 
+        setCachedPluginDetail(pluginName, finalPluginData);
         res.json(finalPluginData);
     } catch (error) {
         console.error(`[API Error] /catalog/:name :`, error);
@@ -374,4 +599,4 @@ router.delete('/bot/:botId/:pluginName/store/:key', authenticateUniversal, autho
     }
 });
 
-module.exports = router;
+module.exports = router;

package/backend/src/container.js

@@ -19,10 +19,13 @@ const ResourceMonitorService = require('./core/services/ResourceMonitorService')
 const TelemetryService = require('./core/services/TelemetryService');
 const BotLifecycleService = require('./core/services/BotLifecycleService');
 const CommandExecutionService = require('./core/services/CommandExecutionService');
+const PluginManagementService = require('./core/services/PluginManagementService');
+const EventGraphService = require('./core/services/EventGraphService');
 
 // Core
 const EventGraphManager = require('./core/EventGraphManager');
 const PluginManager = require('./core/PluginManager');
+const BotManager = require('./core/BotManager');
 
 function createLogger() {
     return {
@@ -36,14 +39,12 @@ function createLogger() {
 function configureContainer() {
     const container = createContainer();
 
-    // Infrastructure
     container.register({
         prisma: asValue(prisma),
         config: asValue(config),
         logger: asFunction(createLogger).singleton(),
     });
 
-    // Repositories
     container.register({
         botRepository: asClass(BotRepository).singleton(),
         commandRepository: asClass(CommandRepository).singleton(),
@@ -55,7 +56,6 @@ function configureContainer() {
         groupRepository: asClass(GroupRepository).singleton(),
     });
 
-    // Core Services
     container.register({
         cacheManager: asClass(CacheManager).singleton(),
         botProcessManager: asClass(BotProcessManager).singleton(),
@@ -63,17 +63,20 @@ function configureContainer() {
         telemetryService: asClass(TelemetryService).singleton(),
     });
 
-    // Managers
+    container.register({
+        botLifecycleService: asClass(BotLifecycleService).singleton(),
+        commandExecutionService: asClass(CommandExecutionService).singleton(),
+        pluginManagementService: asClass(PluginManagementService).singleton(),
+        eventGraphService: asClass(EventGraphService).singleton(),
+    });
+
     container.register({
         pluginManager: asClass(PluginManager).singleton(),
-        // EventGraphManager создаётся без зависимости - botManager передаётся через setter
         eventGraphManager: asClass(EventGraphManager).singleton(),
     });
 
-    // High-level Services (зависят от managers)
     container.register({
-        botLifecycleService: asClass(BotLifecycleService).singleton(),
-        commandExecutionService: asClass(CommandExecutionService).singleton(),
+        botManager: asClass(BotManager).singleton(),
     });
 
     return container;

package/backend/src/core/BotCommandLoader.js

@@ -0,0 +1,161 @@
+const Command = require('./system/Command');
+const { loadCommands } = require('./system/CommandRegistry');
+const { MessageTypes } = require('./ipc/ipcMessageTypes');
+
+async function loadBotCommands(bot, config, prisma) {
+    bot.commands = await loadCommands();
+
+    const dbCommands = await prisma.command.findMany({ where: { botId: config.id } });
+
+    for (const dbCommand of dbCommands) {
+        const existingCommand = bot.commands.get(dbCommand.name);
+
+        if (existingCommand) {
+            existingCommand.isEnabled = dbCommand.isEnabled;
+            existingCommand.description = dbCommand.description;
+            existingCommand.cooldown = dbCommand.cooldown;
+            existingCommand.aliases = JSON.parse(dbCommand.aliases || '[]');
+            existingCommand.permissionId = dbCommand.permissionId;
+            existingCommand.allowedChatTypes = JSON.parse(dbCommand.allowedChatTypes || '[]');
+
+            const aliases = JSON.parse(dbCommand.aliases || '[]');
+            for (const alias of aliases) {
+                bot.commands.set(alias, existingCommand);
+            }
+        } else if (dbCommand.isVisual) {
+            const visualCommand = createVisualCommand(bot, dbCommand);
+            bot.commands.set(visualCommand.name, visualCommand);
+
+            const visualAliases = JSON.parse(dbCommand.aliases || '[]');
+            for (const alias of visualAliases) {
+                bot.commands.set(alias, visualCommand);
+            }
+        }
+    }
+
+    for (const cmd of bot.commands.values()) {
+        if (cmd.aliases && Array.isArray(cmd.aliases)) {
+            for (const alias of cmd.aliases) {
+                if (!bot.commands.has(alias)) {
+                    bot.commands.set(alias, cmd);
+                }
+            }
+        }
+    }
+
+    if (process.send) {
+        for (const cmd of bot.commands.values()) {
+            process.send({
+                type: MessageTypes.COMMAND.REGISTER,
+                commandConfig: {
+                    name: cmd.name,
+                    description: cmd.description,
+                    aliases: cmd.aliases,
+                    owner: cmd.owner,
+                    permissions: cmd.permissions,
+                    cooldown: cmd.cooldown,
+                    allowedChatTypes: cmd.allowedChatTypes,
+                }
+            });
+        }
+    }
+
+    return bot.commands;
+}
+
+function createVisualCommand(bot, dbCommand) {
+    const visualCommand = new Command({
+        name: dbCommand.name,
+        description: dbCommand.description,
+        aliases: JSON.parse(dbCommand.aliases || '[]'),
+        cooldown: dbCommand.cooldown,
+        allowedChatTypes: JSON.parse(dbCommand.allowedChatTypes || '[]'),
+        args: JSON.parse(dbCommand.argumentsJson || '[]'),
+        owner: 'visual_editor',
+    });
+
+    visualCommand.permissionId = dbCommand.permissionId;
+    visualCommand.graphJson = dbCommand.graphJson;
+    visualCommand.owner = 'visual_editor';
+
+    visualCommand.handler = (botInstance, typeChat, user, args) => {
+        const playerList = botInstance ? Object.keys(botInstance.players) : [];
+        const botState = botInstance ? { yaw: botInstance.entity.yaw, pitch: botInstance.entity.pitch } : {};
+        const botEntity = botInstance && botInstance.entity ? {
+            position: botInstance.entity.position,
+            yaw: botInstance.entity.yaw,
+            pitch: botInstance.entity.pitch
+        } : null;
+
+        const context = {
+            bot: botInstance,
+            botApi: botInstance.api,
+            user,
+            args,
+            typeChat,
+            players: playerList,
+            botState,
+            botEntity,
+            botId: botInstance.config.id,
+            graphId: dbCommand.id,
+            eventType: 'command',
+            eventArgs: {
+                commandName: dbCommand.name,
+                user: { username: user?.username },
+                args,
+                typeChat
+            }
+        };
+
+        return botInstance.graphExecutionEngine.execute(visualCommand.graphJson, context);
+    };
+
+    return visualCommand;
+}
+
+function registerTemporaryCommand(bot, commandData) {
+    const tempCommand = new Command({
+        name: commandData.name,
+        description: commandData.description || '',
+        aliases: commandData.aliases || [],
+        cooldown: commandData.cooldown || 0,
+        allowedChatTypes: commandData.allowedChatTypes || ['chat', 'private'],
+        args: [],
+        owner: 'runtime',
+    });
+
+    tempCommand.permissionId = commandData.permissionId || null;
+    tempCommand.isTemporary = true;
+    tempCommand.tempId = commandData.tempId;
+    tempCommand.isVisual = false;
+    tempCommand.handler = () => {};
+
+    bot.commands.set(commandData.name, tempCommand);
+
+    if (Array.isArray(commandData.aliases)) {
+        for (const alias of commandData.aliases) {
+            bot.commands.set(alias, tempCommand);
+        }
+    }
+}
+
+function unregisterTemporaryCommand(bot, commandName, aliases) {
+    if (bot.commands.has(commandName)) {
+        bot.commands.delete(commandName);
+    }
+
+    if (Array.isArray(aliases)) {
+        for (const alias of aliases) {
+            if (bot.commands.has(alias)) {
+                bot.commands.delete(alias);
+            }
+        }
+    }
+}
+
+module.exports = {
+    loadBotCommands,
+    createVisualCommand,
+    registerTemporaryCommand,
+    unregisterTemporaryCommand
+};