plugin-cluster-manager 1.0.12

package/dist/server/actions/cluster-nodes.js

@@ -0,0 +1,351 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cluster_nodes_exports = {};
+__export(cluster_nodes_exports, {
+  clusterActions: () => clusterActions,
+  readLocalLogs: () => readLocalLogs
+});
+module.exports = __toCommonJS(cluster_nodes_exports);
+var import_server = require("@nocobase/server");
+var import_os = __toESM(require("os"));
+var import_fs = require("fs");
+var import_path = __toESM(require("path"));
+var import_crypto = __toESM(require("crypto"));
+var import_redis_node_registry = require("../adapters/redis-node-registry");
+var import_redis = require("../utils/redis");
+var import_node = require("../utils/node");
+const LOG_RESPONSE_KEY_PREFIX = "cluster-manager:log-response:";
+const LOG_RESPONSE_TTL = 30;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function readLocalLogs(app, maxLines) {
+  const logBasePath = process.env.LOGGER_BASE_PATH || import_path.default.resolve(process.cwd(), "storage", "logs");
+  const appName = process.env.APP_NAME || app.name || "main";
+  const logDir = import_path.default.resolve(logBasePath, appName);
+  let logFiles = [];
+  try {
+    const files = await import_fs.promises.readdir(logDir);
+    logFiles = files.filter((f) => f.startsWith("system") && f.endsWith(".log") && !f.includes("error")).sort().reverse();
+  } catch {
+  }
+  const nodeInfo = {
+    hostname: import_os.default.hostname(),
+    pid: process.pid,
+    workerMode: process.env.WORKER_MODE || "main"
+  };
+  if (logFiles.length === 0) {
+    return { node: nodeInfo, lines: [], file: null };
+  }
+  const logFilePath = import_path.default.resolve(logDir, logFiles[0]);
+  const result = [];
+  try {
+    const stat = await import_fs.promises.stat(logFilePath);
+    const bufferSize = Math.min(stat.size, maxLines * 2048);
+    const buffer = Buffer.alloc(bufferSize);
+    const fh = await import_fs.promises.open(logFilePath, "r");
+    await fh.read(buffer, 0, bufferSize, Math.max(0, stat.size - bufferSize));
+    await fh.close();
+    const content = buffer.toString("utf8");
+    const allLines = content.split("\n").filter((l) => l.trim());
+    result.push(...allLines.slice(-maxLines));
+  } catch {
+  }
+  return { node: nodeInfo, lines: result, file: logFiles[0] };
+}
+const clusterActions = {
+  /**
+   * GET /clusterManagerCluster:current
+   * Always returns info about the APP node (not workers).
+   * If this request is handled by a worker, we look up the APP node from Redis.
+   */
+  async current(ctx, next) {
+    var _a, _b;
+    const currentMode = process.env.WORKER_MODE || "main";
+    const isApp = currentMode === "main" || currentMode === "" || currentMode === "app";
+    if (isApp) {
+      const mem = process.memoryUsage();
+      ctx.body = {
+        node: {
+          hostname: import_os.default.hostname(),
+          pid: process.pid,
+          nodeVersion: process.version,
+          platform: process.platform,
+          arch: process.arch,
+          uptime: process.uptime(),
+          workerMode: currentMode,
+          appPort: process.env.APP_PORT || "",
+          clusterMode: process.env.CLUSTER_MODE || ""
+        },
+        memory: {
+          rss: mem.rss,
+          heapUsed: mem.heapUsed,
+          heapTotal: mem.heapTotal,
+          external: mem.external,
+          arrayBuffers: mem.arrayBuffers || 0
+        },
+        os: {
+          totalMemory: import_os.default.totalmem(),
+          freeMemory: import_os.default.freemem(),
+          cpuCount: import_os.default.cpus().length,
+          loadAvg: import_os.default.loadavg()
+        }
+      };
+    } else {
+      const plugin = (_b = (_a = ctx.app.pm) == null ? void 0 : _a.get) == null ? void 0 : _b.call(_a, "plugin-cluster-manager");
+      const registry = (plugin == null ? void 0 : plugin.nodeRegistry) ?? new import_redis_node_registry.RedisNodeRegistry(ctx.app);
+      const nodes = await registry.getNodes();
+      const appNode = nodes.find(
+        (n) => n.workerMode === "main" || n.workerMode === "" || n.workerMode === "app"
+      );
+      if (appNode == null ? void 0 : appNode.nodeDetails) {
+        ctx.body = appNode.nodeDetails;
+      } else {
+        const mem = process.memoryUsage();
+        ctx.body = {
+          node: {
+            hostname: import_os.default.hostname(),
+            pid: process.pid,
+            nodeVersion: process.version,
+            platform: process.platform,
+            arch: process.arch,
+            uptime: process.uptime(),
+            workerMode: currentMode,
+            appPort: process.env.APP_PORT || "",
+            clusterMode: process.env.CLUSTER_MODE || ""
+          },
+          memory: {
+            rss: mem.rss,
+            heapUsed: mem.heapUsed,
+            heapTotal: mem.heapTotal,
+            external: mem.external,
+            arrayBuffers: mem.arrayBuffers || 0
+          },
+          os: {
+            totalMemory: import_os.default.totalmem(),
+            freeMemory: import_os.default.freemem(),
+            cpuCount: import_os.default.cpus().length,
+            loadAvg: import_os.default.loadavg()
+          },
+          _fallback: true,
+          _note: "APP node not found in Redis; showing responding worker data"
+        };
+      }
+    }
+    await next();
+  },
+  /**
+   * GET /clusterManagerCluster:list
+   * Returns all known cluster environments/nodes (if discovery adapter supports it)
+   */
+  async list(ctx, next) {
+    var _a, _b;
+    const supervisor = import_server.AppSupervisor.getInstance();
+    const environments = [];
+    const plugin = (_b = (_a = ctx.app.pm) == null ? void 0 : _a.get) == null ? void 0 : _b.call(_a, "plugin-cluster-manager");
+    const registry = (plugin == null ? void 0 : plugin.nodeRegistry) ?? new import_redis_node_registry.RedisNodeRegistry(ctx.app);
+    const nodes = await registry.getNodes();
+    if (nodes && nodes.length > 0) {
+      for (const env of nodes) {
+        environments.push({
+          id: env.id || env.name,
+          name: env.name,
+          hostname: env.hostname || import_os.default.hostname(),
+          url: env.url,
+          available: env.available,
+          appVersion: env.appVersion,
+          lastHeartbeatAt: env.lastHeartbeatAt ? new Date(env.lastHeartbeatAt).toISOString() : null,
+          status: env.status || "online",
+          workerMode: env.workerMode,
+          isSandbox: env.isSandbox,
+          pid: env.pid
+        });
+      }
+    }
+    if (environments.length === 0) {
+      environments.push({
+        name: import_os.default.hostname(),
+        hostname: import_os.default.hostname(),
+        url: null,
+        available: true,
+        appVersion: null,
+        lastHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "online"
+      });
+    }
+    ctx.body = { data: environments, meta: { count: environments.length } };
+    await next();
+  },
+  /**
+   * GET /clusterManagerCluster:health
+   * Health check for all subsystems
+   */
+  async health(ctx, next) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    const checks = {};
+    try {
+      const redis = (0, import_redis.getRedis)(ctx);
+      if (redis) {
+        const start = Date.now();
+        await redis.ping();
+        checks.redis = { status: "ok", latency: Date.now() - start };
+      } else {
+        checks.redis = { status: "not_configured" };
+      }
+    } catch (e) {
+      checks.redis = { status: "error", detail: e.message };
+    }
+    try {
+      const start = Date.now();
+      await ctx.db.sequelize.query("SELECT 1");
+      checks.database = { status: "ok", latency: Date.now() - start };
+    } catch (e) {
+      checks.database = { status: "error", detail: e.message };
+    }
+    try {
+      const connected = await ((_a = ctx.app.pubSubManager) == null ? void 0 : _a.isConnected());
+      const pubSubAdapter = (_b = ctx.app.pubSubManager) == null ? void 0 : _b.adapter;
+      checks.pubsub = {
+        status: connected ? "connected" : "disconnected",
+        detail: ((_c = pubSubAdapter == null ? void 0 : pubSubAdapter.constructor) == null ? void 0 : _c.name) || "no adapter"
+      };
+    } catch (e) {
+      checks.pubsub = { status: "error", detail: e.message };
+    }
+    try {
+      const connected = (_d = ctx.app.eventQueue) == null ? void 0 : _d.isConnected();
+      const adapterType = ((_g = (_f = (_e = ctx.app.eventQueue) == null ? void 0 : _e.adapter) == null ? void 0 : _f.constructor) == null ? void 0 : _g.name) || "unknown";
+      checks.eventQueue = {
+        status: connected ? "connected" : "disconnected",
+        detail: adapterType
+      };
+    } catch (e) {
+      checks.eventQueue = { status: "error", detail: e.message };
+    }
+    try {
+      const lockOptions = (_h = ctx.app.lockManager) == null ? void 0 : _h.options;
+      const adapterType = (lockOptions == null ? void 0 : lockOptions.defaultAdapter) || "local";
+      checks.lockManager = { status: "ok", detail: `adapter: ${adapterType}` };
+    } catch (e) {
+      checks.lockManager = { status: "error", detail: e.message };
+    }
+    try {
+      const defaultStore = ((_i = ctx.app.cacheManager) == null ? void 0 : _i.defaultStore) || "memory";
+      checks.cache = { status: "ok", detail: `store: ${defaultStore}` };
+    } catch (e) {
+      checks.cache = { status: "error", detail: e.message };
+    }
+    const allOk = Object.values(checks).every(
+      (c) => c.status === "ok" || c.status === "connected" || c.status === "not_configured"
+    );
+    ctx.body = { healthy: allOk, checks };
+    await next();
+  },
+  /**
+   * POST /clusterManagerCluster:restart
+   * Publishes a restart signal to target nodes orchestrating a soft NocoBase restart or a hard docker daemon rebirth
+   */
+  async restart(ctx, next) {
+    const { hostname, mode = "hard" } = ctx.action.params.values || ctx.action.params;
+    if (!hostname) ctx.throw(400, "Hostname required");
+    if (ctx.app.pubSubManager) {
+      await ctx.app.pubSubManager.publish("cluster-manager:restart", JSON.stringify({ hostname, mode }));
+      ctx.body = { success: true, target: hostname, mode };
+    } else {
+      ctx.throw(500, "PubSub manager is not initialized. HA requires PUBSUB_ADAPTER_REDIS_URL to be set.");
+    }
+    await next();
+  },
+  /**
+   * GET /clusterManagerCluster:logs?targetNodeId=xxx&lines=200
+   *
+   * HA-aware log viewer. Reads logs from a specific node in the cluster.
+   *
+   * Flow:
+   *  1. If targetNodeId matches current node (or is empty) → read local FS directly
+   *  2. Otherwise → publish a log request via PubSub → target node reads its local FS
+   *     and writes the result to a Redis key → this handler polls Redis until the
+   *     response arrives (max 10s) → returns it to the client
+   */
+  async logs(ctx, next) {
+    const { lines = 200, targetNodeId } = ctx.action.params;
+    const maxLines = Math.min(Number(lines) || 200, 1e3);
+    const myNodeId = (0, import_node.getLocalNodeId)(ctx.app);
+    if (!targetNodeId || targetNodeId === myNodeId) {
+      ctx.body = await readLocalLogs(ctx.app, maxLines);
+      await next();
+      return;
+    }
+    const redis = (0, import_redis.getRedis)(ctx);
+    const pubSub = ctx.app.pubSubManager;
+    if (!redis || !pubSub) {
+      const localResult = await readLocalLogs(ctx.app, maxLines);
+      localResult._fallback = true;
+      localResult._note = `PubSub/Redis not available; showing logs from local node instead of ${targetNodeId}`;
+      ctx.body = localResult;
+      await next();
+      return;
+    }
+    const requestId = import_crypto.default.randomBytes(8).toString("hex");
+    const responseKey = `${LOG_RESPONSE_KEY_PREFIX}${requestId}`;
+    await pubSub.publish(
+      `cluster-manager:log-request:${targetNodeId}`,
+      JSON.stringify({ requestId, targetNodeId, lines: maxLines })
+    );
+    let responseData = null;
+    for (let i = 0; i < 50; i++) {
+      await sleep(200);
+      try {
+        const raw = await redis.sendCommand(["GET", responseKey]);
+        if (raw) {
+          responseData = JSON.parse(raw);
+          redis.sendCommand(["DEL", responseKey]).catch(() => {
+          });
+          break;
+        }
+      } catch {
+      }
+    }
+    if (responseData) {
+      ctx.body = responseData;
+    } else {
+      ctx.body = {
+        node: { hostname: "unknown", pid: null, workerMode: "unknown", id: targetNodeId },
+        lines: [],
+        file: null,
+        _error: `Timeout waiting for logs from ${targetNodeId}. Node may be offline or PubSub is not connected.`
+      };
+    }
+    await next();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clusterActions,
+  readLocalLogs
+});

