plugin-cluster-manager 1.1.0 → 1.1.6

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

@@ -0,0 +1,23 @@
+/**
+ * DUMMY COLLECTION
+ * This collection is created to prevent NocoBase workflow/ACL from throwing the error:
+ * '[Workflow pre-action]: collection "clusterManagerRedis" not found'
+ * 
+ * Since 'clusterManagerRedis' 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: 'clusterManagerRedis',
+  dumpRules: 'skip',
+  autoGenId: true,
+  createdAt: false,
+  updatedAt: false,
+  fields: [
+    {
+      name: 'name',
+      type: 'string',
+    },
+  ],
+};

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

@@ -0,0 +1,23 @@
+/**
+ * DUMMY COLLECTION
+ * This collection is created to prevent NocoBase workflow/ACL from throwing the error:
+ * '[Workflow pre-action]: collection "clusterManagerWorkflow" not found'
+ * 
+ * Since 'clusterManagerWorkflow' 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: 'clusterManagerWorkflow',
+  dumpRules: 'skip',
+  autoGenId: true,
+  createdAt: false,
+  updatedAt: false,
+  fields: [
+    {
+      name: 'name',
+      type: 'string',
+    },
+  ],
+};

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

@@ -0,0 +1,23 @@
+/**
+ * DUMMY COLLECTION
+ * This collection is created to prevent NocoBase workflow/ACL from throwing the error:
+ * '[Workflow pre-action]: collection "clusterManager" not found'
+ * 
+ * Since 'clusterManager' 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: 'clusterManager',
+  dumpRules: 'skip',
+  autoGenId: true,
+  createdAt: false,
+  updatedAt: false,
+  fields: [
+    {
+      name: 'name',
+      type: 'string',
+    },
+  ],
+};

package/src/server/collections/worker-orchestrator.ts

@@ -0,0 +1,23 @@
+/**
+ * DUMMY COLLECTION
+ * This collection is created to prevent NocoBase workflow/ACL from throwing the error:
+ * '[Workflow pre-action]: collection "workerOrchestrator" not found'
+ * 
+ * Since 'workerOrchestrator' 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: 'workerOrchestrator',
+  dumpRules: 'skip',
+  autoGenId: true,
+  createdAt: false,
+  updatedAt: false,
+  fields: [
+    {
+      name: 'name',
+      type: 'string',
+    },
+  ],
+};

package/src/server/collections/worker-packages.ts

@@ -0,0 +1,23 @@
+/**
+ * DUMMY COLLECTION
+ * This collection is created to prevent NocoBase workflow/ACL from throwing the error:
+ * '[Workflow pre-action]: collection "workerPackages" not found'
+ * 
+ * Since 'workerPackages' 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: 'workerPackages',
+  dumpRules: 'skip',
+  autoGenId: true,
+  createdAt: false,
+  updatedAt: false,
+  fields: [
+    {
+      name: 'name',
+      type: 'string',
+    },
+  ],
+};

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

@@ -116,11 +116,11 @@ export class DockerAdapter implements IOrchestratorAdapter {
         const myContainer = this.docker.getContainer(myContainerId);
         const myInfo = await myContainer.inspect();
         
-        // Inherit Networks if none specified
-        if (!targetNetworkMode && targetNetworks.length === 0) {
-          if (myInfo?.NetworkSettings?.Networks) {
-            targetNetworks = Object.keys(myInfo.NetworkSettings.Networks);
-          }
+        // Always inherit Networks so worker can communicate with main app
+        if (myInfo?.NetworkSettings?.Networks) {
+          const inheritedNetworks = Object.keys(myInfo.NetworkSettings.Networks);
+          targetNetworks = Array.from(new Set([...inheritedNetworks, ...targetNetworks]));
+          console.log('[DockerAdapter] Inherited networks:', targetNetworks);
         }
         
         // Inherit Environment Variables and merge with stack.envVars
@@ -134,16 +134,23 @@ export class DockerAdapter implements IOrchestratorAdapter {
            });
            // Overwrite with explicitly defined env vars
            Object.assign(envDict, stack.envVars || {});
+           
            targetEnvVars = Object.entries(envDict).map(([k, v]) => `${k}=${v}`);
         }
-
         // Inherit Volumes (Binds)
         if (myInfo?.HostConfig?.Binds) {
           const inheritedBinds = myInfo.HostConfig.Binds as string[];
           targetVolumes = Array.from(new Set([...inheritedBinds, ...targetVolumes]));
         }
-      } catch (e) {
+      } catch (e: any) {
         // Ignore error if not running in a container or cannot inspect
+        console.error('[DockerAdapter] Failed to inherit container config:', e.message);
+      }
+
+      // Automatically separate logs for workers to prevent log interleaving with the main app
+      const hasLoggerBase = targetEnvVars.some(e => e.startsWith('LOGGER_BASE_PATH='));
+      if (!hasLoggerBase) {
+        targetEnvVars.push(`LOGGER_BASE_PATH=/app/nocobase/storage/logs/${stack.name}`);
       }
 
       for (let i = 0; i < diff; i++) {
@@ -185,8 +192,9 @@ export class DockerAdapter implements IOrchestratorAdapter {
         const container = await this.docker.createContainer(createOpts);
         
         // Connect to additional networks before starting
-        if (!targetNetworkMode && targetNetworks.length > 1) {
-          for (let i = 1; i < targetNetworks.length; i++) {
+        if (targetNetworks.length > 0) {
+          const startIndex = targetNetworkMode ? 0 : 1;
+          for (let i = startIndex; i < targetNetworks.length; i++) {
             try {
               const net = this.docker.getNetwork(targetNetworks[i]);
               await net.connect({ Container: container.id });
@@ -284,6 +292,14 @@ export class DockerAdapter implements IOrchestratorAdapter {
     return this.demuxDockerLogs(logBuffer);
   }
 
+  async listNetworks(): Promise<{ id: string; name: string }[]> {
+    const networks = await this.docker.listNetworks();
+    return networks.map((n: any) => ({
+      id: n.Id,
+      name: n.Name,
+    }));
+  }
+
   // ─── Private helpers ───
 
   private mapState(state: string): ContainerInfo['status'] {

package/src/server/orchestrator/types.ts

@@ -92,4 +92,7 @@ export interface IOrchestratorAdapter {
 
   /** Get tail logs from a container */
   getLogs(containerId: string, tail?: number): Promise<string>;
