plugin-cluster-manager 1.1.10 → 1.1.13

package/dist/server/orchestrator/docker-adapter.js

@@ -35,9 +35,7 @@ function getDockerode() {
     try {
       Dockerode = require("dockerode");
     } catch {
-      throw new Error(
-        '[DockerAdapter] "dockerode" package not found. Install it: yarn add dockerode'
-      );
+      throw new Error('[DockerAdapter] "dockerode" package not found. Install it: yarn add dockerode');
     }
   }
   return Dockerode;
@@ -71,11 +69,7 @@ class DockerAdapter {
     const containers = await this.docker.listContainers({
       all: true,
       filters: {
-        label: [
-          `${LABEL_STACK}=${stack.name}`,
-          `${LABEL_MANAGED}=true`,
-          ...this.buildLabelFilters(this.workerLabels)
-        ]
+        label: [`${LABEL_STACK}=${stack.name}`, `${LABEL_MANAGED}=true`, ...this.buildLabelFilters(this.workerLabels)]
       }
     });
     return containers.map((c) => ({
@@ -100,7 +94,7 @@ class DockerAdapter {
     }
   }
   async scale(stack, replicas) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f, _g;
     const current = await this.listContainers(stack);
     const running = current.filter((c) => c.status === "running");
     const diff = replicas - running.length;
@@ -112,20 +106,27 @@ class DockerAdapter {
     };
     if (diff > 0) {
       let targetNetworks = stack.networks && stack.networks.length > 0 ? stack.networks : [];
-      let targetNetworkMode = stack.networkMode;
+      const targetNetworkMode = stack.networkMode;
       let targetEnvVars = this.buildEnvArray(stack.envVars);
       let targetVolumes = stack.volumes || [];
+      let targetImage = stack.image;
+      let inheritedCmd;
+      let inheritedEntrypoint;
       try {
         const os = require("os");
         const myContainerId = os.hostname();
         const myContainer = this.docker.getContainer(myContainerId);
         const myInfo = await myContainer.inspect();
-        if ((_a = myInfo == null ? void 0 : myInfo.NetworkSettings) == null ? void 0 : _a.Networks) {
+        if (!targetImage && ((_a = myInfo == null ? void 0 : myInfo.Config) == null ? void 0 : _a.Image)) {
+          targetImage = myInfo.Config.Image;
+          console.log("[DockerAdapter] Inherited image from app container:", targetImage);
+        }
+        if ((_b = myInfo == null ? void 0 : myInfo.NetworkSettings) == null ? void 0 : _b.Networks) {
           const inheritedNetworks = Object.keys(myInfo.NetworkSettings.Networks);
           targetNetworks = Array.from(/* @__PURE__ */ new Set([...inheritedNetworks, ...targetNetworks]));
           console.log("[DockerAdapter] Inherited networks:", targetNetworks);
         }
-        if ((_b = myInfo == null ? void 0 : myInfo.Config) == null ? void 0 : _b.Env) {
+        if ((_c = myInfo == null ? void 0 : myInfo.Config) == null ? void 0 : _c.Env) {
           const envDict = {};
           myInfo.Config.Env.forEach((e) => {
             const idx = e.indexOf("=");
@@ -136,10 +137,16 @@ class DockerAdapter {
           Object.assign(envDict, stack.envVars || {});
           targetEnvVars = Object.entries(envDict).map(([k, v]) => `${k}=${v}`);
         }
-        if ((_c = myInfo == null ? void 0 : myInfo.HostConfig) == null ? void 0 : _c.Binds) {
+        if ((_d = myInfo == null ? void 0 : myInfo.HostConfig) == null ? void 0 : _d.Binds) {
           const inheritedBinds = myInfo.HostConfig.Binds;
           targetVolumes = Array.from(/* @__PURE__ */ new Set([...inheritedBinds, ...targetVolumes]));
         }
+        if (Array.isArray((_e = myInfo == null ? void 0 : myInfo.Config) == null ? void 0 : _e.Cmd) && myInfo.Config.Cmd.length > 0) {
+          inheritedCmd = myInfo.Config.Cmd;
+        }
+        if (Array.isArray((_f = myInfo == null ? void 0 : myInfo.Config) == null ? void 0 : _f.Entrypoint) && myInfo.Config.Entrypoint.length > 0) {
+          inheritedEntrypoint = myInfo.Config.Entrypoint;
+        }
       } catch (e) {
         console.error("[DockerAdapter] Failed to inherit container config:", e.message);
       }
@@ -147,11 +154,16 @@ class DockerAdapter {
       if (!hasLoggerBase) {
         targetEnvVars.push(`LOGGER_BASE_PATH=/app/nocobase/storage/logs/${stack.name}`);
       }
+      if (!targetImage) {
+        throw new Error(
+          `[DockerAdapter] No image configured for stack "${stack.name}" and the app container image could not be determined.`
+        );
+      }
       for (let i = 0; i < diff; i++) {
         const suffix = `${Date.now()}-${Math.random().toString(36).substring(2, 6)}`;
         const containerName = `${stack.name}-${suffix}`;
         const createOpts = {
-          Image: stack.image,
+          Image: targetImage,
           name: containerName,
           Env: targetEnvVars,
           Labels: {
@@ -166,8 +178,15 @@ class DockerAdapter {
         };
         if (stack.command) {
           createOpts.Cmd = ["/bin/sh", "-c", stack.command];
+        } else {
+          if (inheritedEntrypoint) {
+            createOpts.Entrypoint = inheritedEntrypoint;
+          }
+          if (inheritedCmd) {
+            createOpts.Cmd = inheritedCmd;
+          }
         }
-        if ((_d = stack.resourceLimits) == null ? void 0 : _d.memory) {
+        if ((_g = stack.resourceLimits) == null ? void 0 : _g.memory) {
           createOpts.HostConfig.Memory = this.parseMemory(stack.resourceLimits.memory);
         }
         if (targetNetworkMode) {
@@ -184,7 +203,9 @@ class DockerAdapter {
               const net = this.docker.getNetwork(targetNetworks[i2]);
               await net.connect({ Container: container.id });
             } catch (err) {
-              console.warn(`[DockerAdapter] Failed to connect container ${container.id} to network ${targetNetworks[i2]}: ${err.message}`);
+              console.warn(
+                `[DockerAdapter] Failed to connect container ${container.id} to network ${targetNetworks[i2]}: ${err.message}`
+              );
             }
           }
         }
@@ -192,9 +213,7 @@ class DockerAdapter {
         result.containersCreated.push(container.id.substring(0, 12));
       }
     } else if (diff < 0) {
-      const sorted = running.sort(
-        (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
-      );
+      const sorted = running.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
       const toRemove = sorted.slice(0, Math.abs(diff));
       for (const c of toRemove) {
         try {
@@ -293,14 +312,17 @@ class DockerAdapter {
   }
   parseLabelSelector(selector) {
     if (!(selector == null ? void 0 : selector.trim())) return {};
-    return selector.split(",").map((part) => part.trim()).filter(Boolean).reduce((acc, part) => {
-      const [key, ...valueParts] = part.split("=");
-      const value = valueParts.join("=");
-      if ((key == null ? void 0 : key.trim()) && (value == null ? void 0 : value.trim())) {
-        acc[key.trim()] = value.trim();
-      }
-      return acc;
-    }, {});
+    return selector.split(",").map((part) => part.trim()).filter(Boolean).reduce(
+      (acc, part) => {
+        const [key, ...valueParts] = part.split("=");
+        const value = valueParts.join("=");
+        if ((key == null ? void 0 : key.trim()) && (value == null ? void 0 : value.trim())) {
+          acc[key.trim()] = value.trim();
+        }
+        return acc;
+      },
+      {}
+    );
   }
   labelsMatch(labels, expected) {
     return Object.entries(expected).every(([k, v]) => labels[k] === v);

package/dist/server/plugin.js

@@ -58,11 +58,15 @@ var import_redis_node_registry = require("./adapters/redis-node-registry");
 var import_redis_lock_adapter = require("./adapters/redis-lock-adapter");
 var import_orchestrator = require("./actions/orchestrator");
 var import_plugin_operations = require("./actions/plugin-operations");
+var import_queue_mappings = require("./actions/queue-mappings");
 var import_docker_adapter = require("./orchestrator/docker-adapter");
 var import_k8s_adapter = require("./orchestrator/k8s-adapter");
 var import_leader_election = require("./orchestrator/leader-election");
 var import_package_manager = require("./actions/package-manager");
 var import_PackageManager = require("./orchestrator/PackageManager");
+var import_listMetaCacheMiddleware = require("./middlewares/listMetaCacheMiddleware");
+var import_cacheInvalidationHooks = require("./hooks/cacheInvalidationHooks");
+var import_doctor = require("./actions/doctor");
 class PluginClusterManagerServer extends import_server.Plugin {
   nodeRegistry;
   orchestrator = null;
@@ -84,8 +88,7 @@ class PluginClusterManagerServer extends import_server.Plugin {
     this.app.on("afterStart", () => {
       var _a;
       (_a = this.nodeRegistry) == null ? void 0 : _a.start();
-      const mode = process.env.WORKER_MODE || "main";
-      const isWorker = mode === "worker" || mode === "task" || mode === "*" || process.env.APP_ROLE === "worker" || process.env.APP_ROLE === "sandbox";
+      const isWorker = (0, import_node.isWorkerMode)(process.env.WORKER_MODE) || process.env.APP_ROLE === "worker" || process.env.APP_ROLE === "sandbox";
       if (isWorker) {
         setTimeout(async () => {
           try {
@@ -107,7 +110,7 @@ class PluginClusterManagerServer extends import_server.Plugin {
               try {
                 const customRaw = config.get("customPackages");
                 if (customRaw) custom = typeof customRaw === "string" ? JSON.parse(customRaw) : customRaw;
-              } catch {
+              } catch (err) {
               }
               const unique = (arr) => Array.from(new Set(arr.filter(Boolean)));
               const packages = {
@@ -138,9 +141,7 @@ class PluginClusterManagerServer extends import_server.Plugin {
       (_a = this.nodeRegistry) == null ? void 0 : _a.stop();
     });
     this.app.db.on("executions.afterSave", async (model) => {
-      const mode = process.env.WORKER_MODE || "main";
-      const isWorker = mode === "worker" || mode === "task" || mode === "*";
-      if (isWorker) {
+      if ((0, import_node.isWorkerMode)(process.env.WORKER_MODE)) {
         const id = model.get("id");
         const redis = (0, import_redis.getRedisClient)(this.app);
         if (id && redis) {
@@ -170,16 +171,51 @@ class PluginClusterManagerServer extends import_server.Plugin {
           if (!redis || !requestId) return;
           const logData = await (0, import_cluster_nodes.readLocalLogs)(this.app, lines || 200);
           const responseKey = `cluster-manager:log-response:${requestId}`;
+          await redis.sendCommand(["SET", responseKey, JSON.stringify(logData), "EX", "30"]);
+          this.app.logger.debug(`[ClusterManager] Served log request ${requestId} for ${targetNodeId}`);
+        } catch (err) {
+          this.app.logger.error(`[ClusterManager] Error handling log request: ${err.message}`);
+        }
+      });
+      pubSub.subscribe(`cluster-manager:doctor-collect:${myNodeId}`, async (msg) => {
+        const redis = (0, import_redis.getRedisClient)(this.app);
+        let requestId = "";
+        try {
+          const parsed = typeof msg === "string" ? JSON.parse(msg) : msg;
+          requestId = parsed.requestId;
+          if (!redis || !requestId) return;
+          const snapshot = await (0, import_doctor.collectLocalDoctorSnapshot)(this.app, {
+            runId: parsed.runId,
+            sinceMs: parsed.sinceMs,
+            untilMs: parsed.untilMs,
+            maxLines: parsed.maxLines
+          });
           await redis.sendCommand([
             "SET",
-            responseKey,
-            JSON.stringify(logData),
+            `cluster-manager:doctor-response:${requestId}`,
+            JSON.stringify(snapshot),
             "EX",
-            "30"
+            "90"
           ]);
-          this.app.logger.debug(`[ClusterManager] Served log request ${requestId} for ${targetNodeId}`);
+          this.app.logger.debug(`[ClusterManager] Served doctor snapshot request ${requestId}`);
         } catch (err) {
-          this.app.logger.error(`[ClusterManager] Error handling log request: ${err.message}`);
+          const message = err instanceof Error ? err.message : String(err);
+          this.app.logger.error(`[ClusterManager] Error handling doctor snapshot request: ${message}`);
+          if (redis && requestId) {
+            const fallback = {
+              nodeId: (0, import_node.getLocalNodeId)(this.app),
+              collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              error: message
+            };
+            await redis.sendCommand([
+              "SET",
+              `cluster-manager:doctor-response:${requestId}`,
+              JSON.stringify(fallback),
+              "EX",
+              "90"
+            ]).catch(() => {
+            });
+          }
         }
       });
       pubSub.subscribe("cluster-manager.install-packages", async (payload) => {
@@ -195,12 +231,16 @@ class PluginClusterManagerServer extends import_server.Plugin {
         try {
           let target = msg;
           let mode = "hard";
+          let targetNodeId = "";
           if (msg.startsWith("{")) {
             const parsed = JSON.parse(msg);
-            target = parsed.hostname;
+            target = parsed.hostname || parsed.target || "";
+            targetNodeId = parsed.targetNodeId || "";
             mode = parsed.mode || "hard";
           }
-          if (target === os.hostname() || target === "*") {
+          const myNodeId2 = (0, import_node.getLocalNodeId)(this.app);
+          const shouldRestart = targetNodeId ? targetNodeId === myNodeId2 : target === os.hostname() || target === "*";
+          if (shouldRestart) {
             this.app.logger.warn(`[ClusterManager] Received ${mode} restart command for node ${os.hostname()}...`);
             setTimeout(async () => {
               try {
@@ -241,6 +281,10 @@ class PluginClusterManagerServer extends import_server.Plugin {
       name: "clusterManagerCluster",
       actions: import_cluster_nodes.clusterActions
     });
+    this.app.resourcer.define({
+      name: "clusterManagerDoctor",
+      actions: import_doctor.doctorActions
+    });
     this.app.resourcer.define({
       name: "clusterManagerQueue",
       actions: import_event_queue_monitor.eventQueueActions
@@ -261,12 +305,22 @@ class PluginClusterManagerServer extends import_server.Plugin {
       name: "clusterManagerPlugins",
       actions: import_plugin_operations.pluginOperationsActions
     });
+    this.app.resourcer.define({
+      name: "workerQueueMappings",
+      actions: import_queue_mappings.queueMappingsActions
+    });
     const aclCacheMiddleware = (0, import_acl_cache.createAclCacheMiddleware)(this.app);
     this.app.acl.use(aclCacheMiddleware, {
       tag: "aclCache",
       before: "core",
       after: "allow-manager"
     });
+    const listMetaCacheMiddleware = (0, import_listMetaCacheMiddleware.createListMetaCacheMiddleware)(this.app);
+    this.app.resourcer.use(listMetaCacheMiddleware, {
+      tag: "listMetaCache",
+      after: "setCurrentRole"
+    });
+    (0, import_cacheInvalidationHooks.registerCacheHooks)(this.app);
     this.app.use(async (ctx, next) => {
       if (ctx.path === "/api/clusterManager:health" && (ctx.method === "GET" || ctx.method === "HEAD")) {
         ctx.body = {
@@ -286,13 +340,15 @@ class PluginClusterManagerServer extends import_server.Plugin {
         "clusterManagerRedis:*",
         "clusterManagerAclCache:*",
         "clusterManagerCluster:*",
+        "clusterManagerDoctor:*",
         "clusterManagerQueue:*",
         "clusterManagerLock:*",
         "clusterManagerCacheMgr:*",
         "workerOrchestrator:*",
         "orchestratorStacks:*",
         "workerPackages:*",
-        "clusterManagerPlugins:*"
+        "clusterManagerPlugins:*",
+        "workerQueueMappings:*"
       ]
     });
     await this.initOrchestrator();
@@ -443,8 +499,7 @@ class PluginClusterManagerServer extends import_server.Plugin {
     }
   }
   isWorkerOnlyNode() {
-    const workerMode = process.env.WORKER_MODE || "";
-    return workerMode === "worker" || workerMode === "task" || workerMode === "*";
+    return (0, import_node.isWorkerMode)(process.env.WORKER_MODE);
   }
 }
 var plugin_default = PluginClusterManagerServer;

package/dist/server/queue-scanner.js

@@ -0,0 +1,141 @@
+/**
+ * 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 queue_scanner_exports = {};
+__export(queue_scanner_exports, {
+  scanQueues: () => scanQueues
+});
+module.exports = __toCommonJS(queue_scanner_exports);
+var import_redis = require("./utils/redis");
+const KNOWN_QUEUE_LABELS = {
+  "workflow:process": {
+    label: "Workflow",
+    description: "Process workflow executions (plugin-workflow)"
+  },
+  "async-task:process": {
+    label: "Async Tasks",
+    description: "Execute async tasks (plugin-async-task-manager)"
+  },
+  "knowledge-base:document-vectorize": {
+    label: "Document Vectorization",
+    description: "Vectorize knowledge base documents (plugin-knowledge-base)"
+  },
+  "git-review:process": {
+    label: "Git Review",
+    description: "AI code review jobs (plugin-git-manager)"
+  },
+  "build-guide:process": {
+    label: "Build Guide",
+    description: "Build user guide pages (plugin-build-guide-block)"
+  },
+  "build-ui-template:process": {
+    label: "Build UI Template",
+    description: "Build UI template pages (plugin-build-ui-template)"
+  }
+};
+const REDIS_QUEUE_PATTERNS = ["*:plugin-git-manager:review:queue", "*:plugin-build-guide-block:build:queue"];
+function describeRedisQueueKey(key) {
+  const parts = String(key).split(":");
+  const plugin = parts[parts.length - 3] || "unknown";
+  const queue = parts[parts.length - 2] || key;
+  return {
+    label: `${queue} (${plugin})`,
+    description: `Redis List queue from ${plugin}`
+  };
+}
+function scanEventQueue(app) {
+  const eq = app.eventQueue;
+  if (!eq || !eq.events) return [];
+  const events = eq.events;
+  const items = [];
+  for (const [channel] of events.entries()) {
+    const known = KNOWN_QUEUE_LABELS[channel];
+    items.push({
+      name: channel,
+      label: (known == null ? void 0 : known.label) ?? channel,
+      description: (known == null ? void 0 : known.description) ?? `EventQueue channel: ${channel}`,
+      type: "event-queue",
+      pending: null
+    });
+  }
+  return items;
+}
+async function scanRedisQueues(app) {
+  var _a;
+  const redis = (0, import_redis.getRedisClient)(app);
+  if (!redis) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  for (const pattern of REDIS_QUEUE_PATTERNS) {
+    try {
+      const keys = await redis.sendCommand(["SCAN", "0", "MATCH", pattern, "COUNT", "200"]);
+      const keyList = typeof ((_a = keys[1]) == null ? void 0 : _a.length) === "number" ? keys[1] : [];
+      for (const key of keyList) {
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const desc = describeRedisQueueKey(key);
+        let pending = 0;
+        try {
+          pending = Number(await redis.sendCommand(["LLEN", key])) || 0;
+        } catch {
+          pending = 0;
+        }
+        items.push({
+          name: key,
+          label: desc.label,
+          description: desc.description,
+          type: "redis-list",
+          pending
+        });
+      }
+    } catch {
+    }
+  }
+  return items;
+}
+async function scanQueues(app) {
+  const eventQueues = scanEventQueue(app);
+  const redisQueues = await scanRedisQueues(app);
+  const seenNames = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const q of eventQueues) {
+    merged.push(q);
+    seenNames.add(q.name);
+  }
+  for (const q of redisQueues) {
+    if (!seenNames.has(q.name)) {
+      merged.push(q);
+      seenNames.add(q.name);
+    }
+  }
+  return { queues: merged, total: merged.length };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  scanQueues
+});

package/dist/server/utils/node.js

@@ -36,10 +36,35 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var node_exports = {};
 __export(node_exports, {
-  getLocalNodeId: () => getLocalNodeId
+  getLocalNodeId: () => getLocalNodeId,
+  getLocalRole: () => getLocalRole,
+  getNodeRoleFrom: () => getNodeRoleFrom,
+  isWorkerMode: () => isWorkerMode
 });
 module.exports = __toCommonJS(node_exports);
 var import_os = __toESM(require("os"));
+function isWorkerMode(workerMode) {
+  const mode = (workerMode ?? process.env.WORKER_MODE ?? "").trim();
+  if (!mode || mode === "main" || mode === "app") return false;
+  if (mode === "-") return false;
+  const topics = mode.split(",").map((t) => t.trim()).filter(Boolean);
+  if (topics.includes("!")) return false;
+  return true;
+}
+function getNodeRoleFrom(opts) {
+  if (opts.appRole === "app" || opts.appRole === "worker" || opts.appRole === "sandbox") {
+    return opts.appRole;
+  }
+  if (opts.isSandbox) return "sandbox";
+  return isWorkerMode(opts.workerMode) ? "worker" : "app";
+}
+function getLocalRole() {
+  return getNodeRoleFrom({
+    workerMode: process.env.WORKER_MODE,
+    appRole: process.env.APP_ROLE,
+    isSandbox: process.env.SKILL_HUB_SANDBOX === "true"
+  });
+}
 function getLocalNodeId(app) {
   const port = process.env.APP_PORT || "unknown";
   const mode = process.env.WORKER_MODE || "main";
@@ -48,5 +73,8 @@ function getLocalNodeId(app) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getLocalNodeId
+  getLocalNodeId,
+  getLocalRole,
+  getNodeRoleFrom,
+  isWorkerMode
 });

package/dist/server/utils/versionManager.js

@@ -0,0 +1,91 @@
+/**
+ * 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 versionManager_exports = {};
+__export(versionManager_exports, {
+  cacheVersionManager: () => cacheVersionManager
+});
+module.exports = __toCommonJS(versionManager_exports);
+var import_redis = require("./redis");
+const localCounters = /* @__PURE__ */ new Map();
+async function getVersion(app, key) {
+  const redis = (0, import_redis.getRedisClient)(app);
+  if (redis) {
+    try {
+      const val = await redis.sendCommand(["GET", key]);
+      return val ? parseInt(val, 10) : 1;
+    } catch {
+    }
+  }
+  return localCounters.get(key) || 1;
+}
+async function incrementVersion(app, key) {
+  const redis = (0, import_redis.getRedisClient)(app);
+  if (redis) {
+    try {
+      const val = await redis.sendCommand(["INCR", key]);
+      return parseInt(val, 10);
+    } catch {
+    }
+  }
+  const next = (localCounters.get(key) || 1) + 1;
+  localCounters.set(key, next);
+  return next;
+}
+const cacheVersionManager = {
+  async getCollectionVersion(app) {
+    return getVersion(app, "nocobase:version:collections");
+  },
+  async incrementCollectionVersion(app) {
+    app.logger.info("[ClusterManager] Incrementing collections cache version due to schema change");
+    return incrementVersion(app, "nocobase:version:collections");
+  },
+  async getSchemaVersion(app) {
+    return getVersion(app, "nocobase:version:schemas");
+  },
+  async incrementSchemaVersion(app) {
+    app.logger.info("[ClusterManager] Incrementing uiSchemas cache version due to UI change");
+    return incrementVersion(app, "nocobase:version:schemas");
+  },
+  async getAclVersion(app, roleName) {
+    return getVersion(app, `nocobase:version:acl:role:${roleName}`);
+  },
+  async incrementAclVersion(app, roleName) {
+    app.logger.info(`[ClusterManager] Incrementing ACL cache version for role: ${roleName}`);
+    return incrementVersion(app, `nocobase:version:acl:role:${roleName}`);
+  },
+  async incrementAllAclVersions(app) {
+    app.logger.info("[ClusterManager] Incrementing global ACL cache version");
+    return incrementVersion(app, "nocobase:version:acl:global");
+  },
+  async getGlobalAclVersion(app) {
+    return getVersion(app, "nocobase:version:acl:global");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cacheVersionManager
+});

package/package.json

@@ -3,9 +3,9 @@
   "displayName": "Cluster Manager",
   "displayName.zh-CN": "Cluster Manager",
   "description": "Cluster node tracking, task orchestration, worker management, and package distribution",
-  "version": "1.1.10",
+  "version": "1.1.13",
   "license": "Apache-2.0",
-  "main": "./dist/server/index.js",
+  "main": "dist/server/index.js",
   "keywords": [
     "Monitoring",
     "DevOps"
@@ -16,12 +16,16 @@
     "client.js",
     "server.js",
     "client.d.ts",
-    "server.d.ts"
+    "server.d.ts",
+    "client-v2.js",
+    "client-v2.d.ts"
   ],
   "peerDependencies": {
     "@nocobase/client": "2.x",
     "@nocobase/server": "2.x",
-    "@nocobase/database": "2.x"
+    "@nocobase/database": "2.x",
+    "@nocobase/client-v2": "2.x",
+    "@nocobase/flow-engine": "2.x"
   },
   "dependencies": {
     "@nocobase/lock-manager": "2.x"
@@ -39,4 +43,4 @@
     ],
     "editionLevel": 0
   }
-}
+}

package/server.js

@@ -0,0 +1 @@
+module.exports = require('./dist/server/index.js');