@kapeta/local-cluster-service 0.0.0-96f91ef

package/dist/esm/src/types.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DesiredInstanceStatus = exports.InstanceStatus = exports.InstanceOwner = exports.InstanceType = exports.DOCKER_HOST_INTERNAL = exports.KIND_BLOCK_TYPE_EXECUTABLE = exports.KIND_BLOCK_TYPE_OPERATOR = exports.KIND_BLOCK_TYPE = exports.KIND_RESOURCE_OPERATOR = void 0;
+exports.KIND_RESOURCE_OPERATOR = 'core/resource-type-operator';
+exports.KIND_BLOCK_TYPE = 'core/block-type';
+exports.KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
+exports.KIND_BLOCK_TYPE_EXECUTABLE = 'core/block-type-executable';
+exports.DOCKER_HOST_INTERNAL = 'host.docker.internal';
+var InstanceType;
+(function (InstanceType) {
+    InstanceType["DOCKER"] = "docker";
+    InstanceType["LOCAL"] = "local";
+    InstanceType["UNKNOWN"] = "unknown";
+})(InstanceType || (exports.InstanceType = InstanceType = {}));
+var InstanceOwner;
+(function (InstanceOwner) {
+    InstanceOwner["INTERNAL"] = "internal";
+    InstanceOwner["EXTERNAL"] = "external";
+})(InstanceOwner || (exports.InstanceOwner = InstanceOwner = {}));
+var InstanceStatus;
+(function (InstanceStatus) {
+    InstanceStatus["STOPPED"] = "stopped";
+    InstanceStatus["STARTING"] = "starting";
+    InstanceStatus["BUSY"] = "busy";
+    InstanceStatus["READY"] = "ready";
+    InstanceStatus["STOPPING"] = "stopping";
+    InstanceStatus["UNHEALTHY"] = "unhealthy";
+    InstanceStatus["FAILED"] = "failed";
+})(InstanceStatus || (exports.InstanceStatus = InstanceStatus = {}));
+var DesiredInstanceStatus;
+(function (DesiredInstanceStatus) {
+    DesiredInstanceStatus["STOP"] = "stop";
+    DesiredInstanceStatus["RUN"] = "run";
+    DesiredInstanceStatus["EXTERNAL"] = "external";
+})(DesiredInstanceStatus || (exports.DesiredInstanceStatus = DesiredInstanceStatus = {}));

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

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { AnyMap, ProcessInfo } from '../types';
+export declare function resolvePortType(portType: string): string;
+export declare class BlockInstanceRunner {
+    private readonly _systemId;
+    constructor(systemId: string);
+    /**
+     * Start a block
+     *
+     */
+    start(blockRef: string, instanceId: string, configuration: AnyMap): Promise<ProcessInfo>;
+    private _execute;
+    /**
+     * Starts local process
+     */
+    private _startLocalProcess;
+    private _startDockerProcess;
+    private _startOperatorProcess;
+    /**
+     * Get the port bindings for a non-operator block
+     */
+    private getServiceBlockPortBindings;
+    private ensureContainer;
+    private _handleContainer;
+}

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

