@kapeta/local-cluster-service 0.16.8 → 0.17.0

package/dist/esm/src/storageService.js

@@ -1,8 +1,14 @@
-import _ from 'lodash';
-import FS from 'fs';
-import FSExtra from 'fs-extra';
-import YAML from 'yaml';
-import ClusterConfiguration from '@kapeta/local-cluster-config';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storageService = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const fs_1 = __importDefault(require("fs"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const yaml_1 = __importDefault(require("yaml"));
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
 /**
  * Class that handles reading and writing from local configuration file.
  */
@@ -12,15 +18,15 @@ class StorageService {
         this._data = this._readConfig();
     }
     getKapetaBasedir() {
-        return ClusterConfiguration.getKapetaBasedir();
+        return local_cluster_config_1.default.getKapetaBasedir();
     }
     _readConfig() {
-        return ClusterConfiguration.getClusterConfig();
+        return local_cluster_config_1.default.getClusterConfig();
     }
     _writeConfig() {
-        const configFile = ClusterConfiguration.getClusterConfigFile();
-        FSExtra.mkdirsSync(this.getKapetaBasedir());
-        FS.writeFileSync(configFile, YAML.stringify(this._data));
+        const configFile = local_cluster_config_1.default.getClusterConfigFile();
+        fs_extra_1.default.mkdirsSync(this.getKapetaBasedir());
+        fs_1.default.writeFileSync(configFile, yaml_1.default.stringify(this._data));
     }
     section(section, defaultValue) {
         if (!defaultValue) {
@@ -33,7 +39,7 @@ class StorageService {
         return this._data[section];
     }
     put(section, property, value) {
-        if (!_.isString(property)) {
+        if (!lodash_1.default.isString(property)) {
             this._data[section] = property;
             this._writeConfig();
             return;
@@ -68,4 +74,4 @@ class StorageService {
         return out;
     }
 }
-export const storageService = new StorageService();
+exports.storageService = new StorageService();

package/dist/esm/src/taskManager.js

@@ -1,18 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskManager = exports.Task = exports.TaskStatus = void 0;
 /**
  * Class that handles processing background tasks.
  */
-import { socketManager } from './socketManager';
+const socketManager_1 = require("./socketManager");
 const EVENT_TASK_UPDATED = 'task-updated';
 const EVENT_TASK_ADDED = 'task-added';
 const EVENT_TASK_REMOVED = 'task-removed';
-export var TaskStatus;
+var TaskStatus;
 (function (TaskStatus) {
     TaskStatus["PENDING"] = "PENDING";
     TaskStatus["RUNNING"] = "RUNNING";
     TaskStatus["COMPLETED"] = "COMPLETED";
     TaskStatus["FAILED"] = "FAILED";
-})(TaskStatus || (TaskStatus = {}));
-export class Task {
+})(TaskStatus || (exports.TaskStatus = TaskStatus = {}));
+class Task {
     data;
     constructor(task) {
         this.data = task;
@@ -45,7 +48,7 @@ export class Task {
         this.data.metadata = metadata;
     }
     emitUpdate() {
-        socketManager.emitGlobal(EVENT_TASK_UPDATED, this.toData());
+        socketManager_1.socketManager.emitGlobal(EVENT_TASK_UPDATED, this.toData());
     }
     async wait() {
         return this.future.promise;
@@ -54,6 +57,7 @@ export class Task {
         return { ...this.data };
     }
 }
+exports.Task = Task;
 function createFuture() {
     let resolve = () => { };
     let reject = () => { };
@@ -85,7 +89,7 @@ class TaskManager {
             run: runner,
         });
         this._tasks.push(task);
-        socketManager.emitGlobal(EVENT_TASK_ADDED, task.toData());
+        socketManager_1.socketManager.emitGlobal(EVENT_TASK_ADDED, task.toData());
         this.invokeTask(task).catch(() => { });
         return task;
     }
@@ -119,7 +123,7 @@ class TaskManager {
             throw new Error('Cannot remove a running task');
         }
         this._tasks = this._tasks.filter((t) => t.id !== taskId);
-        socketManager.emitGlobal(EVENT_TASK_REMOVED, task.toData());
+        socketManager_1.socketManager.emitGlobal(EVENT_TASK_REMOVED, task.toData());
     }
     list() {
         return this._tasks.map((t) => t.toData());
@@ -158,4 +162,4 @@ class TaskManager {
         }
     }
 }
-export const taskManager = new TaskManager();
+exports.taskManager = new TaskManager();

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

@@ -1,16 +1,21 @@
-import Router from 'express-promise-router';
-import { corsHandler } from '../middleware/cors';
-import { taskManager } from '../taskManager';
-const router = Router();
-router.use('/', corsHandler);
+"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 cors_1 = require("../middleware/cors");
+const taskManager_1 = require("../taskManager");
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
 /**
  * Get all current tasks
  */
 router.get('/', (req, res) => {
-    res.send(taskManager.list());
+    res.send(taskManager_1.taskManager.list());
 });
 router.get('/:taskId', (req, res) => {
-    const task = taskManager.get(req.params.taskId);
+    const task = taskManager_1.taskManager.get(req.params.taskId);
     if (!task) {
         res.status(404).send({ error: 'Task not found' });
         return;
@@ -19,7 +24,7 @@ router.get('/:taskId', (req, res) => {
 });
 router.delete('/:taskId', (req, res) => {
     try {
-        taskManager.remove(req.params.taskId);
+        taskManager_1.taskManager.remove(req.params.taskId);
         res.send({ ok: true });
     }
     catch (e) {
@@ -27,4 +32,4 @@ router.delete('/:taskId', (req, res) => {
         return;
     }
 });
-export default router;
+exports.default = router;

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

@@ -1,13 +1,18 @@
-import Router from 'express-promise-router';
-import { networkManager } from '../networkManager';
-const router = Router();
+"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 networkManager_1 = require("../networkManager");
+const router = (0, express_promise_router_1.default)();
 router.get('/:systemId/target/:connectionId/', (req, res) => {
-    res.send(networkManager.getTrafficForConnection(req.params.systemId, req.params.connectionId));
+    res.send(networkManager_1.networkManager.getTrafficForConnection(req.params.systemId, req.params.connectionId));
 });
 router.get('/:systemId/source/:blockInstanceId/', (req, res) => {
-    res.send(networkManager.getTrafficForSource(req.params.systemId, req.params.blockInstanceId));
+    res.send(networkManager_1.networkManager.getTrafficForSource(req.params.systemId, req.params.blockInstanceId));
 });
 router.get('/:systemId/target/:blockInstanceId/', (req, res) => {
-    res.send(networkManager.getTrafficForTarget(req.params.systemId, req.params.blockInstanceId));
+    res.send(networkManager_1.networkManager.getTrafficForTarget(req.params.systemId, req.params.blockInstanceId));
 });
-export default router;
+exports.default = router;

package/dist/esm/src/types.js

@@ -1,15 +1,18 @@
-export var InstanceType;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DesiredInstanceStatus = exports.InstanceStatus = exports.InstanceOwner = exports.InstanceType = void 0;
+var InstanceType;
 (function (InstanceType) {
     InstanceType["DOCKER"] = "docker";
     InstanceType["LOCAL"] = "local";
     InstanceType["UNKNOWN"] = "unknown";
-})(InstanceType || (InstanceType = {}));
-export var InstanceOwner;
+})(InstanceType || (exports.InstanceType = InstanceType = {}));
+var InstanceOwner;
 (function (InstanceOwner) {
     InstanceOwner["INTERNAL"] = "internal";
     InstanceOwner["EXTERNAL"] = "external";
-})(InstanceOwner || (InstanceOwner = {}));
-export var InstanceStatus;
+})(InstanceOwner || (exports.InstanceOwner = InstanceOwner = {}));
+var InstanceStatus;
 (function (InstanceStatus) {
     InstanceStatus["STOPPED"] = "stopped";
     InstanceStatus["STARTING"] = "starting";
@@ -18,10 +21,10 @@ export var InstanceStatus;
     InstanceStatus["STOPPING"] = "stopping";
     InstanceStatus["UNHEALTHY"] = "unhealthy";
     InstanceStatus["FAILED"] = "failed";
-})(InstanceStatus || (InstanceStatus = {}));
-export var DesiredInstanceStatus;
+})(InstanceStatus || (exports.InstanceStatus = InstanceStatus = {}));
+var DesiredInstanceStatus;
 (function (DesiredInstanceStatus) {
     DesiredInstanceStatus["STOP"] = "stop";
     DesiredInstanceStatus["RUN"] = "run";
     DesiredInstanceStatus["EXTERNAL"] = "external";
-})(DesiredInstanceStatus || (DesiredInstanceStatus = {}));
+})(DesiredInstanceStatus || (exports.DesiredInstanceStatus = DesiredInstanceStatus = {}));

package/dist/esm/src/utils/BlockInstanceRunner.js

@@ -1,13 +1,19 @@
-import FS from 'node:fs';
-import ClusterConfig from '@kapeta/local-cluster-config';
-import { getBindHost, getBlockInstanceContainerName, normalizeKapetaUri, readYML } from './utils';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import { serviceManager } from '../serviceManager';
-import { containerManager, toLocalBindVolume } from '../containerManager';
-import { LogData } from './LogData';
-import { clusterService } from '../clusterService';
-import { InstanceType } from '../types';
-import { definitionsManager } from '../definitionsManager';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockInstanceRunner = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const utils_1 = require("./utils");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const serviceManager_1 = require("../serviceManager");
+const containerManager_1 = require("../containerManager");
+const LogData_1 = require("./LogData");
+const clusterService_1 = require("../clusterService");
+const types_1 = require("../types");
+const definitionsManager_1 = require("../definitionsManager");
 const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
 const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
@@ -22,9 +28,9 @@ const DOCKER_ENV_VARS = [
     `KAPETA_ENVIRONMENT_TYPE=docker`,
 ];
 function getProvider(uri) {
-    return definitionsManager.getProviderDefinitions().find((provider) => {
+    return definitionsManager_1.definitionsManager.getProviderDefinitions().find((provider) => {
         const ref = `${provider.definition.metadata.name}:${provider.version}`;
-        return parseKapetaUri(ref).id === uri.id;
+        return (0, nodejs_utils_1.parseKapetaUri)(ref).id === uri.id;
     });
 }
 function getProviderPorts(assetVersion) {
@@ -34,7 +40,7 @@ function getProviderPorts(assetVersion) {
     })
         .filter((t) => !!t) ?? []);
 }
-export class BlockInstanceRunner {
+class BlockInstanceRunner {
     _systemId;
     constructor(systemId) {
         /**
@@ -42,7 +48,7 @@ export class BlockInstanceRunner {
          * @type {string}
          * @private
          */
-        this._systemId = normalizeKapetaUri(systemId);
+        this._systemId = (0, utils_1.normalizeKapetaUri)(systemId);
     }
     /**
      * Start a block
@@ -66,18 +72,18 @@ export class BlockInstanceRunner {
         if (blockInstance.id) {
             env[KAPETA_INSTANCE_ID] = blockInstance.id;
         }
-        const blockUri = parseKapetaUri(blockInstance.ref);
+        const blockUri = (0, nodejs_utils_1.parseKapetaUri)(blockInstance.ref);
         if (!blockUri.version) {
             blockUri.version = 'local';
         }
-        const assetVersion = definitionsManager.getDefinitions().find((definitions) => {
+        const assetVersion = definitionsManager_1.definitionsManager.getDefinitions().find((definitions) => {
             const ref = `${definitions.definition.metadata.name}:${definitions.version}`;
-            return parseKapetaUri(ref).id === blockUri.id;
+            return (0, nodejs_utils_1.parseKapetaUri)(ref).id === blockUri.id;
         });
         if (!assetVersion) {
             throw new Error(`Block definition not found: ${blockUri.id}`);
         }
-        const kindUri = parseKapetaUri(assetVersion.definition.kind);
+        const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.kind);
         const providerVersion = getProvider(kindUri);
         if (!providerVersion) {
             throw new Error(`Kind not found: ${kindUri.id}`);
@@ -105,15 +111,15 @@ export class BlockInstanceRunner {
      * Starts local process
      */
     async _startLocalProcess(blockInstance, blockInfo, env, assetVersion) {
-        const baseDir = ClusterConfig.getRepositoryAssetPath(blockInfo.handle, blockInfo.name, blockInfo.version);
-        if (!FS.existsSync(baseDir)) {
+        const baseDir = local_cluster_config_1.default.getRepositoryAssetPath(blockInfo.handle, blockInfo.name, blockInfo.version);
+        if (!node_fs_1.default.existsSync(baseDir)) {
             throw new Error(`Local block not registered correctly - expected symlink here: ${baseDir}.\n` +
                 `Make sure you've run "blockctl registry link" in your local directory to connect it to Kapeta`);
         }
         if (!assetVersion.definition.spec?.target?.kind) {
             throw new Error('Missing target kind in block definition');
         }
-        const kindUri = parseKapetaUri(assetVersion.definition.spec?.target?.kind);
+        const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.spec?.target?.kind);
         const targetVersion = getProvider(kindUri);
         if (!targetVersion) {
             throw new Error(`Target not found: ${kindUri.id}`);
@@ -126,7 +132,7 @@ export class BlockInstanceRunner {
         if (!dockerImage) {
             throw new Error(`Missing docker image information: ${JSON.stringify(localContainer)}`);
         }
-        const containerName = getBlockInstanceContainerName(this._systemId, blockInstance.id);
+        const containerName = (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id);
         const startCmd = localContainer.handlers?.onCreate ? localContainer.handlers.onCreate : '';
         const dockerOpts = localContainer.options ?? {};
         const homeDir = localContainer.userHome ? localContainer.userHome : '/root';
@@ -134,7 +140,7 @@ export class BlockInstanceRunner {
         const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion);
         let HealthCheck = undefined;
         if (localContainer.healthcheck) {
-            HealthCheck = containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
+            HealthCheck = containerManager_1.containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
         return this.ensureContainer({
             Image: dockerImage,
@@ -148,7 +154,7 @@ export class BlockInstanceRunner {
             Cmd: startCmd ? startCmd.split(/\s+/g) : [],
             Env: [
                 ...DOCKER_ENV_VARS,
-                `KAPETA_LOCAL_CLUSTER_PORT=${clusterService.getClusterServicePort()}`,
+                `KAPETA_LOCAL_CLUSTER_PORT=${clusterService_1.clusterService.getClusterServicePort()}`,
                 ...Object.entries({
                     ...env,
                     ...addonEnv,
@@ -156,8 +162,8 @@ export class BlockInstanceRunner {
             ],
             HostConfig: {
                 Binds: [
-                    `${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${homeDir}/.kapeta`,
-                    `${toLocalBindVolume(baseDir)}:${workingDir}`,
+                    `${(0, containerManager_1.toLocalBindVolume)(local_cluster_config_1.default.getKapetaBasedir())}:${homeDir}/.kapeta`,
+                    `${(0, containerManager_1.toLocalBindVolume)(baseDir)}:${workingDir}`,
                 ],
                 PortBindings,
             },
@@ -165,12 +171,12 @@ export class BlockInstanceRunner {
         });
     }
     async _startDockerProcess(blockInstance, blockInfo, env, assetVersion) {
-        const { versionFile } = ClusterConfig.getRepositoryAssetInfoPath(blockInfo.handle, blockInfo.name, blockInfo.version);
+        const { versionFile } = local_cluster_config_1.default.getRepositoryAssetInfoPath(blockInfo.handle, blockInfo.name, blockInfo.version);
         const versionYml = versionFile;
-        if (!FS.existsSync(versionYml)) {
+        if (!node_fs_1.default.existsSync(versionYml)) {
             throw new Error(`Did not find version info at the expected path: ${versionYml}`);
         }
-        const versionInfo = readYML(versionYml);
+        const versionInfo = (0, utils_1.readYML)(versionYml);
         if (versionInfo?.artifact?.type !== 'docker') {
             throw new Error(`Unsupported artifact type: ${versionInfo?.artifact?.type}`);
         }
@@ -179,9 +185,9 @@ export class BlockInstanceRunner {
             throw new Error(`Missing docker image information: ${JSON.stringify(versionInfo?.artifact?.details)}`);
         }
         const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion);
-        const containerName = getBlockInstanceContainerName(this._systemId, blockInstance.id);
+        const containerName = (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id);
         // For windows we need to default to root
-        const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
+        const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
         return this.ensureContainer({
             Image: dockerImage,
             name: containerName,
@@ -191,14 +197,14 @@ export class BlockInstanceRunner {
             },
             Env: [
                 ...DOCKER_ENV_VARS,
-                `KAPETA_LOCAL_CLUSTER_PORT=${clusterService.getClusterServicePort()}`,
+                `KAPETA_LOCAL_CLUSTER_PORT=${clusterService_1.clusterService.getClusterServicePort()}`,
                 ...Object.entries({
                     ...env,
                     ...addonEnv,
                 }).map(([key, value]) => `${key}=${value}`),
             ],
             HostConfig: {
-                Binds: [`${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`],
+                Binds: [`${(0, containerManager_1.toLocalBindVolume)(local_cluster_config_1.default.getKapetaBasedir())}:${innerHome}`],
                 PortBindings,
             },
         });
@@ -213,9 +219,9 @@ export class BlockInstanceRunner {
      * @private
      */
     async _startOperatorProcess(blockInstance, blockUri, providerDefinition, env) {
-        const { assetFile } = ClusterConfig.getRepositoryAssetInfoPath(blockUri.handle, blockUri.name, blockUri.version);
+        const { assetFile } = local_cluster_config_1.default.getRepositoryAssetInfoPath(blockUri.handle, blockUri.name, blockUri.version);
         const kapetaYmlPath = assetFile;
-        if (!FS.existsSync(kapetaYmlPath)) {
+        if (!node_fs_1.default.existsSync(kapetaYmlPath)) {
             throw new Error(`Did not find kapeta.yml at the expected path: ${kapetaYmlPath}`);
         }
         const spec = providerDefinition.definition.spec;
@@ -225,9 +231,9 @@ export class BlockInstanceRunner {
         }
         const dockerImage = spec?.local?.image;
         //We only want 1 operator per operator type - across all local systems
-        const containerName = getBlockInstanceContainerName(this._systemId, blockInstance.id);
-        const logs = new LogData();
-        const bindHost = getBindHost();
+        const containerName = (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id);
+        const logs = new LogData_1.LogData();
+        const bindHost = (0, utils_1.getBindHost)();
         const ExposedPorts = {};
         const addonEnv = {};
         const PortBindings = {};
@@ -237,7 +243,7 @@ export class BlockInstanceRunner {
             const dockerPort = `${value.port}/${value.type}`;
             ExposedPorts[dockerPort] = {};
             addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = value.port;
-            const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
+            const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
             PortBindings[dockerPort] = [
                 {
                     HostIp: bindHost,
@@ -252,14 +258,14 @@ export class BlockInstanceRunner {
             });
         }
         if (spec.local?.mounts) {
-            const mounts = await containerManager.createMounts(this._systemId, blockUri.id, spec.local.mounts);
-            Mounts = containerManager.toDockerMounts(mounts);
+            const mounts = await containerManager_1.containerManager.createMounts(this._systemId, blockUri.id, spec.local.mounts);
+            Mounts = containerManager_1.containerManager.toDockerMounts(mounts);
         }
         if (spec.local?.health) {
-            HealthCheck = containerManager.toDockerHealth(spec.local?.health);
+            HealthCheck = containerManager_1.containerManager.toDockerHealth(spec.local?.health);
         }
         // For windows we need to default to root
-        const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
+        const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
         logs.addLog(`Creating new container for block: ${containerName}`);
         const out = await this.ensureContainer({
             Image: dockerImage,
@@ -268,8 +274,8 @@ export class BlockInstanceRunner {
             HealthCheck,
             HostConfig: {
                 Binds: [
-                    `${toLocalBindVolume(kapetaYmlPath)}:/kapeta.yml:ro`,
-                    `${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`,
+                    `${(0, containerManager_1.toLocalBindVolume)(kapetaYmlPath)}:/kapeta.yml:ro`,
+                    `${(0, containerManager_1.toLocalBindVolume)(local_cluster_config_1.default.getKapetaBasedir())}:${innerHome}`,
                 ],
                 PortBindings,
                 Mounts,
@@ -279,7 +285,7 @@ export class BlockInstanceRunner {
             },
             Env: [
                 `KAPETA_INSTANCE_NAME=${blockInstance.ref}`,
-                `KAPETA_LOCAL_CLUSTER_PORT=${clusterService.getClusterServicePort()}`,
+                `KAPETA_LOCAL_CLUSTER_PORT=${clusterService_1.clusterService.getClusterServicePort()}`,
                 ...DOCKER_ENV_VARS,
                 ...Object.entries({
                     ...env,
@@ -294,14 +300,14 @@ export class BlockInstanceRunner {
         return out;
     }
     async getDockerPortBindings(blockInstance, assetVersion) {
-        const bindHost = getBindHost();
+        const bindHost = (0, utils_1.getBindHost)();
         const ExposedPorts = {};
         const addonEnv = {};
         const PortBindings = {};
         const portTypes = getProviderPorts(assetVersion);
         let port = 80;
         const promises = portTypes.map(async (portType) => {
-            const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
+            const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
             const thisPort = port++; //TODO: Not sure how we should handle multiple ports or non-HTTP ports
             const dockerPort = `${thisPort}/tcp`;
             ExposedPorts[dockerPort] = {};
@@ -317,13 +323,14 @@ export class BlockInstanceRunner {
         return { PortBindings, ExposedPorts, addonEnv };
     }
     async ensureContainer(opts) {
-        const container = await containerManager.ensureContainer(opts);
+        const container = await containerManager_1.containerManager.ensureContainer(opts);
         return this._handleContainer(container);
     }
     async _handleContainer(container) {
         return {
-            type: InstanceType.DOCKER,
+            type: types_1.InstanceType.DOCKER,
             pid: container.id,
         };
     }
 }
+exports.BlockInstanceRunner = BlockInstanceRunner;

package/dist/esm/src/utils/DefaultProviderInstaller.d.ts

@@ -0,0 +1,11 @@
+declare class DefaultProviderInstaller {
+    private readonly progressListener;
+    checkForDefault(): Promise<void>;
+    private install;
+    private linkLocal;
+    private scanProjectBase;
+    private ensureDefaultProjectHome;
+    private download;
+}
+export declare const defaultProviderInstaller: DefaultProviderInstaller;
+export {};

package/dist/esm/src/utils/DefaultProviderInstaller.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultProviderInstaller = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const request_1 = __importDefault(require("request"));
+const tar_stream_1 = require("tar-stream");
+const gunzip_maybe_1 = __importDefault(require("gunzip-maybe"));
+const filesystemManager_1 = require("../filesystemManager");
+const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
+const progressListener_1 = require("../progressListener");
+const glob_1 = require("glob");
+const DEFAULT_PROVIDERS_URL = 'https://storage.googleapis.com/kapeta-production-cdn/archives/default-providers.tar.gz';
+const DEFAULT_PROJECT_HOME_DIR = 'KapetaProjects';
+const ARCHIVE_LOCAL_PREFIX = 'local';
+class DefaultProviderInstaller {
+    progressListener = new progressListener_1.ProgressListener();
+    async checkForDefault() {
+        const definitions = local_cluster_config_1.default.getDefinitions();
+        if (definitions.length < 1) {
+            console.log('Installing default providers');
+            try {
+                await this.install();
+            }
+            catch (e) {
+                console.warn('Failed to install defaults', e);
+            }
+        }
+    }
+    async install() {
+        await this.download();
+        await this.linkLocal();
+    }
+    async linkLocal() {
+        const projectBase = await this.ensureDefaultProjectHome();
+        const folders = this.scanProjectBase(projectBase);
+        for (let folder of folders) {
+            console.log('Linking %s', folder);
+            await nodejs_registry_utils_1.Actions.link(this.progressListener, folder);
+        }
+    }
+    scanProjectBase(projectBase) {
+        const assetFiles = glob_1.glob.sync('*/**/kapeta.yml', { cwd: projectBase });
+        return assetFiles.map((assetFile) => {
+            return node_path_1.default.dirname(node_path_1.default.join(projectBase, assetFile));
+        });
+    }
+    async ensureDefaultProjectHome() {
+        const defaultProjectHome = node_path_1.default.join(node_os_1.default.homedir(), DEFAULT_PROJECT_HOME_DIR);
+        let projectBase = filesystemManager_1.filesystemManager.getProjectRootFolder();
+        if (!projectBase) {
+            filesystemManager_1.filesystemManager.setProjectRootFolder(defaultProjectHome);
+            projectBase = defaultProjectHome;
+            if (!(await fs_extra_1.default.pathExists(projectBase))) {
+                await fs_extra_1.default.mkdirp(projectBase);
+            }
+        }
+        return projectBase;
+    }
+    async download() {
+        const projectBase = await this.ensureDefaultProjectHome();
+        const repoBase = local_cluster_config_1.default.getRepositoryBasedir();
+        return new Promise((resolve, reject) => {
+            const extractor = (0, tar_stream_1.extract)();
+            const dirCache = new Set();
+            extractor.on('entry', async function (header, stream, next) {
+                if (header.type !== 'file') {
+                    stream.on('end', function () {
+                        next(); // ready for next entry
+                    });
+                    stream.resume(); // just auto drain the stream
+                    return;
+                }
+                // Local (editable) assets should be stored in the project folder
+                // - installed assets goes into the repository folder
+                const baseDir = header.name.startsWith(ARCHIVE_LOCAL_PREFIX) ? projectBase : repoBase;
+                const parts = header.name.split(/\//g);
+                parts.shift();
+                const filename = parts.join(node_path_1.default.sep);
+                try {
+                    const dirname = node_path_1.default.join(baseDir, node_path_1.default.dirname(filename));
+                    if (!dirCache.has(dirname)) {
+                        let dirExists = false;
+                        try {
+                            await fs_extra_1.default.stat(dirname);
+                            dirExists = true;
+                        }
+                        catch (e) { }
+                        if (!dirExists) {
+                            await fs_extra_1.default.mkdirp(dirname);
+                        }
+                        dirCache.add(dirname);
+                    }
+                    const fileTarget = node_path_1.default.join(baseDir, filename);
+                    stream.on('error', (err) => {
+                        reject(err);
+                    });
+                    stream.on('end', next);
+                    stream.pipe(fs_extra_1.default.createWriteStream(fileTarget, {
+                        mode: header.mode,
+                    }));
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+            extractor.on('finish', function () {
+                // all entries done - lets finalize it
+                console.log('Default providers installed');
+                resolve();
+            });
+            extractor.on('error', function (err) {
+                reject(err);
+            });
+            console.log('Downloading default providers from %s', DEFAULT_PROVIDERS_URL);
+            const response = (0, request_1.default)(DEFAULT_PROVIDERS_URL);
+            response.on('error', function (err) {
+                reject(err);
+            });
+            response.pipe((0, gunzip_maybe_1.default)()).pipe(extractor);
+        });
+    }
+}
+exports.defaultProviderInstaller = new DefaultProviderInstaller();