blockmine 1.25.0 → 1.27.1

package/CHANGELOG.md

@@ -1,6 +1,51 @@
-# История версий
+# История версий
+
+
+### [1.27.1](https://github.com/blockmineJS/blockmine/compare/v1.27.0...v1.27.1) (2026-05-15)
+
+## [1.27.0](https://github.com/blockmineJS/blockmine/compare/v1.25.0...v1.27.0) (2026-05-12)
 
 
+### 🛠 Рефакторинг
+
+* внутренний большой рефактор бэкенда ([eb27f26](https://github.com/blockmineJS/blockmine/commit/eb27f2600218f05a8b8707adfed3a5a2298531f6))
+* полноценный внутренний рефактор нод ([28387a9](https://github.com/blockmineJS/blockmine/commit/28387a917bf89e33e9715cbd03483accc136b9af))
+
+
+### 🐛 Исправления
+
+* нода "сообщение в чате" работает в локал мире ([17bbde8](https://github.com/blockmineJS/blockmine/commit/17bbde82115cecee646a10bc26f21ec23856e33e))
+* пост инсталл скрипт теперь есть... ([c5248cb](https://github.com/blockmineJS/blockmine/commit/c5248cbb805057b52efaea67209bea325b2e0b31))
+* причина кика теперь корректно пишется ([08de739](https://github.com/blockmineJS/blockmine/commit/08de739fc03ce35ae136b3bd5cb5b822145139cf))
+* роут install local теперь может работать и через апи ключ ([03f1176](https://github.com/blockmineJS/blockmine/commit/03f117690cda3d2966a928be217ad78154d4ec87))
+* address PR79 review feedback by САХАРОК ([5dceb17](https://github.com/blockmineJS/blockmine/commit/5dceb174ef3009f47cb5a94f48f5e90c4c790feb))
+* address remaining PR79 review feedback by САХАРОК ([dde6905](https://github.com/blockmineJS/blockmine/commit/dde690593320344f181f9a13fc4dc4905872e2cf))
+* close active connection on API key deletion by САХАРОК ([2f7db12](https://github.com/blockmineJS/blockmine/commit/2f7db123b0b46c3aedf806d7d543316d7aace1f5))
+* close remaining plugin workflow review issues by САХАРОК ([9f2dd7f](https://github.com/blockmineJS/blockmine/commit/9f2dd7fa422b5b276df4da96f7b9302d489b5e9f))
+* polish language selector modal by САХАРОК ([2cebe65](https://github.com/blockmineJS/blockmine/commit/2cebe6554b21191e7f6ce8a532e243832f2a2ded))
+* polish plugin list alignment and text clarity by САХАРОК ([8c27d60](https://github.com/blockmineJS/blockmine/commit/8c27d6062625e5a55e76a193ed1d3500a88f8246))
+* remove remaining emoji from english visual editor by САХАРОК ([5a4f356](https://github.com/blockmineJS/blockmine/commit/5a4f3563fad29a4054bc98b31b5bc79c0d0b8572))
+
+
+### ✨ Новые возможности
+
+* большая переработка интерфейса и прочее ([d28e0fa](https://github.com/blockmineJS/blockmine/commit/d28e0fa4af1815476ad90ddd0fb5799db95707ea))
+* в лайв дебаге появилась функция которая дает опробовать ноды без запуска бота ([bbd669f](https://github.com/blockmineJS/blockmine/commit/bbd669f463d62bffacb65b8d6066d5345a0e237f))
+* новая нода - имя бота ([574eada](https://github.com/blockmineJS/blockmine/commit/574eada6af5e89b2b67159b82ca435a2f8446004))
+* новая нода - прочитать/записать в стор ([eeb588e](https://github.com/blockmineJS/blockmine/commit/eeb588e1305d8bfb68cf7e388abf8b092a7865c2))
+* новая нода - стоп бот ([0639ed4](https://github.com/blockmineJS/blockmine/commit/0639ed439d0263fda229f261f317d54df3876d8c))
+* новая нода - таймер ([1d7899d](https://github.com/blockmineJS/blockmine/commit/1d7899d243232ae3062a84d6bc46f0f05897b40d))
+* новая нода - шаффл. перемешать массив ([67e785a](https://github.com/blockmineJS/blockmine/commit/67e785aa7706eb19a489042fcf2aec20643a0b79))
+* новые ноды - события ([ae4db8e](https://github.com/blockmineJS/blockmine/commit/ae4db8e8a11dcdf9c72536a850d65032fa528661))
+* новые ноды. проверить право у юзера, добавить/убрать из группы ([3249483](https://github.com/blockmineJS/blockmine/commit/32494831636432013aa72978daa41bc4668a51af))
+* обновлен сайдбар ([8d77a48](https://github.com/blockmineJS/blockmine/commit/8d77a4834bc60c76de6010a794b4b79926d3fed1))
+* обновление mineflayer. 4.33 -> 4.37.1 . Поддерживает новые версии майнкрафта ([b7f2317](https://github.com/blockmineJS/blockmine/commit/b7f23175ba983fda2a2108d31e54d291d9d17212))
+* improve plugin workflows and panel UX by САХАРОК ([09f111a](https://github.com/blockmineJS/blockmine/commit/09f111a9c47e7fd639b345be3d95de4c203213a9))
+* polish management, viewer, and toast ux by САХАРОК ([d52e9b3](https://github.com/blockmineJS/blockmine/commit/d52e9b3d5eb56bc45c0417e10f397ad87441809e))
+* polish panel ux, theming, and transitions by САХАРОК ([1f347b4](https://github.com/blockmineJS/blockmine/commit/1f347b442cef70f579cdc74c207554f95e68d15a))
+* polish plugin UX and localize panel states by САХАРОК ([ef32fc0](https://github.com/blockmineJS/blockmine/commit/ef32fc08494c41e7a15312a2d0ed251255f3bd2b))
+* refine visual editor and panel polish by САХАРОК ([0118ec6](https://github.com/blockmineJS/blockmine/commit/0118ec6de81078845551b443e5129b41e6e064f9))
+
 ## [1.25.0](https://github.com/blockmineJS/blockmine/compare/v1.24.0...v1.25.0) (2025-12-22)
 
 

package/backend/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 const fs = require('fs');
 const os = require('os');
 const path = require('path');

package/backend/package.json

@@ -27,7 +27,7 @@
     "ts-jest": "^29.4.5"
   },
   "dependencies": {
-    "@octokit/rest": "^22.0.1",
+    "@octokit/rest": "^20.1.1",
     "awilix": "^12.0.5",
     "date-fns": "^4.1.0",
     "diff": "^8.0.2",
@@ -35,7 +35,7 @@
     "express-validator": "^7.2.1",
     "google-ai-kit": "^1.1.3",
     "lru-cache": "^10.4.3",
-    "mineflayer": "^4.33.0",
+    "mineflayer": "^4.37.1",
     "mineflayer-pathfinder": "^2.4.5",
     "openrouter-kit": "^0.1.81",
     "pino": "^9.7.0",

package/backend/prisma/migrations/20260328173000_add_plugin_source_ref/migration.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "InstalledPlugin" ADD COLUMN "sourceRefType" TEXT;
+ALTER TABLE "InstalledPlugin" ADD COLUMN "sourceRef" TEXT;

package/backend/prisma/migrations/migration_lock.toml

@@ -1,3 +1,3 @@
-# Please do not edit this file manually
-# It should be added in your version-control system (i.e. Git)
+# Please do not edit this file manually
+# It should be added in your version-control system (i.e. Git)
 provider = "sqlite"

package/backend/prisma/schema.prisma

@@ -79,6 +79,8 @@ model InstalledPlugin {
   description String?
   sourceType  String
   sourceUri   String?
+  sourceRefType String?
+  sourceRef   String?
   path        String
   isEnabled   Boolean @default(true)
 

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);
@@ -622,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;