@kapeta/local-cluster-service 0.38.0 → 0.39.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.39.1](https://github.com/kapetacom/local-cluster-service/compare/v0.39.0...v0.39.1) (2024-02-27)
+
+
+### Bug Fixes
+
+* remove dep on ui-web-plan-editor ([#128](https://github.com/kapetacom/local-cluster-service/issues/128)) ([48ee136](https://github.com/kapetacom/local-cluster-service/commit/48ee13629040b19c7eb716f33955c5bce280f069))
+
+# [0.39.0](https://github.com/kapetacom/local-cluster-service/compare/v0.38.0...v0.39.0) (2024-02-26)
+
+
+### Features
+
+* Add support for dotenv and config templates ([#127](https://github.com/kapetacom/local-cluster-service/issues/127)) ([5e78610](https://github.com/kapetacom/local-cluster-service/commit/5e786106f1d6ca69fcd79cde351cc37908c2b4b2))
+
 # [0.38.0](https://github.com/kapetacom/local-cluster-service/compare/v0.37.0...v0.38.0) (2024-02-24)
 
 

package/dist/cjs/index.js

@@ -210,7 +210,10 @@ exports.default = {
                 }
                 reject(err);
             });
-            const bindHost = (0, utils_1.getBindHost)(host);
+            // 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.
+            const bindHost = (0, utils_1.isLinux)() ? '0.0.0.0' : host;
             currentServer.listen(port, bindHost, async () => {
                 try {
                     const ensureCLITask = await (0, commandLineUtils_1.ensureCLI)();

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

@@ -136,7 +136,7 @@ router.get('/provides/:type', async (req, res) => {
  * assign port numbers to it etc.
  */
 router.get('/consumes/resource/:resourceType/:portType/:name', async (req, res) => {
-    const operatorInfo = await operatorManager_1.operatorManager.getConsumerResourceInfo(req.kapeta.systemId, req.kapeta.instanceId, req.params.resourceType, req.params.portType, req.params.name, req.kapeta.environment);
+    const operatorInfo = await operatorManager_1.operatorManager.getConsumerResourceInfo(req.kapeta.systemId, req.kapeta.instanceId, req.params.resourceType, req.params.portType, req.params.name, req.kapeta.environment, req.query.ensure !== 'false');
     res.send(operatorInfo);
 });
 /**
@@ -154,7 +154,7 @@ router.get('/consumes/:resourceName/:type', (req, res) => {
  * If the remote service is not already running it will be started
  */
 router.get('/operator/:instanceId', async (req, res) => {
-    const operatorInfo = await instanceManager_1.instanceManager.getInstanceOperator(req.kapeta.systemId, req.params.instanceId, req.kapeta.environment);
+    const operatorInfo = await instanceManager_1.instanceManager.getInstanceOperator(req.kapeta.systemId, req.params.instanceId, req.kapeta.environment, req.query.ensure !== 'false');
     res.send(operatorInfo);
 });
 exports.default = router;

package/dist/cjs/src/containerManager.js

@@ -19,6 +19,7 @@ const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-co
 const node_uuid_1 = __importDefault(require("node-uuid"));
 const md5_1 = __importDefault(require("md5"));
 const utils_1 = require("./utils/utils");
+const types_1 = require("./types");
 const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
 const taskManager_1 = require("./taskManager");
 const node_events_1 = require("node:events");
@@ -508,7 +509,8 @@ class ContainerManager {
         const newName = 'deleting-' + node_uuid_1.default.v4();
         // Rename the container first to avoid name conflicts if people start the same container
         await container.rename({ name: newName });
-        await container.remove({ force: !!opts?.force });
+        const newContainer = this.docker().getContainer(newName);
+        await newContainer.remove({ force: !!opts?.force });
     }
     /**
      *
@@ -925,11 +927,11 @@ function getExtraHosts(dockerVersion) {
         const [major, minor] = dockerVersion.split('.');
         if (parseInt(major) >= 20 && parseInt(minor) >= 10) {
             // Docker 20.10+ on Linux supports adding host.docker.internal to point to host-gateway
-            return ['host.docker.internal:host-gateway'];
+            return [`${types_1.DOCKER_HOST_INTERNAL}:host-gateway`];
         }
         // Docker versions lower than 20.10 needs an actual IP address. We use the default network bridge which
         // is always 172.17.0.1
-        return ['host.docker.internal:172.17.0.1'];
+        return [`${types_1.DOCKER_HOST_INTERNAL}:172.17.0.1`];
     }
     return undefined;
 }

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

@@ -2,8 +2,9 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { EnvironmentType, InstanceInfo, LogEntry, OperatorInstanceInfo } from './types';
+import { EnvironmentType, InstanceInfo, LogEntry } from './types';
 import { Task } from './taskManager';
+import { InstanceOperator } from '@kapeta/sdk-config';
 export declare class InstanceManager {
     private _interval;
     private readonly _instances;
@@ -14,6 +15,7 @@ export declare class InstanceManager {
     getInstancesForPlan(systemId: string): Promise<InstanceInfo[]>;
     getInstance(systemId: string, instanceId: string): InstanceInfo | undefined;
     private exclusive;
+    private isLocked;
     getLogs(systemId: string, instanceId: string): Promise<LogEntry[]>;
     saveInternalInstance(instance: InstanceInfo): Promise<InstanceInfo>;
     /**
@@ -25,7 +27,7 @@ export declare class InstanceManager {
     markAsStopped(systemId: string, instanceId: string): Promise<void>;
     startAllForPlan(systemId: string): Promise<Task<InstanceInfo[]>>;
     stopAllForPlan(systemId: string): Task<void>;
-    getInstanceOperator(systemId: string, instanceId: string, environment?: EnvironmentType): Promise<OperatorInstanceInfo>;
+    getInstanceOperator(systemId: string, instanceId: string, environment?: EnvironmentType, ensureContainer?: boolean): Promise<InstanceOperator<any, any>>;
     stop(systemId: string, instanceId: string): Promise<void>;
     private stopInner;
     start(systemId: string, instanceId: string, checkForSingleton?: boolean): Promise<InstanceInfo | Task<InstanceInfo>>;

package/dist/cjs/src/instanceManager.js

@@ -79,6 +79,9 @@ class InstanceManager {
         //console.log(`Releasing lock for ${key}`, this.instanceLocks.isBusy(key));
         return result;
     }
+    isLocked(systemId, instanceId) {
+        return this.instanceLocks.isBusy(`${systemId}/${instanceId}`);
+    }
     async getLogs(systemId, instanceId) {
         const instance = this.getInstance(systemId, instanceId);
         if (!instance) {
@@ -268,7 +271,7 @@ class InstanceManager {
             name: `Stopping plan ${systemId}`,
         });
     }
-    async getInstanceOperator(systemId, instanceId, environment) {
+    async getInstanceOperator(systemId, instanceId, environment, ensureContainer = true) {
         const blockInstance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
         if (!blockInstance) {
             throw new Error(`Instance not found: ${systemId}/${instanceId}`);
@@ -279,30 +282,48 @@ class InstanceManager {
             throw new Error(`Block not found: ${blockRef}`);
         }
         const operatorDefinition = await definitionsManager_1.definitionsManager.getDefinition(block.kind);
-        if (!operatorDefinition?.definition.spec.local) {
+        if (!operatorDefinition) {
+            throw new Error(`Operator not found: ${block.kind}`);
+        }
+        if (operatorDefinition.definition.kind !== types_1.KIND_BLOCK_TYPE_OPERATOR) {
+            throw new Error(`Block is not an operator: ${blockRef}`);
+        }
+        if (!operatorDefinition.definition.spec.local) {
             throw new Error(`Operator block has no local definition: ${blockRef}`);
         }
         const localConfig = operatorDefinition.definition.spec.local;
-        let instance = await this.start(systemId, instanceId);
-        if (instance instanceof taskManager_1.Task) {
-            instance = await instance.wait();
-        }
-        const container = await containerManager_1.containerManager.get(instance.pid);
-        if (!container) {
-            throw new Error(`Container not found: ${instance.pid}`);
+        const ports = {};
+        if (ensureContainer) {
+            let instance = await this.start(systemId, instanceId);
+            if (instance instanceof taskManager_1.Task) {
+                instance = await instance.wait();
+            }
+            const container = await containerManager_1.containerManager.get(instance.pid);
+            if (!container) {
+                throw new Error(`Container not found: ${instance.pid}`);
+            }
+            const portInfo = await container.getPorts();
+            if (!portInfo) {
+                throw new Error(`No ports found for instance: ${instanceId}`);
+            }
+            Object.entries(portInfo).forEach(([key, value]) => {
+                ports[key] = {
+                    protocol: value.protocol,
+                    port: parseInt(value.hostPort),
+                };
+            });
         }
-        const portInfo = await container.getPorts();
-        if (!portInfo) {
-            throw new Error(`No ports found for instance: ${instanceId}`);
+        else {
+            // If we're not ensuring the container is running we just get the ports from the local config
+            const instancePorts = await (0, utils_1.getOperatorInstancePorts)(systemId, instanceId, localConfig);
+            instancePorts.forEach((port) => {
+                ports[port.portType] = {
+                    protocol: port.protocol,
+                    port: port.hostPort,
+                };
+            });
         }
-        const hostname = serviceManager_1.serviceManager.getLocalHost(environment);
-        const ports = {};
-        Object.entries(portInfo).forEach(([key, value]) => {
-            ports[key] = {
-                protocol: value.protocol,
-                port: parseInt(value.hostPort),
-            };
-        });
+        const hostname = (0, utils_1.getRemoteHostForEnvironment)(environment);
         return {
             hostname,
             ports,
@@ -347,6 +368,7 @@ class InstanceManager {
             if (changeDesired && instance.desiredStatus !== types_1.DesiredInstanceStatus.EXTERNAL) {
                 instance.desiredStatus = types_1.DesiredInstanceStatus.STOP;
             }
+            const wasFailed = instance.status === types_1.InstanceStatus.FAILED;
             instance.status = types_1.InstanceStatus.STOPPING;
             socketManager_1.socketManager.emitSystemEvent(systemId, socketManager_1.EVENT_STATUS_CHANGED, instance);
             console.log('Stopping instance: %s::%s [desired: %s] [intentional: %s]', systemId, instanceId, instance.desiredStatus, changeDesired);
@@ -357,7 +379,12 @@ class InstanceManager {
                     const container = await containerManager_1.containerManager.getContainerByName(containerName);
                     if (container) {
                         try {
-                            await container.stop();
+                            if (wasFailed) {
+                                await container.remove();
+                            }
+                            else {
+                                await container.stop();
+                            }
                             instance.status = types_1.InstanceStatus.STOPPED;
                             socketManager_1.socketManager.emitSystemEvent(systemId, socketManager_1.EVENT_STATUS_CHANGED, instance);
                             this.save();
@@ -413,7 +440,7 @@ class InstanceManager {
                     existingInstance = undefined;
                 }
             }
-            if (existingInstance?.pid) {
+            if (existingInstance && existingInstance.pid) {
                 if (existingInstance.status === types_1.InstanceStatus.READY) {
                     // Instance is already running
                     return existingInstance;
@@ -474,8 +501,7 @@ class InstanceManager {
                     return existingInstance;
                 }
             }
-            const instanceConfig = await configManager_1.configManager.getConfigForSection(systemId, instanceId);
-            const resolvedConfig = (0, utils_1.getResolvedConfiguration)(blockSpec.configuration, instanceConfig, blockInstance.defaultConfiguration);
+            const resolvedConfig = await configManager_1.configManager.getConfigForBlockInstance(systemId, instanceId);
             const task = taskManager_1.taskManager.add(`instance:start:${systemId}:${instanceId}`, async () => {
                 const runner = new BlockInstanceRunner_1.BlockInstanceRunner(systemId);
                 const startTime = Date.now();
@@ -708,14 +734,20 @@ class InstanceManager {
                 return types_1.InstanceStatus.READY;
             }
             if (statusType === 'created') {
-                if (state.ExitCode !== 0) {
-                    // Failed during creation
-                    return types_1.InstanceStatus.FAILED;
+                if (state.ExitCode !== undefined && state.ExitCode !== 0) {
+                    // Failed during creation. Exit code is not always reliable though
+                    if (state.Error) {
+                        return types_1.InstanceStatus.FAILED;
+                    }
+                    else {
+                        return types_1.InstanceStatus.STOPPED;
+                    }
                 }
                 return types_1.InstanceStatus.STARTING;
             }
             if (statusType === 'exited' || statusType === 'dead') {
-                if (state.ExitCode === 0) {
+                if (!state.Error) {
+                    // Exit code is not always reliable - if there is no error we assume it's stopped
                     return types_1.InstanceStatus.STOPPED;
                 }
                 return types_1.InstanceStatus.FAILED;

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

@@ -4,8 +4,9 @@
  */
 import { DefinitionInfo } from '@kapeta/local-cluster-config';
 import { ContainerInfo } from './containerManager';
-import { EnvironmentType, OperatorInfo } from './types';
+import { AnyMap, EnvironmentType } from './types';
 import { LocalInstance } from '@kapeta/schemas';
+import { ResourceInfo } from '@kapeta/sdk-config';
 declare class Operator {
     private readonly _data;
     constructor(data: DefinitionInfo);
@@ -25,7 +26,8 @@ declare class OperatorManager {
     /**
      * Get information about a specific consumed resource
      */
-    getConsumerResourceInfo(systemId: string, fromServiceId: string, resourceType: string, portType: string, name: string, environment?: EnvironmentType): Promise<OperatorInfo>;
+    getConsumerResourceInfo(systemId: string, fromServiceId: string, resourceType: string, portType: string, name: string, environment?: EnvironmentType, ensureContainer?: boolean): Promise<ResourceInfo<any, any>>;
+    getOperatorPorts(systemId: string, kind: string, version: string): Promise<AnyMap>;
     /**
      * Ensure we have a running operator of given type
      *

package/dist/cjs/src/operatorManager.js

@@ -68,7 +68,7 @@ class OperatorManager {
     /**
      * Get information about a specific consumed resource
      */
-    async getConsumerResourceInfo(systemId, fromServiceId, resourceType, portType, name, environment) {
+    async getConsumerResourceInfo(systemId, fromServiceId, resourceType, portType, name, environment, ensureContainer = true) {
         systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
         const plans = await definitionsManager_1.definitionsManager.getDefinitions(KIND_PLAN);
         const planUri = (0, nodejs_utils_1.parseKapetaUri)(systemId);
@@ -96,18 +96,20 @@ class OperatorManager {
         const kindUri = (0, nodejs_utils_1.parseKapetaUri)(blockResource.kind);
         const operator = await this.getOperator(resourceType, kindUri.version);
         const credentials = operator.getCredentials();
-        const container = await this.ensureOperator(systemId, resourceType, kindUri.version);
-        const portInfo = await container.getPort(portType);
-        if (!portInfo) {
+        if (ensureContainer) {
+            await this.ensureOperator(systemId, resourceType, kindUri.version);
+        }
+        const hostPort = await serviceManager_1.serviceManager.ensureServicePort(systemId, resourceType, portType);
+        if (!hostPort) {
             throw new Error('Unknown resource port type : ' + resourceType + '#' + portType);
         }
         const dbName = name + '_' + fromServiceId.replace(/[^a-z0-9]/gi, '');
         const safeName = dbName.replace('_', '-');
         return {
-            host: environment === 'docker' ? 'host.docker.internal' : '127.0.0.1',
-            port: portInfo.hostPort,
+            host: (0, utils_1.getRemoteHostForEnvironment)(environment),
+            port: hostPort,
             type: portType,
-            protocol: portInfo.protocol,
+            protocol: 'tcp',
             options: {
                 // expose as fullName since that is not operator specific, but unique
                 fullName: safeName,
@@ -116,6 +118,26 @@ class OperatorManager {
             credentials,
         };
     }
+    async getOperatorPorts(systemId, kind, version) {
+        const operator = await this.getOperator(kind, version);
+        const operatorData = operator.getLocalData();
+        const portTypes = Object.keys(operatorData.ports);
+        portTypes.sort();
+        const ports = {};
+        for (let i = 0; i < portTypes.length; i++) {
+            const portType = portTypes[i];
+            let containerPortInfo = operatorData.ports[portType];
+            const hostPort = await serviceManager_1.serviceManager.ensureServicePort(systemId, kind, portType);
+            const portInfo = (0, utils_1.toPortInfo)(containerPortInfo);
+            const portId = portInfo.port + '/' + portInfo.type;
+            ports[portId] = {
+                type: portType,
+                hostPort,
+                protocol: portInfo.type,
+            };
+        }
+        return ports;
+    }
     /**
      * Ensure we have a running operator of given type
      *
@@ -129,20 +151,7 @@ class OperatorManager {
         return await this.operatorLock.acquire(key, async () => {
             const operator = await this.getOperator(kind, version);
             const operatorData = operator.getLocalData();
-            const portTypes = Object.keys(operatorData.ports);
-            portTypes.sort();
-            const ports = {};
-            for (let i = 0; i < portTypes.length; i++) {
-                const portType = portTypes[i];
-                let containerPortInfo = operatorData.ports[portType];
-                const hostPort = await serviceManager_1.serviceManager.ensureServicePort(systemId, kind, portType);
-                const portInfo = (0, utils_1.toPortInfo)(containerPortInfo);
-                const portId = portInfo.port + '/' + portInfo.type;
-                ports[portId] = {
-                    type: portType,
-                    hostPort,
-                };
-            }
+            const ports = await this.getOperatorPorts(systemId, kind, version);
             const nameParts = [systemId, kind.toLowerCase(), version];
             const containerName = `kapeta-resource-${(0, md5_1.default)(nameParts.join('_'))}`;
             const PortBindings = {};
@@ -154,14 +163,14 @@ class OperatorManager {
                 [containerManager_1.COMPOSE_LABEL_SERVICE]: [kind, version].join('_').replace(/[^a-z0-9]/gi, '_'),
             };
             const operatorMetadata = operator.getDefinitionInfo().definition.metadata;
-            const bindHost = (0, utils_1.getBindHost)();
+            const hostIp = (0, utils_1.getDockerHostIp)();
             const ExposedPorts = {};
             lodash_1.default.forEach(ports, (portInfo, containerPort) => {
                 ExposedPorts['' + containerPort] = {};
                 PortBindings['' + containerPort] = [
                     {
                         HostPort: '' + portInfo.hostPort,
-                        HostIp: bindHost,
+                        HostIp: hostIp,
                     },
                 ];
                 Labels[containerManager_1.CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;

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

@@ -9,7 +9,6 @@ export declare const HTTP_PORTS: string[];
 declare class ServiceManager {
     private _systems;
     constructor();
-    getLocalHost(environmentType?: EnvironmentType): string;
     _forLocal(port: string | number, path?: string, environmentType?: EnvironmentType): string;
     _ensureSystem(systemId: string): any;
     _ensureService(systemId: string, serviceId: string): any;

package/dist/cjs/src/serviceManager.js

@@ -13,6 +13,7 @@ const clusterService_1 = require("./clusterService");
 const storageService_1 = require("./storageService");
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const BlockInstanceRunner_1 = require("./utils/BlockInstanceRunner");
+const utils_1 = require("./utils/utils");
 exports.HTTP_PORT_TYPE = 'http';
 exports.DEFAULT_PORT_TYPE = exports.HTTP_PORT_TYPE;
 exports.HTTP_PORTS = [exports.HTTP_PORT_TYPE, 'web', 'rest'];
@@ -31,18 +32,11 @@ class ServiceManager {
             });
         });
     }
-    getLocalHost(environmentType) {
-        if (environmentType === 'docker') {
-            //We're inside a docker container, so we can use this special host name to access the host machine
-            return 'host.docker.internal';
-        }
-        return clusterService_1.clusterService.getClusterServiceHost();
-    }
     _forLocal(port, path, environmentType) {
         if (!path) {
             path = '';
         }
-        const hostname = this.getLocalHost(environmentType);
+        const hostname = (0, utils_1.getRemoteHostForEnvironment)(environmentType);
         if (path.startsWith('/')) {
             path = path.substring(1);
         }

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

@@ -21,6 +21,7 @@ export type WatchEventName = 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir
 export type LogLevel = 'ERROR' | 'WARN' | 'INFO' | 'DEBUG' | 'TRACE' | 'FATAL';
 export type LogSource = 'stdout' | 'stderr';
 export type EnvironmentType = 'docker' | 'process';
+export declare const DOCKER_HOST_INTERNAL = "host.docker.internal";
 export interface LogEntry {
     source: LogSource;
     level: LogLevel;
@@ -60,12 +61,6 @@ export type ProcessInfo = {
     pid?: number | string | null;
     portType?: string;
 };
-export interface Health {
-    cmd: string;
-    interval?: number;
-    timeout?: number;
-    retries?: number;
-}
 export type InstanceInfo = {
     systemId: string;
     instanceId: string;
@@ -83,29 +78,6 @@ export type InstanceInfo = {
     portType?: string;
 };
 export type ProxyRequestHandler = (req: StringBodyRequest, res: express.Response, info: ProxyRequestInfo) => void;
-export interface OperatorInstancePort {
-    protocol: string;
-    port: number;
-}
-export interface OperatorInstanceInfo {
-    hostname: string;
-    ports: {
-        [portType: string]: OperatorInstancePort;
-    };
-    path?: string;
-    query?: string;
-    hash?: string;
-    options?: AnyMap;
-    credentials?: AnyMap;
-}
-export interface OperatorInfo {
-    host: string;
-    port: string;
-    type: string;
-    protocol: string;
-    options: AnyMap;
-    credentials: AnyMap;
-}
 export interface ProxyRequestInfo {
     address: string;
     connection: Connection;

package/dist/cjs/src/types.js

@@ -4,11 +4,12 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DesiredInstanceStatus = exports.InstanceStatus = exports.InstanceOwner = exports.InstanceType = exports.KIND_BLOCK_TYPE_EXECUTABLE = exports.KIND_BLOCK_TYPE_OPERATOR = exports.KIND_BLOCK_TYPE = exports.KIND_RESOURCE_OPERATOR = void 0;
+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";

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

@@ -21,6 +21,8 @@ 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';
@@ -30,7 +32,7 @@ const KAPETA_INSTANCE_ID = 'KAPETA_INSTANCE_ID';
  */
 const DOCKER_ENV_VARS = [
     `KAPETA_LOCAL_SERVER=0.0.0.0`,
-    `KAPETA_LOCAL_CLUSTER_HOST=host.docker.internal`,
+    `KAPETA_LOCAL_CLUSTER_HOST=${types_1.DOCKER_HOST_INTERNAL}`,
     `KAPETA_ENVIRONMENT_TYPE=docker`,
 ];
 async function getProvider(uri) {
@@ -91,16 +93,6 @@ class BlockInstanceRunner {
         });
     }
     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';
@@ -114,18 +106,25 @@ class BlockInstanceRunner {
         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, env);
+            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, env, assetVersion);
+                processInfo = await this._startLocalProcess(blockInstance, blockUri, envVars, assetVersion);
             }
             else {
-                processInfo = await this._startDockerProcess(blockInstance, blockUri, env, assetVersion);
+                processInfo = await this._startDockerProcess(blockInstance, blockUri, envVars, assetVersion);
             }
             if (portTypes.length > 0) {
                 processInfo.portType = portTypes[0];
@@ -193,9 +192,13 @@ class BlockInstanceRunner {
         if (localContainer.healthcheck) {
             HealthCheck = containerManager_1.containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
-        const Mounts = containerManager_1.containerManager.toDockerMounts({
-            [workingDir]: (0, containerManager_1.toLocalBindVolume)(realLocalPath),
-        });
+        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,
@@ -310,29 +313,26 @@ class BlockInstanceRunner {
         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 bindHost = (0, utils_1.getBindHost)();
+            const hostIp = (0, utils_1.getDockerHostIp)();
             const ExposedPorts = {};
             const addonEnv = {};
             const PortBindings = {};
             let HealthCheck = undefined;
             let Mounts = [];
-            const localPorts = local.ports ?? {};
+            const instancePorts = await (0, utils_1.getOperatorInstancePorts)(this._systemId, operatorId, local);
             const labels = {};
-            const promises = Object.entries(localPorts).map(async ([portType, value]) => {
-                const portInfo = (0, utils_1.toPortInfo)(value);
-                const dockerPort = `${portInfo.port}/${portInfo.type}`;
+            instancePorts.forEach((portInfo) => {
+                const dockerPort = `${portInfo.port}/${portInfo.protocol}`;
                 ExposedPorts[dockerPort] = {};
-                addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = `${portInfo.port}`;
-                const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, operatorId, portType);
+                addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portInfo.portType.toUpperCase()}`] = `${portInfo.port}`;
                 PortBindings[dockerPort] = [
                     {
-                        HostIp: bindHost,
-                        HostPort: `${publicPort}`,
+                        HostIp: hostIp,
+                        HostPort: `${portInfo.hostPort}`,
                     },
                 ];
-                labels[containerManager_1.CONTAINER_LABEL_PORT_PREFIX + publicPort] = portType;
+                labels[containerManager_1.CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.portType;
             });
-            await Promise.all(promises);
             if (local.env) {
                 Object.entries(local.env).forEach(([key, value]) => {
                     addonEnv[key] = value;
@@ -396,7 +396,7 @@ class BlockInstanceRunner {
      * Get the port bindings for a non-operator block
      */
     async getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion) {
-        const bindHost = (0, utils_1.getBindHost)();
+        const hostIp = (0, utils_1.getDockerHostIp)();
         const ExposedPorts = {};
         const addonEnv = {};
         const PortBindings = {};
@@ -410,7 +410,7 @@ class BlockInstanceRunner {
             addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = '' + thisPort;
             PortBindings[dockerPort] = [
                 {
-                    HostIp: bindHost,
+                    HostIp: hostIp,
                     HostPort: `${publicPort}`,
                 },
             ];