+
+  /** List available networks (if supported by adapter) */
+  listNetworks?(): Promise<{ id: string; name: 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';
@@ -28,7 +29,7 @@ export class PluginClusterManagerServer extends Plugin {
   public leaderElection: LeaderElection | null = null;
 
   async beforeLoad() {
-    this.db.import({ directory: path.resolve(__dirname, 'collections') });
+    await this.db.import({ directory: path.resolve(__dirname, 'collections') });
   }
 
   async load() {
@@ -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';

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

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

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

@@ -1,23 +0,0 @@
-import { Context } from '@nocobase/actions';
-export declare const cacheMonitorActions: {
-    /**
-     * GET /clusterManagerCacheMgr:stores
-     * List all registered cache stores and their config
-     */
-    stores(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerCacheMgr:caches
-     * List all created named caches
-     */
-    caches(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerCacheMgr:redisMemory
-     * Get Redis memory usage for cache keys
-     */
-    redisMemory(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /clusterManagerCacheMgr:flushAll
-     * Flush all caches via CacheManager
-     */
-    flushAll(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/cluster-nodes.d.ts

@@ -1,49 +0,0 @@
-import { Context } from '@nocobase/actions';
-/**
- * Read the last N lines from the local system log file.
- * Extracted so it can be called from both the HTTP action and the PubSub subscriber.
- */
-export declare function readLocalLogs(app: any, maxLines: number): Promise<{
-    node: {
-        hostname: string;
-        pid: number;
-        workerMode: string;
-    };
-    lines: string[];
-    file: string;
-}>;
-export declare const clusterActions: {
-    /**
-     * GET /clusterManagerCluster:current
-     * Always returns info about the APP node (not workers).
-     * If this request is handled by a worker, we look up the APP node from Redis.
-     */
-    current(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerCluster:list
-     * Returns all known cluster environments/nodes (if discovery adapter supports it)
-     */
-    list(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerCluster:health
-     * Health check for all subsystems
-     */
-    health(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /clusterManagerCluster:restart
-     * Publishes a restart signal to target nodes orchestrating a soft NocoBase restart or a hard docker daemon rebirth
-     */
-    restart(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerCluster:logs?targetNodeId=xxx&lines=200
-     *
-     * HA-aware log viewer. Reads logs from a specific node in the cluster.
-     *
-     * Flow:
-     *  1. If targetNodeId matches current node (or is empty) → read local FS directly
-     *  2. Otherwise → publish a log request via PubSub → target node reads its local FS
-     *     and writes the result to a Redis key → this handler polls Redis until the
-     *     response arrives (max 10s) → returns it to the client
-     */
-    logs(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/event-queue-monitor.d.ts

@@ -1,13 +0,0 @@
-import { Context } from '@nocobase/actions';
-export declare const eventQueueActions: {
-    /**
-     * GET /clusterManagerQueue:stats
-     * Returns event queue statistics
-     */
-    stats(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerQueue:messages
-     * List pending messages in a specific channel (memory adapter only)
-     */
-    messages(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

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

@@ -1,19 +0,0 @@
-import { Context } from '@nocobase/actions';
-export declare const lockActions: {
-    /**
-     * GET /clusterManagerLock:info
-     * Returns lock manager info
-     */
-    info(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerLock:list
-     * List active locks
-     */
-    list(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /clusterManagerLock:release
-     * Force release a stuck lock (admin emergency action)
-     * Uses compare-and-swap via DEL for Redis locks with the correct key prefix.
-     */
-    release(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/orchestrator.d.ts

@@ -1,53 +0,0 @@
-/**
- * Orchestrator Actions
- *
- * API endpoints for container management. Write operations (scale, start, stop, remove)
- * are guarded by leader election — only the leader node can execute them.
- */
-import { Context } from '@nocobase/actions';
-export declare const orchestratorActions: {
-    /**
-     * GET /workerOrchestrator:ping
-     * Test connectivity to the container runtime
-     */
-    ping(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /workerOrchestrator:containers?stackId=1
-     * List live containers for a stack
-     */
-    containers(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /workerOrchestrator:scale
-     * Body: { stackId: 1, replicas: 3 }
-     * Leader-only
-     */
-    scale(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /workerOrchestrator:start
-     * Body: { stackId: 1, containerId: "abc123" }
-     * Leader-only
-     */
-    start(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /workerOrchestrator:stop
-     * Body: { stackId: 1, containerId: "abc123" }
-     * Leader-only
-     */
-    stop(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /workerOrchestrator:remove
-     * Body: { stackId: 1, containerId: "abc123" }
-     * Leader-only
-     */
-    remove(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /workerOrchestrator:stats?containerId=abc123
-     * Get real-time stats for a container
-     */
-    stats(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /workerOrchestrator:logs?containerId=abc123&tail=100
-     * Get tail logs from a container
-     */
-    logs(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/package-manager.d.ts

@@ -1,6 +0,0 @@
-export declare const packageManagerActions: {
-    installPackages(ctx: any, next: () => Promise<void>): Promise<void>;
-    getPackageConfig(ctx: any, next: () => Promise<void>): Promise<void>;
-    savePackageConfig(ctx: any, next: () => Promise<void>): Promise<void>;
-    resetInitStatus(ctx: any, next: () => Promise<void>): Promise<void>;
-};

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

@@ -1,12 +0,0 @@
-import { Context } from '@nocobase/actions';
-export declare const redisActions: {
-    info(ctx: Context, next: () => Promise<void>): Promise<void>;
-    clients(ctx: Context, next: () => Promise<void>): Promise<void>;
-    pubsub(ctx: Context, next: () => Promise<void>): Promise<void>;
-    slowlog(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerRedis:syncMessages
-     * Returns info about NocoBase sync message channels (pub/sub layer)
-     */
-    syncMessages(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/tasks.d.ts

@@ -1,7 +0,0 @@
-import { Context } from '@nocobase/actions';
-export declare const tasksActions: {
-    list(ctx: Context, next: () => Promise<void>): Promise<void>;
-    cancel(ctx: Context, next: () => Promise<void>): Promise<void>;
-    retry(ctx: Context, next: () => Promise<void>): Promise<void>;
-    purge(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/workflow-executions.d.ts

@@ -1,7 +0,0 @@
-import { Context } from '@nocobase/actions';
-export declare const workflowActions: {
-    list(ctx: Context, next: () => Promise<void>): Promise<void>;
-    getJobs(ctx: Context, next: () => Promise<void>): Promise<void>;
-    cancel(ctx: Context, next: () => Promise<void>): Promise<void>;
-    purge(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/adapters/redis-lock-adapter.d.ts

@@ -1,15 +0,0 @@
-import { ILockAdapter, ILock, Releaser } from '@nocobase/lock-manager';
-import { Application } from '@nocobase/server';
-export declare class RedisLockAdapter implements ILockAdapter {
-    private options;
-    private client;
-    constructor(options: {
-        url?: string;
-        app: Application;
-    });
-    connect(): Promise<void>;
-    close(): Promise<void>;
-    acquire(key: string, ttl: number): Promise<Releaser>;
-    runExclusive<T>(key: string, fn: () => Promise<T>, ttl: number): Promise<T>;
-    tryAcquire(key: string, timeout?: number): Promise<ILock>;
-}

package/dist/server/adapters/redis-node-registry.d.ts

@@ -1,12 +0,0 @@
-export declare class RedisNodeRegistry {
-    private app;
-    private timer;
-    private readonly ttlSecs;
-    private readonly intervalMs;
-    private readonly keyPrefix;
-    constructor(app: any);
-    start(): void;
-    stop(): void;
-    private heartbeat;
-    getNodes(): Promise<any[]>;
-}