plugin-cluster-manager 1.1.5 → 1.1.6

package/src/server/actions/event-queue-monitor.ts

@@ -1,95 +1,234 @@
-import { Context } from '@nocobase/actions';
-
-export const eventQueueActions = {
-  /**
-   * GET /clusterManagerQueue:stats
-   * Returns event queue statistics
-   */
-  async stats(ctx: Context, next: () => Promise<void>) {
-    const eq = ctx.app.eventQueue;
-    if (!eq) {
-      ctx.throw(503, 'Event queue is not available');
-    }
-
-    const adapter = (eq as any).adapter;
-    const events = (eq as any).events as Map<string, any>;
-    const adapterName = adapter?.constructor?.name || 'unknown';
-    const connected = eq.isConnected();
-
-    const channels: any[] = [];
-    if (events) {
-      for (const [channel, opts] of events.entries()) {
-        const queueData: any = { channel };
-        queueData.concurrency = opts.concurrency || 1;
-        queueData.interval = opts.interval || 250;
-
-        // For MemoryEventQueueAdapter, we can peek at queue depth
-        if (adapter?.queues) {
-          const fullChannel = eq.getFullChannel(channel, opts.shared);
-          const queue = adapter.queues.get(fullChannel);
-          queueData.pending = queue?.length || 0;
-        } else {
-          queueData.pending = null; // Unknown for external adapters
-        }
-
-        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: Context, next: () => Promise<void>) {
-    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 as any).adapter;
-
-    if (!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 as any).events as Map<string, any>;
-    let fullChannel = channel;
-    if (events?.has(channel)) {
-      fullChannel = eq.getFullChannel(channel, events.get(channel)?.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: any) => ({
-        id: msg.id,
-        content: msg.content,
-        timestamp: msg.options?.timestamp,
-        retried: msg.options?.retried || 0,
-        maxRetries: msg.options?.maxRetries || 0,
-      })),
-      meta: { count: queue.length, page: Number(page), pageSize: Number(pageSize) },
-    };
-    await next();
-  },
-};
+import { Context } from '@nocobase/actions';
+import { scanKeys } from '../utils/redis';
+
+const REDIS_QUEUE_CONNECTION = 'cluster-manager:queue-monitor';
+const REDIS_QUEUE_PATTERNS = ['*:plugin-git-manager:review:queue', '*:plugin-build-guide-block:build:queue'];
+
+function getQueueRedisUrl() {
+  return process.env.QUEUE_ADAPTER_REDIS_URL || process.env.REDIS_URL;
+}
+
+async function getQueueRedis(ctx: Context) {
+  const url = getQueueRedisUrl();
+  const manager = (ctx.app as any).redisConnectionManager;
+  if (!url || !manager?.getConnectionSync) {
+    return null;
+  }
+  return manager.getConnectionSync(REDIS_QUEUE_CONNECTION, { connectionString: url });
+}
+
+function knownRedisQueueKeys(ctx: Context) {
+  const appName = (ctx.app as any).name || process.env.APP_NAME || 'main';
+  return [`${appName}:plugin-git-manager:review:queue`, `${appName}:plugin-build-guide-block:build:queue`];
+}
+
+function isKnownRedisQueueKey(key: string) {
+  return REDIS_QUEUE_PATTERNS.some((pattern) => {
+    const suffix = pattern.replace('*:', '');
+    return key === suffix || key.endsWith(`:${suffix}`);
+  });
+}
+
+function describeRedisQueueKey(key: string) {
+  const parts = String(key).split(':');
+  const queue = parts[parts.length - 2] || key;
+  const plugin = parts[parts.length - 3] || 'unknown';
+  const appName = parts.slice(0, Math.max(1, parts.length - 3)).join(':') || 'main';
+  return {
+    appName,
+    plugin,
+    queue,
+    channel: `${plugin}.${queue}`,
+  };
+}
+
+async function getRedisQueues(ctx: Context) {
+  const redis = await getQueueRedis(ctx);
+  if (!redis) {
+    return {
+      connected: false,
+      urlConfigured: Boolean(getQueueRedisUrl()),
+      queues: [],
+      note: 'Redis queue connection is not configured',
+    };
+  }
+
+  const keys = new Set<string>(knownRedisQueueKeys(ctx));
+  for (const pattern of REDIS_QUEUE_PATTERNS) {
+    try {
+      const scanned = await scanKeys(redis, pattern, 200);
+      scanned.forEach((key) => keys.add(key));
+    } catch {
+      // Keep known keys even if SCAN is not available.
+    }
+  }
+
+  const queues = [];
+  for (const key of keys) {
+    if (!isKnownRedisQueueKey(key)) continue;
+    let pending = 0;
+    try {
+      pending = Number(await redis.sendCommand(['LLEN', key])) || 0;
+    } catch {
+      pending = 0;
+    }
+    queues.push({
+      source: 'redis',
+      key,
+      type: 'list',
+      pending,
+      ...describeRedisQueueKey(key),
+    });
+  }
+
+  return {
+    connected: true,
+    urlConfigured: true,
+    queues,
+    totalPending: queues.reduce((sum, queue) => sum + (queue.pending || 0), 0),
+  };
+}
+
+function parseRedisQueueMessage(raw: string, key: string, index: number) {
+  let content: any = raw;
+  try {
+    content = JSON.parse(raw);
+  } catch {
+    // Keep the raw string for non-JSON messages.
+  }
+  const queuedAt = content?.queuedAt ? Date.parse(content.queuedAt) : null;
+  return {
+    id: `${key}:${index}`,
+    index,
+    content,
+    raw,
+    timestamp: Number.isFinite(queuedAt) ? queuedAt : null,
+  };
+}
+
+export const eventQueueActions = {
+  /**
+   * GET /clusterManagerQueue:stats
+   * Returns event queue statistics
+   */
+  async stats(ctx: Context, next: () => Promise<void>) {
+    const eq = ctx.app.eventQueue;
+    if (!eq) {
+      ctx.throw(503, 'Event queue is not available');
+    }
+
+    const adapter = (eq as any).adapter;
+    const events = (eq as any).events as Map<string, any>;
+    const adapterName = adapter?.constructor?.name || 'unknown';
+    const connected = eq.isConnected();
+
+    const channels: any[] = [];
+    if (events) {
+      for (const [channel, opts] of events.entries()) {
+        const queueData: any = { channel };
+        queueData.concurrency = opts.concurrency || 1;
+        queueData.interval = opts.interval || 250;
+
+        // For MemoryEventQueueAdapter, we can peek at queue depth
+        if (adapter?.queues) {
+          const fullChannel = eq.getFullChannel(channel, opts.shared);
+          const queue = adapter.queues.get(fullChannel);
+          queueData.pending = queue?.length || 0;
+        } else {
+          queueData.pending = null; // Unknown for external adapters
+        }
+
+        channels.push(queueData);
+      }
+    }
+
+    const totalPending = channels.reduce((sum, c) => sum + (c.pending || 0), 0);
+    const redisQueues = await getRedisQueues(ctx);
+
+    ctx.body = {
+      adapter: adapterName,
+      connected,
+      totalChannels: channels.length,
+      totalPending,
+      redisQueues,
+      channels,
+    };
+    await next();
+  },
+
+  /**
+   * GET /clusterManagerQueue:messages
+   * List pending messages in a specific channel (memory adapter only)
+   */
+  async messages(ctx: Context, next: () => Promise<void>) {
+    const eq = ctx.app.eventQueue;
+    if (!eq) {
+      ctx.throw(503, 'Event queue is not available');
+    }
+
+    const { channel, key, source, page = 1, pageSize = 20 } = ctx.action.params;
+    if (source === 'redis') {
+      const redisKey = String(key || channel || '');
+      if (!redisKey || !isKnownRedisQueueKey(redisKey)) {
+        ctx.throw(400, 'Invalid Redis queue key');
+      }
+
+      const redis = await getQueueRedis(ctx);
+      if (!redis) {
+        ctx.body = {
+          data: [],
+          meta: { count: 0, page: 1, pageSize: 20, note: 'Redis queue connection is not configured' },
+        };
+        await next();
+        return;
+      }
+
+      const currentPage = Number(page);
+      const currentPageSize = Number(pageSize);
+      const start = (currentPage - 1) * currentPageSize;
+      const end = start + currentPageSize - 1;
+      const count = Number(await redis.sendCommand(['LLEN', redisKey])) || 0;
+      const rows = (await redis.sendCommand(['LRANGE', redisKey, String(start), String(end)])) as string[];
+
+      ctx.body = {
+        data: rows.map((raw, offset) => parseRedisQueueMessage(raw, redisKey, start + offset)),
+        meta: { count, page: currentPage, pageSize: currentPageSize, source: 'redis', key: redisKey },
+      };
+      await next();
+      return;
+    }
+
+    const adapter = (eq as any).adapter;
+
+    if (!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 as any).events as Map<string, any>;
+    let fullChannel = channel;
+    if (events?.has(channel)) {
+      fullChannel = eq.getFullChannel(channel, events.get(channel)?.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: any) => ({
+        id: msg.id,
+        content: msg.content,
+        timestamp: msg.options?.timestamp,
+        retried: msg.options?.retried || 0,
+        maxRetries: msg.options?.maxRetries || 0,
+      })),
+      meta: { count: queue.length, page: Number(page), pageSize: Number(pageSize) },
+    };
+    await next();
+  },
+};

