plugin-cluster-manager 1.1.10 → 1.1.11

package/dist/server/collections/cluster-manager-doctor-runs.d.ts

@@ -0,0 +1,3 @@
+import { CollectionOptions } from '@nocobase/database';
+declare const _default: CollectionOptions;
+export default _default;

package/dist/server/collections/cluster-manager-doctor-runs.js

@@ -0,0 +1,52 @@
+/**
+ * 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 cluster_manager_doctor_runs_exports = {};
+__export(cluster_manager_doctor_runs_exports, {
+  default: () => cluster_manager_doctor_runs_default
+});
+module.exports = __toCommonJS(cluster_manager_doctor_runs_exports);
+var cluster_manager_doctor_runs_default = {
+  name: "clusterManagerDoctorRuns",
+  title: "Cluster Manager Doctor Runs",
+  fields: [
+    { name: "id", type: "bigInt", autoIncrement: true, primaryKey: true },
+    { name: "runId", type: "string", length: 64, unique: true, allowNull: false },
+    { name: "status", type: "string", length: 20, defaultValue: "running", allowNull: false },
+    { name: "durationMs", type: "integer", defaultValue: 12e4, allowNull: false },
+    { name: "progress", type: "integer", defaultValue: 0, allowNull: false },
+    { name: "startedAt", type: "date", allowNull: false },
+    { name: "deadlineAt", type: "date", allowNull: false },
+    { name: "finishedAt", type: "date", allowNull: true },
+    { name: "finishReason", type: "string", length: 40, allowNull: true },
+    { name: "startedBy", type: "string", length: 200, allowNull: true },
+    { name: "summary", type: "json", allowNull: true },
+    { name: "report", type: "json", allowNull: true },
+    { name: "error", type: "text", allowNull: true },
+    { name: "createdAt", type: "date" },
+    { name: "updatedAt", type: "date" }
+  ]
+};

package/dist/server/collections/cluster-manager-doctor.d.ts

@@ -0,0 +1,18 @@
+/**
+ * DUMMY COLLECTION
+ * Keeps the `clusterManagerDoctor` resourcer compatible with NocoBase
+ * workflow/ACL collection lookups. Diagnostic run data lives in
+ * `clusterManagerDoctorRuns`.
+ */
+declare const _default: {
+    name: string;
+    dumpRules: string;
+    autoGenId: boolean;
+    createdAt: boolean;
+    updatedAt: boolean;
+    fields: {
+        name: string;
+        type: string;
+    }[];
+};
+export default _default;

package/dist/server/collections/cluster-manager-doctor.js