@@ -0,0 +1,432 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockInstanceRunner = exports.resolvePortType = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+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 node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const taskManager_1 = require("../taskManager");
+const InternalConfigProvider_1 = require("./InternalConfigProvider");
+const config_mapper_1 = require("@kapeta/config-mapper");
+const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
+const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
+const KAPETA_INSTANCE_ID = 'KAPETA_INSTANCE_ID';
+/**
+ * Needed when running local docker containers as part of plan
+ * @type {string[]}
+ */
+const DOCKER_ENV_VARS = [
+    `KAPETA_LOCAL_SERVER=0.0.0.0`,
+    `KAPETA_LOCAL_CLUSTER_HOST=${types_1.DOCKER_HOST_INTERNAL}`,
+    `KAPETA_ENVIRONMENT_TYPE=docker`,
+];
+async function getProvider(uri) {
+    const providers = await definitionsManager_1.definitionsManager.getProviderDefinitions();
+    return providers.find((provider) => {
+        const ref = `${provider.definition.metadata.name}:${provider.version}`;
+        return (0, nodejs_utils_1.parseKapetaUri)(ref).id === uri.id;
+    });
+}
+function resolvePortType(portType) {
+    if (portType && serviceManager_1.HTTP_PORTS.includes(portType.toLowerCase())) {
+        return serviceManager_1.HTTP_PORT_TYPE;
+    }
+    return portType;
+}
+exports.resolvePortType = resolvePortType;
+/**
+ * Get the port types for a non-operator block instance
+ */
+function getServiceProviderPorts(assetVersion, providerVersion) {
+    const out = assetVersion.definition?.spec?.providers
+        ?.filter((provider) => {
+        // We only support HTTP provider ports for now. Need to figure out how to handle other types
+        return serviceManager_1.HTTP_PORTS.includes(provider.spec?.port?.type?.toLowerCase());
+    })
+        ?.map((provider) => {
+        return resolvePortType(provider.spec?.port?.type?.toLowerCase());
+    })
+        .filter((t) => !!t) ?? [];
+    if (out.length === 0) {
+        if (providerVersion.definition.spec?.defaultPort?.type) {
+            return [resolvePortType(providerVersion.definition.spec?.defaultPort?.type)];
+        }
+        return [resolvePortType(serviceManager_1.DEFAULT_PORT_TYPE)];
+    }
+    // Duplicated port types are not allowed
+    return Array.from(new Set(out));
+}
+class BlockInstanceRunner {
+    _systemId;
+    constructor(systemId) {
+        /**
+         *
+         * @type {string}
+         * @private
+         */
+        this._systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+    }
+    /**
+     * Start a block
+     *
+     */
+    async start(blockRef, instanceId, configuration) {
+        return this._execute({
+            ref: blockRef,
+            id: instanceId,
+            configuration,
+        });
+    }
+    async _execute(blockInstance) {
+        const blockUri = (0, nodejs_utils_1.parseKapetaUri)(blockInstance.ref);
+        if (!blockUri.version) {
+            blockUri.version = 'local';
+        }
+        const assetVersion = await definitionsManager_1.definitionsManager.getDefinition(blockUri.id);
+        if (!assetVersion) {
+            throw new Error(`Block definition not found: ${blockUri.id}`);
+        }
+        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}`);
+        }
+        const baseDir = local_cluster_config_1.default.getRepositoryAssetPath(blockUri.handle, blockUri.name, blockUri.version);
+        const realBaseDir = await fs_extra_1.default.realpath(baseDir);
+        const internalConfigProvider = await (0, InternalConfigProvider_1.createInternalConfigProvider)(this._systemId, blockInstance.id, assetVersion);
+        // Resolve the environment variables
+        const envVars = await (0, config_mapper_1.resolveKapetaVariables)(realBaseDir, internalConfigProvider);
+        // Write out the config templates if they exist
+        await (0, config_mapper_1.writeConfigTemplates)(envVars, realBaseDir);
+        let processInfo;
+        if (providerVersion.definition.kind === types_1.KIND_BLOCK_TYPE_OPERATOR) {
+            processInfo = await this._startOperatorProcess(blockInstance, blockUri, providerVersion, envVars);
+        }
+        else {
+            //We need a port type to know how to connect to the block consistently
+            const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
+            if (blockUri.version === 'local') {
+                processInfo = await this._startLocalProcess(blockInstance, blockUri, envVars, assetVersion);
+            }
+            else {
+                processInfo = await this._startDockerProcess(blockInstance, blockUri, envVars, assetVersion);
+            }
+            if (portTypes.length > 0) {
+                processInfo.portType = portTypes[0];
+            }
+        }
+        return processInfo;
+    }
+    /**
+     * Starts local process
+     */
+    async _startLocalProcess(blockInstance, blockInfo, env, assetVersion) {
+        const baseDir = local_cluster_config_1.default.getRepositoryAssetPath(blockInfo.handle, blockInfo.name, blockInfo.version);
+        if (!fs_extra_1.default.existsSync(baseDir)) {
+            throw new Error(`Local block not registered correctly - expected symlink here: ${baseDir}.\n` +
+                `Make sure you've run "kap 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 realLocalPath = await fs_extra_1.default.realpath(baseDir);
+        const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.kind);
+        const providerVersion = await getProvider(kindUri);
+        if (!providerVersion) {
+            throw new Error(`Block type not found: ${kindUri.id}`);
+        }
+        const targetKindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.spec?.target?.kind);
+        const targetVersion = await getProvider(targetKindUri);
+        if (!targetVersion) {
+            throw new Error(`Target not found: ${targetKindUri.id}`);
+        }
+        const localContainer = targetVersion.definition.spec.local;
+        if (!localContainer) {
+            throw new Error(`Missing local container information from target: ${targetKindUri.id}`);
+        }
+        let dockerImage = localContainer.image;
+        const isDockerImage = !localContainer.type || localContainer.type.toLowerCase() === 'docker';
+        const isDockerFile = Boolean(localContainer.type && localContainer.type.toLowerCase() === 'dockerfile');
+        if (isDockerImage && !dockerImage) {
+            throw new Error(`Missing docker image information: ${JSON.stringify(localContainer)}`);
+        }
+        if (isDockerFile) {
+            dockerImage = blockInfo.fullName + ':local';
+            const dockerFile = node_path_1.default.join(realLocalPath, localContainer.file ?? 'Dockerfile');
+            if (!fs_extra_1.default.existsSync(dockerFile)) {
+                throw new Error(`Dockerfile not found at: ${dockerFile}`);
+            }
+            const task = containerManager_1.containerManager.buildDockerImage(dockerFile, blockInfo.fullName + ':local');
+            await task.wait();
+        }
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id, targetKindUri.id);
+        const startCmd = localContainer.handlers?.onCreate ? localContainer.handlers.onCreate : '';
+        const dockerOpts = localContainer.options ?? {};
+        const homeDir = localContainer.userHome ? localContainer.userHome : '/root';
+        const workingDir = localContainer.workingDir ? localContainer.workingDir : '/workspace';
+        const customHostConfigs = localContainer.HostConfig ?? {};
+        const Binds = customHostConfigs.Binds ?? [];
+        delete customHostConfigs.Binds;
+        const customLabels = localContainer.Labels ?? {};
+        const customEnvs = localContainer.Env ?? [];
+        delete localContainer.HostConfig;
+        delete localContainer.Labels;
+        delete localContainer.Env;
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion);
+        let HealthCheck = undefined;
+        if (localContainer.healthcheck) {
+            HealthCheck = containerManager_1.containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
+        }
+        const Mounts = isDockerImage
+            ? // For docker images we mount the local directory to the working directory
+                containerManager_1.containerManager.toDockerMounts({
+                    [workingDir]: (0, containerManager_1.toLocalBindVolume)(realLocalPath),
+                })
+            : // For dockerfiles we don't mount anything
+                [];
+        const systemUri = (0, nodejs_utils_1.parseKapetaUri)(this._systemId);
+        return this.ensureContainer({
+            ...dockerOpts,
+            Image: dockerImage,
+            name: containerName,
+            WorkingDir: workingDir,
+            Labels: {
+                ...customLabels,
+                instance: blockInstance.id,
+                [containerManager_1.COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
+                [containerManager_1.COMPOSE_LABEL_SERVICE]: blockInfo.id.replace(/[^a-z0-9]/gi, '_'),
+            },
+            HealthCheck,
+            ExposedPorts,
+            Cmd: startCmd ? startCmd.split(/\s+/g) : [],
+            Env: [
+                ...customEnvs,
+                ...DOCKER_ENV_VARS,
+                `KAPETA_LOCAL_CLUSTER_PORT=${clusterService_1.clusterService.getClusterServicePort()}`,
+                ...Object.entries({
+                    ...env,
+                    ...addonEnv,
+                }).map(([key, value]) => `${key}=${value}`),
+            ],
+            HostConfig: {
+                ...customHostConfigs,
+                Binds: [
+                    `${(0, containerManager_1.toLocalBindVolume)(local_cluster_config_1.default.getKapetaBasedir())}:${homeDir}/.kapeta`,
+                    ...Binds.map((bind) => {
+                        let [host, container] = bind.split(':');
+                        if (host.startsWith('~')) {
+                            host = node_os_1.default.homedir() + host.substring(1);
+                        }
+                        if (container.startsWith('~')) {
+                            container = homeDir + container.substring(1);
+                        }
+                        return `${(0, containerManager_1.toLocalBindVolume)(host)}:${container}`;
+                    }),
+                ],
+                PortBindings,
+                Mounts,
+            },
+        });
+    }
+    async _startDockerProcess(blockInstance, blockInfo, env, assetVersion) {
+        const { versionFile } = local_cluster_config_1.default.getRepositoryAssetInfoPath(blockInfo.handle, blockInfo.name, blockInfo.version);
+        const versionYml = versionFile;
+        if (!fs_extra_1.default.existsSync(versionYml)) {
+            throw new Error(`Did not find version info at the expected path: ${versionYml}`);
+        }
+        const versionInfo = (0, utils_1.readYML)(versionYml);
+        if (versionInfo?.artifact?.type !== 'docker') {
+            throw new Error(`Unsupported artifact type: ${versionInfo?.artifact?.type}`);
+        }
+        const dockerImage = versionInfo?.artifact?.details?.primary;
+        if (!dockerImage) {
+            throw new Error(`Missing docker image information: ${JSON.stringify(versionInfo?.artifact?.details)}`);
+        }
+        const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.kind);
+        const providerVersion = await getProvider(kindUri);
+        if (!providerVersion) {
+            throw new Error(`Block type not found: ${kindUri.id}`);
+        }
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion);
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id, kindUri.id);
+        // For windows we need to default to root
+        const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
+        const systemUri = (0, nodejs_utils_1.parseKapetaUri)(this._systemId);
+        return this.ensureContainer({
+            Image: dockerImage,
+            name: containerName,
+            ExposedPorts,
+            Labels: {
+                instance: blockInstance.id,
+                [containerManager_1.COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
+                [containerManager_1.COMPOSE_LABEL_SERVICE]: blockInfo.id.replace(/[^a-z0-9]/gi, '_'),
+            },
+            Env: [
+                ...DOCKER_ENV_VARS,
+                `KAPETA_LOCAL_CLUSTER_PORT=${clusterService_1.clusterService.getClusterServicePort()}`,
+                ...Object.entries({
+                    ...env,
+                    ...addonEnv,
+                }).map(([key, value]) => `${key}=${value}`),
+            ],
+            HostConfig: {
+                Binds: [`${(0, containerManager_1.toLocalBindVolume)(local_cluster_config_1.default.getKapetaBasedir())}:${innerHome}`],
+                PortBindings,
+            },
+        });
+    }
+    async _startOperatorProcess(blockInstance, blockUri, providerDefinition, env) {
+        const { assetFile } = local_cluster_config_1.default.getRepositoryAssetInfoPath(blockUri.handle, blockUri.name, blockUri.version);
+        const kapetaYmlPath = assetFile;
+        if (!fs_extra_1.default.existsSync(kapetaYmlPath)) {
+            throw new Error(`Did not find kapeta.yml at the expected path: ${kapetaYmlPath}`);
+        }
+        const spec = providerDefinition.definition.spec;
+        const providerRef = `${providerDefinition.definition.metadata.name}:${providerDefinition.version}`;
+        if (!spec?.local?.image) {
+            throw new Error(`Provider did not have local image: ${providerRef}`);
+        }
+        const local = spec.local;
+        const dockerImage = local.image;
+        const operatorUri = local.singleton ? (0, nodejs_utils_1.parseKapetaUri)(providerRef) : blockUri;
+        const operatorId = local.singleton ? providerRef : blockInstance.id;
+        const operatorRef = local.singleton ? providerRef : blockInstance.ref;
+        if (local.singleton && env) {
+            env[KAPETA_BLOCK_REF] = operatorRef;
+            env[KAPETA_INSTANCE_ID] = operatorId;
+        }
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id, providerRef);
+        const task = taskManager_1.taskManager.add(`container:start:${containerName}`, async () => {
+            const logs = new LogData_1.LogData();
+            const hostIp = (0, utils_1.getDockerHostIp)();
+            const ExposedPorts = {};
+            const addonEnv = {};
+            const PortBindings = {};
+            let HealthCheck = undefined;
+            let Mounts = [];
+            const instancePorts = await (0, utils_1.getOperatorInstancePorts)(this._systemId, operatorId, local);
+            const labels = {};
+            instancePorts.forEach((portInfo) => {
+                const dockerPort = `${portInfo.port}/${portInfo.protocol}`;
+                ExposedPorts[dockerPort] = {};
+                addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portInfo.portType.toUpperCase()}`] = `${portInfo.port}`;
+                PortBindings[dockerPort] = [
+                    {
+                        HostIp: hostIp,
+                        HostPort: `${portInfo.hostPort}`,
+                    },
+                ];
+                labels[containerManager_1.CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.portType;
+            });
+            if (local.env) {
+                Object.entries(local.env).forEach(([key, value]) => {
+                    addonEnv[key] = value;
+                });
+            }
+            if (local.mounts) {
+                Mounts = await containerManager_1.containerManager.createVolumes(this._systemId, operatorUri.id, local.mounts);
+            }
+            if (local.health) {
+                HealthCheck = containerManager_1.containerManager.toDockerHealth(local.health);
+            }
+            // For windows we need to default to root
+            const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
+            const Binds = local.singleton
+                ? [`${(0, containerManager_1.toLocalBindVolume)(local_cluster_config_1.default.getKapetaBasedir())}:${innerHome}`]
+                : [
+                    `${(0, containerManager_1.toLocalBindVolume)(kapetaYmlPath)}:/kapeta.yml:ro`,
+                    `${(0, containerManager_1.toLocalBindVolume)(local_cluster_config_1.default.getKapetaBasedir())}:${innerHome}`,
+                ];
+            const systemUri = (0, nodejs_utils_1.parseKapetaUri)(this._systemId);
+            console.log(`Ensuring container for operator block: ${containerName} [singleton: ${!!local.singleton}]`);
+            logs.addLog(`Ensuring container for operator block: ${containerName}`);
+            const out = await this.ensureContainer({
+                Image: dockerImage,
+                name: containerName,
+                ExposedPorts,
+                HealthCheck,
+                HostConfig: {
+                    Binds,
+                    PortBindings,
+                    Mounts,
+                },
+                Labels: {
+                    ...labels,
+                    instance: operatorId,
+                    [containerManager_1.COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
+                    [containerManager_1.COMPOSE_LABEL_SERVICE]: operatorUri.id.replace(/[^a-z0-9]/gi, '_'),
+                },
+                Env: [
+                    `KAPETA_INSTANCE_NAME=${operatorRef}`,
+                    `KAPETA_LOCAL_CLUSTER_PORT=${clusterService_1.clusterService.getClusterServicePort()}`,
+                    ...DOCKER_ENV_VARS,
+                    ...Object.entries({
+                        ...env,
+                        ...addonEnv,
+                    }).map(([key, value]) => `${key}=${value}`),
+                ],
+            });
+            const portTypes = local.ports ? Object.keys(local.ports) : [];
+            if (portTypes.length > 0) {
+                out.portType = portTypes[0];
+            }
+            return out;
+        }, {
+            name: `Starting container for ${providerRef}`,
+            systemId: this._systemId,
+        });
+        return task.wait();
+    }
+    /**
+     * Get the port bindings for a non-operator block
+     */
+    async getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion) {
+        const hostIp = (0, utils_1.getDockerHostIp)();
+        const ExposedPorts = {};
+        const addonEnv = {};
+        const PortBindings = {};
+        const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
+        let port = 80;
+        const promises = portTypes.map(async (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] = {};
+            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = '' + thisPort;
+            PortBindings[dockerPort] = [
+                {
+                    HostIp: hostIp,
+                    HostPort: `${publicPort}`,
+                },
+            ];
+        });
+        await Promise.all(promises);
+        return { PortBindings, ExposedPorts, addonEnv };
+    }
+    async ensureContainer(opts) {
+        const container = await containerManager_1.containerManager.ensureContainer(opts);
+        return this._handleContainer(container);
+    }
+    async _handleContainer(container) {
+        return {
+            type: types_1.InstanceType.DOCKER,
+            pid: container.id,
+        };
+    }
+}
+exports.BlockInstanceRunner = BlockInstanceRunner;

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

@@ -0,0 +1,15 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+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,136 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+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 PROVIDERS_FILENAME = local_cluster_config_1.default.getEnvironment() === 'staging'
+    ? 'default-providers-staging.tar.gz'
+    : 'default-providers.tar.gz';
+const DEFAULT_PROVIDERS_URL = `https://storage.googleapis.com/kapeta-production-cdn/archives/${PROVIDERS_FILENAME}`;
+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();