plugin-cluster-manager 1.1.11 → 1.1.13

package/src/server/orchestrator/docker-adapter.ts

@@ -17,9 +17,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;
@@ -58,11 +56,7 @@ export class DockerAdapter implements IOrchestratorAdapter {
     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)],
       },
     });
 
@@ -105,9 +99,20 @@ export class DockerAdapter implements IOrchestratorAdapter {
     if (diff > 0) {
       // Scale UP
       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 || [];
+      // Default the worker image to whatever the app container is running, so
+      // workers stay version-locked with the app even when the stack record
+      // has a stale/empty image. An explicit stack.image still wins.
+      let targetImage = stack.image;
+      // Inherit the app container's startup command/entrypoint so workers boot
+      // identically (e.g. source-tarball extraction + `yarn start`). Without
+      // this, a worker created from the bare image runs the image default
+      // command, skips the app's bootstrap, never finishes booting, and never
+      // registers a heartbeat — so it never appears in Cluster Nodes.
+      let inheritedCmd: string[] | undefined;
+      let inheritedEntrypoint: string[] | undefined;
 
       // Auto-detect current container's configuration to inherit networks and env vars
       try {
@@ -115,50 +120,70 @@ export class DockerAdapter implements IOrchestratorAdapter {
         const myContainerId = os.hostname();
         const myContainer = this.docker.getContainer(myContainerId);
         const myInfo = await myContainer.inspect();
-        
+
+        // Inherit the app container's image when the stack does not pin one
+        if (!targetImage && myInfo?.Config?.Image) {
+          targetImage = myInfo.Config.Image;
+          console.log('[DockerAdapter] Inherited image from app container:', targetImage);
+        }
+
         // Always inherit Networks so worker can communicate with main app
         if (myInfo?.NetworkSettings?.Networks) {
           const inheritedNetworks = Object.keys(myInfo.NetworkSettings.Networks);
           targetNetworks = Array.from(new Set([...inheritedNetworks, ...targetNetworks]));
           console.log('[DockerAdapter] Inherited networks:', targetNetworks);
         }
-        
+
         // Inherit Environment Variables and merge with stack.envVars
         if (myInfo?.Config?.Env) {
-           const envDict: Record<string, string> = {};
-           myInfo.Config.Env.forEach((e: string) => {
-             const idx = e.indexOf('=');
-             if (idx !== -1) {
-               envDict[e.substring(0, idx)] = e.substring(idx + 1);
-             }
-           });
-           // Overwrite with explicitly defined env vars
-           Object.assign(envDict, stack.envVars || {});
-           
-           targetEnvVars = Object.entries(envDict).map(([k, v]) => `${k}=${v}`);
+          const envDict: Record<string, string> = {};
+          myInfo.Config.Env.forEach((e: string) => {
+            const idx = e.indexOf('=');
+            if (idx !== -1) {
+              envDict[e.substring(0, idx)] = e.substring(idx + 1);
+            }
+          });
+          // Overwrite with explicitly defined env vars
+          Object.assign(envDict, stack.envVars || {});
+
+          targetEnvVars = Object.entries(envDict).map(([k, v]) => `${k}=${v}`);
         }
         // Inherit Volumes (Binds)
         if (myInfo?.HostConfig?.Binds) {
           const inheritedBinds = myInfo.HostConfig.Binds as string[];
           targetVolumes = Array.from(new Set([...inheritedBinds, ...targetVolumes]));
         }
+        // Inherit the startup Cmd/Entrypoint so the worker runs the same bootstrap
+        // as the app container (used only when the stack pins no explicit command).
+        if (Array.isArray(myInfo?.Config?.Cmd) && myInfo.Config.Cmd.length > 0) {
+          inheritedCmd = myInfo.Config.Cmd as string[];
+        }
+        if (Array.isArray(myInfo?.Config?.Entrypoint) && myInfo.Config.Entrypoint.length > 0) {
+          inheritedEntrypoint = myInfo.Config.Entrypoint as string[];
+        }
       } catch (e: any) {
         // Ignore error if not running in a container or cannot inspect
         console.error('[DockerAdapter] Failed to inherit container config:', e.message);
       }
 
       // Automatically separate logs for workers to prevent log interleaving with the main app
-      const hasLoggerBase = targetEnvVars.some(e => e.startsWith('LOGGER_BASE_PATH='));
+      const hasLoggerBase = targetEnvVars.some((e) => e.startsWith('LOGGER_BASE_PATH='));
       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: any = {
-          Image: stack.image,
+          Image: targetImage,
           name: containerName,
           Env: targetEnvVars,
           Labels: {
@@ -174,6 +199,15 @@ export class DockerAdapter implements IOrchestratorAdapter {
 
         if (stack.command) {
           createOpts.Cmd = ['/bin/sh', '-c', stack.command];
+        } else {
+          // No explicit command: replay the app container's bootstrap so the
+          // worker boots NocoBase the same way and registers a heartbeat.
+          if (inheritedEntrypoint) {
+            createOpts.Entrypoint = inheritedEntrypoint;
+          }
+          if (inheritedCmd) {
+            createOpts.Cmd = inheritedCmd;
+          }
         }
 
         if (stack.resourceLimits?.memory) {
@@ -190,7 +224,7 @@ export class DockerAdapter implements IOrchestratorAdapter {
         createOpts.HostConfig.SecurityOpt = ['no-new-privileges:true'];
 
         const container = await this.docker.createContainer(createOpts);
-        
+
         // Connect to additional networks before starting
         if (targetNetworks.length > 0) {
           const startIndex = targetNetworkMode ? 0 : 1;
@@ -199,7 +233,9 @@ export class DockerAdapter implements IOrchestratorAdapter {
               const net = this.docker.getNetwork(targetNetworks[i]);
               await net.connect({ Container: container.id });
             } catch (err: any) {
-              console.warn(`[DockerAdapter] Failed to connect container ${container.id} to network ${targetNetworks[i]}: ${err.message}`);
+              console.warn(
+                `[DockerAdapter] Failed to connect container ${container.id} to network ${targetNetworks[i]}: ${err.message}`,
+              );
             }
           }
         }
@@ -209,9 +245,7 @@ export class DockerAdapter implements IOrchestratorAdapter {
       }
     } else if (diff < 0) {
       // Scale DOWN — remove newest first (LIFO)
-      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) {
@@ -334,14 +368,17 @@ export class DockerAdapter implements IOrchestratorAdapter {
       .split(',')
       .map((part) => part.trim())
       .filter(Boolean)
-      .reduce((acc, part) => {
-        const [key, ...valueParts] = part.split('=');
-        const value = valueParts.join('=');
-        if (key?.trim() && value?.trim()) {
-          acc[key.trim()] = value.trim();
-        }
-        return acc;
-      }, {} as Record<string, string>);
+      .reduce(
+        (acc, part) => {
+          const [key, ...valueParts] = part.split('=');
+          const value = valueParts.join('=');
+          if (key?.trim() && value?.trim()) {
+            acc[key.trim()] = value.trim();
+          }
+          return acc;
+        },
+        {} as Record<string, string>,
+      );
   }
 
   private labelsMatch(labels: Record<string, string>, expected: Record<string, string>): boolean {

package/src/server/plugin.ts

@@ -7,7 +7,7 @@ import { redisActions } from './actions/redis-monitor';
 import { aclCacheActions, createAclCacheMiddleware } from './actions/acl-cache';
 import { clusterActions, readLocalLogs } from './actions/cluster-nodes';
 import { getRedisClient } from './utils/redis';
-import { getLocalNodeId } from './utils/node';
+import { getLocalNodeId, isWorkerMode } from './utils/node';
 import { eventQueueActions } from './actions/event-queue-monitor';
 import { lockActions } from './actions/lock-monitor';
 import { cacheMonitorActions } from './actions/cache-monitor';
@@ -16,6 +16,7 @@ import { RedisNodeRegistry } from './adapters/redis-node-registry';
 import { RedisLockAdapter } from './adapters/redis-lock-adapter';
 import { orchestratorActions } from './actions/orchestrator';
 import { pluginOperationsActions } from './actions/plugin-operations';
+import { queueMappingsActions } from './actions/queue-mappings';
 import type { IOrchestratorAdapter } from './orchestrator/types';
 import { DockerAdapter } from './orchestrator/docker-adapter';
 import { K8sAdapter } from './orchestrator/k8s-adapter';
@@ -57,11 +58,8 @@ export class PluginClusterManagerServer extends Plugin {
       this.nodeRegistry?.start();
 
       // Automatically install packages on boot for worker nodes
-      const mode = process.env.WORKER_MODE || 'main';
       const isWorker =
-        mode === 'worker' ||
-        mode === 'task' ||
-        mode === '*' ||
+        isWorkerMode(process.env.WORKER_MODE) ||
         process.env.APP_ROLE === 'worker' ||
         process.env.APP_ROLE === 'sandbox';
       if (isWorker) {
@@ -125,9 +123,7 @@ export class PluginClusterManagerServer extends Plugin {
 
     // Workflow hook to trace executing node
     this.app.db.on('executions.afterSave', async (model: any) => {
-      const mode = process.env.WORKER_MODE || 'main';
-      const isWorker = mode === 'worker' || mode === 'task' || mode === '*';
-      if (isWorker) {
+      if (isWorkerMode(process.env.WORKER_MODE)) {
         const id = model.get('id');
         const redis = getRedisClient(this.app);
         if (id && redis) {
@@ -332,6 +328,12 @@ export class PluginClusterManagerServer extends Plugin {
       actions: pluginOperationsActions,
     });
 
+    // Queue Mappings (queue-to-worker-stack assignments)
+    this.app.resourcer.define({
+      name: 'workerQueueMappings',
+      actions: queueMappingsActions,
+    });
+
     // Install ACL cache middleware inside the ACL chain so cached permissions are not overwritten.
     const aclCacheMiddleware = createAclCacheMiddleware(this.app);
     (this.app as any).acl.use(aclCacheMiddleware, {
@@ -380,6 +382,7 @@ export class PluginClusterManagerServer extends Plugin {
         'orchestratorStacks:*',
         'workerPackages:*',
         'clusterManagerPlugins:*',
+        'workerQueueMappings:*',
       ],
     });
 
@@ -558,8 +561,7 @@ export class PluginClusterManagerServer extends Plugin {
   }
 
   private isWorkerOnlyNode(): boolean {
-    const workerMode = process.env.WORKER_MODE || '';
-    return workerMode === 'worker' || workerMode === 'task' || workerMode === '*';
+    return isWorkerMode(process.env.WORKER_MODE);
   }
 }
 

package/src/server/queue-scanner.ts

@@ -0,0 +1,154 @@
+/**
+ * QueueScanner — discovers all registered queues in the system.
+ *
+ * Two sources:
+ *   1. EventQueue events (registered via app.eventQueue.subscribe)
+ *   2. Redis List-based queues (convention *:plugin-*:queue)
+ *
+ * Used by the Queue Assignment UI to let admins map queues to worker stacks.
+ */
+
+import type { Application } from '@nocobase/server';
+import { getRedisClient } from './utils/redis';
+
+export type QueueItem = {
+  name: string;
+  label: string;
+  description: string;
+  type: 'event-queue' | 'redis-list';
+  pending: number | null;
+};
+
+const KNOWN_QUEUE_LABELS: Record<string, { label: string; description: string }> = {
+  '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)',
+  },
+};
+
+/** Redis key patterns for List-based queues (same as event-queue-monitor.ts) */
+const REDIS_QUEUE_PATTERNS = ['*:plugin-git-manager:review:queue', '*:plugin-build-guide-block:build:queue'];
+
+function describeRedisQueueKey(key: string): { label: string; description: string } {
+  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}`,
+  };
+}
+
+/**
+ * Discover all queues from EventQueue subscribers.
+ */
+function scanEventQueue(app: Application): QueueItem[] {
+  const eq = (app as any).eventQueue;
+  if (!eq || !eq.events) return [];
+
+  const events: Map<string, { concurrency?: number; interval?: number; shared?: boolean }> = eq.events;
+  const items: QueueItem[] = [];
+
+  for (const [channel] of events.entries()) {
+    const known = KNOWN_QUEUE_LABELS[channel];
+    items.push({
+      name: channel,
+      label: known?.label ?? channel,
+      description: known?.description ?? `EventQueue channel: ${channel}`,
+      type: 'event-queue',
+      pending: null,
+    });
+  }
+
+  return items;
+}
+
+/**
+ * Discover Redis List-based queues via SCAN.
+ */
+async function scanRedisQueues(app: Application): Promise<QueueItem[]> {
+  const redis = getRedisClient(app);
+  if (!redis) {
+    return [];
+  }
+
+  const seen = new Set<string>();
+  const items: QueueItem[] = [];
+
+  for (const pattern of REDIS_QUEUE_PATTERNS) {
+    try {
+      const keys: string[] = await redis.sendCommand(['SCAN', '0', 'MATCH', pattern, 'COUNT', '200']);
+      const keyList: string[] = typeof keys[1]?.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 {
+      // SCAN not supported or permission denied
+    }
+  }
+
+  return items;
+}
+
+/**
+ * Full queue scan — merges EventQueue + Redis results.
+ */
+export async function scanQueues(app: Application): Promise<{ queues: QueueItem[]; total: number }> {
+  const eventQueues = scanEventQueue(app);
+  const redisQueues = await scanRedisQueues(app);
+
+  // Deduplicate: if a queue name appears in both sources, prefer EventQueue
+  const seenNames = new Set<string>();
+  const merged: QueueItem[] = [];
+
+  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 };
+}

package/src/server/utils/node.ts

@@ -1,5 +1,53 @@
 import os from 'os';
 
+export type NodeRole = 'app' | 'worker' | 'sandbox';
+
+/**
+ * Determine whether a WORKER_MODE value denotes a queue-processing worker
+ * (i.e. a node that does NOT serve HTTP), following NocoBase v2.1.x semantics:
+ *   ''            → app node (serves HTTP + every queue)
+ *   '!'           → app node (serves HTTP only)
+ *   '*'           → worker (serves all queues, no HTTP)
+ *   'a:b,c:d'     → worker (serves the listed queue topics, no HTTP)
+ *   '-'           → transient subprocess (not a long-lived worker)
+ * Legacy literals 'worker' / 'task' are still tolerated for older deployments.
+ * A combined value containing '!' (e.g. '!,workflow:process') still serves
+ * HTTP, so it is treated as an app node.
+ */
+export function isWorkerMode(workerMode?: string): boolean {
+  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;
+}
+
+/**
+ * Resolve a node role from its descriptor. APP_ROLE (explicit) wins, then an
+ * explicit sandbox flag, then WORKER_MODE parsing. Works for both the local
+ * process (pass process.env values) and remote node records read from Redis.
+ */
+export function getNodeRoleFrom(opts: { workerMode?: string; appRole?: string; isSandbox?: boolean }): NodeRole {
+  if (opts.appRole === 'app' || opts.appRole === 'worker' || opts.appRole === 'sandbox') {
+    return opts.appRole;
+  }
+  if (opts.isSandbox) return 'sandbox';
+  return isWorkerMode(opts.workerMode) ? 'worker' : 'app';
+}
+
+/** Resolve the role of the current Node.js process from its environment. */
+export function getLocalRole(): NodeRole {
+  return getNodeRoleFrom({
+    workerMode: process.env.WORKER_MODE,
+    appRole: process.env.APP_ROLE,
+    isSandbox: process.env.SKILL_HUB_SANDBOX === 'true',
+  });
+}
+
 /**
  * Generate a universally unique identifier for this specific Node.js process.
  * Combines app name, worker mode, hostname, port, and PID to ensure uniqueness

package/dist/client/AclCacheManager.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function AclCacheManager(): React.JSX.Element;

package/dist/client/CacheMonitor.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function CacheMonitor(): React.JSX.Element;

package/dist/client/ClusterManagerLayout.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function ClusterManagerLayout(): React.JSX.Element;

package/dist/client/ClusterNodes.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function ClusterNodes(): React.JSX.Element;

package/dist/client/ContainerOrchestrator.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function ContainerOrchestrator(): React.JSX.Element;

package/dist/client/Doctor.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function Doctor(): React.JSX.Element;

package/dist/client/EventQueueMonitor.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function EventQueueMonitor(): React.JSX.Element;

package/dist/client/LockMonitor.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function LockMonitor(): React.JSX.Element;

package/dist/client/NginxCacheManager.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function NginxCacheManager(): React.JSX.Element;

package/dist/client/PackageInstaller.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare const PackageInstaller: React.FC;

package/dist/client/PluginOperations.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function PluginOperations(): React.JSX.Element;

package/dist/client/RedisMonitor.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function RedisMonitor(): React.JSX.Element;

package/dist/client/TaskManager.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function TaskManager(): React.JSX.Element;

package/dist/client/WorkflowExecutions.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function WorkflowExecutions(): React.JSX.Element;

package/dist/client/index.d.ts

@@ -1,5 +0,0 @@
-import { Plugin } from '@nocobase/client';
-export declare class PluginClusterManagerClient extends Plugin {
-    load(): Promise<void>;
-}
-export default PluginClusterManagerClient;

package/dist/client/utils/clientSafeCache.d.ts

@@ -1,3 +0,0 @@
-import { APIClient } from '@nocobase/client';
-export declare function clearClientCache(): void;
-export declare function setupClientSafeCache(apiClient: APIClient): void;

package/dist/client/utils/requestDedupInterceptor.d.ts

@@ -1,2 +0,0 @@
-import { APIClient } from '@nocobase/client';
-export declare function setupRequestDedupAndCache(apiClient: APIClient): void;

package/dist/client/utils.d.ts

@@ -1,12 +0,0 @@
-/**
- * Shared i18n hook for the cluster-manager plugin.
- */
-export declare function useT(): (key: string) => string;
-/**
- * Format bytes into human-readable string (B, KB, MB, GB).
- */
-export declare function formatBytes(bytes: number): string;
-/**
- * Format seconds into human-readable uptime string (e.g., "2d 5h 30m").
- */
-export declare function formatUptime(seconds: number): string;

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export * from './server';
-export { default } from './server';

package/dist/server/actions/acl-cache.d.ts

@@ -1,53 +0,0 @@
-import { Context } from '@nocobase/actions';
-/**
- * In-memory ACL stats counter.
- * Tracks total checks, cache hits/misses per role:resource:action.
- */
-export interface AclCacheStats {
-    totalChecks: number;
-    cacheHits: number;
-    cacheMisses: number;
-    startedAt: string;
-    detailByRole: Record<string, {
-        checks: number;
-        hits: number;
-        misses: number;
-    }>;
-}
-/**
- * Middleware that caches the permission object computed by the ACL middleware.
- * Install via: app.acl.use(aclCacheMiddleware, { tag: 'aclCache', before: 'core', after: 'allow-manager' })
- *
- * FIX: Previously monkey-patched ctx.app.acl.can per-request, which is a race condition
- * because acl is a shared singleton across concurrent requests. Now we use a post-check
- * approach that reads from cache first and writes after the ACL middleware runs, without
- * ever replacing the shared acl.can method.
- */
-export declare function createAclCacheMiddleware(app: any): (ctx: Context, next: () => Promise<void>) => Promise<void>;
-export declare const aclCacheActions: {
-    /**
-     * GET /clusterManagerAclCache:stats
-     * Returns ACL cache hit/miss statistics
-     */
-    stats(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerAclCache:listKeys
-     * Lists all cached ACL permission keys
-     */
-    listKeys(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /clusterManagerAclCache:clear
-     * Clear all ACL cache entries and reset stats
-     */
-    clear(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /clusterManagerAclCache:resetStats
-     * Reset the in-memory ACL stats counters
-     */
-    resetStats(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /clusterManagerAclCache:clearRole
-     * Clear ACL cache entries for a specific role
-     */
-    clearRole(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

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

@@ -1,33 +0,0 @@
-import { Context } from '@nocobase/actions';
-export declare const cacheMonitorActions: {
-    /**
-     * GET /clusterManagerCacheMgr:stores
-     * List all registered cache stores and their config
-     */
-    stores(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerCacheMgr:caches
-     * List all created named caches
-     */
-    caches(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerCacheMgr:redisMemory
-     * Get Redis memory usage for cache keys
-     */
-    redisMemory(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /clusterManagerCacheMgr:flushAll
-     * Flush all caches via CacheManager
-     */
-    flushAll(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerCacheMgr:nginxCacheStatus
-     * Detect if Nginx is installed, locate conf, and auto-load cache paths
-     */
-    nginxCacheStatus(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /clusterManagerCacheMgr:clearNginxCache
-     * Clear physical cache files or send an HTTP Purge request
-     */
-    clearNginxCache(ctx: Context, next: () => Promise<void>): Promise<void>;
-};