plugin-cluster-manager 1.1.10 → 1.1.13

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,12 +16,16 @@ 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';
 import { LeaderElection } from './orchestrator/leader-election';
 import { packageManagerActions } from './actions/package-manager';
 import { PackageManager } from './orchestrator/PackageManager';
+import { createListMetaCacheMiddleware } from './middlewares/listMetaCacheMiddleware';
+import { registerCacheHooks } from './hooks/cacheInvalidationHooks';
+import { collectLocalDoctorSnapshot, doctorActions } from './actions/doctor';
 
 export class PluginClusterManagerServer extends Plugin {
   public nodeRegistry: RedisNodeRegistry;
@@ -54,8 +58,10 @@ 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 === '*' || process.env.APP_ROLE === 'worker' || process.env.APP_ROLE === 'sandbox';
+      const isWorker =
+        isWorkerMode(process.env.WORKER_MODE) ||
+        process.env.APP_ROLE === 'worker' ||
+        process.env.APP_ROLE === 'sandbox';
       if (isWorker) {
         setTimeout(async () => {
           try {
@@ -68,29 +74,31 @@ export class PluginClusterManagerServer extends Plugin {
             }
             if (config) {
               this.app.logger.info('[ClusterManager] Auto-installing configured packages on worker boot...');
-              
+
               const { packagesFromConfig } = require('../shared/packages');
-              
+
               const configured = packagesFromConfig({
                 aptPackages: config.get('aptPackages'),
                 pythonPackages: config.get('pythonPackages'),
                 npmPackages: config.get('npmPackages'),
               });
-              
+
               let custom = { python: [], node: [], npm: [] };
               try {
                 const customRaw = config.get('customPackages');
                 if (customRaw) custom = typeof customRaw === 'string' ? JSON.parse(customRaw) : customRaw;
-              } catch {}
-              
+              } catch (err) {
+                // ignore
+              }
+
               const unique = (arr: any[]) => Array.from(new Set(arr.filter(Boolean)));
-              
+
               const packages = {
                 apt: unique([...(configured.apt || [])]),
                 npm: unique([...(configured.npm || []), ...(custom.node || []), ...(custom.npm || [])]),
                 python: unique([...(configured.python || []), ...(custom.python || [])]),
               };
-              
+
               const pm = new PackageManager(this.app);
               await pm.executeInstall({
                 targetRole: 'all', // executeInstall will filter internally based on current role
@@ -99,7 +107,7 @@ export class PluginClusterManagerServer extends Plugin {
                   aptMirrorUrl: config.get('aptMirrorUrl'),
                   npmRegistryUrl: config.get('npmRegistryUrl'),
                   pypiIndexUrl: config.get('pypiIndexUrl'),
-                }
+                },
               });
             }
           } catch (err: any) {
@@ -115,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) {
@@ -136,7 +142,7 @@ export class PluginClusterManagerServer extends Plugin {
     if (lockMgr && lockMgr.registry && !lockMgr.registry.get('redis') && !lockMgr.adapters.get('redis')) {
       lockMgr.registerAdapter('redis', {
         Adapter: RedisLockAdapter,
-        options: { app: this.app }
+        options: { app: this.app },
       });
       this.app.logger.info('[ClusterManager] Polyfilled RedisLockAdapter as an active distributed lock provider');
     }
@@ -145,7 +151,7 @@ export class PluginClusterManagerServer extends Plugin {
     const pubSub = (this.app as any).pubSubManager;
     if (pubSub) {
       const myNodeId = getLocalNodeId(this.app);
-      
+
       // ── Log request handler: ONLY the targeted node receives this via dynamic channel ──
       pubSub.subscribe(`cluster-manager:log-request:${myNodeId}`, async (msg: string) => {
         try {
@@ -156,14 +162,56 @@ export class PluginClusterManagerServer extends Plugin {
 
           const logData = await readLocalLogs(this.app, lines || 200);
           const responseKey = `cluster-manager:log-response:${requestId}`;
-          await redis.sendCommand([
-            'SET', responseKey, JSON.stringify(logData), 'EX', '30',
-          ]);
+          await redis.sendCommand(['SET', responseKey, JSON.stringify(logData), 'EX', '30']);
           this.app.logger.debug(`[ClusterManager] Served log request ${requestId} for ${targetNodeId}`);
         } catch (err: any) {
           this.app.logger.error(`[ClusterManager] Error handling log request: ${err.message}`);
         }
-      });
+      });
+
+      pubSub.subscribe(`cluster-manager:doctor-collect:${myNodeId}`, async (msg: string) => {
+        const redis = getRedisClient(this.app);
+        let requestId = '';
+        try {
+          const parsed = typeof msg === 'string' ? JSON.parse(msg) : msg;
+          requestId = parsed.requestId;
+          if (!redis || !requestId) return;
+
+          const snapshot = await collectLocalDoctorSnapshot(this.app, {
+            runId: parsed.runId,
+            sinceMs: parsed.sinceMs,
+            untilMs: parsed.untilMs,
+            maxLines: parsed.maxLines,
+          });
+          await redis.sendCommand([
+            'SET',
+            `cluster-manager:doctor-response:${requestId}`,
+            JSON.stringify(snapshot),
+            'EX',
+            '90',
+          ]);
+          this.app.logger.debug(`[ClusterManager] Served doctor snapshot request ${requestId}`);
+        } catch (err: unknown) {
+          const message = err instanceof Error ? err.message : String(err);
+          this.app.logger.error(`[ClusterManager] Error handling doctor snapshot request: ${message}`);
+          if (redis && requestId) {
+            const fallback = {
+              nodeId: getLocalNodeId(this.app),
+              collectedAt: new Date().toISOString(),
+              error: message,
+            };
+            await redis
+              .sendCommand([
+                'SET',
+                `cluster-manager:doctor-response:${requestId}`,
+                JSON.stringify(fallback),
+                'EX',
+                '90',
+              ])
+              .catch(() => {});
+          }
+        }
+      });
       // Package installation handler. PubSub delivers this to every node, and PackageManager
       // filters by the requested target role before executing anything locally.
       pubSub.subscribe('cluster-manager.install-packages', async (payload: any) => {
@@ -177,85 +225,97 @@ export class PluginClusterManagerServer extends Plugin {
       });
 
       pubSub.subscribe('cluster-manager:restart', (msg: string) => {
-        try {
-          let target = msg;
-          let mode = 'hard';
-          
-          if (msg.startsWith('{')) {
-            const parsed = JSON.parse(msg);
-            target = parsed.hostname;
-            mode = parsed.mode || 'hard';
-          }
-
-          if (target === os.hostname() || target === '*') {
-            this.app.logger.warn(`[ClusterManager] Received ${mode} restart command for node ${os.hostname()}...`);
-            setTimeout(async () => {
-              try {
-                if (mode === 'soft') {
-                  this.app.logger.warn(`[ClusterManager] Triggering NocoBase Soft Restart...`);
-                  await this.app.restart();
-                } else {
-                  this.app.logger.warn(`[ClusterManager] Shutting down Node.js process for Hard Restart...`);
-                  await this.app.stop();
-                  process.exit(1);
-                }
-              } catch (e: any) {}
-            }, 1000); // 1-second delay so HTTP API can gracefully respond first
-          }
-        } catch (err) {
-          this.app.logger.error(`[ClusterManager] Parse error for restart message: ${msg}`);
-        }
-      });
-    }
-
-    // Task management (reads asyncTasks table)
-    this.app.resourcer.define({
-      name: 'clusterManager',
-      actions: tasksActions,
-    });
-
-    // Workflow execution management (reads executions + jobs tables)
-    this.app.resourcer.define({
-      name: 'clusterManagerWorkflow',
-      actions: workflowActions,
-    });
-
-    // Redis live metrics
-    this.app.resourcer.define({
-      name: 'clusterManagerRedis',
-      actions: redisActions,
-    });
-
-    // ACL cache management
-    this.app.resourcer.define({
-      name: 'clusterManagerAclCache',
-      actions: aclCacheActions,
-    });
-
-    // Cluster nodes & health
-    this.app.resourcer.define({
-      name: 'clusterManagerCluster',
-      actions: clusterActions,
-    });
-
-    // Event queue monitoring
-    this.app.resourcer.define({
-      name: 'clusterManagerQueue',
-      actions: eventQueueActions,
-    });
-
-    // Distributed lock monitoring
-    this.app.resourcer.define({
-      name: 'clusterManagerLock',
-      actions: lockActions,
-    });
-
-    // Cache manager monitoring
-    this.app.resourcer.define({
-      name: 'clusterManagerCacheMgr',
-      actions: cacheMonitorActions,
-    });
-
+        try {
+          let target = msg;
+          let mode = 'hard';
+          let targetNodeId = '';
+
+          if (msg.startsWith('{')) {
+            const parsed = JSON.parse(msg);
+            target = parsed.hostname || parsed.target || '';
+            targetNodeId = parsed.targetNodeId || '';
+            mode = parsed.mode || 'hard';
+          }
+
+          const myNodeId = getLocalNodeId(this.app);
+          const shouldRestart = targetNodeId ? targetNodeId === myNodeId : target === os.hostname() || target === '*';
+          if (shouldRestart) {
+            this.app.logger.warn(`[ClusterManager] Received ${mode} restart command for node ${os.hostname()}...`);
+            setTimeout(async () => {
+              try {
+                if (mode === 'soft') {
+                  this.app.logger.warn(`[ClusterManager] Triggering NocoBase Soft Restart...`);
+                  await this.app.restart();
+                } else {
+                  this.app.logger.warn(`[ClusterManager] Shutting down Node.js process for Hard Restart...`);
+                  await this.app.stop();
+                  process.exit(1);
+                }
+              } catch (e: any) {
+                // ignore
+              }
+            }, 1000); // 1-second delay so HTTP API can gracefully respond first
+          }
+        } catch (err) {
+          this.app.logger.error(`[ClusterManager] Parse error for restart message: ${msg}`);
+        }
+      });
+    }
+
+    // Task management (reads asyncTasks table)
+    this.app.resourcer.define({
+      name: 'clusterManager',
+      actions: tasksActions,
+    });
+
+    // Workflow execution management (reads executions + jobs tables)
+    this.app.resourcer.define({
+      name: 'clusterManagerWorkflow',
+      actions: workflowActions,
+    });
+
+    // Redis live metrics
+    this.app.resourcer.define({
+      name: 'clusterManagerRedis',
+      actions: redisActions,
+    });
+
+    // ACL cache management
+    this.app.resourcer.define({
+      name: 'clusterManagerAclCache',
+      actions: aclCacheActions,
+    });
+
+    // Cluster nodes & health
+    this.app.resourcer.define({
+      name: 'clusterManagerCluster',
+      actions: clusterActions,
+    });
+
+    // Time-boxed diagnostic sessions and report download
+    this.app.resourcer.define({
+      name: 'clusterManagerDoctor',
+      actions: doctorActions,
+    });
+
+    // Event queue monitoring
+    this.app.resourcer.define({
+      name: 'clusterManagerQueue',
+      actions: eventQueueActions,
+    });
+
+    // Distributed lock monitoring
+    this.app.resourcer.define({
+      name: 'clusterManagerLock',
+      actions: lockActions,
+    });
+
+    // Cache manager monitoring
+    this.app.resourcer.define({
+      name: 'clusterManagerCacheMgr',
+      actions: cacheMonitorActions,
+    });
+
     // Package manager (installs apt/npm/python packages across nodes)
     this.app.resourcer.define({
       name: 'workerPackages',
@@ -267,7 +327,13 @@ export class PluginClusterManagerServer extends Plugin {
       name: 'clusterManagerPlugins',
       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, {
@@ -275,119 +341,131 @@ export class PluginClusterManagerServer extends Plugin {
       before: 'core',
       after: 'allow-manager',
     });
-
-    // Lightweight healthcheck endpoint avoiding workflow pre-action and resourcer spam
-    this.app.use(async (ctx: any, next: any) => {
-      if (ctx.path === '/api/clusterManager:health' && (ctx.method === 'GET' || ctx.method === 'HEAD')) {
-        ctx.body = {
-          status: 'ok',
-          version: process.env.NOCOBASE_VERSION || process.version,
-          mode: process.env.WORKER_MODE || 'main',
-        };
-        return;
-      }
-      await next();
-    });
-
-    // Admin-only access
-    this.app.acl.registerSnippet({
-      name: `pm.${this.name}`,
-      actions: [
-        'clusterManager:*',
-        'clusterManagerWorkflow:*',
-        'clusterManagerRedis:*',
-        'clusterManagerAclCache:*',
-        'clusterManagerCluster:*',
-        'clusterManagerQueue:*',
-        'clusterManagerLock:*',
-        'clusterManagerCacheMgr:*',
+
+    // Install collections:listMeta resource cache middleware after setCurrentRole
+    const listMetaCacheMiddleware = createListMetaCacheMiddleware(this.app);
+    this.app.resourcer.use(listMetaCacheMiddleware, {
+      tag: 'listMetaCache',
+      after: 'setCurrentRole',
+    });
+
+    // Register DB hooks for invalidating cache versions
+    registerCacheHooks(this.app);
+
+    // Lightweight healthcheck endpoint avoiding workflow pre-action and resourcer spam
+    this.app.use(async (ctx: any, next: any) => {
+      if (ctx.path === '/api/clusterManager:health' && (ctx.method === 'GET' || ctx.method === 'HEAD')) {
+        ctx.body = {
+          status: 'ok',
+          version: process.env.NOCOBASE_VERSION || process.version,
+          mode: process.env.WORKER_MODE || 'main',
+        };
+        return;
+      }
+      await next();
+    });
+
+    // Admin-only access
+    this.app.acl.registerSnippet({
+      name: `pm.${this.name}`,
+      actions: [
+        'clusterManager:*',
+        'clusterManagerWorkflow:*',
+        'clusterManagerRedis:*',
+        'clusterManagerAclCache:*',
+        'clusterManagerCluster:*',
+        'clusterManagerDoctor:*',
+        'clusterManagerQueue:*',
+        'clusterManagerLock:*',
+        'clusterManagerCacheMgr:*',
         'workerOrchestrator:*',
         'orchestratorStacks:*',
         'workerPackages:*',
         'clusterManagerPlugins:*',
+        'workerQueueMappings:*',
       ],
     });
-
-    // ── Container Orchestrator ──
-    await this.initOrchestrator();
-  }
-
-  private registerPubSubAdapter() {
-    const url = process.env.PUBSUB_ADAPTER_REDIS_URL;
-    if (!url) {
-      this.app.logger.info('[cluster-manager] PUBSUB_ADAPTER_REDIS_URL not set, skipping Redis PubSub adapter');
-      return;
-    }
-
-    // Don't override if another plugin already set an adapter
-    const existingAdapter = (this.app.pubSubManager as any).adapter;
-    if (existingAdapter) {
-      this.app.logger.info('[cluster-manager] PubSub adapter already registered, skipping');
-      return;
-    }
-
-    const adapter = new RedisPubSubAdapter(url, this.app.logger);
-    this.app.pubSubManager.setAdapter(adapter);
-    this.app.logger.info('[cluster-manager] Redis PubSub adapter registered');
-  }
-
-  /**
-   * Initialize the Container Orchestrator subsystem.
-   * Config is loaded from DB (orchestratorSettings collection) first,
-   * then falls back to ORCHESTRATOR_ADAPTER env var.
-   * This allows manual configuration via the NocoBase admin UI.
-   */
-  private async initOrchestrator() {
-    // Always register actions + collections so the UI can configure settings
-    // even before an adapter is connected
-    this.app.resourcer.define({
-      name: 'workerOrchestrator',
-      actions: {
-        ...orchestratorActions,
-        // Settings CRUD: read/write orchestrator config from DB
-        async getSettings(ctx: any, next: () => Promise<void>) {
-          try {
-            const repo = ctx.db.getRepository('orchestratorSettings');
-            let settings = await repo.findOne();
-            if (!settings) {
-              settings = await repo.create({
-                values: { adapterType: process.env.ORCHESTRATOR_ADAPTER || 'none' },
-              });
-            }
-            ctx.body = settings.toJSON();
-          } catch {
-            // Table may not exist during migration window
-            ctx.body = { adapterType: 'none', _note: 'Settings table not yet ready.' };
-          }
-          await next();
-        },
-        async saveSettings(ctx: any, next: () => Promise<void>) {
-          const values = ctx.action.params.values || {};
-          const repo = ctx.db.getRepository('orchestratorSettings');
-          let settings = await repo.findOne();
-          if (settings) {
-            await repo.update({ filterByTk: settings.get('id'), values });
-          } else {
-            settings = await repo.create({ values });
-          }
-          // Reinitialize adapter with new settings
-          const plugin = ctx.app.pm.get('plugin-cluster-manager') as PluginClusterManagerServer;
-          await plugin.connectAdapter(values);
-          ctx.body = { success: true, message: 'Settings saved. Adapter reinitialized.' };
-          await next();
-        },
-      },
-    });
-
-    // Load settings from DB and try to connect
-    try {
-      const repo = this.app.db.getRepository('orchestratorSettings');
-      const settings = await repo.findOne();
-      if (settings) {
-        await this.connectAdapter(settings.toJSON());
-      } else {
-        // Fall back to env var for initial setup
-        const envAdapter = process.env.ORCHESTRATOR_ADAPTER;
+
+    // ── Container Orchestrator ──
+    await this.initOrchestrator();
+  }
+
+  private registerPubSubAdapter() {
+    const url = process.env.PUBSUB_ADAPTER_REDIS_URL;
+    if (!url) {
+      this.app.logger.info('[cluster-manager] PUBSUB_ADAPTER_REDIS_URL not set, skipping Redis PubSub adapter');
+      return;
+    }
+
+    // Don't override if another plugin already set an adapter
+    const existingAdapter = (this.app.pubSubManager as any).adapter;
+    if (existingAdapter) {
+      this.app.logger.info('[cluster-manager] PubSub adapter already registered, skipping');
+      return;
+    }
+
+    const adapter = new RedisPubSubAdapter(url, this.app.logger);
+    this.app.pubSubManager.setAdapter(adapter);
+    this.app.logger.info('[cluster-manager] Redis PubSub adapter registered');
+  }
+
+  /**
+   * Initialize the Container Orchestrator subsystem.
+   * Config is loaded from DB (orchestratorSettings collection) first,
+   * then falls back to ORCHESTRATOR_ADAPTER env var.
+   * This allows manual configuration via the NocoBase admin UI.
+   */
+  private async initOrchestrator() {
+    // Always register actions + collections so the UI can configure settings
+    // even before an adapter is connected
+    this.app.resourcer.define({
+      name: 'workerOrchestrator',
+      actions: {
+        ...orchestratorActions,
+        // Settings CRUD: read/write orchestrator config from DB
+        async getSettings(ctx: any, next: () => Promise<void>) {
+          try {
+            const repo = ctx.db.getRepository('orchestratorSettings');
+            let settings = await repo.findOne();
+            if (!settings) {
+              settings = await repo.create({
+                values: { adapterType: process.env.ORCHESTRATOR_ADAPTER || 'none' },
+              });
+            }
+            ctx.body = settings.toJSON();
+          } catch {
+            // Table may not exist during migration window
+            ctx.body = { adapterType: 'none', _note: 'Settings table not yet ready.' };
+          }
+          await next();
+        },
+        async saveSettings(ctx: any, next: () => Promise<void>) {
+          const values = ctx.action.params.values || {};
+          const repo = ctx.db.getRepository('orchestratorSettings');
+          let settings = await repo.findOne();
+          if (settings) {
+            await repo.update({ filterByTk: settings.get('id'), values });
+          } else {
+            settings = await repo.create({ values });
+          }
+          // Reinitialize adapter with new settings
+          const plugin = ctx.app.pm.get('plugin-cluster-manager') as PluginClusterManagerServer;
+          await plugin.connectAdapter(values);
+          ctx.body = { success: true, message: 'Settings saved. Adapter reinitialized.' };
+          await next();
+        },
+      },
+    });
+
+    // Load settings from DB and try to connect
+    try {
+      const repo = this.app.db.getRepository('orchestratorSettings');
+      const settings = await repo.findOne();
+      if (settings) {
+        await this.connectAdapter(settings.toJSON());
+      } else {
+        // Fall back to env var for initial setup
+        const envAdapter = process.env.ORCHESTRATOR_ADAPTER;
         if (envAdapter && envAdapter !== 'none') {
           await this.connectAdapter({
             adapterType: envAdapter,
@@ -398,10 +476,10 @@ export class PluginClusterManagerServer extends Plugin {
           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}`);
-    }
-
+    } catch (err: any) {
+      this.app.logger.warn(`[Orchestrator] Could not load settings: ${err.message}`);
+    }
+
     // Leader election runs on app nodes only. Worker-only pods still load the
     // plugin for monitoring/package installation, but they must not become the
     // Kubernetes orchestrator leader.
@@ -411,41 +489,41 @@ export class PluginClusterManagerServer extends Plugin {
       disabledReason: workerOnlyNode ? 'Worker-only nodes do not run orchestrator write operations.' : '',
     });
     await this.leaderElection.init();
-
-    (this.app as any).on('afterStart', async () => {
-      if (this.leaderElection) {
-        await this.leaderElection.tryBecomeLeader();
-      }
-    });
-
-    (this.app as any).on('beforeStop', async () => {
-      if (this.leaderElection) {
-        await this.leaderElection.release();
-      }
-    });
-  }
-
-  /**
-   * Connect (or reconnect) the orchestrator adapter based on settings.
-   * Can be called at startup or when user saves new settings via UI.
-   */
+
+    (this.app as any).on('afterStart', async () => {
+      if (this.leaderElection) {
+        await this.leaderElection.tryBecomeLeader();
+      }
+    });
+
+    (this.app as any).on('beforeStop', async () => {
+      if (this.leaderElection) {
+        await this.leaderElection.release();
+      }
+    });
+  }
+
+  /**
+   * Connect (or reconnect) the orchestrator adapter based on settings.
+   * Can be called at startup or when user saves new settings via UI.
+   */
   public async connectAdapter(settings: any): Promise<boolean> {
-    const adapterType = settings?.adapterType || 'none';
-
-    if (adapterType === 'none') {
-      this.orchestrator = null;
-      this.app.logger.info('[Orchestrator] Adapter disabled');
-      return false;
-    }
-
-    try {
-      if (adapterType === 'docker') {
-        const opts: any = {};
+    const adapterType = settings?.adapterType || 'none';
+
+    if (adapterType === 'none') {
+      this.orchestrator = null;
+      this.app.logger.info('[Orchestrator] Adapter disabled');
+      return false;
+    }
+
+    try {
+      if (adapterType === 'docker') {
+        const opts: any = {};
         if (settings.dockerHost) {
-          // TCP connection (remote Docker or Docker Desktop on Windows)
-          const url = new URL(settings.dockerHost);
-          opts.host = url.hostname;
-          opts.port = parseInt(url.port, 10) || 2376;
+          // TCP connection (remote Docker or Docker Desktop on Windows)
+          const url = new URL(settings.dockerHost);
+          opts.host = url.hostname;
+          opts.port = parseInt(url.port, 10) || 2376;
         } else {
           opts.socketPath = settings.dockerSocketPath || '/var/run/docker.sock';
         }
@@ -458,34 +536,33 @@ export class PluginClusterManagerServer extends Plugin {
           namespace: settings.k8sNamespace || 'nocobase',
           workerLabelSelector: settings.workerLabelSelector || 'role=worker',
         });
-        this.app.logger.info('[Orchestrator] Kubernetes adapter initialized');
-      } else {
-        this.app.logger.warn(`[Orchestrator] Unknown adapter type: ${adapterType}`);
-        this.orchestrator = null;
-        return false;
-      }
-
-      // Test connectivity
-      const connected = await this.orchestrator.ping();
-      if (!connected) {
-        this.app.logger.error(`[Orchestrator] Failed to connect to ${adapterType} runtime`);
-        this.orchestrator = null;
-        return false;
-      }
-
-      this.app.logger.info(`[Orchestrator] ✅ Connected to ${adapterType} runtime`);
-      return true;
-    } catch (err: any) {
-      this.app.logger.error(`[Orchestrator] Adapter init failed: ${err.message}`);
-      this.orchestrator = null;
-      return false;
-    }
+        this.app.logger.info('[Orchestrator] Kubernetes adapter initialized');
+      } else {
+        this.app.logger.warn(`[Orchestrator] Unknown adapter type: ${adapterType}`);
+        this.orchestrator = null;
+        return false;
+      }
+
+      // Test connectivity
+      const connected = await this.orchestrator.ping();
+      if (!connected) {
+        this.app.logger.error(`[Orchestrator] Failed to connect to ${adapterType} runtime`);
+        this.orchestrator = null;
+        return false;
+      }
+
+      this.app.logger.info(`[Orchestrator] ✅ Connected to ${adapterType} runtime`);
+      return true;
+    } catch (err: any) {
+      this.app.logger.error(`[Orchestrator] Adapter init failed: ${err.message}`);
+      this.orchestrator = null;
+      return false;
+    }
   }
 
   private isWorkerOnlyNode(): boolean {
-    const workerMode = process.env.WORKER_MODE || '';
-    return workerMode === 'worker' || workerMode === 'task' || workerMode === '*';
+    return isWorkerMode(process.env.WORKER_MODE);
   }
 }
-
-export default PluginClusterManagerServer;
+
+export default PluginClusterManagerServer;