@@ -0,0 +1,44 @@
+/**
+ * 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 cluster_manager_doctor_exports = {};
+__export(cluster_manager_doctor_exports, {
+  default: () => cluster_manager_doctor_default
+});
+module.exports = __toCommonJS(cluster_manager_doctor_exports);
+var cluster_manager_doctor_default = {
+  name: "clusterManagerDoctor",
+  dumpRules: "skip",
+  autoGenId: true,
+  createdAt: false,
+  updatedAt: false,
+  fields: [
+    {
+      name: "name",
+      type: "string"
+    }
+  ]
+};

package/dist/server/hooks/cacheInvalidationHooks.d.ts

@@ -0,0 +1 @@
+export declare function registerCacheHooks(app: any): void;

package/dist/server/hooks/cacheInvalidationHooks.js

@@ -0,0 +1,81 @@
+/**
+ * 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 cacheInvalidationHooks_exports = {};
+__export(cacheInvalidationHooks_exports, {
+  registerCacheHooks: () => registerCacheHooks
+});
+module.exports = __toCommonJS(cacheInvalidationHooks_exports);
+var import_versionManager = require("../utils/versionManager");
+function registerCacheHooks(app) {
+  const db = app.db;
+  db.on("collections.afterSave", async () => {
+    await import_versionManager.cacheVersionManager.incrementCollectionVersion(app);
+  });
+  db.on("collections.afterDestroy", async () => {
+    await import_versionManager.cacheVersionManager.incrementCollectionVersion(app);
+  });
+  db.on("fields.afterSave", async () => {
+    await import_versionManager.cacheVersionManager.incrementCollectionVersion(app);
+  });
+  db.on("fields.afterDestroy", async () => {
+    await import_versionManager.cacheVersionManager.incrementCollectionVersion(app);
+  });
+  db.on("uiSchemas.afterSave", async () => {
+    await import_versionManager.cacheVersionManager.incrementSchemaVersion(app);
+  });
+  db.on("uiSchemas.afterDestroy", async () => {
+    await import_versionManager.cacheVersionManager.incrementSchemaVersion(app);
+  });
+  const invalidateRole = async (model) => {
+    var _a, _b;
+    const roleName = ((_a = model.get) == null ? void 0 : _a.call(model, "roleName")) || ((_b = model.get) == null ? void 0 : _b.call(model, "name"));
+    if (roleName) {
+      await import_versionManager.cacheVersionManager.incrementAclVersion(app, roleName);
+    } else {
+      await import_versionManager.cacheVersionManager.incrementAllAclVersions(app);
+    }
+  };
+  db.on("roles.afterSave", invalidateRole);
+  db.on("roles.afterDestroy", invalidateRole);
+  db.on("rolesResources.afterSave", invalidateRole);
+  db.on("rolesResources.afterDestroy", invalidateRole);
+  db.on("rolesResourcesActions.afterSave", invalidateRole);
+  db.on("rolesResourcesActions.afterDestroy", invalidateRole);
+  db.on("rolesUsers.afterSave", invalidateRole);
+  db.on("rolesUsers.afterDestroy", invalidateRole);
+  db.on("scopes.afterSave", async () => {
+    await import_versionManager.cacheVersionManager.incrementAllAclVersions(app);
+  });
+  db.on("scopes.afterDestroy", async () => {
+    await import_versionManager.cacheVersionManager.incrementAllAclVersions(app);
+  });
+  app.logger.info("[ClusterManager] Cache invalidation hooks registered successfully");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerCacheHooks
+});

package/dist/server/middlewares/listMetaCacheMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { Context } from '@nocobase/actions';
+export declare function createListMetaCacheMiddleware(app: any): (ctx: Context, next: () => Promise<void>) => Promise<void>;

package/dist/server/middlewares/listMetaCacheMiddleware.js

@@ -0,0 +1,79 @@
+/**
+ * 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 listMetaCacheMiddleware_exports = {};
+__export(listMetaCacheMiddleware_exports, {
+  createListMetaCacheMiddleware: () => createListMetaCacheMiddleware
+});
+module.exports = __toCommonJS(listMetaCacheMiddleware_exports);
+var import_versionManager = require("../utils/versionManager");
+const LIST_META_CACHE_TTL = 1e3 * 60 * 10;
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createListMetaCacheMiddleware(app) {
+  return async function listMetaCacheMiddleware(ctx, next) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const cache = app.cache;
+    if (!cache || ((_a = ctx.action) == null ? void 0 : _a.resourceName) !== "collections" || ((_b = ctx.action) == null ? void 0 : _b.actionName) !== "listMeta") {
+      return next();
+    }
+    const currentRole = ((_c = ctx.state) == null ? void 0 : _c.currentRole) || "anonymous";
+    const appName = ctx.headers["x-app"] || "main";
+    const dataSource = ctx.headers["x-data-source"] || "main";
+    const locale = ctx.headers["x-locale"] || ctx.headers["accept-language"] || "en-US";
+    let cacheKey = "";
+    let version = 0;
+    try {
+      version = await import_versionManager.cacheVersionManager.getCollectionVersion(app);
+      cacheKey = `nb:cache:${appName}:meta:v${version}:ds:${dataSource}:role:${currentRole}:lang:${locale}`;
+      const cached = await cache.get(cacheKey);
+      if (cached !== void 0 && cached !== null) {
+        ctx.body = typeof cached === "string" ? JSON.parse(cached) : cached;
+        (_d = ctx.set) == null ? void 0 : _d.call(ctx, "X-Cache", "HIT");
+        (_e = ctx.set) == null ? void 0 : _e.call(ctx, "X-Collection-Version", String(version));
+        return;
+      }
+    } catch (err) {
+      app.logger.warn(`[ClusterManager] listMeta cache read skipped: ${getErrorMessage(err)}`);
+    }
+    await next();
+    if (ctx.status === 200 && ctx.body && cacheKey) {
+      try {
+        const valueToCache = typeof ctx.body === "string" ? ctx.body : JSON.stringify(ctx.body);
+        await cache.set(cacheKey, valueToCache, LIST_META_CACHE_TTL);
+        (_f = ctx.set) == null ? void 0 : _f.call(ctx, "X-Cache", "MISS");
+        (_g = ctx.set) == null ? void 0 : _g.call(ctx, "X-Collection-Version", String(version));
+      } catch (err) {
+        app.logger.warn(`[ClusterManager] listMeta cache write skipped: ${getErrorMessage(err)}`);
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createListMetaCacheMiddleware
+});

package/dist/server/orchestrator/PackageManager.js

@@ -41,6 +41,7 @@ __export(PackageManager_exports, {
 module.exports = __toCommonJS(PackageManager_exports);
 var import_child_process = require("child_process");
 var import_redis = require("../utils/redis");
+var import_node = require("../utils/node");
 var import_fs = require("fs");
 var import_path = __toESM(require("path"));
 const SAFE_PKG_RE = /^(?:[a-zA-Z0-9_.@/-]|\[|\])+$/;
@@ -408,22 +409,25 @@ ${logs.join("\n")}`);
       const redisClient = (0, import_redis.getRedisClient)(this.app);
       const podName = process.env.POD_NAME || require("os").hostname();
       if (redisClient) {
-        const key = `orchestrator:pkg-status:${podName}`;
-        await redisClient.sendCommand([
-          "SET",
-          key,
-          JSON.stringify({
-            initStatus,
-            initProgressPercent,
-            initProgressLog,
-            lastInitAt: /* @__PURE__ */ new Date(),
-            lastInitLog: logs.join("\n"),
-            ...extraValues
-          }),
-          "EX",
-          "86400"
-          // expire after 1 day
-        ]);
+        const statusPayload = JSON.stringify({
+          initStatus,
+          initProgressPercent,
+          initProgressLog,
+          lastInitAt: /* @__PURE__ */ new Date(),
+          lastInitLog: logs.join("\n"),
+          ...extraValues
+        });
+        const keys = [`orchestrator:pkg-status:${podName}`, `cluster-manager:pkg-status:${(0, import_node.getLocalNodeId)(this.app)}`];
+        for (const key of keys) {
+          await redisClient.sendCommand([
+            "SET",
+            key,
+            statusPayload,
+            "EX",
+            "86400"
+            // expire after 1 day
+          ]);
+        }
       }
       const repo = this.app.db.getRepository("workerPackagesConfigs");
       let config = await repo.findOne();

