blockmine 1.24.0 → 1.27.0

package/backend/src/core/node-registries/usersNodes.js

@@ -0,0 +1,126 @@
+const { GRAPH_TYPES } = require('../../core/constants/graphTypes');
+
+const usersNodes = [
+  {
+    type: 'user:check_blacklist',
+    label: '❓ В черном списке?',
+    category: 'Пользователи',
+    description: 'Проверяет, находится ли пользователь в черном списке.',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../../core/nodes/users/check_blacklist').evaluate,
+    computeInputs: (data) => [
+      { id: 'user', name: 'Пользователь', type: 'User', required: true }
+    ],
+    computeOutputs: () => [
+      { id: 'is_blacklisted', name: 'В ЧС', type: 'Boolean' }
+    ],
+    defaultData: {},
+    theme: { headerColor: '#7c3aed', accentColor: '#8b5cf6' }
+  },
+  {
+    type: 'user:set_blacklist',
+    label: '🚫 Установить ЧС',
+    category: 'Пользователи',
+    description: 'Добавляет или убирает пользователя из черного списка.',
+    graphType: GRAPH_TYPES.ALL,
+    executor: require('../../core/nodes/users/set_blacklist').execute,
+    computeInputs: (data) => [
+      { id: 'exec', name: 'Выполнить', type: 'Exec', required: true },
+      { id: 'user', name: 'Пользователь', type: 'User', required: true },
+      { id: 'blacklist_status', name: 'Статус ЧС', type: 'Boolean', required: true, inlineField: true }
+    ],
+    computeOutputs: () => [
+      { id: 'exec', name: 'Далее', type: 'Exec' },
+      { id: 'updated_user', name: 'Обновленный пользователь', type: 'User' }
+    ],
+    defaultData: { blacklist_status: false },
+    theme: { headerColor: '#7c3aed', accentColor: '#8b5cf6' }
+  },
+  {
+    type: 'user:get_groups',
+    label: '👥 Получить группы',
+    category: 'Пользователи',
+    description: 'Возвращает массив названий групп, в которых состоит пользователь.',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../../core/nodes/users/get_groups').evaluate,
+    computeInputs: (data) => [
+      { id: 'user', name: 'Пользователь', type: 'User', required: true }
+    ],
+    computeOutputs: () => [
+      { id: 'groups', name: 'Группы', type: 'Array' }
+    ],
+    defaultData: {},
+    theme: { headerColor: '#7c3aed', accentColor: '#8b5cf6' }
+  },
+  {
+    type: 'user:get_permissions',
+    label: '🔑 Получить права',
+    category: 'Пользователи',
+    description: 'Возвращает массив прав пользователя.',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../../core/nodes/users/get_permissions').evaluate,
+    computeInputs: (data) => [
+      { id: 'user', name: 'Пользователь', type: 'User', required: true }
+    ],
+    computeOutputs: () => [
+      { id: 'permissions', name: 'Права', type: 'Array' }
+    ],
+    defaultData: {},
+    theme: { headerColor: '#7c3aed', accentColor: '#8b5cf6' }
+  },
+  {
+    type: 'user:check_permission',
+    label: '🔐 Проверить право',
+    category: 'Пользователи',
+    description: 'Проверяет, есть ли у пользователя указанное право.',
+    graphType: GRAPH_TYPES.ALL,
+    evaluator: require('../../core/nodes/users/check_permission').evaluate,
+    computeInputs: (data) => [
+      { id: 'user', name: 'Пользователь', type: 'User', required: true },
+      { id: 'permission', name: 'Право', type: 'String', required: true, inlineField: true, placeholder: 'admin.*' }
+    ],
+    computeOutputs: () => [
+      { id: 'has_permission', name: 'Есть право', type: 'Boolean' }
+    ],
+    defaultData: { permission: '' },
+    theme: { headerColor: '#7c3aed', accentColor: '#8b5cf6' }
+  },
+  {
+    type: 'user:add_to_group',
+    label: '➕ Добавить в группу',
+    category: 'Пользователи',
+    description: 'Добавляет пользователя в указанную группу.',
+    graphType: GRAPH_TYPES.ALL,
+    executor: require('../../core/nodes/users/add_to_group').execute,
+    computeInputs: (data) => [
+      { id: 'exec', name: 'Выполнить', type: 'Exec', required: true },
+      { id: 'user', name: 'Пользователь', type: 'User', required: true },
+      { id: 'group', name: 'Группа', type: 'String', required: true, inlineField: true, placeholder: 'Admin' }
+    ],
+    computeOutputs: () => [
+      { id: 'exec', name: 'Далее', type: 'Exec' }
+    ],
+    defaultData: { group: '' },
+    theme: { headerColor: '#7c3aed', accentColor: '#8b5cf6' }
+  },
+  {
+    type: 'user:remove_from_group',
+    label: '➖ Убрать из группы',
+    category: 'Пользователи',
+    description: 'Убирает пользователя из указанной группы.',
+    graphType: GRAPH_TYPES.ALL,
+    executor: require('../../core/nodes/users/remove_from_group').execute,
+    computeInputs: (data) => [
+      { id: 'exec', name: 'Выполнить', type: 'Exec', required: true },
+      { id: 'user', name: 'Пользователь', type: 'User', required: true },
+      { id: 'group', name: 'Группа', type: 'String', required: true, inlineField: true, placeholder: 'Admin' }
+    ],
+    computeOutputs: () => [
+      { id: 'exec', name: 'Далее', type: 'Exec' }
+    ],
+    defaultData: { group: '' },
+    theme: { headerColor: '#7c3aed', accentColor: '#8b5cf6' }
+  }
+];
+
+module.exports = usersNodes;

