@kapeta/local-cluster-service 0.16.8 → 0.18.0

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';
@@ -21,10 +27,11 @@ const DOCKER_ENV_VARS = [
     `KAPETA_LOCAL_CLUSTER_HOST=host.docker.internal`,
     `KAPETA_ENVIRONMENT_TYPE=docker`,
 ];
-function getProvider(uri) {
-    return definitionsManager.getProviderDefinitions().find((provider) => {
+async function getProvider(uri) {
+    const providers = await definitionsManager_1.definitionsManager.getProviderDefinitions();
+    return providers.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 +41,7 @@ function getProviderPorts(assetVersion) {
     })
         .filter((t) => !!t) ?? []);
 }
-export class BlockInstanceRunner {
+class BlockInstanceRunner {
     _systemId;
     constructor(systemId) {
         /**
@@ -42,7 +49,7 @@ export class BlockInstanceRunner {
          * @type {string}
          * @private
          */
-        this._systemId = normalizeKapetaUri(systemId);
+        this._systemId = (0, utils_1.normalizeKapetaUri)(systemId);
     }
     /**
      * Start a block
@@ -66,19 +73,16 @@ 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 ref = `${definitions.definition.metadata.name}:${definitions.version}`;
-            return parseKapetaUri(ref).id === blockUri.id;
-        });
+        const assetVersion = await definitionsManager_1.definitionsManager.getDefinition(blockUri.id);
         if (!assetVersion) {
             throw new Error(`Block definition not found: ${blockUri.id}`);
         }
-        const kindUri = parseKapetaUri(assetVersion.definition.kind);
-        const providerVersion = getProvider(kindUri);
+        const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.kind);
+        const providerVersion = await getProvider(kindUri);
         if (!providerVersion) {
             throw new Error(`Kind not found: ${kindUri.id}`);
         }
@@ -105,16 +109,16 @@ 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 targetVersion = getProvider(kindUri);
+        const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.spec?.target?.kind);
+        const targetVersion = await getProvider(kindUri);
         if (!targetVersion) {
             throw new Error(`Target not found: ${kindUri.id}`);
         }
@@ -126,7 +130,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 +138,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 +152,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 +160,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 +169,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 +183,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 +195,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 +217,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 +229,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 +241,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 +256,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 +272,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 +283,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 +298,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 +321,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();

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

@@ -1,5 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogData = void 0;
 const MAX_LINES = 1000;
-export class LogData {
+class LogData {
     static MAX_LINES = MAX_LINES;
     entries = [];
     constructor() { }
@@ -36,3 +39,4 @@ export class LogData {
             .join('\n');
     }
 }
+exports.LogData = LogData;

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

@@ -1,14 +1,18 @@
-import { spawn, hasApp } from '@kapeta/nodejs-process';
-import { taskManager } from '../taskManager';
-export async function hasCLI() {
-    return hasApp('kap');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureCLI = exports.hasCLI = void 0;
+const nodejs_process_1 = require("@kapeta/nodejs-process");
+const taskManager_1 = require("../taskManager");
+async function hasCLI() {
+    return (0, nodejs_process_1.hasApp)('kap');
 }
-export async function ensureCLI() {
+exports.hasCLI = hasCLI;
+async function ensureCLI() {
     if (await hasCLI()) {
         return null;
     }
-    return taskManager.add(`cli:install`, () => {
-        const process = spawn('npm', ['install', '-g', '@kapeta/kap'], {
+    return taskManager_1.taskManager.add(`cli:install`, () => {
+        const process = (0, nodejs_process_1.spawn)('npm', ['install', '-g', '@kapeta/kap'], {
             shell: true,
         });
         return process.wait();
@@ -16,3 +20,4 @@ export async function ensureCLI() {
         name: `Installing Kapeta CLI`,
     });
 }
+exports.ensureCLI = ensureCLI;

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

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathTemplateParser = exports.PathTemplate = void 0;
 const TYPE_VARIABLE = 'variable';
 const TYPE_PATH = 'path';
 /**
@@ -11,7 +14,7 @@ const TYPE_PATH = 'path';
  *  /foo/{bar:[0-9]+}/baz
  *
  */
-export class PathTemplate {
+class PathTemplate {
     _path;
     _parts = [];
     constructor(pathTemplate) {
@@ -108,9 +111,11 @@ export class PathTemplate {
         return 'tmpl: ' + this.path;
     }
 }
+exports.PathTemplate = PathTemplate;
 /**
  * Parses a path into a RESTPath
  */
-export function pathTemplateParser(path) {
+function pathTemplateParser(path) {
     return new PathTemplate(path);
 }
+exports.pathTemplateParser = pathTemplateParser;

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

@@ -1,40 +1,53 @@
-import FS from 'node:fs';
-import YAML from 'yaml';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import md5 from 'md5';
-export function getBlockInstanceContainerName(systemId, instanceId) {
-    return `kapeta-block-instance-${md5(systemId + instanceId)}`;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBindHost = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = exports.normalizeKapetaUri = exports.getBlockInstanceContainerName = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const yaml_1 = __importDefault(require("yaml"));
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const md5_1 = __importDefault(require("md5"));
+function getBlockInstanceContainerName(systemId, instanceId) {
+    return `kapeta-block-instance-${(0, md5_1.default)(systemId + instanceId)}`;
 }
-export function normalizeKapetaUri(uri) {
+exports.getBlockInstanceContainerName = getBlockInstanceContainerName;
+function normalizeKapetaUri(uri) {
     if (!uri) {
         return '';
     }
-    const uriObj = parseKapetaUri(uri);
+    const uriObj = (0, nodejs_utils_1.parseKapetaUri)(uri);
     if (!uriObj.version) {
-        return `kapeta://${parseKapetaUri(uri).fullName}`;
+        return `kapeta://${(0, nodejs_utils_1.parseKapetaUri)(uri).fullName}`;
     }
-    return `kapeta://${parseKapetaUri(uri).id}`;
+    return `kapeta://${(0, nodejs_utils_1.parseKapetaUri)(uri).id}`;
 }
-export function readYML(path) {
-    const rawYaml = FS.readFileSync(path);
+exports.normalizeKapetaUri = normalizeKapetaUri;
+function readYML(path) {
+    const rawYaml = node_fs_1.default.readFileSync(path);
     try {
-        return YAML.parse(rawYaml.toString());
+        return yaml_1.default.parse(rawYaml.toString());
     }
     catch (err) {
         throw new Error(`Failed to parse plan YAML: ${err}`);
     }
 }
-export function isWindows() {
+exports.readYML = readYML;
+function isWindows() {
     return 'win32' === process.platform;
 }
-export function isMac() {
+exports.isWindows = isWindows;
+function isMac() {
     return 'darwin' === process.platform;
 }
-export function isLinux() {
+exports.isMac = isMac;
+function isLinux() {
     return !isWindows() && !isMac();
 }
-export function getBindHost(preferredHost = '127.0.0.1') {
+exports.isLinux = isLinux;
+function getBindHost(preferredHost = '127.0.0.1') {
     // On Linux we need to bind to 0.0.0.0 to be able to connect to it from docker containers.
     // TODO: This might pose a security risk - so we should authenticate all requests using a shared secret/nonce that we pass around.
     return isLinux() ? '0.0.0.0' : preferredHost;
 }
+exports.getBindHost = getBindHost;

package/dist/esm/start.js

@@ -1,5 +1,10 @@
-import localClusterService from './index';
-localClusterService
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+index_1.default
     .start()
     .then(({ host, port }) => console.log('Listening on port %s:%s', host, port))
     .catch((e) => {

package/index.ts

@@ -22,6 +22,8 @@ import { getBindHost } from './src/utils/utils';
 import request from 'request';
 import { repositoryManager } from './src/repositoryManager';
 import { ensureCLI } from './src/utils/commandLineUtils';
+import { defaultProviderInstaller } from './src/utils/DefaultProviderInstaller';
+import { authManager } from './src/authManager';
 
 export type LocalClusterService = HTTP.Server & { host?: string; port?: number };
 
@@ -122,6 +124,8 @@ export default {
             );
         }
 
+        await defaultProviderInstaller.checkForDefault();
+
         const clusterPort = storageService.get('cluster', 'port');
         if (clusterPort) {
             clusterService.setClusterServicePort(clusterPort);
@@ -144,6 +148,7 @@ export default {
         }
 
         await clusterService.init();
+        await authManager.listenForChanges();
 
         currentServer = createServer();
 
@@ -174,7 +179,7 @@ export default {
 
             const bindHost = getBindHost(host);
 
-            currentServer.listen(port, bindHost, () => {
+            currentServer.listen(port, bindHost, async () => {
                 try {
                     ensureCLI().catch((e: any) => console.error('Failed to install CLI.', e));
                 } catch (e: any) {
@@ -183,7 +188,7 @@ export default {
 
                 try {
                     // Start installation process for all default providers
-                    repositoryManager.ensureDefaultProviders();
+                    await repositoryManager.ensureDefaultProviders();
                 } catch (e: any) {
                     console.error('Failed to install default providers.', e);
                 }