plugin-cluster-manager 1.1.7 → 1.1.11

package/dist/server/collections/orchestrator-stacks.d.ts

@@ -0,0 +1,102 @@
+declare const _default: {
+    name: string;
+    autoGenId: boolean;
+    createdAt: boolean;
+    updatedAt: boolean;
+    fields: ({
+        name: string;
+        type: string;
+        unique: boolean;
+        interface: string;
+        uiSchema: {
+            title: string;
+            'x-component': string;
+            enum?: undefined;
+        };
+        defaultValue?: undefined;
+    } | {
+        name: string;
+        type: string;
+        defaultValue: string;
+        interface: string;
+        uiSchema: {
+            title: string;
+            'x-component': string;
+            enum: {
+                value: string;
+                label: string;
+            }[];
+        };
+        unique?: undefined;
+    } | {
+        name: string;
+        type: string;
+        interface: string;
+        uiSchema: {
+            title: string;
+            'x-component': string;
+            enum?: undefined;
+        };
+        unique?: undefined;
+        defaultValue?: undefined;
+    } | {
+        name: string;
+        type: string;
+        defaultValue: {};
+        interface: string;
+        uiSchema: {
+            title: string;
+            'x-component'?: undefined;
+            enum?: undefined;
+        };
+        unique?: undefined;
+    } | {
+        name: string;
+        type: string;
+        defaultValue: any[];
+        interface: string;
+        uiSchema: {
+            title: string;
+            'x-component'?: undefined;
+            enum?: undefined;
+        };
+        unique?: undefined;
+    } | {
+        name: string;
+        type: string;
+        defaultValue: number;
+        interface: string;
+        uiSchema: {
+            title: string;
+            'x-component'?: undefined;
+            enum?: undefined;
+        };
+        unique?: undefined;
+    } | {
+        name: string;
+        type: string;
+        defaultValue: boolean;
+        interface: string;
+        uiSchema: {
+            title: string;
+            'x-component'?: undefined;
+            enum?: undefined;
+        };
+        unique?: undefined;
+    } | {
+        name: string;
+        type: string;
+        defaultValue: string;
+        unique?: undefined;
+        interface?: undefined;
+        uiSchema?: undefined;
+    } | {
+        name: string;
+        type: string;
+        unique?: undefined;
+        interface?: undefined;
+        uiSchema?: undefined;
+        defaultValue?: undefined;
+    })[];
+};
+export default _default;

package/dist/server/collections/worker-orchestrator.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+declare const _default: {
+    name: string;
+    dumpRules: string;
+    autoGenId: boolean;
+    createdAt: boolean;
+    updatedAt: boolean;
+    fields: {
+        name: string;
+        type: string;
+    }[];
+};
+export default _default;

package/dist/server/collections/worker-packages-configs.d.ts

@@ -0,0 +1,3 @@
+import { CollectionOptions } from '@nocobase/database';
+declare const _default: CollectionOptions;
+export default _default;

package/dist/server/collections/worker-packages.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+declare const _default: {
+    name: string;
+    dumpRules: string;
+    autoGenId: boolean;
+    createdAt: boolean;
+    updatedAt: boolean;
+    fields: {
+        name: string;
+        type: string;
+    }[];
+};
+export default _default;

package/dist/server/hooks/cacheInvalidationHooks.d.ts

@@ -0,0 +1 @@
+export declare function registerCacheHooks(app: any): void;

package/dist/server/hooks/cacheInvalidationHooks.js