package/src/server/actions/orchestrator.ts

@@ -13,7 +13,7 @@ import type { IOrchestratorAdapter, StackConfig } from '../orchestrator/types';
 function getAdapter(ctx: Context): IOrchestratorAdapter {
   const plugin = ctx.app.pm.get('plugin-cluster-manager') as any;
   if (!plugin?.orchestrator) {
-    ctx.throw(503, 'Orchestrator adapter not configured. Configure it in Worker Monitor settings.');
+    ctx.throw(503, 'Orchestrator adapter not configured. Configure it in Cluster Manager settings.');
   }
   return plugin.orchestrator;
 }

package/src/server/actions/plugin-operations.ts

@@ -0,0 +1,151 @@
+import { Context } from '@nocobase/actions';
+
+const PROTECTED_PLUGIN_NAMES = new Set(['nocobase', 'plugin-cluster-manager']);
+const PROTECTED_PACKAGE_NAMES = new Set(['nocobase', '@nocobase/preset-nocobase', 'plugin-cluster-manager']);
+
+function getPayload(ctx: Context) {
+  return (ctx.action.params.values || (ctx as any).request?.body?.values || (ctx as any).request?.body || {}) as any;
+}
+
+function pluginDisplayName(plugin: any) {
+  return plugin.displayName || plugin.name || plugin.packageName;
+}
+
+function isProtectedPlugin(plugin: any) {
+  return PROTECTED_PLUGIN_NAMES.has(plugin.name) || PROTECTED_PACKAGE_NAMES.has(plugin.packageName);
+}
+
+async function getApplicationPlugins(ctx: Context) {
+  const repo = ctx.db.getRepository('applicationPlugins');
+  const rows = await repo.find({ sort: ['name'] });
+  return rows.map((row: any) => row.toJSON());
+}
+
+async function findPlugin(ctx: Context, requestedName?: string) {
+  const name = String(requestedName || '').trim();
+  if (!name) {
+    ctx.throw(400, 'Plugin name is required.');
+  }
+
+  const plugins = await getApplicationPlugins(ctx);
+  const plugin = plugins.find((item: any) => item.name === name || item.packageName === name);
+  if (!plugin) {
+    ctx.throw(404, `Plugin "${name}" was not found in applicationPlugins.`);
+  }
+  return plugin;
+}
+
+async function getLoadedPluginInfo(ctx: Context, plugin: any, locale: string): Promise<any> {
+  const pm = (ctx.app as any).pm;
+  const instance = pm?.get?.(plugin.name) || pm?.get?.(plugin.packageName);
+  if (!instance) {
+    return {};
+  }
+
+  try {
+    return await instance.toJSON({ locale, withOutOpenFile: true });
+  } catch {
+    return {
+      name: instance.name,
+      packageName: instance.options?.packageName,
+      displayName: instance.options?.packageJson?.displayName,
+      description: instance.options?.packageJson?.description,
+    };
+  }
+}
+
+async function getPackageInfo(ctx: Context, plugin: any, locale: string): Promise<any> {
+  const loadedInfo = await getLoadedPluginInfo(ctx, plugin, locale);
+  if (loadedInfo.displayName || loadedInfo.description) {
+    return loadedInfo;
+  }
+
+  try {
+    const pmCtor = (ctx.app as any).pm?.constructor as any;
+    const pkgJson = await pmCtor.getPackageJson(plugin.packageName);
+    return {
+      displayName: pkgJson?.[`displayName.${locale}`] || pkgJson?.displayName || plugin.name,
+      description: pkgJson?.[`description.${locale}`] || pkgJson?.description,
+      keywords: pkgJson?.keywords,
+    };
+  } catch {
+    return {};
+  }
+}
+
+export const pluginOperationsActions = {
+  async list(ctx: Context, next: () => Promise<void>) {
+    const locale = (ctx as any).getCurrentLocale?.() || 'en-US';
+    const plugins = await getApplicationPlugins(ctx);
+    const data = await Promise.all(
+      plugins.map(async (plugin: any) => {
+        const info = await getPackageInfo(ctx, plugin, locale);
+        const loaded = Boolean((ctx.app as any).pm?.get?.(plugin.name) || (ctx.app as any).pm?.get?.(plugin.packageName));
+        return {
+          ...plugin,
+          displayName: info.displayName || plugin.name,
+          description: info.description || '',
+          keywords: info.keywords || [],
+          loaded,
+          protected: isProtectedPlugin(plugin),
+        };
+      }),
+    );
+
+    ctx.body = {
+      data,
+      meta: { count: data.length },
+    };
+    await next();
+  },
+
+  async forceDisable(ctx: Context, next: () => Promise<void>) {
+    const payload = getPayload(ctx);
+    const plugin = await findPlugin(ctx, payload.name || payload.packageName || ctx.action.params.filterByTk);
+    if (isProtectedPlugin(plugin)) {
+      ctx.throw(400, `Plugin "${pluginDisplayName(plugin)}" is protected and cannot be disabled from Cluster Manager.`);
+    }
+
+    const repo = ctx.db.getRepository('applicationPlugins');
+    await repo.update({
+      filter: { name: plugin.name },
+      values: { enabled: false },
+    });
+
+    const instance = (ctx.app as any).pm?.get?.(plugin.name) || (ctx.app as any).pm?.get?.(plugin.packageName);
+    if (instance) {
+      instance.enabled = false;
+    }
+
+    ctx.body = {
+      success: true,
+      name: plugin.name,
+      packageName: plugin.packageName,
+      restartRequired: true,
+      message: `Plugin "${pluginDisplayName(plugin)}" was force disabled. Restart or reload the app to fully unload it.`,
+    };
+    await next();
+  },
+
+  async forceRemove(ctx: Context, next: () => Promise<void>) {
+    const payload = getPayload(ctx);
+    const plugin = await findPlugin(ctx, payload.name || payload.packageName || ctx.action.params.filterByTk);
+    if (isProtectedPlugin(plugin)) {
+      ctx.throw(400, `Plugin "${pluginDisplayName(plugin)}" is protected and cannot be removed from Cluster Manager.`);
+    }
+
+    const repo = ctx.db.getRepository('applicationPlugins');
+    await repo.destroy({
+      filter: { name: plugin.name },
+    });
+
+    ctx.body = {
+      success: true,
+      name: plugin.name,
+      packageName: plugin.packageName,
+      restartRequired: true,
+      message: `Plugin "${pluginDisplayName(plugin)}" was force removed from the application registry. Package files were not deleted.`,
+    };
+    await next();
+  },
+};

