@kapeta/local-cluster-service 0.16.8 → 0.18.0

package/dist/esm/src/instances/routes.js

@@ -1,37 +1,42 @@
-import Router from 'express-promise-router';
-import { instanceManager } from '../instanceManager';
-import { serviceManager } from '../serviceManager';
-import { corsHandler } from '../middleware/cors';
-import { kapetaHeaders } from '../middleware/kapeta';
-import { stringBody } from '../middleware/stringBody';
-import { DesiredInstanceStatus, InstanceOwner, InstanceType } from '../types';
-import { Task } from '../taskManager';
-const router = Router();
-router.use('/', corsHandler);
-router.use('/', kapetaHeaders);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const instanceManager_1 = require("../instanceManager");
+const serviceManager_1 = require("../serviceManager");
+const cors_1 = require("../middleware/cors");
+const kapeta_1 = require("../middleware/kapeta");
+const stringBody_1 = require("../middleware/stringBody");
+const types_1 = require("../types");
+const taskManager_1 = require("../taskManager");
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
+router.use('/', kapeta_1.kapetaHeaders);
 /**
  * Get all instances
  */
 router.get('/', (req, res) => {
-    res.send(instanceManager.getInstances());
+    res.send(instanceManager_1.instanceManager.getInstances());
 });
 /**
  * Get all instances
  */