@@ -0,0 +1,81 @@
+/**
+ * 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 cacheInvalidationHooks_exports = {};
+__export(cacheInvalidationHooks_exports, {
+  registerCacheHooks: () => registerCacheHooks
+});
+module.exports = __toCommonJS(cacheInvalidationHooks_exports);
+var import_versionManager = require("../utils/versionManager");
+function registerCacheHooks(app) {
+  const db = app.db;
+  db.on("collections.afterSave", async () => {
+    await import_versionManager.cacheVersionManager.incrementCollectionVersion(app);
+  });
+  db.on("collections.afterDestroy", async () => {
+    await import_versionManager.cacheVersionManager.incrementCollectionVersion(app);
+  });
+  db.on("fields.afterSave", async () => {
+    await import_versionManager.cacheVersionManager.incrementCollectionVersion(app);
+  });
+  db.on("fields.afterDestroy", async () => {
+    await import_versionManager.cacheVersionManager.incrementCollectionVersion(app);
+  });
+  db.on("uiSchemas.afterSave", async () => {
+    await import_versionManager.cacheVersionManager.incrementSchemaVersion(app);
+  });
+  db.on("uiSchemas.afterDestroy", async () => {
+    await import_versionManager.cacheVersionManager.incrementSchemaVersion(app);
+  });
+  const invalidateRole = async (model) => {
+    var _a, _b;
+    const roleName = ((_a = model.get) == null ? void 0 : _a.call(model, "roleName")) || ((_b = model.get) == null ? void 0 : _b.call(model, "name"));
+    if (roleName) {
+      await import_versionManager.cacheVersionManager.incrementAclVersion(app, roleName);
+    } else {
+      await import_versionManager.cacheVersionManager.incrementAllAclVersions(app);
+    }
+  };
+  db.on("roles.afterSave", invalidateRole);
+  db.on("roles.afterDestroy", invalidateRole);
+  db.on("rolesResources.afterSave", invalidateRole);
+  db.on("rolesResources.afterDestroy", invalidateRole);
+  db.on("rolesResourcesActions.afterSave", invalidateRole);
+  db.on("rolesResourcesActions.afterDestroy", invalidateRole);
+  db.on("rolesUsers.afterSave", invalidateRole);
+  db.on("rolesUsers.afterDestroy", invalidateRole);
+  db.on("scopes.afterSave", async () => {
+    await import_versionManager.cacheVersionManager.incrementAllAclVersions(app);
+  });
+  db.on("scopes.afterDestroy", async () => {
+    await import_versionManager.cacheVersionManager.incrementAllAclVersions(app);
+  });
+  app.logger.info("[ClusterManager] Cache invalidation hooks registered successfully");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerCacheHooks
+});

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export { default } from './plugin';

package/dist/server/middlewares/listMetaCacheMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { Context } from '@nocobase/actions';
+export declare function createListMetaCacheMiddleware(app: any): (ctx: Context, next: () => Promise<void>) => Promise<void>;

package/dist/server/middlewares/listMetaCacheMiddleware.js

@@ -0,0 +1,79 @@
+/**
+ * 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 listMetaCacheMiddleware_exports = {};
+__export(listMetaCacheMiddleware_exports, {
+  createListMetaCacheMiddleware: () => createListMetaCacheMiddleware
+});
+module.exports = __toCommonJS(listMetaCacheMiddleware_exports);
+var import_versionManager = require("../utils/versionManager");
+const LIST_META_CACHE_TTL = 1e3 * 60 * 10;
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createListMetaCacheMiddleware(app) {
+  return async function listMetaCacheMiddleware(ctx, next) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const cache = app.cache;
+    if (!cache || ((_a = ctx.action) == null ? void 0 : _a.resourceName) !== "collections" || ((_b = ctx.action) == null ? void 0 : _b.actionName) !== "listMeta") {
+      return next();
+    }
+    const currentRole = ((_c = ctx.state) == null ? void 0 : _c.currentRole) || "anonymous";
+    const appName = ctx.headers["x-app"] || "main";
+    const dataSource = ctx.headers["x-data-source"] || "main";
+    const locale = ctx.headers["x-locale"] || ctx.headers["accept-language"] || "en-US";
+    let cacheKey = "";
+    let version = 0;
+    try {
+      version = await import_versionManager.cacheVersionManager.getCollectionVersion(app);
+      cacheKey = `nb:cache:${appName}:meta:v${version}:ds:${dataSource}:role:${currentRole}:lang:${locale}`;
+      const cached = await cache.get(cacheKey);
+      if (cached !== void 0 && cached !== null) {
+        ctx.body = typeof cached === "string" ? JSON.parse(cached) : cached;
+        (_d = ctx.set) == null ? void 0 : _d.call(ctx, "X-Cache", "HIT");
+        (_e = ctx.set) == null ? void 0 : _e.call(ctx, "X-Collection-Version", String(version));
+        return;
+      }
+    } catch (err) {
+      app.logger.warn(`[ClusterManager] listMeta cache read skipped: ${getErrorMessage(err)}`);
+    }
+    await next();
+    if (ctx.status === 200 && ctx.body && cacheKey) {
+      try {
+        const valueToCache = typeof ctx.body === "string" ? ctx.body : JSON.stringify(ctx.body);
+        await cache.set(cacheKey, valueToCache, LIST_META_CACHE_TTL);
+        (_f = ctx.set) == null ? void 0 : _f.call(ctx, "X-Cache", "MISS");
+        (_g = ctx.set) == null ? void 0 : _g.call(ctx, "X-Collection-Version", String(version));
+      } catch (err) {
+        app.logger.warn(`[ClusterManager] listMeta cache write skipped: ${getErrorMessage(err)}`);
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createListMetaCacheMiddleware
+});

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

@@ -0,0 +1,39 @@
+import Application from '@nocobase/server';
+type TargetRole = 'app' | 'worker' | 'sandbox' | 'all';
+interface InstallPayload {
+    targetRole: TargetRole;
+    packages: {
+        apt?: string[];
+        npm?: string[];
+        python?: string[];
+    };
+    registryConfig?: {
+        aptMirrorUrl?: string;
+        npmRegistryUrl?: string;
+        pypiIndexUrl?: string;
+        pypiTrustedHost?: string;
+    };
+}
+export declare class PackageManager {
+    private app;
+    constructor(app: Application);
+    /**
+     * Called from REST action when admin clicks "Install Packages".
+     * Publishes task to all nodes via PubSub. Nodes will filter by targetRole.
+     */
+    dispatchInstall(payload: InstallPayload): Promise<string>;
+    executeInstall(payload: InstallPayload): Promise<void>;
+    /**
+     * Run a command without a shell so registry URLs and package names are not re-parsed as shell syntax.
+     */
+    private runCommand;
+    private getMissingPackages;
+    private isPackageInstalled;
+    private runStatus;
+    private getAptOsInfo;
+    private buildAptSources;
+    private configureAptMirror;
+    private moveIfExists;
+    private updateInstallStatus;
+}
+export {};