package/dist/server/actions/event-queue-monitor.d.ts

@@ -0,0 +1,13 @@
+import { Context } from '@nocobase/actions';
+export declare const eventQueueActions: {
+    /**
+     * GET /clusterManagerQueue:stats
+     * Returns event queue statistics
+     */
+    stats(ctx: Context, next: () => Promise<void>): Promise<void>;
+    /**
+     * GET /clusterManagerQueue:messages
+     * List pending messages in a specific channel (memory adapter only)
+     */
+    messages(ctx: Context, next: () => Promise<void>): Promise<void>;
+};

package/dist/server/actions/event-queue-monitor.js

@@ -0,0 +1,111 @@
+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 event_queue_monitor_exports = {};
+__export(event_queue_monitor_exports, {
+  eventQueueActions: () => eventQueueActions
+});
+module.exports = __toCommonJS(event_queue_monitor_exports);
+const eventQueueActions = {
+  /**
+   * GET /clusterManagerQueue:stats
+   * Returns event queue statistics
+   */
+  async stats(ctx, next) {
+    var _a;
+    const eq = ctx.app.eventQueue;
+    if (!eq) {
+      ctx.throw(503, "Event queue is not available");
+    }
+    const adapter = eq.adapter;
+    const events = eq.events;
+    const adapterName = ((_a = adapter == null ? void 0 : adapter.constructor) == null ? void 0 : _a.name) || "unknown";
+    const connected = eq.isConnected();
+    const channels = [];
+    if (events) {
+      for (const [channel, opts] of events.entries()) {
+        const queueData = { channel };
+        queueData.concurrency = opts.concurrency || 1;
+        queueData.interval = opts.interval || 250;
+        if (adapter == null ? void 0 : adapter.queues) {
+          const fullChannel = eq.getFullChannel(channel, opts.shared);
+          const queue = adapter.queues.get(fullChannel);
+          queueData.pending = (queue == null ? void 0 : queue.length) || 0;
+        } else {
+          queueData.pending = null;
+        }
+        channels.push(queueData);
+      }
+    }
+    const totalPending = channels.reduce((sum, c) => sum + (c.pending || 0), 0);
+    ctx.body = {
+      adapter: adapterName,
+      connected,
+      totalChannels: channels.length,
+      totalPending,
+      channels
+    };
+    await next();
+  },
+  /**
+   * GET /clusterManagerQueue:messages
+   * List pending messages in a specific channel (memory adapter only)
+   */
+  async messages(ctx, next) {
+    var _a;
+    const eq = ctx.app.eventQueue;
+    if (!eq) {
+      ctx.throw(503, "Event queue is not available");
+    }
+    const { channel, page = 1, pageSize = 20 } = ctx.action.params;
+    const adapter = eq.adapter;
+    if (!(adapter == null ? void 0 : adapter.queues)) {
+      ctx.body = {
+        data: [],
+        meta: { count: 0, page: 1, pageSize: 20, note: "Message inspection not available for this adapter" }
+      };
+      await next();
+      return;
+    }
+    const events = eq.events;
+    let fullChannel = channel;
+    if (events == null ? void 0 : events.has(channel)) {
+      fullChannel = eq.getFullChannel(channel, (_a = events.get(channel)) == null ? void 0 : _a.shared);
+    }
+    const queue = adapter.queues.get(fullChannel) || [];
+    const start = (Number(page) - 1) * Number(pageSize);
+    const slice = queue.slice(start, start + Number(pageSize));
+    ctx.body = {
+      data: slice.map((msg) => {
+        var _a2, _b, _c;
+        return {
+          id: msg.id,
+          content: msg.content,
+          timestamp: (_a2 = msg.options) == null ? void 0 : _a2.timestamp,
+          retried: ((_b = msg.options) == null ? void 0 : _b.retried) || 0,
+          maxRetries: ((_c = msg.options) == null ? void 0 : _c.maxRetries) || 0
+        };
+      }),
+      meta: { count: queue.length, page: Number(page), pageSize: Number(pageSize) }
+    };
+    await next();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  eventQueueActions
+});

