plugin-cluster-manager 1.1.0 → 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;
 }
@@ -251,4 +251,24 @@ export const orchestratorActions = {
     }
     await next();
   },
+
+  /**
+   * GET /workerOrchestrator:networks
+   * List available networks (if supported by adapter)
+   */
+  async networks(ctx: Context, next: () => Promise<void>) {
+    const adapter = getAdapter(ctx);
+    if (!adapter.listNetworks) {
+      ctx.body = { data: [] };
+    } else {
+      try {
+        const networks = await adapter.listNetworks();
+        ctx.body = { data: networks };
+      } catch (err: any) {
+        ctx.app.logger.warn(`Failed to list networks: ${err.message}`);
+        ctx.body = { data: [] };
+      }
+    }
+    await next();
+  },
 };

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/app.ts

@@ -0,0 +1,7 @@
+export default {
+  name: 'app',
+  autoCreate: false,
+  dumpRules: 'skip',
+  model: 'Collection',
+  fields: [],
+};

package/src/server/collections/cluster-manager-acl-cache.ts

@@ -0,0 +1,23 @@
+/**
+ * DUMMY COLLECTION
+ * This collection is created to prevent NocoBase workflow/ACL from throwing the error:
+ * '[Workflow pre-action]: collection "clusterManagerAclCache" not found'
+ * 
+ * Since 'clusterManagerAclCache' is registered as a resourcer in plugin.ts, NocoBase 
+ * implicitly looks for a collection with the same name.
+ * We set dumpRules: 'skip' and avoid timestamps to ensure this collection 
+ * is completely ignored during backups/migrations and doesn't pollute the actual DB.
+ */
+export default {
+  name: 'clusterManagerAclCache',
+  dumpRules: 'skip',
+  autoGenId: true,
+  createdAt: false,
+  updatedAt: false,
+  fields: [
+    {
+      name: 'name',
+      type: 'string',
+    },
+  ],
+};

package/src/server/collections/cluster-manager-cache-mgr.ts

@@ -0,0 +1,23 @@
+/**
+ * DUMMY COLLECTION
+ * This collection is created to prevent NocoBase workflow/ACL from throwing the error:
+ * '[Workflow pre-action]: collection "clusterManagerCacheMgr" not found'
+ * 
+ * Since 'clusterManagerCacheMgr' is registered as a resourcer in plugin.ts, NocoBase 
+ * implicitly looks for a collection with the same name.
+ * We set dumpRules: 'skip' and avoid timestamps to ensure this collection 
+ * is completely ignored during backups/migrations and doesn't pollute the actual DB.
+ */
+export default {
+  name: 'clusterManagerCacheMgr',
+  dumpRules: 'skip',
+  autoGenId: true,
+  createdAt: false,
+  updatedAt: false,
+  fields: [
+    {
+      name: 'name',
+      type: 'string',
+    },
+  ],
+};

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

@@ -0,0 +1,23 @@
+/**
+ * DUMMY COLLECTION
+ * This collection is created to prevent NocoBase workflow/ACL from throwing the error:
+ * '[Workflow pre-action]: collection "clusterManagerCluster" not found'
+ * 
+ * Since 'clusterManagerCluster' is registered as a resourcer in plugin.ts, NocoBase 
+ * implicitly looks for a collection with the same name.
+ * We set dumpRules: 'skip' and avoid timestamps to ensure this collection 
+ * is completely ignored during backups/migrations and doesn't pollute the actual DB.
+ */
+export default {
+  name: 'clusterManagerCluster',
+  dumpRules: 'skip',
+  autoGenId: true,
+  createdAt: false,
+  updatedAt: false,
+  fields: [
+    {
+      name: 'name',
+      type: 'string',
+    },
+  ],
+};

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

@@ -0,0 +1,23 @@
+/**
+ * DUMMY COLLECTION
+ * This collection is created to prevent NocoBase workflow/ACL from throwing the error:
+ * '[Workflow pre-action]: collection "clusterManagerLock" not found'
+ * 
+ * Since 'clusterManagerLock' is registered as a resourcer in plugin.ts, NocoBase 
+ * implicitly looks for a collection with the same name.
+ * We set dumpRules: 'skip' and avoid timestamps to ensure this collection 
+ * is completely ignored during backups/migrations and doesn't pollute the actual DB.
+ */
+export default {
+  name: 'clusterManagerLock',
+  dumpRules: 'skip',
+  autoGenId: true,
+  createdAt: false,
+  updatedAt: false,
+  fields: [
+    {
+      name: 'name',
+      type: 'string',
+    },
+  ],
+};

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/collections/cluster-manager-queue.ts

@@ -0,0 +1,23 @@
+/**
+ * DUMMY COLLECTION
+ * This collection is created to prevent NocoBase workflow/ACL from throwing the error:
+ * '[Workflow pre-action]: collection "clusterManagerQueue" not found'
+ * 
+ * Since 'clusterManagerQueue' is registered as a resourcer in plugin.ts, NocoBase 
+ * implicitly looks for a collection with the same name.
+ * We set dumpRules: 'skip' and avoid timestamps to ensure this collection 
+ * is completely ignored during backups/migrations and doesn't pollute the actual DB.
+ */
+export default {
+  name: 'clusterManagerQueue',
+  dumpRules: 'skip',
+  autoGenId: true,
+  createdAt: false,
+  updatedAt: false,
+  fields: [
+    {
+      name: 'name',
+      type: 'string',
+    },
+  ],
+};