plugin-cluster-manager 1.1.16 → 1.1.17

package/dist/server/utils/redis.js

@@ -27,21 +27,54 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var redis_exports = {};
 __export(redis_exports, {
   deleteKeysChunked: () => deleteKeysChunked,
+  getClusterRedisUrl: () => getClusterRedisUrl,
   getRedis: () => getRedis,
   getRedisClient: () => getRedisClient,
   getRedisOrThrow: () => getRedisOrThrow,
+  isClusterRedisConfigured: () => isClusterRedisConfigured,
   scanKeys: () => scanKeys
 });
 module.exports = __toCommonJS(redis_exports);
 var import_redis = require("redis");
 let globalRedisClient = null;
+const CLUSTER_REDIS_CONNECTION = "cluster-manager:registry";
+const CLUSTER_REDIS_ENV_CANDIDATES = [
+  "NODE_REGISTRY_REDIS_URL",
+  "CLUSTER_MANAGER_REDIS_URL",
+  "REDIS_URL",
+  "CACHE_REDIS_URL",
+  "PUBSUB_ADAPTER_REDIS_URL",
+  "QUEUE_ADAPTER_REDIS_URL",
+  "LOCK_ADAPTER_REDIS_URL"
+];
+function getClusterRedisUrl() {
+  for (const key of CLUSTER_REDIS_ENV_CANDIDATES) {
+    const value = process.env[key];
+    if (value == null ? void 0 : value.trim()) {
+      return value.trim();
+    }
+  }
+  return "";
+}
+function isClusterRedisConfigured(app) {
+  var _a;
+  if (getClusterRedisUrl()) {
+    return true;
+  }
+  const manager = app == null ? void 0 : app.redisConnectionManager;
+  return Boolean((_a = manager == null ? void 0 : manager.getConnection) == null ? void 0 : _a.call(manager));
+}
 function getRedisClient(app) {
   if (globalRedisClient) return globalRedisClient;
+  const url = getClusterRedisUrl();
   if (app == null ? void 0 : app.redisConnectionManager) {
+    if (url) {
+      const conn2 = app.redisConnectionManager.getConnection(CLUSTER_REDIS_CONNECTION, { connectionString: url });
+      if (conn2) return conn2;
+    }
     const conn = app.redisConnectionManager.getConnection();
     if (conn) return conn;
   }
-  const url = process.env.REDIS_URL || process.env.CACHE_REDIS_URL || process.env.PUBSUB_ADAPTER_REDIS_URL;
   if (!url) return null;
   globalRedisClient = (0, import_redis.createClient)({ url });
   globalRedisClient.connect().catch((err) => {
@@ -64,14 +97,7 @@ async function scanKeys(redis, pattern, batchSize = 200) {
   const keys = [];
   let cursor = "0";
   do {
-    const result = await redis.sendCommand([
-      "SCAN",
-      cursor,
-      "MATCH",
-      pattern,
-      "COUNT",
-      String(batchSize)
-    ]);
+    const result = await redis.sendCommand(["SCAN", cursor, "MATCH", pattern, "COUNT", String(batchSize)]);
     cursor = String(result[0]);
     if (Array.isArray(result[1])) {
       keys.push(...result[1]);
@@ -96,8 +122,10 @@ async function deleteKeysChunked(redis, keys, chunkSize = 500) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   deleteKeysChunked,
+  getClusterRedisUrl,
   getRedis,
   getRedisClient,
   getRedisOrThrow,
+  isClusterRedisConfigured,
   scanKeys
 });

package/dist/shared/worker-processes.js

@@ -0,0 +1,233 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var worker_processes_exports = {};
+__export(worker_processes_exports, {
+  WORKER_PROCESS_DEFINITIONS: () => WORKER_PROCESS_DEFINITIONS,
+  getCommonWorkerProcesses: () => getCommonWorkerProcesses,
+  getWorkerProcessByChannel: () => getWorkerProcessByChannel,
+  getWorkerProcessDefinition: () => getWorkerProcessDefinition,
+  isAppServingMode: () => isAppServingMode,
+  isWorkerOnlyMode: () => isWorkerOnlyMode,
+  normalizeWorkerMode: () => normalizeWorkerMode,
+  resolveWorkerProcessName: () => resolveWorkerProcessName,
+  workerModeServesProcess: () => workerModeServesProcess,
+  workerModeTokens: () => workerModeTokens
+});
+module.exports = __toCommonJS(worker_processes_exports);
+const WORKER_PROCESS_DEFINITIONS = [
+  {
+    name: "workflow:process",
+    label: "Workflow",
+    description: "Process workflow executions",
+    kind: "event-queue",
+    aliases: ["workflow.pendingExecution", "@nocobase/plugin-workflow.pendingExecution"],
+    common: true
+  },
+  {
+    name: "async-task:process",
+    label: "Async Tasks",
+    description: "Execute async tasks",
+    kind: "event-queue",
+    aliases: ["async-task-manager.task", "@nocobase/plugin-async-task-manager.task"],
+    common: true
+  },
+  {
+    name: "notification:send",
+    label: "Notifications",
+    description: "Send notification messages",
+    kind: "event-queue",
+    aliases: ["notification-manager.send", "@nocobase/plugin-notification-manager.send"],
+    common: true
+  },
+  {
+    name: "knowledge-base:document-vectorize",
+    label: "Document Vectorization",
+    description: "Vectorize knowledge base documents",
+    kind: "event-queue",
+    aliases: ["knowledge-base:document-vectorize"],
+    pluginName: "plugin-knowledge-base",
+    common: true
+  },
+  {
+    name: "git-review:process",
+    label: "Git Review",
+    description: "AI code review jobs",
+    kind: "redis-list",
+    aliases: ["plugin-git-manager.review"],
+    redisKeySuffixes: [":plugin-git-manager:review:queue"],
+    pluginName: "plugin-git-manager",
+    common: true
+  },
+  {
+    name: "build-guide:process",
+    label: "Build Guide",
+    description: "Build user guide pages",
+    kind: "redis-list",
+    aliases: ["plugin-build-guide-block.build"],
+    redisKeySuffixes: [":plugin-build-guide-block:build:queue"],
+    pluginName: "plugin-build-guide-block",
+    common: true
+  },
+  {
+    name: "build-visualization:process",
+    label: "Build Visualization",
+    description: "Build visualization blocks",
+    kind: "redis-list",
+    aliases: ["plugin-build-visualization-block.build"],
+    redisKeySuffixes: [":plugin-build-visualization-block:build:queue"],
+    pluginName: "plugin-build-visualization-block",
+    common: true
+  },
+  {
+    name: "build-ui-template:process",
+    label: "Build UI Template",
+    description: "Build UI template pages",
+    kind: "event-queue",
+    aliases: ["plugin-build-ui-template.build"],
+    pluginName: "plugin-build-ui-template",
+    common: true
+  },
+  {
+    name: "file-preview-auth:ocr",
+    label: "File Preview OCR",
+    description: "Run OCR extraction for authenticated file previews",
+    kind: "redis-list",
+    aliases: ["file-preview-auth.ocr.queue"],
+    redisKeySuffixes: ["file-preview-auth.ocr.queue"],
+    pluginName: "plugin-file-preview-auth",
+    common: true
+  },
+  {
+    name: "skill-hub:sandbox",
+    label: "Skill Sandbox",
+    description: "Execute Skill Hub sandbox tasks",
+    kind: "pubsub",
+    aliases: ["skill-hub.task"],
+    pluginName: "plugin-agent-orchestrator",
+    sandbox: true
+  }
+];
+const PROCESS_BY_NAME = new Map(WORKER_PROCESS_DEFINITIONS.map((definition) => [definition.name, definition]));
+const ALIAS_TO_PROCESS = /* @__PURE__ */ new Map();
+for (const definition of WORKER_PROCESS_DEFINITIONS) {
+  ALIAS_TO_PROCESS.set(definition.name, definition.name);
+  for (const alias of definition.aliases || []) {
+    ALIAS_TO_PROCESS.set(alias, definition.name);
+  }
+}
+function splitWorkerModeTokens(value) {
+  const rawTokens = Array.isArray(value) ? value : String(value || "").split(",");
+  return rawTokens.map((token) => String(token).trim()).filter(Boolean);
+}
+function stripKnownPrefixes(token) {
+  const candidates = [token];
+  const dotIndex = token.indexOf(".");
+  if (dotIndex > 0) {
+    candidates.push(token.slice(dotIndex + 1));
+  }
+  const colonIndex = token.indexOf(":");
+  if (colonIndex > 0) {
+    candidates.push(token.slice(colonIndex + 1));
+  }
+  return Array.from(new Set(candidates));
+}
+function resolveWorkerProcessName(token) {
+  const value = String(token || "").trim();
+  if (!value || value === "*" || value === "!" || value === "-") {
+    return value;
+  }
+  const directProcessName = ALIAS_TO_PROCESS.get(value);
+  if (directProcessName) {
+    return directProcessName;
+  }
+  for (const candidate of stripKnownPrefixes(value)) {
+    const processName = ALIAS_TO_PROCESS.get(candidate);
+    if (processName) {
+      return processName;
+    }
+  }
+  for (const definition of WORKER_PROCESS_DEFINITIONS) {
+    if ((definition.redisKeySuffixes || []).some((suffix) => value.endsWith(suffix))) {
+      return definition.name;
+    }
+  }
+  return value;
+}
+function normalizeWorkerMode(value) {
+  const resolved = splitWorkerModeTokens(value).map(resolveWorkerProcessName);
+  if (resolved.includes("*")) {
+    return "*";
+  }
+  const unique = Array.from(new Set(resolved.filter(Boolean)));
+  return unique.length ? unique.join(",") : void 0;
+}
+function workerModeTokens(value) {
+  const normalized = normalizeWorkerMode(value);
+  return normalized ? normalized.split(",") : [];
+}
+function workerModeServesProcess(workerMode, processNameOrAlias) {
+  const mode = normalizeWorkerMode(workerMode);
+  if (!mode) return true;
+  if (mode === "main" || mode === "app") return true;
+  if (mode === "-") return false;
+  if (mode === "*") return true;
+  const processName = resolveWorkerProcessName(processNameOrAlias);
+  return mode.split(",").includes(processName);
+}
+function isWorkerOnlyMode(workerMode) {
+  const mode = normalizeWorkerMode(workerMode);
+  if (!mode || mode === "main" || mode === "app" || mode === "-") return false;
+  return !mode.split(",").includes("!");
+}
+function isAppServingMode(workerMode) {
+  const mode = normalizeWorkerMode(workerMode);
+  if (!mode || mode === "main" || mode === "app") return true;
+  return mode.split(",").includes("!");
+}
+function getWorkerProcessDefinition(nameOrAlias) {
+  return PROCESS_BY_NAME.get(resolveWorkerProcessName(nameOrAlias));
+}
+function getCommonWorkerProcesses() {
+  return WORKER_PROCESS_DEFINITIONS.filter((definition) => definition.common && !definition.sandbox);
+}
+function getWorkerProcessByChannel(channel) {
+  const processName = resolveWorkerProcessName(channel);
+  return PROCESS_BY_NAME.get(processName);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WORKER_PROCESS_DEFINITIONS,
+  getCommonWorkerProcesses,
+  getWorkerProcessByChannel,
+  getWorkerProcessDefinition,
+  isAppServingMode,
+  isWorkerOnlyMode,
+  normalizeWorkerMode,
+  resolveWorkerProcessName,
+  workerModeServesProcess,
+  workerModeTokens
+});

package/package.json

@@ -3,7 +3,7 @@
   "displayName": "Cluster Manager",
   "displayName.zh-CN": "Cluster Manager",
   "description": "Cluster node tracking, task orchestration, worker management, and package distribution",
-  "version": "1.1.16",
+  "version": "1.1.17",
   "license": "Apache-2.0",
   "main": "dist/server/index.js",
   "keywords": [

package/src/client/ClusterNodes.tsx

@@ -31,6 +31,7 @@ import {
 } from '@ant-design/icons';
 import { useApp } from '@nocobase/client-v2';
 import { useT, formatBytes, formatUptime } from './utils';
+import { isWorkerOnlyMode } from '../shared/worker-processes';
 
 function LogViewerModal({ open, node, onClose }: { open: boolean; node: any; onClose: () => void }) {
   const t = useT();
@@ -195,12 +196,46 @@ function countPackages(packages?: { apt?: string[]; npm?: string[]; python?: str
   return (packages?.apt?.length || 0) + (packages?.npm?.length || 0) + (packages?.python?.length || 0);
 }
 
+function getNodeRole(record: any): 'app' | 'worker' | 'sandbox' {
+  if (record?.appRole === 'app' || record?.appRole === 'worker' || record?.appRole === 'sandbox') {
+    return record.appRole;
+  }
+  if (record?.isSandbox) {
+    return 'sandbox';
+  }
+  return isWorkerOnlyMode(record?.workerMode) ? 'worker' : 'app';
+}
+
+function servesWorkerQueues(record: any) {
+  return record?.appRole === 'worker' || isWorkerOnlyMode(record?.workerMode);
+}
+
+function readClusterListPayload(response: any) {
+  const body = response?.data;
+  const wrapped = body?.data;
+
+  if (Array.isArray(wrapped)) {
+    return { rows: wrapped, meta: body?.meta || {} };
+  }
+
+  if (Array.isArray(wrapped?.data)) {
+    return { rows: wrapped.data, meta: wrapped.meta || {} };
+  }
+
+  if (Array.isArray(body?.rows)) {
+    return { rows: body.rows, meta: body?.meta || {} };
+  }
+
+  return { rows: [], meta: {} };
+}
+
 export function ClusterNodes() {
   const t = useT();
   const api = useApp().apiClient;
   const [loading, setLoading] = useState(false);
   const [currentNode, setCurrentNode] = useState<any>(null);
   const [environments, setEnvironments] = useState<any[]>([]);
+  const [clusterListMeta, setClusterListMeta] = useState<any>(null);
   const [health, setHealth] = useState<any>(null);
   const [drift, setDrift] = useState<any>(null);
   const [legacyDiagnostics, setLegacyDiagnostics] = useState<any>(null);
@@ -221,8 +256,10 @@ export function ClusterNodes() {
         api.request({ url: 'clusterManagerCluster:drift' }),
         api.request({ url: 'clusterManagerCluster:legacyDiagnostics' }),
       ]);
+      const listPayload = readClusterListPayload(listRes);
       setCurrentNode(currentRes?.data?.data);
-      setEnvironments(listRes?.data?.data?.data || []);
+      setEnvironments(listPayload.rows);
+      setClusterListMeta(listPayload.meta);
       setHealth(healthRes?.data?.data);
       setDrift(driftRes?.data?.data);
       setLegacyDiagnostics(legacyRes?.data?.data);
@@ -309,13 +346,21 @@ export function ClusterNodes() {
       title: t('Type'),
       dataIndex: 'workerMode',
       key: 'workerMode',
-      width: 100,
+      width: 150,
       render: (mode: string, record: any) => {
-        if (record.isSandbox) {
+        const role = getNodeRole(record);
+        if (role === 'sandbox') {
           return <Tag color="purple">SANDBOX</Tag>;
         }
-        const isWorker = mode === 'worker' || mode === 'task' || mode === '*';
-        return <Tag color={isWorker ? 'blue' : 'green'}>{isWorker ? 'WORKER' : 'APP'}</Tag>;
+        if (role === 'app' && isWorkerOnlyMode(mode)) {
+          return (
+            <Space size={4}>
+              <Tag color="green">APP</Tag>
+              <Tag color="blue">QUEUES</Tag>
+            </Space>
+          );
+        }
+        return <Tag color={role === 'worker' ? 'blue' : 'green'}>{role === 'worker' ? 'WORKER' : 'APP'}</Tag>;
       },
     },
     { title: t('PID'), dataIndex: 'pid', key: 'pid', width: 80 },
@@ -346,6 +391,10 @@ export function ClusterNodes() {
   const versionDrifts = drift?.versionDrifts || [];
   const runtimeDrifts = drift?.runtimeDrifts || [];
   const legacyFindings = legacyDiagnostics?.findings || [];
+  const registryStatus = clusterListMeta?.registry || {};
+  const showRegistryNotice = Boolean(
+    clusterListMeta?.fallback || registryStatus.lastHeartbeatError || registryStatus.lastReadError,
+  );
   const renderFindingMessage = (finding: any) => {
     const template = finding.messageKey ? t(finding.messageKey) : finding.message;
     if (!finding.messageArgs) {
@@ -416,11 +465,7 @@ export function ClusterNodes() {
             <Card size="small">
               <Statistic
                 title={t('Worker Nodes')}
-                value={
-                  environments.filter(
-                    (e) => e.workerMode === 'worker' || e.workerMode === 'task' || e.workerMode === '*',
-                  ).length
-                }
+                value={environments.filter((e) => servesWorkerQueues(e)).length}
                 prefix={<ClusterOutlined />}
               />
             </Card>
@@ -643,6 +688,27 @@ export function ClusterNodes() {
 
         {/* Cluster nodes table */}
         <Card title={t('Cluster Nodes')} size="small">
+          {showRegistryNotice && (
+            <Alert
+              type={registryStatus.configured ? 'warning' : 'info'}
+              showIcon
+              style={{ marginBottom: 12 }}
+              message={
+                registryStatus.configured
+                  ? t('Cluster registry has no worker heartbeats')
+                  : t('Cluster registry Redis is not configured')
+              }
+              description={
+                registryStatus.configured
+                  ? t(
+                      'Cluster Nodes reads Redis heartbeats, not the container runtime. Check worker boot, plugin-cluster-manager, and shared Redis configuration.',
+                    )
+                  : t(
+                      'Set REDIS_URL or CLUSTER_MANAGER_REDIS_URL on every app and worker to enable cluster node discovery.',
+                    )
+              }
+            />
+          )}
           <Table
             dataSource={environments}
             columns={nodeColumns}