package/src/server/collections/cluster-manager-plugins.ts

@@ -0,0 +1,19 @@
+/**
+ * DUMMY COLLECTION
+ * Keeps the `clusterManagerPlugins` resourcer compatible with NocoBase
+ * workflow/ACL collection lookups. The actual plugin records live in
+ * the core `applicationPlugins` collection.
+ */
+export default {
+  name: 'clusterManagerPlugins',
+  dumpRules: 'skip',
+  autoGenId: true,
+  createdAt: false,
+  updatedAt: false,
+  fields: [
+    {
+      name: 'name',
+      type: 'string',
+    },
+  ],
+};

package/src/server/plugin.ts

@@ -15,6 +15,7 @@ import { RedisPubSubAdapter } from './adapters/redis-pubsub-adapter';
 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 type { IOrchestratorAdapter } from './orchestrator/types';
 import { DockerAdapter } from './orchestrator/docker-adapter';
 import { K8sAdapter } from './orchestrator/k8s-adapter';
@@ -240,11 +241,17 @@ export class PluginClusterManagerServer extends Plugin {
       actions: cacheMonitorActions,
     });
 
-    // Package manager (installs apt/npm/python packages across nodes)
-    this.app.resourcer.define({
-      name: 'workerPackages',
-      actions: packageManagerActions,
-    });
+    // Package manager (installs apt/npm/python packages across nodes)
+    this.app.resourcer.define({
+      name: 'workerPackages',
+      actions: packageManagerActions,
+    });
+
+    // Plugin operations (force disable/remove application plugin records)
+    this.app.resourcer.define({
+      name: 'clusterManagerPlugins',
+      actions: pluginOperationsActions,
+    });
 
     // Install ACL cache middleware inside the ACL chain so cached permissions are not overwritten.
     const aclCacheMiddleware = createAclCacheMiddleware(this.app);