package/dist/server/plugin.js

@@ -63,6 +63,9 @@ 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;
@@ -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 = {
@@ -170,16 +173,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 +233,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 +283,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
@@ -267,6 +313,12 @@ class PluginClusterManagerServer extends import_server.Plugin {
       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,6 +338,7 @@ class PluginClusterManagerServer extends import_server.Plugin {
         "clusterManagerRedis:*",
         "clusterManagerAclCache:*",
         "clusterManagerCluster:*",
+        "clusterManagerDoctor:*",
         "clusterManagerQueue:*",
         "clusterManagerLock:*",
         "clusterManagerCacheMgr:*",

package/dist/server/utils/versionManager.d.ts

@@ -0,0 +1,10 @@
+export declare const cacheVersionManager: {
+    getCollectionVersion(app: any): Promise<number>;
+    incrementCollectionVersion(app: any): Promise<number>;
+    getSchemaVersion(app: any): Promise<number>;
+    incrementSchemaVersion(app: any): Promise<number>;
+    getAclVersion(app: any, roleName: string): Promise<number>;
+    incrementAclVersion(app: any, roleName: string): Promise<number>;
+    incrementAllAclVersions(app: any): Promise<number>;
+    getGlobalAclVersion(app: any): Promise<number>;
+};

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

@@ -1,42 +1,42 @@
-{
-  "name": "plugin-cluster-manager",
-  "displayName": "Cluster Manager",
-  "displayName.zh-CN": "Cluster Manager",
-  "description": "Cluster node tracking, task orchestration, worker management, and package distribution",
-  "version": "1.1.10",
-  "license": "Apache-2.0",
-  "main": "./dist/server/index.js",
-  "keywords": [
-    "Monitoring",
-    "DevOps"
-  ],
-  "files": [
-    "dist",
-    "src",
-    "client.js",
-    "server.js",
-    "client.d.ts",
-    "server.d.ts"
-  ],
-  "peerDependencies": {
-    "@nocobase/client": "2.x",
-    "@nocobase/server": "2.x",
-    "@nocobase/database": "2.x"
-  },
-  "dependencies": {
-    "@nocobase/lock-manager": "2.x"
-  },
-  "devDependencies": {
-    "@kubernetes/client-node": "^0.22.3",
-    "dockerode": "^3.3.5",
-    "redis": "^5.10.0",
-    "redlock": "5.0.0-beta.2",
-    "uuid": "^9.0.1"
-  },
-  "nocobase": {
-    "supportedVersions": [
-      "2.x"
-    ],
-    "editionLevel": 0
-  }
+{
+  "name": "plugin-cluster-manager",
+  "displayName": "Cluster Manager",
+  "displayName.zh-CN": "Cluster Manager",
+  "description": "Cluster node tracking, task orchestration, worker management, and package distribution",
+  "version": "1.1.11",
+  "license": "Apache-2.0",
+  "main": "./dist/server/index.js",
+  "keywords": [
+    "Monitoring",
+    "DevOps"
+  ],
+  "files": [
+    "dist",
+    "src",
+    "client.js",
+    "server.js",
+    "client.d.ts",
+    "server.d.ts"
+  ],
+  "peerDependencies": {
+    "@nocobase/client": "2.x",
+    "@nocobase/server": "2.x",
+    "@nocobase/database": "2.x"
+  },
+  "dependencies": {
+    "@nocobase/lock-manager": "2.x"
+  },
+  "devDependencies": {
+    "@kubernetes/client-node": "^0.22.3",
+    "dockerode": "^3.3.5",
+    "redis": "^5.10.0",
+    "redlock": "5.0.0-beta.2",
+    "uuid": "^9.0.1"
+  },
+  "nocobase": {
+    "supportedVersions": [
+      "2.x"
+    ],
+    "editionLevel": 0
+  }
 }

package/server.js

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