package/backend/src/core/nodes/arrays/shuffle.js

@@ -0,0 +1,14 @@
+async function evaluate(node, pinId, context, helpers) {
+    if (pinId !== 'shuffled') return null;
+    const { resolvePinValue } = helpers;
+    const array = await resolvePinValue(node, 'array', []);
+    if (!Array.isArray(array)) return [];
+    const result = [...array];
+    for (let i = result.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/bot/get_name.js

@@ -0,0 +1,8 @@
+async function evaluate(node, pinId, context, helpers) {
+    if (pinId === 'name') {
+        return context.bot?.username || null;
+    }
+    return null;
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/bot/stop_bot.js

@@ -0,0 +1,5 @@
+async function execute(node, context, helpers) {
+    process.send({ type: 'stop' });
+}
+
+module.exports = { execute };

package/backend/src/core/nodes/container/open.js

@@ -1,111 +1,101 @@
-const Vec3 = require('vec3');
-
-/**
- * container:open - Открыть контейнер по координатам
- *
- * Executor для action ноды с exec пинами.
- * Использует helpers.traverse для перехода к следующему exec выходу.
- */
-async function execute(node, context, helpers) {
-  const { resolvePinValue, traverse, memo } = helpers;
-  const bot = context.bot;
-
-  if (!bot) {
-    memo.set(`${node.id}:success`, false);
-    memo.set(`${node.id}:container`, null);
-    await traverse(node, 'exec_failed');
-    return;
-  }
-
-  const x = await resolvePinValue(node, 'x', node.data?.x);
-  const y = await resolvePinValue(node, 'y', node.data?.y);
-  const z = await resolvePinValue(node, 'z', node.data?.z);
-
-  const targetX = Number(x ?? 0);
-  const targetY = Number(y ?? 64);
-  const targetZ = Number(z ?? 0);
-
-  try {
-    const block = bot.blockAt(new Vec3(targetX, targetY, targetZ));
-
-    if (!block) {
-      memo.set(`${node.id}:success`, false);
-      memo.set(`${node.id}:container`, null);
-      await traverse(node, 'exec_failed');
-      return;
-    }
-
-    const containerTypes = [
-      'chest', 'trapped_chest', 'barrel', 'shulker_box',
-      'hopper', 'dropper', 'dispenser', 'furnace',
-      'blast_furnace', 'smoker', 'brewing_stand'
-    ];
-    const isContainer = containerTypes.some(type => block.name.includes(type));
-
-    if (!isContainer) {
-      memo.set(`${node.id}:success`, false);
-      memo.set(`${node.id}:container`, null);
-      await traverse(node, 'exec_failed');
-      return;
-    }
-
-    const distance = bot.entity.position.distanceTo(block.position);
-
-    if (distance > 4) {
-      if (bot.pathfinder) {
-        const { goals } = require('mineflayer-pathfinder');
-        const goal = new goals.GoalNear(block.position.x, block.position.y, block.position.z, 2);
-        await bot.pathfinder.goto(goal);
-      } else {
-        memo.set(`${node.id}:success`, false);
-        memo.set(`${node.id}:container`, null);
-        await traverse(node, 'exec_failed');
-        return;
-      }
-    }
-
-    if (bot.currentWindow) {
-      bot.closeWindow(bot.currentWindow);
-      await new Promise(r => setTimeout(r, 300));
-    }
-
-    const blockCenter = block.position.offset(0.5, 0.5, 0.5);
-    await bot.lookAt(blockCenter);
-    await new Promise(r => setTimeout(r, 100));
-
-    const container = await bot.openContainer(block);
-
-    if (!container) {
-      throw new Error('Container is null');
-    }
-
-    context.openContainer = container;
-
-    memo.set(`${node.id}:success`, true);
-    memo.set(`${node.id}:container`, container);
-
-    await traverse(node, 'exec');
-  } catch (error) {
-    memo.set(`${node.id}:success`, false);
-    memo.set(`${node.id}:container`, null);
-    await traverse(node, 'exec_failed');
-  }
-}
-
-/**
- * Evaluator для data пинов (success, container)
- */
-async function evaluate(node, pinId, context, helpers) {
-  const { memo } = helpers;
-
-  if (pinId === 'success') {
-    return memo.get(`${node.id}:success`) ?? false;
-  }
-  if (pinId === 'container') {
-    return memo.get(`${node.id}:container`) ?? context.openContainer ?? null;
-  }
-
-  return null;
-}
-
-module.exports = { execute, evaluate };
+const Vec3 = require('vec3');
+
+async function execute(node, context, helpers) {
+  const { resolvePinValue, traverse, memo } = helpers;
+  const bot = context.bot;
+
+  if (!bot) {
+    memo.set(`${node.id}:success`, false);
+    await traverse(node, 'exec');
+    return;
+  }
+
+  const x = await resolvePinValue(node, 'x', node.data?.x);
+  const y = await resolvePinValue(node, 'y', node.data?.y);
+  const z = await resolvePinValue(node, 'z', node.data?.z);
+
+  const targetX = Number(x ?? 0);
+  const targetY = Number(y ?? 64);
+  const targetZ = Number(z ?? 0);
+
+  try {
+    const block = bot.blockAt(new Vec3(targetX, targetY, targetZ));
+
+    if (!block) {
+      memo.set(`${node.id}:success`, false);
+      memo.set(`${node.id}:container`, null);
+      await traverse(node, 'exec_failed');
+      return;
+    }
+
+    const containerTypes = [
+      'chest', 'trapped_chest', 'barrel', 'shulker_box',
+      'hopper', 'dropper', 'dispenser', 'furnace',
+      'blast_furnace', 'smoker', 'brewing_stand'
+    ];
+    const isContainer = containerTypes.some(type => block.name.includes(type));
+
+    if (!isContainer) {
+      memo.set(`${node.id}:success`, false);
+      memo.set(`${node.id}:container`, null);
+      await traverse(node, 'exec_failed');
+      return;
+    }
+
+    const distance = bot.entity.position.distanceTo(block.position);
+
+    if (distance > 4) {
+      if (bot.pathfinder) {
+        const { goals } = require('mineflayer-pathfinder');
+        const goal = new goals.GoalNear(block.position.x, block.position.y, block.position.z, 2);
+        await bot.pathfinder.goto(goal);
+      } else {
+        memo.set(`${node.id}:success`, false);
+        memo.set(`${node.id}:container`, null);
+        await traverse(node, 'exec_failed');
+        return;
+      }
+    }
+
+    if (bot.currentWindow) {
+      bot.closeWindow(bot.currentWindow);
+      await new Promise(r => setTimeout(r, 300));
+    }
+
+    const blockCenter = block.position.offset(0.5, 0.5, 0.5);
+    await bot.lookAt(blockCenter);
+    await new Promise(r => setTimeout(r, 100));
+
+    const container = await bot.openContainer(block);
+
+    if (!container) {
+      throw new Error('Container is null');
+    }
+
+    context.openContainer = container;
+
+    memo.set(`${node.id}:success`, true);
+    memo.set(`${node.id}:container`, container);
+
+    await traverse(node, 'exec');
+  } catch (error) {
+    memo.set(`${node.id}:success`, false);
+    memo.set(`${node.id}:container`, null);
+    await traverse(node, 'exec_failed');
+  }
+}
+
+async function evaluate(node, pinId, context, helpers) {
+  const { memo } = helpers;
+
+  if (pinId === 'success') {
+    return memo.get(`${node.id}:success`) ?? false;
+  }
+  if (pinId === 'container') {
+    return memo.get(`${node.id}:container`) ?? context.openContainer ?? null;
+  }
+
+  return null;
+}
+
+module.exports = { execute, evaluate };

package/backend/src/core/nodes/data/store_read.js

@@ -0,0 +1,26 @@
+const prismaService = require('../../PrismaService');
+const prisma = prismaService.getClient();
+
+async function evaluate(node, pinId, context, helpers) {
+    if (pinId !== 'value') return null;
+    const { resolvePinValue } = helpers;
+
+    const pluginName = await resolvePinValue(node, 'plugin_name', node.data?.plugin_name || '');
+    const key = await resolvePinValue(node, 'key', node.data?.key || '');
+
+    if (!pluginName || !key) return null;
+
+    const row = await prisma.pluginDataStore.findUnique({
+        where: { pluginName_botId_key: { pluginName, botId: context.botId, key } }
+    });
+
+    if (!row) return null;
+
+    try {
+        return JSON.parse(row.value);
+    } catch {
+        return row.value;
+    }
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/data/store_write.js

@@ -0,0 +1,23 @@
+const prismaService = require('../../PrismaService');
+const prisma = prismaService.getClient();
+
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse } = helpers;
+
+    const pluginName = await resolvePinValue(node, 'plugin_name', node.data?.plugin_name || '');
+    const key = await resolvePinValue(node, 'key', node.data?.key || '');
+    const value = await resolvePinValue(node, 'value', null);
+
+    if (pluginName && key) {
+        const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
+        await prisma.pluginDataStore.upsert({
+            where: { pluginName_botId_key: { pluginName, botId: context.botId, key } },
+            update: { value: stringValue },
+            create: { pluginName, botId: context.botId, key, value: stringValue }
+        });
+    }
+
+    await traverse(node, 'exec');
+}
+
+module.exports = { execute };

package/backend/src/core/nodes/event/call_event.js

@@ -0,0 +1,31 @@
+async function executor(node, context, helpers) {
+    const { resolvePinValue, traverse, memo } = helpers;
+
+    const selectedEventId = node.data?.selectedEventId;
+    if (!selectedEventId) {
+        await traverse(node, 'exec');
+        return;
+    }
+
+    const targetNode = this.activeGraph.nodes.find(n => n.id === selectedEventId);
+    if (!targetNode || targetNode.type !== 'event:custom_event') {
+        await traverse(node, 'exec');
+        return;
+    }
+
+    const eventPins = targetNode.data?.pins || [];
+    for (const pin of eventPins) {
+        if (pin.type === 'Exec') continue;
+        const value = await resolvePinValue(node, pin.id);
+        memo.set(`${targetNode.id}:${pin.id}`, value);
+    }
+
+    const cacheKey = `${targetNode.id}_executed`;
+    memo.delete(cacheKey);
+
+    await traverse(targetNode, 'exec');
+
+    await traverse(node, 'exec');
+}
+
+module.exports = { executor };

package/backend/src/core/nodes/event/custom_event.js

@@ -0,0 +1,8 @@
+async function evaluate(node, pinId, context, helpers) {
+    const { memo } = helpers;
+    const cached = memo.get(`${node.id}:${pinId}`);
+    if (cached !== undefined) return cached;
+    return null;
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/flow/timer.js

@@ -0,0 +1,35 @@
+const BreakLoopSignal = require('../../BreakLoopSignal');
+
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse, clearLoopBodyMemo, memo } = helpers;
+
+    const intervalSec = await resolvePinValue(node, 'interval', 1);
+    const maxTicks = await resolvePinValue(node, 'max_ticks', 0);
+    const intervalMs = Math.max(100, (intervalSec || 1) * 1000);
+
+    let tick = 0;
+
+    const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+    try {
+        while (maxTicks === 0 || tick < maxTicks) {
+            memo.set(`${node.id}:tick`, tick);
+            clearLoopBodyMemo(node);
+            await traverse(node, 'loop_body');
+            tick++;
+            await delay(intervalMs);
+        }
+    } catch (e) {
+        if (!(e instanceof BreakLoopSignal)) throw e;
+    }
+
+    await traverse(node, 'completed');
+}
+
+async function evaluate(node, pinId, context, helpers) {
+    const { memo } = helpers;
+    if (pinId === 'tick') return memo.get(`${node.id}:tick`) ?? 0;
+    return null;
+}
+
+module.exports = { execute, evaluate };

package/backend/src/core/nodes/inventory/drop.js

@@ -1,65 +1,73 @@
-/**
- * inventory:drop - Выбросить предмет из инвентаря
- */
-async function evaluate(node, pinId, context, helpers) {
-  const bot = context.bot;
-  const itemName = await helpers.resolvePinValue(node, 'itemName');
-  const count = await helpers.resolvePinValue(node, 'count');
-  const dropAll = await helpers.resolvePinValue(node, 'dropAll');
-
-  if (pinId === 'exec') {
-    return true; // Exec output
-  }
-
-  if (!bot?.inventory || !itemName) {
-    if (pinId === 'dropped') return 0;
-    return null;
-  }
-
-  try {
-    // Ищем предмет(ы) в инвентаре
-    const searchName = itemName.toLowerCase().replace('minecraft:', '');
-    const items = bot.inventory.items().filter(i =>
-      i.name.toLowerCase().includes(searchName) ||
-      i.displayName?.toLowerCase().includes(searchName)
-    );
-
-    if (items.length === 0) {
-      if (pinId === 'dropped') return 0;
-      return null;
-    }
-
-    let totalDropped = 0;
-
-    if (dropAll) {
-      // Выбрасываем все такие предметы
-      for (const item of items) {
-        await bot.tossStack(item);
-        totalDropped += item.count;
-      }
-    } else {
-      // Выбрасываем указанное количество или один стак
-      const item = items[0];
-      const toDrop = count || item.count;
-
-      if (toDrop >= item.count) {
-        await bot.tossStack(item);
-        totalDropped = item.count;
-      } else {
-        await bot.toss(item.type, item.metadata, toDrop);
-        totalDropped = toDrop;
-      }
-    }
-
-    if (pinId === 'dropped') {
-      return totalDropped;
-    }
-  } catch (error) {
-    console.error('[inventory:drop] Error:', error.message);
-    if (pinId === 'dropped') return 0;
-  }
-
-  return null;
-}
-
-module.exports = { evaluate };
+async function execute(node, context, helpers) {
+  const { resolvePinValue, traverse, memo } = helpers;
+  const bot = context.bot;
+
+  if (!bot?.inventory) {
+    memo.set(`${node.id}:dropped`, 0);
+    await traverse(node, 'exec');
+    return;
+  }
+
+  const itemName = await resolvePinValue(node, 'itemName', node.data?.itemName);
+  const count = await resolvePinValue(node, 'count', node.data?.count);
+  const dropAll = await resolvePinValue(node, 'dropAll', node.data?.dropAll);
+
+  if (!itemName) {
+    memo.set(`${node.id}:dropped`, 0);
+    await traverse(node, 'exec');
+    return;
+  }
+
+  try {
+    const searchName = itemName.toLowerCase().replace('minecraft:', '');
+    const items = bot.inventory.items().filter(i =>
+      i.name.toLowerCase().includes(searchName) ||
+      i.displayName?.toLowerCase().includes(searchName)
+    );
+
+    if (items.length === 0) {
+      memo.set(`${node.id}:dropped`, 0);
+      await traverse(node, 'exec');
+      return;
+    }
+
+    let totalDropped = 0;
+
+    if (dropAll) {
+      for (const item of items) {
+        await bot.tossStack(item);
+        totalDropped += item.count;
+      }
+    } else {
+      const item = items[0];
+      const toDrop = count || item.count;
+
+      if (toDrop >= item.count) {
+        await bot.tossStack(item);
+        totalDropped = item.count;
+      } else {
+        await bot.toss(item.type, item.metadata, toDrop);
+        totalDropped = toDrop;
+      }
+    }
+
+    memo.set(`${node.id}:dropped`, totalDropped);
+    await traverse(node, 'exec');
+  } catch (error) {
+    console.error('[inventory:drop] Error:', error.message);
+    memo.set(`${node.id}:dropped`, 0);
+    await traverse(node, 'exec');
+  }
+}
+
+async function evaluate(node, pinId, context, helpers) {
+  const { memo } = helpers;
+
+  if (pinId === 'dropped') {
+    return memo.get(`${node.id}:dropped`) ?? 0;
+  }
+
+  return null;
+}
+
+module.exports = { execute, evaluate };