blockmine 1.24.0 → 1.27.0

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

@@ -163,6 +163,14 @@ router.delete('/:keyId', authorize('bot:update'), async (req, res) => {
         const botId = parseInt(req.params.botId, 10);
         const keyId = parseInt(req.params.keyId, 10);
 
+        const { getIO } = require('../../real-time/socketHandler');
+
+        const io = getIO();
+
+        io.of("/bot-api")
+            .in(`key_${keyId}`)
+            .disconnectSockets(true)
+
         const result = await prisma.botApiKey.deleteMany({
             where: { id: keyId, botId },
         });

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

@@ -17,6 +17,7 @@ const { deepMergeSettings } = require('../../core/utils/settingsMerger');
 const { checkBotAccess } = require('../middleware/botAccess');
 const { filterSecretSettings, prepareSettingsForSave, isGroupedSettings } = require('../../core/utils/secretsFilter');
 const PluginHooks = require('../../core/PluginHooks');
+const rateLimit = require('express-rate-limit');
 
 const multer = require('multer');
 const archiver = require('archiver');
@@ -26,6 +27,160 @@ const os = require('os');
 const upload = multer({ storage: multer.memoryStorage() });
 
 const router = express.Router();
+const GITHUB_REQUEST_TIMEOUT_MS = 10000;
+const GITHUB_OWNER_REPO_PATTERN = /^[A-Za-z0-9_.-]+$/;
+
+const githubPreviewLimiter = rateLimit({
+    windowMs: 60 * 1000,
+    max: 30,
+    standardHeaders: true,
+    legacyHeaders: false,
+    message: { message: 'Too many GitHub preview requests. Try again later.' },
+});
+
+const githubInstallLimiter = rateLimit({
+    windowMs: 60 * 1000,
+    max: 20,
+    standardHeaders: true,
+    legacyHeaders: false,
+    message: { message: 'Too many GitHub install requests. Try again later.' },
+});
+
+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}`;
+    }
+
+    return headers;
+}
+
+function parseGithubRepoUrl(repoUrl) {
+    if (typeof repoUrl !== 'string') {
+        throw new Error('Repository URL is required.');
+    }
+
+    const trimmed = repoUrl.trim();
+    if (!trimmed) {
+        throw new Error('Repository URL is required.');
+    }
+
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(trimmed);
+    } catch (error) {
+        throw new Error('Invalid GitHub repository URL.');
+    }
+
+    if (!['github.com', 'www.github.com'].includes(parsedUrl.hostname)) {
+        throw new Error('Only GitHub repository links are supported.');
+    }
+
+    const pathParts = parsedUrl.pathname.replace(/\/+$/, '').split('/').filter(Boolean);
+    if (pathParts.length < 2) {
+        throw new Error('GitHub repository URL must include owner and repository name.');
+    }
+
+    const owner = pathParts[0];
+    const repo = pathParts[1].replace(/\.git$/i, '');
+
+    if (!owner || !repo) {
+        throw new Error('GitHub repository URL must include owner and repository name.');
+    }
+    if (!GITHUB_OWNER_REPO_PATTERN.test(owner) || !GITHUB_OWNER_REPO_PATTERN.test(repo)) {
+        throw new Error('GitHub repository URL contains unsupported owner or repository characters.');
+    }
+
+    return {
+        owner,
+        repo,
+        normalizedUrl: `https://github.com/${owner}/${repo}`
+    };
+}
+
+function normalizeGithubRepoUrl(repoUrl) {
+    return parseGithubRepoUrl(repoUrl).normalizedUrl;
+}
+
+async function fetchGithubJson(url) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), GITHUB_REQUEST_TIMEOUT_MS);
+    let response;
+    try {
+        response = await fetch(url, {
+            headers: getGithubHeaders(),
+            signal: controller.signal
+        });
+    } finally {
+        clearTimeout(timeoutId);
+    }
+
+    if (!response.ok) {
+        const error = new Error(`GitHub API request failed with status ${response.status}.`);
+        error.status = response.status;
+        throw error;
+    }
+
+    return response.json();
+}
+
+async function fetchGithubReadme(owner, repo) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), GITHUB_REQUEST_TIMEOUT_MS);
+    let response;
+    try {
+        response = await fetch(`https://api.github.com/repos/${owner}/${repo}/readme`, {
+            headers: getGithubHeaders({ 'Accept': 'application/vnd.github.raw+json' }),
+            signal: controller.signal
+        });
+    } finally {
+        clearTimeout(timeoutId);
+    }
+
+    if (!response.ok) {
+        return null;
+    }
+
+    return response.text();
+}
+
+async function renderGithubMarkdown(markdown, owner, repo) {
+    if (!markdown) {
+        return null;
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), GITHUB_REQUEST_TIMEOUT_MS);
+    let response;
+    try {
+        response = await fetch('https://api.github.com/markdown', {
+            method: 'POST',
+            headers: getGithubHeaders({
+                'Accept': 'text/html',
+                'Content-Type': 'application/json',
+            }),
+            signal: controller.signal,
+            body: JSON.stringify({
+                text: markdown,
+                mode: 'gfm',
+                context: `${owner}/${repo}`
+            })
+        });
+    } finally {
+        clearTimeout(timeoutId);
+    }
+
+    if (!response.ok) {
+        return null;
+    }
+
+    return response.text();
+}
 
 const conditionalRestartAuth = (req, res, next) => {
     if (process.env.DEBUG === 'true' || process.env.NODE_ENV === 'development') {
@@ -352,6 +507,17 @@ router.get('/:id/logs', conditionalListAuth, authenticateUniversal, checkBotAcce
     }
 });
 
