@kapeta/local-cluster-service 0.6.1 → 0.7.0

package/dist/cjs/src/storageService.js

@@ -0,0 +1,74 @@
+"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.
+ */
+class StorageService {
+    _data;
+    constructor() {
+        this._data = this._readConfig();
+    }
+    getKapetaBasedir() {
+        return local_cluster_config_1.default.getKapetaBasedir();
+    }
+    _readConfig() {
+        return local_cluster_config_1.default.getClusterConfig();
+    }
+    _writeConfig() {
+        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) {
+            defaultValue = {};
+        }
+        if (!this._data[section]) {
+            this._data[section] = defaultValue;
+            this._writeConfig();
+        }
+        return this._data[section];
+    }
+    put(section, property, value) {
+        if (!lodash_1.default.isString(property)) {
+            this._data[section] = property;
+            this._writeConfig();
+            return;
+        }
+        this.section(section)[property] = value;
+        this._writeConfig();
+    }
+    get(section, property) {
+        if (!property) {
+            return this.section(section);
+        }
+        return this.section(section)[property];
+    }
+    contains(section, property) {
+        if (!this._data[section]) {
+            return false;
+        }
+        return this._data[section].hasOwnProperty(property);
+    }
+    ensure(section, property, value) {
+        if (this.contains(section, property)) {
+            return this.get(section, property);
+        }
+        let out = value;
+        if (typeof value === 'function') {
+            out = value();
+        }
+        this.put(section, property, out);
+        return out;
+    }
+}
+exports.storageService = new StorageService();

package/dist/cjs/src/traffic/routes.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;

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

@@ -0,0 +1,18 @@
+"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_1.networkManager.getTrafficForConnection(req.params.systemId, req.params.connectionId));
+});
+router.get('/:systemId/source/:blockInstanceId/', (req, res) => {
+    res.send(networkManager_1.networkManager.getTrafficForSource(req.params.systemId, req.params.blockInstanceId));
+});
+router.get('/:systemId/target/:blockInstanceId/', (req, res) => {
+    res.send(networkManager_1.networkManager.getTrafficForTarget(req.params.systemId, req.params.blockInstanceId));
+});
+exports.default = router;

package/dist/cjs/src/types.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import express from 'express';
+import { Resource } from '@kapeta/schemas';
+import { StringBodyRequest } from './middleware/stringBody';
+import { KapetaRequest } from './middleware/kapeta';
+export type StringMap = {
+    [key: string]: string;
+};
+export type AnyMap = {
+    [key: string]: any;
+};
+export type LogLevel = 'ERROR' | 'WARN' | 'INFO' | 'DEBUG' | 'TRACE' | 'FATAL';
+export type LogSource = 'stdout' | 'stderr';
+export type EnvironmentType = 'docker' | 'process';
+export interface LogEntry {
+    source: LogSource;
+    level: LogLevel;
+    message: string;
+    time: number;
+}
+export interface BlockProcessParams {
+    id: string;
+    ref: string;
+    configuration?: AnyMap;
+}
+export type ProcessType = 'docker' | 'local';
+export interface ProcessDetails {
+    pid: number | string;
+    type: ProcessType;
+    portType?: string;
+    output: EventEmitter;
+    logs: () => LogEntry[];
+    stop: () => Promise<void> | void;
+}
+export interface ProcessInfo extends ProcessDetails {
+    id: string;
+    ref: string;
+    name: string;
+}
+export type InstanceInfo = {
+    systemId: string;
+    instanceId: string;
+    address?: string;
+    health?: string | null;
+    status: string;
+    pid?: number | string | null;
+    type: ProcessType;
+    portType?: string;
+};
+interface ResourceRef {
+    blockId: string;
+    resourceName: string;
+}
+export type ProxyRequestHandler = (req: StringBodyRequest, res: express.Response, info: ProxyRequestInfo) => void;
+export interface Connection {
+    mapping: any;
+    provider: ResourceRef;
+    consumer: ResourceRef;
+}
+export interface OperatorInfo {
+    host: string;
+    port: string;
+    type: string;
+    protocol: string;
+    options: AnyMap;
+    credentials: AnyMap;
+}
+export interface ProxyRequestInfo {
+    address: string;
+    connection: Connection;
+    providerResource: Resource;
+    consumerResource: Resource;
+    consumerPath: string;
+}
+export interface SimpleResponse {
+    code: number;
+    headers: StringMap;
+    body: any;
+}
+export interface SimpleRequest {
+    method: string;
+    url: string;
+    headers: StringMap;
+    body: any;
+}
+export type KapetaBodyRequest = KapetaRequest & StringBodyRequest;
+export {};