-router.get('/:systemId/instances', (req, res) => {
-    res.send(instanceManager.getInstancesForPlan(req.params.systemId));
+router.get('/:systemId/instances', async (req, res) => {
+    res.send(await instanceManager_1.instanceManager.getInstancesForPlan(req.params.systemId));
 });
 /**
  * Get single instance in a plan
  */
 router.get('/:systemId/instances/:instanceId', (req, res) => {
-    res.send(instanceManager.getInstance(req.params.systemId, req.params.instanceId));
+    res.send(instanceManager_1.instanceManager.getInstance(req.params.systemId, req.params.instanceId));
 });
 /**
  * Start all instances in a plan
  */
 router.post('/:systemId/start', async (req, res) => {
-    const task = await instanceManager.startAllForPlan(req.params.systemId);
+    const task = await instanceManager_1.instanceManager.startAllForPlan(req.params.systemId);
     res.status(202).send({
         ok: true,
         taskId: task.id,
@@ -41,7 +46,7 @@ router.post('/:systemId/start', async (req, res) => {
  * Stop all instances in plan
  */
 router.post('/:systemId/stop', async (req, res) => {
-    const task = instanceManager.stopAllForPlan(req.params.systemId);
+    const task = instanceManager_1.instanceManager.stopAllForPlan(req.params.systemId);
     res.status(202).send({
         ok: true,
         taskId: task.id,
@@ -51,8 +56,8 @@ router.post('/:systemId/stop', async (req, res) => {
  * Start single instance in a plan
  */
 router.post('/:systemId/:instanceId/start', async (req, res) => {
-    const result = await instanceManager.start(req.params.systemId, req.params.instanceId);
-    if (result instanceof Task) {
+    const result = await instanceManager_1.instanceManager.start(req.params.systemId, req.params.instanceId);
+    if (result instanceof taskManager_1.Task) {
         res.status(202).send({
             ok: true,
             taskId: result.id,
@@ -70,20 +75,20 @@ router.post('/:systemId/:instanceId/start', async (req, res) => {
  * Stop single instance in a plan
  */
 router.post('/:systemId/:instanceId/stop', async (req, res) => {
-    await instanceManager.stop(req.params.systemId, req.params.instanceId);
+    await instanceManager_1.instanceManager.stop(req.params.systemId, req.params.instanceId);
     res.status(202).send({ ok: true });
 });
 /**
  * Get logs for instance in a plan
  */
 router.get('/:systemId/:instanceId/logs', async (req, res) => {
-    const instanceInfo = instanceManager.getInstance(req.params.systemId, req.params.instanceId);
+    const instanceInfo = instanceManager_1.instanceManager.getInstance(req.params.systemId, req.params.instanceId);
     if (!instanceInfo) {
         res.status(404).send({ ok: false });
         return;
     }
     try {
-        const logs = await instanceManager.getLogs(req.params.systemId, req.params.instanceId);
+        const logs = await instanceManager_1.instanceManager.getLogs(req.params.systemId, req.params.instanceId);
         res.status(200).send({
             logs,
         });
@@ -96,7 +101,7 @@ router.get('/:systemId/:instanceId/logs', async (req, res) => {
  * Get public address for instance in a plan if available
  */
 router.get('/:systemId/:instanceId/address/public', (req, res) => {
-    const instance = instanceManager.getInstance(req.params.systemId, req.params.instanceId);
+    const instance = instanceManager_1.instanceManager.getInstance(req.params.systemId, req.params.instanceId);
     if (!instance) {
         res.status(404).send({ ok: false });
         return;
@@ -111,9 +116,9 @@ router.get('/:systemId/:instanceId/address/public', (req, res) => {
  * Get public address for particular resource on instance in a plan if available
  */
 router.get('/:systemId/:instanceId/provider/:portType/:resourceName/address/public', (req, res) => {
-    res.send(serviceManager.getConsumerAddress(req.params.systemId, req.params.instanceId, req.params.resourceName, req.params.portType, req.kapeta?.environment));
+    res.send(serviceManager_1.serviceManager.getConsumerAddress(req.params.systemId, req.params.instanceId, req.params.resourceName, req.params.portType, req.kapeta?.environment));
 });
-router.use('/', stringBody);
+router.use('/', stringBody_1.stringBody);
 router.use('/', (req, res, next) => {
     if (!req.kapeta.blockRef) {
         res.status(400).send({ error: 'Missing X-Kapeta-Block header.' });
@@ -128,22 +133,22 @@ router.put('/', async (req, res) => {
     let instance = req.stringBody ? JSON.parse(req.stringBody) : null;
     if (req.kapeta.environment === 'docker') {
         //A bit hacky but we want to avoid overwriting the docker PID with a process PID
-        const oldInstance = instanceManager.getInstance(req.kapeta.systemId, req.kapeta.instanceId);
+        const oldInstance = instanceManager_1.instanceManager.getInstance(req.kapeta.systemId, req.kapeta.instanceId);
         if (oldInstance) {
             instance.pid = oldInstance.pid;
             instance.desiredStatus = oldInstance.desiredStatus;
         }
-        instance.type = InstanceType.DOCKER;
-        instance.owner = InstanceOwner.INTERNAL;
+        instance.type = types_1.InstanceType.DOCKER;
+        instance.owner = types_1.InstanceOwner.INTERNAL;
     }
     else {
         // Coming from user starting the instance outside of kapeta
-        instance.type = InstanceType.LOCAL;
-        instance.owner = InstanceOwner.EXTERNAL;
-        instance.desiredStatus = DesiredInstanceStatus.EXTERNAL;
+        instance.type = types_1.InstanceType.LOCAL;
+        instance.owner = types_1.InstanceOwner.EXTERNAL;
+        instance.desiredStatus = types_1.DesiredInstanceStatus.EXTERNAL;
     }
     try {
-        await instanceManager.registerInstanceFromSDK(req.kapeta.systemId, req.kapeta.instanceId, instance);
+        await instanceManager_1.instanceManager.registerInstanceFromSDK(req.kapeta.systemId, req.kapeta.instanceId, instance);
         res.status(202).send({ ok: true });
     }
     catch (e) {
@@ -154,7 +159,7 @@ router.put('/', async (req, res) => {
  * Delete instance
  */
 router.delete('/', async (req, res) => {
-    await instanceManager.markAsStopped(req.kapeta.systemId, req.kapeta.instanceId);
+    await instanceManager_1.instanceManager.markAsStopped(req.kapeta.systemId, req.kapeta.instanceId);
     res.status(202).send({ ok: true });
 });
-export default router;
+exports.default = router;

package/dist/esm/src/middleware/cors.js

@@ -1,6 +1,10 @@
-export function corsHandler(req, res, next) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.corsHandler = void 0;
+function corsHandler(req, res, next) {
     res.set('Access-Control-Allow-Origin', req.headers.origin);
     res.set('Access-Control-Allow-Methods', 'GET, PUT, POST, DELETE, HEAD, PATCH');
     res.set('Access-Control-Allow-Headers', '*');
     next();
 }
+exports.corsHandler = corsHandler;

package/dist/esm/src/middleware/kapeta.js

@@ -1,14 +1,17 @@
-import { normalizeKapetaUri } from '../utils/utils';
-export function kapetaHeaders(req, res, next) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kapetaHeaders = void 0;
+const utils_1 = require("../utils/utils");
+function kapetaHeaders(req, res, next) {
     let blockRef = req.headers['x-kapeta-block'];
     let systemId = req.headers['x-kapeta-system'];
     let instanceId = req.headers['x-kapeta-instance'];
     let environment = req.headers['x-kapeta-environment'];
     if (blockRef) {
-        blockRef = normalizeKapetaUri(blockRef);
+        blockRef = (0, utils_1.normalizeKapetaUri)(blockRef);
     }
     if (systemId) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
     }
     req.kapeta = {
         blockRef,
@@ -18,3 +21,4 @@ export function kapetaHeaders(req, res, next) {
     };
     next();
 }
+exports.kapetaHeaders = kapetaHeaders;

package/dist/esm/src/middleware/stringBody.js

@@ -1,4 +1,7 @@
-export function stringBody(req, res, next) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringBody = void 0;
+function stringBody(req, res, next) {
     // push the data to body
     const body = [];
     req.on('data', (chunk) => {
@@ -8,3 +11,4 @@ export function stringBody(req, res, next) {
         next();
     });
 }
+exports.stringBody = stringBody;

package/dist/esm/src/networkManager.js

@@ -1,5 +1,11 @@
-import uuid from 'node-uuid';
-import { normalizeKapetaUri } from './utils/utils';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.networkManager = void 0;
+const node_uuid_1 = __importDefault(require("node-uuid"));
+const utils_1 = require("./utils/utils");
 class NetworkManager {
     _connections;
     _sources;
@@ -18,7 +24,7 @@ class NetworkManager {
         this._targets = {};
     }
     _ensureSystem(systemId) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         if (!this._connections[systemId]) {
             this._connections[systemId] = {};
         }
@@ -30,7 +36,7 @@ class NetworkManager {
         }
     }
     _ensureConnection(systemId, connectionId) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         this._ensureSystem(systemId);
         if (!this._connections[systemId][connectionId]) {
             this._connections[systemId][connectionId] = [];
@@ -38,7 +44,7 @@ class NetworkManager {
         return this._connections[systemId][connectionId];
     }
     _ensureSource(systemId, sourceBlockInstanceId) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         this._ensureSystem(systemId);
         if (!this._sources[systemId][sourceBlockInstanceId]) {
             this._sources[systemId][sourceBlockInstanceId] = [];
@@ -46,7 +52,7 @@ class NetworkManager {
         return this._sources[systemId][sourceBlockInstanceId];
     }
     _ensureTarget(systemId, targetBlockInstanceId) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         this._ensureSystem(systemId);
         if (!this._targets[systemId][targetBlockInstanceId]) {
             this._targets[systemId][targetBlockInstanceId] = [];
@@ -54,7 +60,7 @@ class NetworkManager {
         return this._targets[systemId][targetBlockInstanceId];
     }
     addRequest(systemId, connection, request, consumerMethodId, providerMethodId) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         const traffic = new Traffic(connection, request, consumerMethodId, providerMethodId);
         this._ensureConnection(systemId, traffic.connectionId).push(traffic);
         this._ensureSource(systemId, connection.provider.blockId).push(traffic);
@@ -82,7 +88,7 @@ class Traffic {
     error;
     response;
     constructor(connection, request, consumerMethodId, providerMethodId) {
-        this.id = uuid.v4();
+        this.id = node_uuid_1.default.v4();
         this.connectionId = NetworkManager.toConnectionId(connection);
         this.consumerMethodId = consumerMethodId;
         this.providerMethodId = providerMethodId;
@@ -106,4 +112,4 @@ class Traffic {
         this.response = response;
     }
 }
-export const networkManager = new NetworkManager();
+exports.networkManager = new NetworkManager();

package/dist/esm/src/operatorManager.d.ts

@@ -21,7 +21,7 @@ declare class OperatorManager {
      * @param {string} version
      * @return {Operator}
      */
-    getOperator(resourceType: string, version: string): Operator;
+    getOperator(resourceType: string, version: string): Promise<Operator>;
     /**
      * Get information about a specific consumed resource
      */

package/dist/esm/src/operatorManager.js

@@ -1,16 +1,23 @@
-import Path from 'path';
-import md5 from 'md5';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import { serviceManager } from './serviceManager';
-import { storageService } from './storageService';
-import { CONTAINER_LABEL_PORT_PREFIX, ContainerInfo, containerManager } from './containerManager';
-import FSExtra from 'fs-extra';
-import { definitionsManager } from './definitionsManager';
-import { getBindHost, normalizeKapetaUri } from './utils/utils';
-import _ from 'lodash';
-import AsyncLock from 'async-lock';
-import { taskManager } from './taskManager';
-export const KIND_OPERATOR = 'core/resource-type-operator';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operatorManager = exports.KIND_OPERATOR = void 0;
+const path_1 = __importDefault(require("path"));
+const md5_1 = __importDefault(require("md5"));
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const serviceManager_1 = require("./serviceManager");
+const storageService_1 = require("./storageService");
+const containerManager_1 = require("./containerManager");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const definitionsManager_1 = require("./definitionsManager");
+const utils_1 = require("./utils/utils");
+const lodash_1 = __importDefault(require("lodash"));
+const async_lock_1 = __importDefault(require("async-lock"));
+const taskManager_1 = require("./taskManager");
+exports.KIND_OPERATOR = 'core/resource-type-operator';
+const KIND_PLAN = 'core/plan';
 class Operator {
     _data;
     constructor(data) {
@@ -28,13 +35,13 @@ class Operator {
 }
 class OperatorManager {
     _mountDir;
-    operatorLock = new AsyncLock();
+    operatorLock = new async_lock_1.default();
     constructor() {
-        this._mountDir = Path.join(storageService.getKapetaBasedir(), 'mounts');
-        FSExtra.mkdirpSync(this._mountDir);
+        this._mountDir = path_1.default.join(storageService_1.storageService.getKapetaBasedir(), 'mounts');
+        fs_extra_1.default.mkdirpSync(this._mountDir);
     }
     _getMountPoint(operatorType, mountName) {
-        return Path.join(this._mountDir, operatorType, mountName);
+        return path_1.default.join(this._mountDir, operatorType, mountName);
     }
     /**
      * Get operator definition for resource type
@@ -43,8 +50,8 @@ class OperatorManager {
      * @param {string} version
      * @return {Operator}
      */
-    getOperator(resourceType, version) {
-        const operators = definitionsManager.getDefinitions(KIND_OPERATOR);
+    async getOperator(resourceType, version) {
+        const operators = await definitionsManager_1.definitionsManager.getDefinitions(exports.KIND_OPERATOR);
         const operator = operators.find((operator) => operator.definition &&
             operator.definition.metadata &&
             operator.definition.metadata.name &&
@@ -62,9 +69,9 @@ class OperatorManager {
      * Get information about a specific consumed resource
      */
     async getConsumerResourceInfo(systemId, fromServiceId, resourceType, portType, name, environment) {
-        systemId = normalizeKapetaUri(systemId);
-        const plans = definitionsManager.getDefinitions('core/plan');
-        const planUri = parseKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
+        const plans = await definitionsManager_1.definitionsManager.getDefinitions(KIND_PLAN);
+        const planUri = (0, nodejs_utils_1.parseKapetaUri)(systemId);
         const currentPlan = plans.find((plan) => plan.definition.metadata.name === planUri.fullName && plan.version === planUri.version);
         if (!currentPlan) {
             throw new Error(`Unknown plan: ${systemId}`);
@@ -73,10 +80,7 @@ class OperatorManager {
         if (!currentInstance) {
             throw new Error(`Unknown instance: ${fromServiceId} in plan ${systemId}`);
         }
-        const blockUri = parseKapetaUri(currentInstance.block.ref);
-        const blockDefinition = definitionsManager
-            .getDefinitions()
-            .find((definition) => definition.version === blockUri.version && definition.definition.metadata.name === blockUri.fullName);
+        const blockDefinition = await definitionsManager_1.definitionsManager.getDefinition(currentInstance.block.ref);
         if (!blockDefinition) {
             throw new Error(`Unknown block: ${currentInstance.block.ref} in plan ${systemId}`);
         }
@@ -84,8 +88,8 @@ class OperatorManager {
         if (!blockResource) {
             throw new Error(`Unknown resource: ${name} in block ${currentInstance.block.ref} in plan ${systemId}`);
         }
-        const kindUri = parseKapetaUri(blockResource.kind);
-        const operator = this.getOperator(resourceType, kindUri.version);
+        const kindUri = (0, nodejs_utils_1.parseKapetaUri)(blockResource.kind);
+        const operator = await this.getOperator(resourceType, kindUri.version);
         const credentials = operator.getCredentials();
         const container = await this.ensureResource(systemId, resourceType, kindUri.version);
         const portInfo = await container.getPort(portType);
@@ -113,10 +117,10 @@ class OperatorManager {
      * @return {Promise<ContainerInfo>}
      */
     async ensureResource(systemId, resourceType, version) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         const key = `${systemId}#${resourceType}:${version}`;
         return await this.operatorLock.acquire(key, async () => {
-            const operator = this.getOperator(resourceType, version);
+            const operator = await this.getOperator(resourceType, version);
             const operatorData = operator.getLocalData();
             const portTypes = Object.keys(operatorData.ports);
             portTypes.sort();
@@ -124,7 +128,7 @@ class OperatorManager {
             for (let i = 0; i < portTypes.length; i++) {
                 const portType = portTypes[i];
                 let containerPortInfo = operatorData.ports[portType];
-                const hostPort = await serviceManager.ensureServicePort(systemId, resourceType, portType);
+                const hostPort = await serviceManager_1.serviceManager.ensureServicePort(systemId, resourceType, portType);
                 if (typeof containerPortInfo === 'number' || typeof containerPortInfo === 'string') {
                     containerPortInfo = { port: containerPortInfo, type: 'tcp' };
                 }
@@ -137,18 +141,18 @@ class OperatorManager {
                     hostPort,
                 };
             }
-            const mounts = await containerManager.createMounts(systemId, resourceType, operatorData.mounts);
+            const mounts = await containerManager_1.containerManager.createMounts(systemId, resourceType, operatorData.mounts);
             const nameParts = [systemId, resourceType.toLowerCase(), version];
-            const containerName = `kapeta-resource-${md5(nameParts.join('_'))}`;
+            const containerName = `kapeta-resource-${(0, md5_1.default)(nameParts.join('_'))}`;
             const PortBindings = {};
             const Env = [];
             const Labels = {
                 kapeta: 'true',
             };
             const operatorMetadata = operator.getDefinitionInfo().definition.metadata;
-            const bindHost = getBindHost();
+            const bindHost = (0, utils_1.getBindHost)();
             const ExposedPorts = {};
-            _.forEach(ports, (portInfo, containerPort) => {
+            lodash_1.default.forEach(ports, (portInfo, containerPort) => {
                 ExposedPorts['' + containerPort] = {};
                 PortBindings['' + containerPort] = [
                     {
@@ -156,18 +160,18 @@ class OperatorManager {
                         HostIp: bindHost,
                     },
                 ];
-                Labels[CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
+                Labels[containerManager_1.CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
             });
-            const Mounts = containerManager.toDockerMounts(mounts);
-            _.forEach(operatorData.env, (value, name) => {
+            const Mounts = containerManager_1.containerManager.toDockerMounts(mounts);
+            lodash_1.default.forEach(operatorData.env, (value, name) => {
                 Env.push(name + '=' + value);
             });
-            const task = taskManager.add(`operator:ensure:${key}`, async () => {
+            const task = taskManager_1.taskManager.add(`operator:ensure:${key}`, async () => {
                 let HealthCheck = undefined;
                 if (operatorData.health) {
-                    HealthCheck = containerManager.toDockerHealth(operatorData.health);
+                    HealthCheck = containerManager_1.containerManager.toDockerHealth(operatorData.health);
                 }
-                const container = await containerManager.ensureContainer({
+                const container = await containerManager_1.containerManager.ensureContainer({
                     name: containerName,
                     Image: operatorData.image,
                     Hostname: containerName + '.kapeta',
@@ -181,8 +185,8 @@ class OperatorManager {
                         Mounts,
                     },
                 });
-                await containerManager.waitForReady(container);
-                return new ContainerInfo(container);
+                await containerManager_1.containerManager.waitForReady(container);
+                return new containerManager_1.ContainerInfo(container);
             }, {
                 name: `Ensuring ${operatorMetadata.title ?? operatorMetadata.name}`,
                 systemId,
@@ -191,4 +195,4 @@ class OperatorManager {
         });
     }
 }
-export const operatorManager = new OperatorManager();
+exports.operatorManager = new OperatorManager();

package/dist/esm/src/progressListener.js

@@ -1,7 +1,10 @@
-import { spawn } from '@kapeta/nodejs-process';
-import { socketManager } from './socketManager';
-import { format } from 'node:util';
-export class ProgressListener {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressListener = void 0;
+const nodejs_process_1 = require("@kapeta/nodejs-process");
+const socketManager_1 = require("./socketManager");
+const node_util_1 = require("node:util");
+class ProgressListener {
     systemId;
     instanceId;
     constructor(systemId, instanceId) {
@@ -15,21 +18,21 @@ export class ProgressListener {
             time: Date.now(),
         };
         if (this.systemId && this.instanceId) {
-            socketManager.emitInstanceLog(this.systemId, this.instanceId, logEntry);
+            socketManager_1.socketManager.emitInstanceLog(this.systemId, this.instanceId, logEntry);
             return;
         }
         if (this.systemId) {
-            socketManager.emitSystemLog(this.systemId, logEntry);
+            socketManager_1.socketManager.emitSystemLog(this.systemId, logEntry);
             return;
         }
-        socketManager.emitGlobalLog(logEntry);
+        socketManager_1.socketManager.emitGlobalLog(logEntry);
     }
     run(command, directory) {
         this.info(`Running command "${command}"`);
         return new Promise(async (resolve, reject) => {
             try {
                 const chunks = [];
-                const child = spawn(command, [], {
+                const child = (0, nodejs_process_1.spawn)(command, [], {
                     cwd: directory ? directory : process.cwd(),
                     shell: true,
                 });
@@ -89,26 +92,27 @@ export class ProgressListener {
     }
     error(msg, ...args) {
         this.emitLog({
-            message: format(msg, args),
+            message: (0, node_util_1.format)(msg, args),
             level: 'ERROR',
         });
     }
     warn(msg, ...args) {
         this.emitLog({
-            message: format(msg, args),
+            message: (0, node_util_1.format)(msg, args),
             level: 'WARN',
         });
     }
     info(msg, ...args) {
         this.emitLog({
-            message: format(msg, args),
+            message: (0, node_util_1.format)(msg, args),
             level: 'INFO',
         });
     }
     debug(msg, ...args) {
         this.emitLog({
-            message: format(msg, args),
+            message: (0, node_util_1.format)(msg, args),
             level: 'DEBUG',
         });
     }
 }
+exports.ProgressListener = ProgressListener;

package/dist/esm/src/providerManager.d.ts

@@ -1,5 +1,6 @@
+import { DefinitionInfo } from '@kapeta/local-cluster-config';
 declare class ProviderManager {
-    getWebProviders(): import("@kapeta/local-cluster-config").DefinitionInfo[];
+    getWebProviders(): Promise<DefinitionInfo[]>;
     getProviderWebJS(handle: string, name: string, version: string, sourceMap?: boolean): Promise<unknown>;
 }
 export declare const providerManager: ProviderManager;