package/dist/server/orchestrator/PackageManager.js

@@ -41,9 +41,10 @@ __export(PackageManager_exports, {
 module.exports = __toCommonJS(PackageManager_exports);
 var import_child_process = require("child_process");
 var import_redis = require("../utils/redis");
+var import_node = require("../utils/node");
 var import_fs = require("fs");
 var import_path = __toESM(require("path"));
-const SAFE_PKG_RE = /^[a-zA-Z0-9_\-\.@\/\[\]]+$/;
+const SAFE_PKG_RE = /^(?:[a-zA-Z0-9_.@/-]|\[|\])+$/;
 const INSTALL_CHANNEL = "cluster-manager.install-packages";
 function sanitizePkg(name) {
   if (typeof name !== "string") {
@@ -99,6 +100,35 @@ function formatCommand(command, args) {
     return /^[a-zA-Z0-9_./:@=-]+$/.test(value) ? value : JSON.stringify(value);
   }).join(" ");
 }
+function parseOsRelease(content) {
+  const values = {};
+  for (const line of content.split("\n")) {
+    const match = line.match(/^([A-Z0-9_]+)=(.*)$/);
+    if (!match) continue;
+    values[match[1]] = match[2].replace(/^"|"$/g, "");
+  }
+  return values;
+}
+function normalizeMirrorUrl(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+function isInternalCacheMirror(url) {
+  return url.hostname === "nginx-cache-registry";
+}
+function resolveAptMirrorForOs(aptMirrorUrl, osInfo, logs) {
+  const url = new URL(normalizeMirrorUrl(aptMirrorUrl));
+  const original = url.toString();
+  if (isInternalCacheMirror(url) && osInfo.id === "debian" && url.pathname === "/ubuntu/") {
+    url.pathname = "/debian/";
+  } else if (isInternalCacheMirror(url) && osInfo.id === "ubuntu" && url.pathname === "/debian/") {
+    url.pathname = "/ubuntu/";
+  }
+  const resolved = url.toString();
+  if (resolved !== original) {
+    logs.push(`Adjusted APT mirror for ${osInfo.id}: ${redactUrl(resolved)}`);
+  }
+  return resolved;
+}
 class PackageManager {
   constructor(app) {
     this.app = app;
@@ -143,7 +173,7 @@ class PackageManager {
         if (registryConfig.aptMirrorUrl) {
           const aptMirrorUrl = sanitizeHttpUrl(registryConfig.aptMirrorUrl, "APT mirror URL");
           logs.push(`Applying APT mirror: ${redactUrl(aptMirrorUrl)}`);
-          await this.configureAptMirror(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);
@@ -245,11 +275,11 @@ ${logs.join("\n")}`);
       let stdout = "";
       let stderr = "";
       let settled = false;
-      let timer;
+      const state = {};
       const finish = (error) => {
         if (settled) return;
         settled = true;
-        clearTimeout(timer);
+        if (state.timer) clearTimeout(state.timer);
         if (stdout) logs.push(stdout.slice(0, 500));
         if (stderr) logs.push(`WARN: ${stderr.slice(0, 300)}`);
         if (error) {
@@ -259,7 +289,7 @@ ${logs.join("\n")}`);
           resolve();
         }
       };
-      timer = setTimeout(() => {
+      state.timer = setTimeout(() => {
         child.kill("SIGTERM");
         finish(new Error(`${command} timed out after ${timeoutMs}ms`));
       }, timeoutMs);
@@ -312,14 +342,14 @@ ${logs.join("\n")}`);
       const child = (0, import_child_process.spawn)(command, args, { stdio: ["ignore", "pipe", "ignore"] });
       let stdout = "";
       let settled = false;
-      let timer;
+      const state = {};
       const finish = (ok) => {
         if (settled) return;
         settled = true;
-        clearTimeout(timer);
+        if (state.timer) clearTimeout(state.timer);
         resolve(ok);
       };
-      timer = setTimeout(() => {
+      state.timer = setTimeout(() => {
         child.kill("SIGTERM");
         finish(false);
       }, timeoutMs);
@@ -330,7 +360,31 @@ ${logs.join("\n")}`);
       child.on("close", (code) => finish(code === 0 && (isSuccess ? isSuccess(stdout) : true)));
     });
   }
-  async configureAptMirror(aptMirrorUrl) {
+  async getAptOsInfo() {
+    const values = parseOsRelease(await import_fs.promises.readFile("/etc/os-release", "utf8"));
+    const id = (values.ID || "").toLowerCase();
+    const codename = values.VERSION_CODENAME || values.UBUNTU_CODENAME;
+    if (!id || !codename) {
+      throw new Error("Cannot detect OS ID/version codename from /etc/os-release for APT mirror configuration.");
+    }
+    return { id, codename };
+  }
+  buildAptSources(aptMirrorUrl, osInfo) {
+    const mirror = normalizeMirrorUrl(aptMirrorUrl);
+    if (osInfo.id === "ubuntu") {
+      return `deb ${mirror} ${osInfo.codename} main universe restricted multiverse
+`;
+    }
+    if (osInfo.id === "debian") {
+      return `deb ${mirror} ${osInfo.codename} main contrib non-free non-free-firmware
+`;
+    }
+    return `deb ${mirror} ${osInfo.codename} main
+`;
+  }
+  async configureAptMirror(aptMirrorUrl, logs) {
+    const osInfo = await this.getAptOsInfo();
+    const resolvedMirrorUrl = resolveAptMirrorForOs(aptMirrorUrl, osInfo, logs);
     const backupDir = "/etc/apt/sources.list.d.bak";
     await import_fs.promises.mkdir(backupDir, { recursive: true });
     await this.moveIfExists("/etc/apt/sources.list", import_path.default.join(backupDir, `sources.list.${Date.now()}.bak`));
@@ -342,8 +396,7 @@ ${logs.join("\n")}`);
       }
     } catch {
     }
-    await import_fs.promises.writeFile("/etc/apt/sources.list", `deb ${aptMirrorUrl} bookworm main
-`, "utf8");
+    await import_fs.promises.writeFile("/etc/apt/sources.list", this.buildAptSources(resolvedMirrorUrl, osInfo), "utf8");
   }
   async moveIfExists(from, to) {
     try {
@@ -356,22 +409,25 @@ ${logs.join("\n")}`);
       const redisClient = (0, import_redis.getRedisClient)(this.app);
       const podName = process.env.POD_NAME || require("os").hostname();
       if (redisClient) {
-        const key = `orchestrator:pkg-status:${podName}`;
-        await redisClient.sendCommand([
-          "SET",
-          key,
-          JSON.stringify({
-            initStatus,
-            initProgressPercent,
-            initProgressLog,
-            lastInitAt: /* @__PURE__ */ new Date(),
-            lastInitLog: logs.join("\n"),
-            ...extraValues
-          }),
-          "EX",
-          "86400"
-          // expire after 1 day
-        ]);
+        const statusPayload = JSON.stringify({
+          initStatus,
+          initProgressPercent,
+          initProgressLog,
+          lastInitAt: /* @__PURE__ */ new Date(),
+          lastInitLog: logs.join("\n"),
+          ...extraValues
+        });
+        const keys = [`orchestrator:pkg-status:${podName}`, `cluster-manager:pkg-status:${(0, import_node.getLocalNodeId)(this.app)}`];
+        for (const key of keys) {
+          await redisClient.sendCommand([
+            "SET",
+            key,
+            statusPayload,
+            "EX",
+            "86400"
+            // expire after 1 day
+          ]);
+        }
       }
       const repo = this.app.db.getRepository("workerPackagesConfigs");
       let config = await repo.findOne();

package/dist/server/orchestrator/docker-adapter.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Docker Adapter — MVP implementation
+ *
+ * Uses dockerode to communicate with the Docker daemon via unix socket.
+ * Containers are tagged with label `orchestrator.stack=<stackName>` for identification.
+ *
+ * Security: Docker socket = root on host. Only admin users should access
+ * orchestrator actions (enforced by ACL in plugin.ts).
+ */
+import type { IOrchestratorAdapter, ContainerInfo, ScaleResult, ContainerStats, StackConfig } from './types';
+export declare class DockerAdapter implements IOrchestratorAdapter {
+    readonly name = "docker";
+    private docker;
+    private workerLabels;
+    constructor(options?: {
+        socketPath?: string;
+        host?: string;
+        port?: number;
+        workerLabelSelector?: string;
+    });
+    ping(): Promise<boolean>;
+    listContainers(stack: StackConfig): Promise<ContainerInfo[]>;
+    assertManagedByStack(stack: StackConfig, containerId: string): Promise<void>;
+    scale(stack: StackConfig, replicas: number): Promise<ScaleResult>;
+    startContainer(containerId: string): Promise<void>;
+    stopContainer(containerId: string, timeoutSecs?: number): Promise<void>;
+    removeContainer(containerId: string): Promise<void>;
+    getStats(containerId: string): Promise<ContainerStats>;
+    getLogs(containerId: string, tail?: number): Promise<string>;
+    listNetworks(): Promise<{
+        id: string;
+        name: string;
+    }[]>;
+    private mapState;
+    private buildEnvArray;
+    private buildLabelFilters;
+    private parseLabelSelector;
+    private labelsMatch;
+    private parseMemory;
+    private demuxDockerLogs;
+}

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

@@ -0,0 +1,4 @@
+export { IOrchestratorAdapter, ContainerInfo, ScaleResult, ContainerStats, StackConfig } from './types';
+export { DockerAdapter } from './docker-adapter';
+export { K8sAdapter } from './k8s-adapter';
+export { LeaderElection } from './leader-election';

package/dist/server/orchestrator/k8s-adapter.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Kubernetes Adapter
+ *
+ * Manages worker Deployments/Pods via the K8s API using in-cluster ServiceAccount
+ * or kubeconfig. Only manages resources labeled with `orchestrator.stack=<stackName>`.
+ *
+ * Prerequisites:
+ *   - ServiceAccount with RBAC: get/list/create/patch/update on Deployments and Deployments/scale
+ *   - get/list/delete on Pods and get on Pods/log
+ *   - Or KUBECONFIG env var pointing to a valid kubeconfig file
+ */
+import type { IOrchestratorAdapter, ContainerInfo, ScaleResult, ContainerStats, StackConfig } from './types';
+export declare class K8sAdapter implements IOrchestratorAdapter {
+    readonly name = "kubernetes";
+    private appsApi;
+    private coreApi;
+    private kc;
+    private namespace;
+    private workerLabelSelector;
+    private workerLabels;
+    constructor(options?: {
+        kubeconfig?: string;
+        context?: string;
+        namespace?: string;
+        workerLabelSelector?: string;
+    });
+    ping(): Promise<boolean>;
+    listContainers(stack: StackConfig): Promise<ContainerInfo[]>;
+    scale(stack: StackConfig, replicas: number): Promise<ScaleResult>;
+    startContainer(containerId: string): Promise<void>;
+    stopContainer(containerId: string): Promise<void>;
+    removeContainer(containerId: string): Promise<void>;
+    getStats(containerId: string): Promise<ContainerStats>;
+    getLogs(containerId: string, tail?: number): Promise<string>;
+    assertManagedByStack(stack: StackConfig, containerId: string): Promise<void>;
+    private parsePodRef;
+    private buildDeployment;
+    private buildWorkerLabels;
+    private buildContainerEnv;
+    private buildResources;
+    private cleanArray;
+    private isEmptyValue;
+    private isNotFound;
+    private assertDeploymentManagedByStack;
+    private joinSelectors;
+    private parseLabelSelector;
+    private labelsMatch;
+    private mapPodPhase;
+    private parseK8sMemory;
+}