+router.post('/:botId/plugins/install/local', authenticateUniversal, checkBotAccess, authorize('plugin:install'), async (req, res) => {
+    const { botId } = req.params;
+    const { path } = req.body;
+    try {
+        const newPlugin = await pluginManager.installFromLocalPath(parseInt(botId), path);
+        res.status(201).json(newPlugin);
+    } catch (error) {
+        res.status(500).json({ message: error.message });
+    }
+});
+
 router.use(authenticate);
 router.use('/:botId/event-graphs', eventGraphsRouter);
 router.use('/:botId/plugins/ide', pluginIdeRouter);
@@ -477,8 +643,21 @@ router.put('/:id', authenticateUniversal, checkBotAccess, authorize('bot:update'
             const proxyIdValue = dataToUpdate.proxyId;
             delete dataToUpdate.proxyId;
             if (proxyIdValue) {
+                // Используем прокси из списка - очищаем кастомные поля
                 dataToUpdate.proxy = { connect: { id: proxyIdValue } };
+                dataToUpdate.proxyHost = null;
+                dataToUpdate.proxyPort = null;
+                dataToUpdate.proxyUsername = null;
+                dataToUpdate.proxyPassword = null;
+            } else if (!dataToUpdate.proxyHost) {
+                // Отключаем прокси только если нет кастомного proxyHost
+                dataToUpdate.proxy = { disconnect: true };
+                dataToUpdate.proxyHost = null;
+                dataToUpdate.proxyPort = null;
+                dataToUpdate.proxyUsername = null;
+                dataToUpdate.proxyPassword = null;
             } else {
+                // Кастомный прокси: отключаем связь с proxy, но сохраняем кастомные поля
                 dataToUpdate.proxy = { disconnect: true };
             }
         }
@@ -609,25 +788,108 @@ router.get('/:botId/plugins', authenticateUniversal, checkBotAccess, authorize('
     } catch (error) { res.status(500).json({ error: 'Не удалось получить плагины бота' }); }
 });
 