package/dist/server/actions/lock-monitor.d.ts

@@ -0,0 +1,19 @@
+import { Context } from '@nocobase/actions';
+export declare const lockActions: {
+    /**
+     * GET /clusterManagerLock:info
+     * Returns lock manager info
+     */
+    info(ctx: Context, next: () => Promise<void>): Promise<void>;
+    /**
+     * GET /clusterManagerLock:list
+     * List active locks
+     */
+    list(ctx: Context, next: () => Promise<void>): Promise<void>;
+    /**
+     * POST /clusterManagerLock:release
+     * Force release a stuck lock (admin emergency action)
+     * Uses compare-and-swap via DEL for Redis locks with the correct key prefix.
+     */
+    release(ctx: Context, next: () => Promise<void>): Promise<void>;
+};

package/dist/server/actions/lock-monitor.js

@@ -0,0 +1,169 @@
+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 lock_monitor_exports = {};
+__export(lock_monitor_exports, {
+  lockActions: () => lockActions
+});
+module.exports = __toCommonJS(lock_monitor_exports);
+var import_redis = require("../utils/redis");
+const REDIS_LOCK_PREFIX = "nocobase:lock:";
+function getRedis(ctx) {
+  var _a;
+  return (_a = ctx.app.redisConnectionManager) == null ? void 0 : _a.getConnection();
+}
+const lockActions = {
+  /**
+   * GET /clusterManagerLock:info
+   * Returns lock manager info
+   */
+  async info(ctx, next) {
+    var _a, _b, _c, _d;
+    const lm = ctx.app.lockManager;
+    if (!lm) {
+      ctx.throw(503, "Lock manager is not available");
+    }
+    const options = lm.options || {};
+    const adapterType = options.defaultAdapter || "local";
+    let activeLocks = 0;
+    if (adapterType === "local") {
+      try {
+        const adapter = (_b = (_a = lm.adapters) == null ? void 0 : _a.get) == null ? void 0 : _b.call(_a, "local");
+        const lockMap = (_c = adapter == null ? void 0 : adapter.constructor) == null ? void 0 : _c.locks;
+        if (lockMap instanceof Map) {
+          for (const mutex of lockMap.values()) {
+            if ((_d = mutex.isLocked) == null ? void 0 : _d.call(mutex)) activeLocks++;
+          }
+        }
+      } catch {
+      }
+    } else {
+      try {
+        const redis = getRedis(ctx);
+        if (redis) {
+          const keys = await (0, import_redis.scanKeys)(redis, `${REDIS_LOCK_PREFIX}*`);
+          activeLocks = keys.length;
+        }
+      } catch {
+      }
+    }
+    ctx.body = {
+      adapter: adapterType,
+      activeLocks
+    };
+    await next();
+  },
+  /**
+   * GET /clusterManagerLock:list
+   * List active locks
+   */
+  async list(ctx, next) {
+    var _a, _b, _c, _d;
+    const lm = ctx.app.lockManager;
+    if (!lm) {
+      ctx.throw(503, "Lock manager is not available");
+    }
+    const options = lm.options || {};
+    const adapterType = options.defaultAdapter || "local";
+    const locks = [];
+    if (adapterType === "local") {
+      try {
+        const adapter = (_b = (_a = lm.adapters) == null ? void 0 : _a.get) == null ? void 0 : _b.call(_a, "local");
+        const lockMap = (_c = adapter == null ? void 0 : adapter.constructor) == null ? void 0 : _c.locks;
+        if (lockMap instanceof Map) {
+          for (const [key, mutex] of lockMap.entries()) {
+            if ((_d = mutex.isLocked) == null ? void 0 : _d.call(mutex)) {
+              locks.push({ key, locked: true, ttl: null, adapter: "local" });
+            }
+          }
+        }
+      } catch {
+      }
+    } else {
+      try {
+        const redis = getRedis(ctx);
+        if (redis) {
+          const keys = await (0, import_redis.scanKeys)(redis, `${REDIS_LOCK_PREFIX}*`);
+          for (const key of keys) {
+            const ttl = await redis.sendCommand(["PTTL", key]);
+            locks.push({
+              key,
+              displayKey: key.replace(REDIS_LOCK_PREFIX, ""),
+              locked: true,
+              ttl: ttl > 0 ? ttl : null,
+              adapter: "redis"
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    ctx.body = { data: locks, meta: { count: locks.length } };
+    await next();
+  },
+  /**
+   * POST /clusterManagerLock:release
+   * Force release a stuck lock (admin emergency action)
+   * Uses compare-and-swap via DEL for Redis locks with the correct key prefix.
+   */
+  async release(ctx, next) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    const { key } = ctx.action.params.values || ctx.action.params;
+    if (!key) {
+      ctx.throw(400, "Lock key is required");
+    }
+    const lm = ctx.app.lockManager;
+    const options = lm.options || {};
+    const adapterType = options.defaultAdapter || "local";
+    let released = false;
+    const user = ((_b = (_a = ctx.state) == null ? void 0 : _a.currentUser) == null ? void 0 : _b.nickname) || ((_d = (_c = ctx.state) == null ? void 0 : _c.currentUser) == null ? void 0 : _d.id) || "unknown";
+    ctx.app.logger.warn(`[cluster-manager] Force releasing lock "${key}" by user ${user}`);
+    if (adapterType === "local") {
+      try {
+        const adapter = (_f = (_e = lm.adapters) == null ? void 0 : _e.get) == null ? void 0 : _f.call(_e, "local");
+        const lockMap = (_g = adapter == null ? void 0 : adapter.constructor) == null ? void 0 : _g.locks;
+        if (lockMap instanceof Map && lockMap.has(key)) {
+          const mutex = lockMap.get(key);
+          if ((_h = mutex.isLocked) == null ? void 0 : _h.call(mutex)) {
+            (_i = mutex.release) == null ? void 0 : _i.call(mutex);
+          }
+          lockMap.delete(key);
+          released = true;
+        }
+      } catch {
+      }
+    } else {
+      try {
+        const redis = getRedis(ctx);
+        if (redis) {
+          let result = await redis.sendCommand(["DEL", key]);
+          if (Number(result) === 0 && !key.startsWith(REDIS_LOCK_PREFIX)) {
+            result = await redis.sendCommand(["DEL", `${REDIS_LOCK_PREFIX}${key}`]);
+          }
+          released = Number(result) > 0;
+        }
+      } catch {
+      }
+    }
+    ctx.body = { success: released };
+    await next();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  lockActions
+});