@@ -279,11 +286,12 @@ export class PluginClusterManagerServer extends Plugin {
         'clusterManagerQueue:*',
         'clusterManagerLock:*',
         'clusterManagerCacheMgr:*',
-        'workerOrchestrator:*',
-        'orchestratorStacks:*',
-        'workerPackages:*',
-      ],
-    });
+        'workerOrchestrator:*',
+        'orchestratorStacks:*',
+        'workerPackages:*',
+        'clusterManagerPlugins:*',
+      ],
+    });
 
     // ── Container Orchestrator ──
     await this.initOrchestrator();
@@ -365,16 +373,16 @@ export class PluginClusterManagerServer extends Plugin {
       } else {
         // Fall back to env var for initial setup
         const envAdapter = process.env.ORCHESTRATOR_ADAPTER;
-        if (envAdapter && envAdapter !== 'none') {
-          await this.connectAdapter({
-            adapterType: envAdapter,
-            dockerSocketPath: process.env.DOCKER_SOCKET || '/var/run/docker.sock',
-            k8sNamespace: 'nocobase',
-          });
-        } else {
-          this.app.logger.info('[Orchestrator] No adapter configured — configurable via Worker Monitor UI');
-        }
-      }
+        if (envAdapter && envAdapter !== 'none') {
+          await this.connectAdapter({
+            adapterType: envAdapter,
+            dockerSocketPath: process.env.DOCKER_SOCKET || '/var/run/docker.sock',
+            k8sNamespace: 'nocobase',
+          });
+        } else {
+          this.app.logger.info('[Orchestrator] No adapter configured — configurable via Cluster Manager UI');
+        }
+      }
     } catch (err: any) {
       this.app.logger.warn(`[Orchestrator] Could not load settings: ${err.message}`);
     }

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/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/PackageInstaller.d.ts

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

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.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';