package/dist/cjs/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,29 @@
+import { DefinitionInfo } from '@kapeta/local-cluster-config';
+import { KapetaURI } from '@kapeta/nodejs-utils';
+import { AnyMap, BlockProcessParams, ProcessDetails, ProcessInfo, StringMap } from '../types';
+export declare class BlockInstanceRunner {
+    private readonly _systemId;
+    constructor(planReference: string);
+    /**
+     * Start a block
+     *
+     */
+    start(blockRef: string, instanceId: string, configuration: AnyMap): Promise<ProcessInfo>;
+    private _execute;
+    /**
+     * Starts local process
+     */
+    private _startLocalProcess;
+    private _handleContainer;
+    private _startDockerProcess;
+    /**
+     *
+     * @param blockInstance
+     * @param blockUri
+     * @param providerDefinition
+     * @param {{[key:string]:string}} env
+     * @return {Promise<ProcessDetails>}
+     * @private
+     */
+    _startOperatorProcess(blockInstance: BlockProcessParams, blockUri: KapetaURI, providerDefinition: DefinitionInfo, env: StringMap): Promise<ProcessDetails>;
+}

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

@@ -0,0 +1,468 @@
+"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 events_1 = __importDefault(require("events"));
+const md5_1 = __importDefault(require("md5"));
+const clusterService_1 = require("../clusterService");
+const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
+const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
+const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
+const KAPETA_INSTANCE_ID = 'KAPETA_INSTANCE_ID';
+const KAPETA_LOCAL_CLUSTER_PORT = 'KAPETA_LOCAL_CLUSTER_PORT';
+/**
+ * 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=host.docker.internal`,
+    `KAPETA_ENVIRONMENT_TYPE=docker`,
+];
+function getProvider(uri) {
+    return local_cluster_config_1.default.getProviderDefinitions().find((provider) => {
+        const ref = `${provider.definition.metadata.name}:${provider.version}`;
+        return (0, nodejs_utils_1.parseKapetaUri)(ref).id === uri.id;
+    });
+}
+function getProviderPorts(assetVersion) {
+    return (assetVersion.definition?.spec?.providers
+        ?.map((provider) => {
+        return provider.spec?.port?.type;
+    })
+        .filter((t) => !!t) ?? []);
+}
+class BlockInstanceRunner {
+    _systemId;
+    constructor(planReference) {
+        /**
+         *
+         * @type {string}
+         * @private
+         */
+        this._systemId = planReference ?? '';
+    }
+    /**
+     * Start a block
+     *
+     */
+    async start(blockRef, instanceId, configuration) {
+        return this._execute({
+            ref: blockRef,
+            id: instanceId,
+            configuration,
+        });
+    }
+    async _execute(blockInstance) {
+        const env = {};
+        if (this._systemId) {
+            env[KAPETA_SYSTEM_ID] = this._systemId;
+        }
+        if (blockInstance.ref) {
+            env[KAPETA_BLOCK_REF] = blockInstance.ref;
+        }
+        if (blockInstance.id) {
+            env[KAPETA_INSTANCE_ID] = blockInstance.id;
+        }
+        const blockUri = (0, nodejs_utils_1.parseKapetaUri)(blockInstance.ref);
+        if (!blockUri.version) {
+            blockUri.version = 'local';
+        }
+        const assetVersion = local_cluster_config_1.default.getDefinitions().find((definitions) => {
+            const ref = `${definitions.definition.metadata.name}:${definitions.version}`;
+            return (0, nodejs_utils_1.parseKapetaUri)(ref).id === 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 = getProvider(kindUri);
+        if (!providerVersion) {
+            throw new Error(`Kind not found: ${kindUri.id}`);
+        }
+        let processDetails;
+        if (providerVersion.definition.kind === KIND_BLOCK_TYPE_OPERATOR) {
+            processDetails = await this._startOperatorProcess(blockInstance, blockUri, providerVersion, env);
+        }
+        else {
+            //We need a port type to know how to connect to the block consistently
+            const portTypes = getProviderPorts(assetVersion);
+            if (blockUri.version === 'local') {
+                processDetails = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
+            }
+            else {
+                processDetails = await this._startDockerProcess(blockInstance, blockUri, env);
+            }
+            if (portTypes.length > 0) {
+                processDetails.portType = portTypes[0];
+            }
+        }
+        return {
+            name: blockUri.id,
+            ...blockInstance,
+            ...processDetails,
+        };
+    }
+    /**
+     * Starts local process
+     */
+    async _startLocalProcess(blockInstance, blockInfo, env, assetVersion) {
+        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 = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.spec?.target?.kind);
+        const targetVersion = getProvider(kindUri);
+        if (!targetVersion) {
+            throw new Error(`Target not found: ${kindUri.id}`);
+        }
+        const localContainer = targetVersion.definition.spec.local;
+        if (!localContainer) {
+            throw new Error(`Missing local container information from target: ${kindUri.id}`);
+        }
+        const dockerImage = localContainer.image;
+        if (!dockerImage) {
+            throw new Error(`Missing docker image information: ${JSON.stringify(localContainer)}`);
+        }
+        const containerName = `kapeta-block-instance-${blockInstance.id}`;
+        const logs = new LogData_1.LogData();
+        logs.addLog(`Starting block ${blockInstance.ref}`);
+        let container = (await containerManager_1.containerManager.getContainerByName(containerName)) ?? null;
+        console.log('Starting dev container', containerName);
+        if (container) {
+            console.log(`Container already exists. Deleting...`);
+            try {
+                await container.delete({
+                    force: true,
+                });
+            }
+            catch (e) {
+                throw new Error('Failed to delete existing container: ' + e.message);
+            }
+            container = null;
+        }
+        logs.addLog(`Creating new container for block: ${containerName}`);
+        console.log('Creating new dev container', containerName, dockerImage);
+        await containerManager_1.containerManager.pull(dockerImage);
+        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 ExposedPorts = {};
+        const addonEnv = {};
+        const PortBindings = {};
+        const portTypes = getProviderPorts(assetVersion);
+        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: '127.0.0.1',
+                    HostPort: `${publicPort}`,
+                },
+            ];
+        });
+        await Promise.all(promises);
+        let HealthCheck = undefined;
+        if (localContainer.healthcheck) {
+            HealthCheck = containerManager_1.containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
+        }
+        container = await containerManager_1.containerManager.startContainer({
+            Image: dockerImage,
+            name: containerName,
+            WorkingDir: workingDir,
+            Labels: {
+                instance: blockInstance.id,
+            },
+            HealthCheck,
+            ExposedPorts,
+            Cmd: startCmd ? startCmd.split(/\s+/g) : [],
+            Env: [
+                ...DOCKER_ENV_VARS,
+                `KAPETA_LOCAL_CLUSTER_PORT=${clusterService_1.clusterService.getClusterServicePort()}`,
+                ...Object.entries({
+                    ...env,
+                    ...addonEnv,
+                }).map(([key, value]) => `${key}=${value}`),
+            ],
+            HostConfig: {
+                Binds: [
+                    `${local_cluster_config_1.default.getKapetaBasedir()}:${homeDir}/.kapeta`,
+                    `${baseDir}:${workingDir}`, //We mount
+                ],
+                PortBindings,
+            },
+            ...dockerOpts,
+        });
+        try {
+            if (HealthCheck) {
+                await containerManager_1.containerManager.waitForHealthy(container);
+            }
+            else {
+                await containerManager_1.containerManager.waitForReady(container);
+            }
+        }
+        catch (e) {
+            logs.addLog(e.message, 'ERROR');
+        }
+        return this._handleContainer(container, logs);
+    }
+    async _handleContainer(container, logs, deleteOnExit = false) {
+        let localContainer = container;
+        const logStream = (await container.logs({
+            follow: true,
+            stdout: true,
+            stderr: true,
+            tail: LogData_1.LogData.MAX_LINES,
+        }));
+        const outputEvents = new events_1.default();
+        logStream.on('data', (data) => {
+            logs.addLog(data.toString());
+            outputEvents.emit('data', data);
+        });
+        logStream.on('error', (data) => {
+            logs.addLog(data.toString());
+            outputEvents.emit('data', data);
+        });
+        logStream.on('close', async () => {
+            const status = await container.status();
+            const data = status.data;
+            if (deleteOnExit) {
+                try {
+                    await container.delete();
+                }
+                catch (e) { }
+            }
+            outputEvents.emit('exit', data?.State?.ExitCode ?? 0);
+        });
+        return {
+            type: 'docker',
+            pid: container.id,
+            output: outputEvents,
+            stop: async () => {
+                if (!localContainer) {
+                    return;
+                }
+                try {
+                    await localContainer.stop();
+                    if (deleteOnExit) {
+                        await localContainer.delete();
+                    }
+                }
+                catch (e) { }
+                localContainer = null;
+            },
+            logs: () => {
+                return logs.getLogs();
+            },
+        };
+    }
+    async _startDockerProcess(blockInstance, blockInfo, env) {
+        const { versionFile } = local_cluster_config_1.default.getRepositoryAssetInfoPath(blockInfo.handle, blockInfo.name, blockInfo.version);
+        const versionYml = versionFile;
+        if (!node_fs_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 containerName = `kapeta-block-instance-${blockInstance.id}`;
+        const logs = new LogData_1.LogData();
+        let container = await containerManager_1.containerManager.getContainerByName(containerName);
+        if (container) {
+            const containerData = container.data;
+            if (containerData.State === 'running') {
+                logs.addLog(`Found existing running container for block: ${containerName}`);
+            }
+            else {
+                logs.addLog(`Found existing container for block: ${containerName}. Starting now`);
+                await container.start();
+            }
+        }
+        else {
+            logs.addLog(`Creating new container for block: ${containerName}`);
+            container = await containerManager_1.containerManager.startContainer({
+                Image: dockerImage,
+                name: containerName,
+                Labels: {
+                    instance: blockInstance.id,
+                },
+                Env: [
+                    ...DOCKER_ENV_VARS,
+                    `KAPETA_LOCAL_CLUSTER_PORT=${clusterService_1.clusterService.getClusterServicePort()}`,
+                    ...Object.entries(env).map(([key, value]) => `${key}=${value}`),
+                ],
+                HostConfig: {
+                    Binds: [`${local_cluster_config_1.default.getKapetaBasedir()}:${local_cluster_config_1.default.getKapetaBasedir()}`],
+                },
+            });
+            try {
+                await containerManager_1.containerManager.waitForReady(container);
+            }
+            catch (e) {
+                logs.addLog(e.message, 'ERROR');
+            }
+        }
+        return this._handleContainer(container, logs);
+    }
+    /**
+     *
+     * @param blockInstance
+     * @param blockUri
+     * @param providerDefinition
+     * @param {{[key:string]:string}} env
+     * @return {Promise<ProcessDetails>}
+     * @private
+     */
+    async _startOperatorProcess(blockInstance, blockUri, providerDefinition, env) {
+        const { assetFile } = local_cluster_config_1.default.getRepositoryAssetInfoPath(blockUri.handle, blockUri.name, blockUri.version);
+        const kapetaYmlPath = assetFile;
+        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;
+        const providerRef = `${providerDefinition.definition.metadata.name}:${providerDefinition.version}`;
+        if (!spec?.local?.image) {
+            throw new Error(`Provider did not have local image: ${providerRef}`);
+        }
+        const dockerImage = spec?.local?.image;
+        try {
+            await containerManager_1.containerManager.pull(dockerImage);
+        }
+        catch (e) {
+            console.warn('Failed to pull image. Continuing...', e);
+        }
+        const containerName = `kapeta-block-instance-${(0, md5_1.default)(blockInstance.id)}`;
+        const logs = new LogData_1.LogData();
+        let container = (await containerManager_1.containerManager.getContainerByName(containerName)) ?? null;
+        if (container) {
+            const containerData = container.data;
+            if (containerData.State === 'running') {
+                logs.addLog(`Found existing running container for block: ${containerName}`);
+            }
+            else {
+                if (containerData.State?.ExitCode > 0) {
+                    logs.addLog(`Container exited with code: ${containerData.State.ExitCode}. Deleting...`);
+                    try {
+                        await container.delete();
+                    }
+                    catch (e) { }
+                    container = null;
+                }
+                else {
+                    logs.addLog(`Found existing container for block: ${containerName}. Starting now`);
+                    try {
+                        await container.start();
+                    }
+                    catch (e) {
+                        console.warn('Failed to start container. Deleting...', e);
+                        try {
+                            await container.delete();
+                        }
+                        catch (e) { }
+                        container = null;
+                    }
+                }
+            }
+        }
+        if (!container) {
+            const ExposedPorts = {};
+            const addonEnv = {};
+            const PortBindings = {};
+            let HealthCheck = undefined;
+            let Mounts = [];
+            const promises = Object.entries(spec.local.ports).map(async ([portType, value]) => {
+                const dockerPort = `${value.port}/${value.type}`;
+                ExposedPorts[dockerPort] = {};
+                addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = value.port;
+                const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
+                PortBindings[dockerPort] = [
+                    {
+                        HostIp: '127.0.0.1',
+                        HostPort: `${publicPort}`,
+                    },
+                ];
+            });
+            await Promise.all(promises);
+            if (spec.local?.env) {
+                Object.entries(spec.local.env).forEach(([key, value]) => {
+                    addonEnv[key] = value;
+                });
+            }
+            if (spec.local?.mounts) {
+                const mounts = containerManager_1.containerManager.createMounts(blockUri.id, spec.local.mounts);
+                Mounts = containerManager_1.containerManager.toDockerMounts(mounts);
+            }
+            if (spec.local?.health) {
+                HealthCheck = containerManager_1.containerManager.toDockerHealth(spec.local?.health);
+            }
+            logs.addLog(`Creating new container for block: ${containerName}`);
+            container = await containerManager_1.containerManager.startContainer({
+                Image: dockerImage,
+                name: containerName,
+                ExposedPorts,
+                HealthCheck,
+                HostConfig: {
+                    Binds: [
+                        `${kapetaYmlPath}:/kapeta.yml:ro`,
+                        `${local_cluster_config_1.default.getKapetaBasedir()}:${local_cluster_config_1.default.getKapetaBasedir()}`,
+                    ],
+                    PortBindings,
+                    Mounts,
+                },
+                Labels: {
+                    instance: blockInstance.id,
+                },
+                Env: [
+                    `KAPETA_INSTANCE_NAME=${blockInstance.ref}`,
+                    `KAPETA_LOCAL_CLUSTER_PORT=${clusterService_1.clusterService.getClusterServicePort()}`,
+                    ...DOCKER_ENV_VARS,
+                    ...Object.entries({
+                        ...env,
+                        ...addonEnv,
+                    }).map(([key, value]) => `${key}=${value}`),
+                ],
+            });
+            try {
+                if (HealthCheck) {
+                    await containerManager_1.containerManager.waitForHealthy(container);
+                }
+                else {
+                    await containerManager_1.containerManager.waitForReady(container);
+                }
+            }
+            catch (e) {
+                logs.addLog(e.message, 'ERROR');
+            }
+        }
+        const out = await this._handleContainer(container, logs, true);
+        const portTypes = spec.local.ports ? Object.keys(spec.local.ports) : [];
+        if (portTypes.length > 0) {
+            out.portType = portTypes[0];
+        }
+        return out;
+    }
+}
+exports.BlockInstanceRunner = BlockInstanceRunner;