plugin-cluster-manager 1.1.15 → 1.1.17

package/dist/server/adapters/redis-event-queue-adapter.js

@@ -0,0 +1,188 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var redis_event_queue_adapter_exports = {};
+__export(redis_event_queue_adapter_exports, {
+  RedisEventQueueAdapter: () => RedisEventQueueAdapter
+});
+module.exports = __toCommonJS(redis_event_queue_adapter_exports);
+var import_redis = require("redis");
+var import_crypto = require("crypto");
+var import_worker_processes = require("../../shared/worker-processes");
+const DEFAULT_INTERVAL_MS = 250;
+const DEFAULT_CONCURRENCY = 1;
+const DEFAULT_ACK_TIMEOUT_MS = 15e3;
+const REDIS_QUEUE_PREFIX = "nocobase:event-queue";
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createTimeoutSignal(timeout) {
+  if (typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function") {
+    return AbortSignal.timeout(timeout);
+  }
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(), timeout);
+  return controller.signal;
+}
+class RedisEventQueueAdapter {
+  constructor(options) {
+    this.options = options;
+    this.client = (0, import_redis.createClient)({ url: options.url });
+    this.client.on("error", (error) => {
+      this.options.app.logger.error(`[RedisEventQueueAdapter] Redis error: ${error.message}`);
+    });
+  }
+  client;
+  connected = false;
+  events = /* @__PURE__ */ new Map();
+  reading = /* @__PURE__ */ new Map();
+  consuming = /* @__PURE__ */ new Set();
+  isConnected() {
+    return this.connected;
+  }
+  async connect() {
+    if (this.connected) return;
+    if (!this.client.isOpen) {
+      await this.client.connect();
+    }
+    this.connected = true;
+    for (const channel of this.events.keys()) {
+      this.startConsumer(channel);
+    }
+    this.options.app.logger.info("[RedisEventQueueAdapter] Connected");
+  }
+  async close() {
+    this.connected = false;
+    const batches = Array.from(this.reading.values()).flatMap((items) => Array.from(items));
+    if (batches.length) {
+      await Promise.allSettled(batches);
+    }
+    if (this.client.isOpen) {
+      await this.client.quit().catch(() => this.client.disconnect());
+    }
+    this.options.app.logger.info("[RedisEventQueueAdapter] Closed");
+  }
+  subscribe(channel, event) {
+    this.events.set(channel, event);
+    if (this.connected) {
+      this.startConsumer(channel);
+    }
+  }
+  unsubscribe(channel) {
+    this.events.delete(channel);
+  }
+  async publish(channel, content, options = {}) {
+    if (!this.connected) {
+      throw new Error("redis event queue is not connected");
+    }
+    const message = {
+      id: (0, import_crypto.randomUUID)(),
+      content,
+      options: {
+        ...options,
+        timestamp: Date.now()
+      }
+    };
+    await this.client.rPush(this.getQueueKey(channel), JSON.stringify(message));
+  }
+  getQueueKey(channel) {
+    return `${REDIS_QUEUE_PREFIX}:${channel}`;
+  }
+  startConsumer(channel) {
+    if (this.consuming.has(channel)) return;
+    this.consuming.add(channel);
+    return this.consume(channel).catch((error) => {
+      this.options.app.logger.error(`[RedisEventQueueAdapter] Consumer failed for ${channel}: ${error.message}`);
+    }).finally(() => {
+      this.consuming.delete(channel);
+      if (this.connected && this.events.has(channel)) {
+        this.startConsumer(channel);
+      }
+    });
+  }
+  async consume(channel) {
+    while (this.connected && this.events.has(channel)) {
+      const event = this.events.get(channel);
+      if (event && this.canProcess(channel, event)) {
+        this.read(channel, event);
+      }
+      await sleep((event == null ? void 0 : event.interval) || DEFAULT_INTERVAL_MS);
+    }
+  }
+  canProcess(channel, event) {
+    if (!(0, import_worker_processes.workerModeServesProcess)(process.env.WORKER_MODE, channel)) {
+      return false;
+    }
+    return event.idle();
+  }
+  read(channel, event) {
+    const active = this.reading.get(channel) || /* @__PURE__ */ new Set();
+    this.reading.set(channel, active);
+    const available = (event.concurrency || DEFAULT_CONCURRENCY) - active.size;
+    for (let index = 0; index < available; index += 1) {
+      const promise = this.readOne(channel, event).finally(() => active.delete(promise));
+      active.add(promise);
+    }
+  }
+  async readOne(channel, event) {
+    const raw = await this.client.lPop(this.getQueueKey(channel));
+    if (!raw) return;
+    let message;
+    try {
+      message = JSON.parse(raw);
+    } catch (error) {
+      this.options.app.logger.warn(`[RedisEventQueueAdapter] Dropped invalid message from ${channel}`, error);
+      return;
+    }
+    await this.process(channel, event, message);
+  }
+  async process(channel, event, message) {
+    const { timeout = DEFAULT_ACK_TIMEOUT_MS, maxRetries = 0, retried = 0 } = message.options || {};
+    try {
+      await event.process(message.content, {
+        id: message.id,
+        retried,
+        signal: createTimeoutSignal(timeout),
+        queueOptions: message.options
+      });
+    } catch (error) {
+      if (maxRetries > 0 && retried < maxRetries) {
+        await this.publish(channel, message.content, {
+          ...message.options,
+          timeout,
+          maxRetries,
+          retried: retried + 1
+        });
+        return;
+      }
+      this.options.app.logger.error(`[RedisEventQueueAdapter] Message failed on ${channel}`, error);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RedisEventQueueAdapter
+});

package/dist/server/adapters/redis-node-registry.js

@@ -52,6 +52,10 @@ class RedisNodeRegistry {
   intervalMs = 1e4;
   // Heartbeat every 10 seconds
   keyPrefix = "cluster-manager:nodes:";
+  warnedMissingRedis = false;
+  lastHeartbeatAt = null;
+  lastHeartbeatError = null;
+  lastReadError = null;
   start() {
     if (this.timer) {
       clearInterval(this.timer);
@@ -69,7 +73,16 @@ class RedisNodeRegistry {
   }
   async heartbeat() {
     const redis = (0, import_redis.getRedisClient)(this.app);
-    if (!redis) return;
+    if (!redis) {
+      this.lastHeartbeatError = "Redis is not configured for cluster node discovery";
+      if (!this.warnedMissingRedis) {
+        this.warnedMissingRedis = true;
+        this.app.logger.warn(
+          "[RedisNodeRegistry] Redis is not configured; Cluster Nodes can only show the local fallback node."
+        );
+      }
+      return;
+    }
     const port = process.env.APP_PORT || "unknown";
     const mode = process.env.WORKER_MODE || "main";
     const appName = process.env.APP_NAME || this.app.name || "main";
@@ -82,6 +95,7 @@ class RedisNodeRegistry {
       hostname: import_os.default.hostname(),
       appVersion: process.env.NOCOBASE_VERSION || process.version,
       workerMode: mode,
+      appRole: process.env.APP_ROLE,
       isSandbox: process.env.SKILL_HUB_SANDBOX === "true",
       pid: process.pid,
       url: process.env.APP_PUBLIC_URL || null,
@@ -100,6 +114,8 @@ class RedisNodeRegistry {
           arch: process.arch,
           uptime: process.uptime(),
           workerMode: mode,
+          appRole: process.env.APP_ROLE || "",
+          isSandbox: process.env.SKILL_HUB_SANDBOX === "true",
           appPort: port,
           clusterMode: process.env.CLUSTER_MODE || ""
         },
@@ -119,23 +135,26 @@ class RedisNodeRegistry {
       }
     };
     try {
-      await redis.sendCommand([
-        "SET",
-        key,
-        JSON.stringify(metadata),
-        "EX",
-        this.ttlSecs.toString()
-      ]);
+      await redis.sendCommand(["SET", key, JSON.stringify(metadata), "EX", this.ttlSecs.toString()]);
+      this.lastHeartbeatAt = Date.now();
+      this.lastHeartbeatError = null;
     } catch (err) {
+      this.lastHeartbeatError = err.message;
       this.app.logger.error(`[RedisNodeRegistry] Heartbeat failed: ${err.message}`);
     }
   }
   async getNodes() {
     const redis = (0, import_redis.getRedisClient)(this.app);
-    if (!redis) return [];
+    if (!redis) {
+      this.lastReadError = "Redis is not configured for cluster node discovery";
+      return [];
+    }
     try {
       const rawKeys = await (0, import_redis.scanKeys)(redis, `${this.keyPrefix}*`);
-      if (rawKeys.length === 0) return [];
+      if (rawKeys.length === 0) {
+        this.lastReadError = null;
+        return [];
+      }
       const values = await redis.sendCommand(["MGET", ...rawKeys]);
       const nodes = [];
       if (Array.isArray(values)) {
@@ -148,12 +167,27 @@ class RedisNodeRegistry {
           }
         }
       }
+      this.lastReadError = null;
       return nodes;
     } catch (err) {
+      this.lastReadError = err.message;
       this.app.logger.error(`[RedisNodeRegistry] Error fetching nodes: ${err.message}`);
       return [];
     }
   }
+  getStatus() {
+    const redis = (0, import_redis.getRedisClient)(this.app);
+    return {
+      configured: (0, import_redis.isClusterRedisConfigured)(this.app),
+      connected: Boolean(redis),
+      keyPrefix: this.keyPrefix,
+      ttlSecs: this.ttlSecs,
+      intervalMs: this.intervalMs,
+      lastHeartbeatAt: this.lastHeartbeatAt,
+      lastHeartbeatError: this.lastHeartbeatError,
+      lastReadError: this.lastReadError
+    };
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/server/collections/orchestrator-stacks.js

@@ -75,6 +75,12 @@ var orchestrator_stacks_default = {
       interface: "json",
       uiSchema: { title: "Environment Variables" }
     },
+    {
+      name: "workerMode",
+      type: "string",
+      interface: "input",
+      uiSchema: { title: "Worker Mode", "x-component": "Input" }
+    },
     {
       name: "volumes",
       type: "json",

package/dist/server/collections/worker-queue-mappings.js

@@ -88,7 +88,7 @@ var worker_queue_mappings_default = {
         "x-component": "Select",
         "x-component-props": {
           allowClear: true,
-          placeholder: "Unassigned (worker runs all queues)"
+          placeholder: "Unassigned (fallback only)"
         }
       }
     },

package/dist/server/orchestrator/PackageManager.js

@@ -46,6 +46,17 @@ var import_fs = require("fs");
 var import_path = __toESM(require("path"));
 const SAFE_PKG_RE = /^(?:[a-zA-Z0-9_.@/-]|\[|\])+$/;
 const INSTALL_CHANNEL = "cluster-manager.install-packages";
+const APT_ENV = {
+  DEBIAN_FRONTEND: "noninteractive",
+  DEBCONF_NONINTERACTIVE_SEEN: "true",
+  APT_LISTCHANGES_FRONTEND: "none",
+  TERM: "dumb",
+  NEEDRESTART_MODE: "a",
+  UCF_FORCE_CONFOLD: "1",
+  UCF_FORCE_CONFFOLD: "1"
+};
+const APT_DPKG_OPTIONS = ["-o", "Dpkg::Options::=--force-confdef", "-o", "Dpkg::Options::=--force-confold"];
+const DPKG_CONFIGURE_OPTIONS = ["--force-confdef", "--force-confold", "--configure", "-a"];
 function sanitizePkg(name) {
   if (typeof name !== "string") {
     throw new Error("Package name must be a string");
@@ -162,21 +173,26 @@ class PackageManager {
         npm: await this.getMissingPackages("npm", safePackages.npm, logs),
         python: await this.getMissingPackages("python", safePackages.python, logs)
       };
-      if (missingPackages.apt.length > 0) {
+      if (safePackages.apt.length > 0) {
         if (registryConfig.aptMirrorUrl) {
           const aptMirrorUrl = sanitizeHttpUrl(registryConfig.aptMirrorUrl, "APT mirror URL");
           logs.push(`Applying APT mirror: ${redactUrl(aptMirrorUrl)}`);
           await this.configureAptMirror(aptMirrorUrl, logs);
         }
-        await this.updateInstallStatus("running", 20, "Installing APT packages...", logs);
-        await this.runCommand("apt-get", ["update", "-qq"], "Updating APT package index...", logs, 12e5);
-        await this.runCommand(
-          "apt-get",
-          ["install", "-y", "--no-install-recommends", ...missingPackages.apt],
-          "Installing APT packages...",
-          logs,
-          12e5
-        );
+        await this.updateInstallStatus("running", 20, "Preparing APT/dpkg...", logs);
+        await this.repairAptState(logs);
+        if (missingPackages.apt.length > 0) {
+          await this.updateInstallStatus("running", 25, "Installing APT packages...", logs);
+          await this.runCommand("apt-get", ["update", "-qq"], "Updating APT package index...", logs, 12e5, APT_ENV);
+          await this.runCommand(
+            "apt-get",
+            [...APT_DPKG_OPTIONS, "install", "-y", "--no-install-recommends", ...missingPackages.apt],
+            "Installing APT packages...",
+            logs,
+            12e5,
+            APT_ENV
+          );
+        }
       }
       if (missingPackages.npm.length > 0) {
         if (registryConfig.npmRegistryUrl) {
@@ -259,12 +275,12 @@ ${logs.join("\n")}`);
   /**
    * Run a command without a shell so registry URLs and package names are not re-parsed as shell syntax.
    */
-  async runCommand(command, args, label, logs, timeoutMs = 12e5) {
+  async runCommand(command, args, label, logs, timeoutMs = 12e5, env) {
     logs.push(`RUNNING: ${formatCommand(command, args)}`);
     logs.push(`${label}`);
     await new Promise((resolve, reject) => {
       var _a, _b;
-      const child = (0, import_child_process.spawn)(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+      const child = (0, import_child_process.spawn)(command, args, { stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, ...env } });
       let stdout = "";
       let stderr = "";
       let settled = false;
@@ -302,6 +318,25 @@ ${logs.join("\n")}`);
       });
     });
   }
+  async repairAptState(logs) {
+    logs.push("Preparing APT/dpkg in non-interactive mode...");
+    await this.runCommand(
+      "dpkg",
+      DPKG_CONFIGURE_OPTIONS,
+      "Repairing interrupted dpkg configuration...",
+      logs,
+      12e5,
+      APT_ENV
+    );
+    await this.runCommand(
+      "apt-get",
+      [...APT_DPKG_OPTIONS, "-f", "install", "-y", "--no-install-recommends"],
+      "Repairing incomplete APT dependencies...",
+      logs,
+      12e5,
+      APT_ENV
+    );
+  }
   async getMissingPackages(kind, packages, logs) {
     const missing = [];
     for (const pkg of packages) {

package/dist/server/plugin.js

@@ -54,6 +54,7 @@ var import_event_queue_monitor = require("./actions/event-queue-monitor");
 var import_lock_monitor = require("./actions/lock-monitor");
 var import_cache_monitor = require("./actions/cache-monitor");
 var import_redis_pubsub_adapter = require("./adapters/redis-pubsub-adapter");
+var import_redis_event_queue_adapter = require("./adapters/redis-event-queue-adapter");
 var import_redis_node_registry = require("./adapters/redis-node-registry");
 var import_redis_lock_adapter = require("./adapters/redis-lock-adapter");
 var import_orchestrator = require("./actions/orchestrator");
@@ -88,7 +89,7 @@ class PluginClusterManagerServer extends import_server.Plugin {
     this.app.on("afterStart", () => {
       var _a;
       (_a = this.nodeRegistry) == null ? void 0 : _a.start();
-      const isWorker = (0, import_node.isWorkerMode)(process.env.WORKER_MODE) || process.env.APP_ROLE === "worker" || process.env.APP_ROLE === "sandbox";
+      const isWorker = (0, import_node.isWorkerMode)(process.env.WORKER_MODE) || process.env.APP_ROLE === "worker" || process.env.APP_ROLE === "sandbox" || process.env.SKILL_HUB_SANDBOX === "true";
       if (isWorker) {
         setTimeout(async () => {
           try {
@@ -153,6 +154,7 @@ class PluginClusterManagerServer extends import_server.Plugin {
       }
     });
     this.registerPubSubAdapter();
+    await this.registerEventQueueAdapter();
     const lockMgr = this.app.lockManager;
     if (lockMgr && lockMgr.registry && !lockMgr.registry.get("redis") && !lockMgr.adapters.get("redis")) {
       lockMgr.registerAdapter("redis", {
@@ -368,6 +370,35 @@ class PluginClusterManagerServer extends import_server.Plugin {
     this.app.pubSubManager.setAdapter(adapter);
     this.app.logger.info("[cluster-manager] Redis PubSub adapter registered");
   }
+  async registerEventQueueAdapter() {
+    var _a, _b;
+    const enabled = process.env.QUEUE_ADAPTER === "redis" || Boolean(process.env.QUEUE_ADAPTER_REDIS_URL);
+    if (!enabled) {
+      return;
+    }
+    const url = process.env.QUEUE_ADAPTER_REDIS_URL || process.env.REDIS_URL;
+    if (!url) {
+      this.app.logger.warn("[cluster-manager] QUEUE_ADAPTER=redis but QUEUE_ADAPTER_REDIS_URL/REDIS_URL is not set");
+      return;
+    }
+    const eventQueue = this.app.eventQueue;
+    const existingAdapter = eventQueue == null ? void 0 : eventQueue.adapter;
+    const existingName = (_a = existingAdapter == null ? void 0 : existingAdapter.constructor) == null ? void 0 : _a.name;
+    if (existingAdapter && existingName !== "MemoryEventQueueAdapter") {
+      this.app.logger.info(`[cluster-manager] EventQueue adapter already registered (${existingName}), skipping`);
+      return;
+    }
+    const adapter = new import_redis_event_queue_adapter.RedisEventQueueAdapter({ app: this.app, url });
+    const wasConnected = Boolean((_b = eventQueue == null ? void 0 : eventQueue.isConnected) == null ? void 0 : _b.call(eventQueue));
+    if (wasConnected) {
+      await eventQueue.close();
+    }
+    eventQueue.setAdapter(adapter);
+    if (wasConnected) {
+      await eventQueue.connect();
+    }
+    this.app.logger.info("[cluster-manager] Redis EventQueue adapter registered");
+  }
   /**
    * Initialize the Container Orchestrator subsystem.
    * Config is loaded from DB (orchestratorSettings collection) first,
@@ -431,10 +462,10 @@ class PluginClusterManagerServer extends import_server.Plugin {
     } catch (err) {
       this.app.logger.warn(`[Orchestrator] Could not load settings: ${err.message}`);
     }
-    const workerOnlyNode = this.isWorkerOnlyNode();
+    const nonAppNode = this.isNonAppNode();
     this.leaderElection = new import_leader_election.LeaderElection(this.app, {
-      enabled: !workerOnlyNode,
-      disabledReason: workerOnlyNode ? "Worker-only nodes do not run orchestrator write operations." : ""
+      enabled: !nonAppNode,
+      disabledReason: nonAppNode ? "Non-app nodes do not run orchestrator write operations." : ""
     });
     await this.leaderElection.init();
     this.app.on("afterStart", async () => {
@@ -498,8 +529,8 @@ class PluginClusterManagerServer extends import_server.Plugin {
       return false;
     }
   }
-  isWorkerOnlyNode() {
-    return (0, import_node.isWorkerMode)(process.env.WORKER_MODE);
+  isNonAppNode() {
+    return (0, import_node.getLocalRole)() !== "app";
   }
 }
 var plugin_default = PluginClusterManagerServer;

package/dist/server/queue-scanner.js

@@ -29,35 +29,24 @@ __export(queue_scanner_exports, {
   scanQueues: () => scanQueues
 });
 module.exports = __toCommonJS(queue_scanner_exports);
+var import_worker_processes = require("../shared/worker-processes");
 var import_redis = require("./utils/redis");
-const KNOWN_QUEUE_LABELS = {
-  "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)"
-  }
-};
-const REDIS_QUEUE_PATTERNS = ["*:plugin-git-manager:review:queue", "*:plugin-build-guide-block:build:queue"];
+const REDIS_QUEUE_PATTERNS = [
+  "*:plugin-git-manager:review:queue",
+  "*:plugin-build-guide-block:build:queue",
+  "*:plugin-build-visualization-block:build:queue",
+  "file-preview-auth.ocr.queue"
+];
 function describeRedisQueueKey(key) {
+  const workerProcessName = (0, import_worker_processes.resolveWorkerProcessName)(key);
+  const definition = (0, import_worker_processes.getWorkerProcessDefinition)(workerProcessName);
+  if (definition) {
+    return {
+      label: definition.label,
+      description: definition.description,
+      workerProcessName: definition.name
+    };
+  }
   const parts = String(key).split(":");
   const plugin = parts[parts.length - 3] || "unknown";
   const queue = parts[parts.length - 2] || key;
@@ -68,23 +57,46 @@ function describeRedisQueueKey(key) {
 }
 function scanEventQueue(app) {
   const eq = app.eventQueue;
-  if (!eq || !eq.events) return [];
+  if (!(eq == null ? void 0 : eq.events)) return [];
   const events = eq.events;
   const items = [];
   for (const [channel] of events.entries()) {
-    const known = KNOWN_QUEUE_LABELS[channel];
+    const workerProcessName = (0, import_worker_processes.resolveWorkerProcessName)(channel);
+    const known = (0, import_worker_processes.getWorkerProcessDefinition)(workerProcessName);
     items.push({
       name: channel,
       label: (known == null ? void 0 : known.label) ?? channel,
       description: (known == null ? void 0 : known.description) ?? `EventQueue channel: ${channel}`,
       type: "event-queue",
-      pending: null
+      pending: null,
+      workerProcessName: known == null ? void 0 : known.name
     });
   }
   return items;
 }
+function scanKnownWorkerModes(app) {
+  const pluginManager = app.pm;
+  if (!(pluginManager == null ? void 0 : pluginManager.get)) return [];
+  const hasPlugin = (name) => {
+    var _a;
+    try {
+      return Boolean((_a = pluginManager.get) == null ? void 0 : _a.call(pluginManager, name));
+    } catch {
+      return false;
+    }
+  };
+  return import_worker_processes.WORKER_PROCESS_DEFINITIONS.filter(
+    (definition) => definition.common && !definition.sandbox && (!definition.pluginName || hasPlugin(definition.pluginName))
+  ).map((definition) => ({
+    name: definition.name,
+    label: definition.label,
+    description: definition.description,
+    type: definition.kind === "redis-list" ? "redis-list" : "event-queue",
+    pending: null,
+    workerProcessName: definition.name
+  }));
+}
 async function scanRedisQueues(app) {
-  var _a;
   const redis = (0, import_redis.getRedisClient)(app);
   if (!redis) {
     return [];
@@ -93,8 +105,8 @@ async function scanRedisQueues(app) {
   const items = [];
   for (const pattern of REDIS_QUEUE_PATTERNS) {
     try {
-      const keys = await redis.sendCommand(["SCAN", "0", "MATCH", pattern, "COUNT", "200"]);
-      const keyList = typeof ((_a = keys[1]) == null ? void 0 : _a.length) === "number" ? keys[1] : [];
+      const result = await redis.sendCommand(["SCAN", "0", "MATCH", pattern, "COUNT", "200"]);
+      const keyList = Array.isArray(result == null ? void 0 : result[1]) ? result[1] : [];
       for (const key of keyList) {
         if (seen.has(key)) continue;
         seen.add(key);
@@ -110,7 +122,8 @@ async function scanRedisQueues(app) {
           label: desc.label,
           description: desc.description,
           type: "redis-list",
-          pending
+          pending,
+          workerProcessName: desc.workerProcessName
         });
       }
     } catch {
@@ -120,6 +133,7 @@ async function scanRedisQueues(app) {
 }
 async function scanQueues(app) {
   const eventQueues = scanEventQueue(app);
+  const knownWorkerModes = scanKnownWorkerModes(app);
   const redisQueues = await scanRedisQueues(app);
   const seenNames = /* @__PURE__ */ new Set();
   const merged = [];
@@ -127,6 +141,12 @@ async function scanQueues(app) {
     merged.push(q);
     seenNames.add(q.name);
   }
+  for (const q of knownWorkerModes) {
+    if (!seenNames.has(q.name)) {
+      merged.push(q);
+      seenNames.add(q.name);
+    }
+  }
   for (const q of redisQueues) {
     if (!seenNames.has(q.name)) {
       merged.push(q);

package/dist/server/utils/node.js

@@ -43,13 +43,9 @@ __export(node_exports, {
 });
 module.exports = __toCommonJS(node_exports);
 var import_os = __toESM(require("os"));
+var import_worker_processes = require("../../shared/worker-processes");
 function isWorkerMode(workerMode) {
-  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;
+  return (0, import_worker_processes.isWorkerOnlyMode)(workerMode ?? process.env.WORKER_MODE);
 }
 function getNodeRoleFrom(opts) {
   if (opts.appRole === "app" || opts.appRole === "worker" || opts.appRole === "sandbox") {
@@ -67,7 +63,7 @@ function getLocalRole() {
 }
 function getLocalNodeId(app) {
   const port = process.env.APP_PORT || "unknown";
-  const mode = process.env.WORKER_MODE || "main";
+  const mode = (0, import_worker_processes.normalizeWorkerMode)(process.env.WORKER_MODE) || "main";
   const appName = process.env.APP_NAME || (app == null ? void 0 : app.name) || "main";
   return `${appName}_${mode}_${import_os.default.hostname()}_${port}_${process.pid}`;
 }