-router.post('/:botId/plugins/install/github', authenticateUniversal, checkBotAccess, authorize('plugin:install'), async (req, res) => {
-    const { botId } = req.params;
+router.post('/:botId/plugins/install/github/preview', githubPreviewLimiter, authenticateUniversal, checkBotAccess, authorize('plugin:install'), async (req, res) => {
     const { repoUrl } = req.body;
+
     try {
-        const newPlugin = await pluginManager.installFromGithub(parseInt(botId), repoUrl);
-        res.status(201).json(newPlugin);
+        const { owner, repo, normalizedUrl } = parseGithubRepoUrl(repoUrl);
+        const repoInfo = await fetchGithubJson(`https://api.github.com/repos/${owner}/${repo}`);
+
+        let tags = [];
+        let latestRelease = null;
+        let readme = null;
+        let readmeHtml = null;
+
+        try {
+            const tagsData = await fetchGithubJson(`https://api.github.com/repos/${owner}/${repo}/tags?per_page=20`);
+            tags = Array.isArray(tagsData) ? tagsData.map(tag => ({
+                name: tag.name,
+                sha: tag.commit?.sha || null
+            })) : [];
+        } catch (error) {
+            console.warn(`[GitHub Preview] Failed to load tags for ${owner}/${repo}:`, error.message);
+        }
+
+        try {
+            latestRelease = await fetchGithubJson(`https://api.github.com/repos/${owner}/${repo}/releases/latest`);
+        } catch (error) {
+            console.warn(`[GitHub Preview] Failed to load latest release for ${owner}/${repo}:`, error.message);
+        }
+
+        try {
+            readme = await fetchGithubReadme(owner, repo);
+        } catch (error) {
+            console.warn(`[GitHub Preview] Failed to load README for ${owner}/${repo}:`, error.message);
+        }
+
+        try {
+            readmeHtml = await renderGithubMarkdown(readme, owner, repo);
+        } catch (error) {
+            console.warn(`[GitHub Preview] Failed to render README for ${owner}/${repo}:`, error.message);
+        }
+
+        res.json({
+            repo: {
+                name: repoInfo.name,
+                fullName: repoInfo.full_name,
+                description: repoInfo.description || '',
+                defaultBranch: repoInfo.default_branch,
+                stars: repoInfo.stargazers_count || 0,
+                htmlUrl: repoInfo.html_url || normalizedUrl,
+                visibility: repoInfo.private ? 'private' : 'public'
+            },
+            latestReleaseTag: latestRelease?.tag_name || null,
+            tags,
+            readme,
+            readmeHtml
+        });
     } catch (error) {
-        res.status(500).json({ message: error.message });
+        if (error.name === 'AbortError') {
+            return res.status(504).json({ message: 'GitHub request timed out. Please try again.' });
+        }
+        if (error.status === 404) {
+            return res.status(404).json({ message: 'GitHub repository not found or it is private.' });
+        }
+        if (error.status === 403) {
+            return res.status(503).json({ message: 'GitHub API rate limit exceeded. Try again a bit later.' });
+        }
+        const status = error.status || (/required|invalid|only github|must include|unsupported/i.test(error.message) ? 400 : 500);
+        res.status(status).json({ message: error.message });
     }
 });
 
-router.post('/:botId/plugins/install/local', authenticateUniversal, checkBotAccess, authorize('plugin:install'), async (req, res) => {
+router.post('/:botId/plugins/install/github', githubInstallLimiter, authenticateUniversal, checkBotAccess, authorize('plugin:install'), async (req, res) => {
     const { botId } = req.params;
-    const { path } = req.body;
+    const { repoUrl, tag } = req.body;
+    let normalizedRepoUrl = repoUrl;
+    const normalizedTag = typeof tag === 'string' && tag.trim() ? tag.trim() : null;
     try {
-        const newPlugin = await pluginManager.installFromLocalPath(parseInt(botId), path);
+        normalizedRepoUrl = normalizeGithubRepoUrl(repoUrl);
+        const newPlugin = await pluginManager.installFromGithub(parseInt(botId), normalizedRepoUrl, prisma, false, normalizedTag);
         res.status(201).json(newPlugin);
     } catch (error) {
-        res.status(500).json({ message: error.message });
+        let status = /required|invalid|only github|must include|unsupported/i.test(error.message) ? 400 : 500;
+        let message = error.message;
+
+        if (/status:\s*404|статус:\s*404/i.test(message)) {
+            status = 404;
+            message = normalizedTag
+                ? `GitHub tag "${normalizedTag}" was not found in ${normalizedRepoUrl}.`
+                : `GitHub repository was not found or is private: ${normalizedRepoUrl}.`;
+        } else if (/status:\s*403|статус:\s*403/i.test(message)) {
+            status = 503;
+            message = 'GitHub temporarily refused the request or rate limit was exceeded. Try again later.';
+        } else if (/package\.json/i.test(message)) {
+            status = 400;
+            message = 'The GitHub repository does not contain a valid plugin package.json.';
+        } else if (/fetch/i.test(message)) {
+            status = 502;
+            message = normalizedTag
+                ? `Failed to connect to GitHub while downloading tag "${normalizedTag}".`
+                : 'Failed to connect to GitHub while downloading the repository.';
+        }
+
+        res.status(status).json({ message });
     }
 });
 

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

@@ -178,7 +178,11 @@ router.put('/:graphId',
           dataToUpdate.graphJson = graphJson;
 
           const parsedGraph = JSON.parse(graphJson);
-          const eventNodes = parsedGraph.nodes.filter(node => node.type.startsWith('event:'));
+          const NON_TRIGGER_TYPES = ['custom_event', 'call_event'];
+          const eventNodes = parsedGraph.nodes.filter(node => 
+              node.type.startsWith('event:') && 
+              !NON_TRIGGER_TYPES.includes(node.type.split(':')[1])
+          );
           const eventTypes = [...new Set(eventNodes.map(node => node.type.split(':')[1]))];
           
           const existingGraph = await prisma.eventGraph.findUnique({
@@ -458,5 +462,151 @@ router.post('/:graphId/duplicate',
   }
 );
 
+router.post('/test-run/:graphId',
+  authorize('management:edit'),
+  async (req, res) => {
+    const { botId, graphId } = req.params;
+    const { eventType = 'chat', eventArgs = {} } = req.body || {};
+
+    try {
+      const eventGraph = await prisma.eventGraph.findFirst({
+        where: { id: parseInt(graphId), botId: parseInt(botId) }
+      });
+      if (!eventGraph) {
+        return res.status(404).json({ error: 'Event graph not found' });
+      }
+      if (!eventGraph.graphJson) {
+        return res.status(400).json({ error: 'Graph has no data' });
+      }
+
+      const parsed = JSON.parse(eventGraph.graphJson);
+      const graph = {
+        id: eventGraph.id,
+        name: eventGraph.name,
+        nodes: parsed.nodes || [],
+        connections: parsed.connections || [],
+        variables: parsed.variables || []
+      };
+
+      const nodeRegistry = require('../../core/NodeRegistry');
+      const GraphExecutionEngine = require('../../core/GraphExecutionEngine');
+      const { getGlobalDebugManager } = require('../../core/services/DebugSessionManager');
+      const { buildTestContext } = require('../../core/services/TestModeContext');
+
+      const debugManager = getGlobalDebugManager();
+      const debugState = debugManager.getOrCreate(parseInt(botId), parseInt(graphId));
+      debugState.enableTestMode({ botId: parseInt(botId), graphId: parseInt(graphId), eventType, eventArgs });
+
+      const engine = new GraphExecutionEngine(nodeRegistry, null);
+
+      const context = buildTestContext({
+        botId: parseInt(botId),
+        graphId: parseInt(graphId),
+        eventArgs
+      });
+
+      engine.execute(graph, context, eventType).catch(err => {
+        if (!err) return;
+        if (err.name === 'BreakLoopSignal') return;
+        if (err.message === 'Execution stopped by debugger') return;
+        logger.error('[Test Run] Execution error:', err.message);
+      });
+
+      res.json({ success: true, message: 'Test run started in step mode' });
+    } catch (error) {
+      logger.error('[Test Run] Failed:', error);
+      res.status(500).json({ error: error.message || 'Test run failed' });
+    }
+  }
+);
+
+router.post('/run-node/:graphId/:nodeId',
+  authorize('management:edit'),
+  async (req, res) => {
+    const { botId, graphId, nodeId } = req.params;
+    const { inputs = {}, variables = {} } = req.body || {};
+
+    try {
+      const eventGraph = await prisma.eventGraph.findFirst({
+        where: { id: parseInt(graphId), botId: parseInt(botId) }
+      });
+      if (!eventGraph) {
+        return res.status(404).json({ error: 'Event graph not found' });
+      }
+      const parsed = JSON.parse(eventGraph.graphJson || '{}');
+      const node = (parsed.nodes || []).find(n => n.id === nodeId);
+      if (!node) {
+        return res.status(404).json({ error: 'Node not found in graph' });
+      }
+
+      const nodeRegistry = require('../../core/NodeRegistry');
+      const nodeConfig = nodeRegistry.getNodeConfig(node.type);
+      if (!nodeConfig) {
+        return res.status(400).json({ error: `Unknown node type: ${node.type}` });
+      }
+
+      const GraphExecutionEngine = require('../../core/GraphExecutionEngine');
+      const { buildTestContext } = require('../../core/services/TestModeContext');
+      const engine = new GraphExecutionEngine(nodeRegistry, null);
+
+      engine.activeGraph = {
+        id: parseInt(graphId),
+        nodes: parsed.nodes || [],
+        connections: parsed.connections || [],
+        variables: parsed.variables || []
+      };
+      engine.context = {
+        ...buildTestContext({
+          botId: parseInt(botId),
+          graphId: parseInt(graphId),
+          eventArgs: inputs
+        }),
+        variables
+      };
+
+      for (const [pin, value] of Object.entries(inputs)) {
+        engine.memo.set(`__forced:${node.id}:${pin}`, value);
+      }
+      const originalResolve = engine.resolvePinValue.bind(engine);
+      engine.resolvePinValue = async function(targetNode, pinName) {
+        if (targetNode.id === node.id && engine.memo.has(`__forced:${node.id}:${pinName}`)) {
+          return engine.memo.get(`__forced:${node.id}:${pinName}`);
+        }
+        return originalResolve(targetNode, pinName);
+      };
+
+      const startedAt = Date.now();
+      const helpers = {
+        resolvePinValue: engine.resolvePinValue.bind(engine),
+        traverse: async () => {},
+        memo: engine.memo,
+        clearLoopBodyMemo: () => {}
+      };
+
+      let outputs = {};
+      let errorMsg = null;
+      try {
+        await nodeConfig.executor.call(engine, node, engine.context, helpers);
+        outputs = await engine._captureNodeOutputs(node);
+      } catch (e) {
+        errorMsg = e.message;
+      }
+
+      res.json({
+        success: !errorMsg,
+        nodeId: node.id,
+        nodeType: node.type,
+        executionTime: Date.now() - startedAt,
+        outputs,
+        error: errorMsg,
+        variables: engine.context.variables
+      });
+    } catch (error) {
+      logger.error('[Run Node] Failed:', error);
+      res.status(500).json({ error: error.message || 'Run node failed' });
+    }
+  }
+);
+
 module.exports = router;
 

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

@@ -0,0 +1,38 @@
+const express = require('express');
+const router = express.Router();
+
+router.get('/', async (req, res) => {
+    const startTime = Date.now();
+    const checks = {};
+    let overallHealthy = true;
+
+    try {
+        const prisma = require('../../lib/prisma');
+        await prisma.$queryRaw`SELECT 1`;
+        checks.database = { status: 'healthy' };
+    } catch (err) {
+        checks.database = { status: 'unhealthy', error: err.message };
+        overallHealthy = false;
+    }
+
+    try {
+        const botManager = req.app.get('botManager');
+        checks.botManager = { status: botManager ? 'healthy' : 'unhealthy' };
+        if (!botManager) overallHealthy = false;
+    } catch (err) {
+        checks.botManager = { status: 'unhealthy', error: err.message };
+        overallHealthy = false;
+    }
+
+    const duration = Date.now() - startTime;
+    const status = overallHealthy ? 200 : 503;
+
+    res.status(status).json({
+        status: overallHealthy ? 'healthy' : 'unhealthy',
+        checks,
+        duration,
+        timestamp: new Date().toISOString(),
+    });
+});
+
+module.exports = router;

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;