@kapeta/local-cluster-service 0.38.0 → 0.39.1

package/dist/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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}`,
                 },
             ];

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

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { BlockInstanceDetails, ConfigProvider, DefaultCredentials, DefaultResourceOptions, InstanceOperator, ResourceInfo } from '@kapeta/sdk-config';
+import { Definition, DefinitionInfo } from '@kapeta/local-cluster-config';
+import { BlockDefinition, Plan } from '@kapeta/schemas';
+import { AnyMap, EnvironmentType } from '../types';
+/**
+ * A configuration provider that does the same as the LocalConfigProvider
+ * but without calling the API of the local cluster service (since it's running in the same process)
+ */
+export declare class InternalConfigProvider implements ConfigProvider {
+    private readonly info;
+    private readonly systemId;
+    private readonly instanceId;
+    private readonly config;
+    private readonly environment;
+    constructor(systemId: string, instanceId: string, info: DefinitionInfo, config: AnyMap, environment?: EnvironmentType);
+    getBlockDefinition(): Definition;
+    getBlockReference(): string;
+    getSystemId(): string;
+    getInstanceId(): string;
+    getServerPort(portType?: string | undefined): Promise<string>;
+    getServiceAddress(serviceName: string, portType: string): Promise<string | null>;
+    getResourceInfo<Options = DefaultResourceOptions, Credentials = DefaultCredentials>(resourceType: string, portType: string, resourceName: string): Promise<ResourceInfo<Options, Credentials> | null>;
+    getInstanceHost(instanceId: string): Promise<string | null>;
+    getServerHost(): Promise<string>;
+    getProviderId(): string;
+    getOrDefault<T = any>(path: string, defaultValue: T): T;
+    get<T = any>(path: string): T | undefined;
+    getInstanceOperator<Options = any, Credentials extends DefaultCredentials = DefaultCredentials>(instanceId: string): Promise<InstanceOperator<Options, Credentials> | null>;
+    getInstanceForConsumer<BlockType = BlockDefinition>(resourceName: string): Promise<BlockInstanceDetails<BlockType> | null>;
+    getInstancesForProvider<BlockType = BlockDefinition>(resourceName: string): Promise<BlockInstanceDetails<BlockType>[]>;
+    getBlock(ref: any): Promise<Definition>;
+    getPlan(): Promise<Plan>;
+}
+export declare function createInternalConfigProvider(systemId: string, instanceId: string, info: DefinitionInfo): Promise<InternalConfigProvider>;

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

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInternalConfigProvider = exports.InternalConfigProvider = void 0;
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const configManager_1 = require("../configManager");
+const lodash_1 = __importDefault(require("lodash"));
+const serviceManager_1 = require("../serviceManager");
+const operatorManager_1 = require("../operatorManager");
+const instanceManager_1 = require("../instanceManager");
+const definitionsManager_1 = require("../definitionsManager");
+const utils_1 = require("./utils");
+/**
+ * A configuration provider that does the same as the LocalConfigProvider
+ * but without calling the API of the local cluster service (since it's running in the same process)
+ */
+class InternalConfigProvider {
+    info;
+    systemId;
+    instanceId;
+    config;
+    environment;
+    constructor(systemId, instanceId, info, config, environment = 'docker') {
+        this.info = info;
+        this.systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        this.instanceId = instanceId;
+        this.config = config;
+        this.environment = environment;
+    }
+    getBlockDefinition() {
+        return this.info.definition;
+    }
+    getBlockReference() {
+        return (0, nodejs_utils_1.normalizeKapetaUri)(this.info.definition.metadata.name + ':' + this.info.version);
+    }
+    getSystemId() {
+        return this.systemId;
+    }
+    getInstanceId() {
+        return this.instanceId;
+    }
+    getServerPort(portType) {
+        return serviceManager_1.serviceManager.ensureServicePort(this.systemId, this.instanceId, portType);
+    }
+    async getServiceAddress(serviceName, portType) {
+        return serviceManager_1.serviceManager.getConsumerAddress(this.systemId, this.instanceId, serviceName, portType, this.environment);
+    }
+    getResourceInfo(resourceType, portType, resourceName) {
+        return operatorManager_1.operatorManager.getConsumerResourceInfo(this.systemId, this.instanceId, resourceType, portType, resourceName, this.environment, false);
+    }
+    async getInstanceHost(instanceId) {
+        const instance = instanceManager_1.instanceManager.getInstance(this.systemId, instanceId);
+        return instance?.address ?? null;
+    }
+    async getServerHost() {
+        return (0, utils_1.getBindAddressForEnvironment)(this.environment);
+    }
+    getProviderId() {
+        return 'internal';
+    }
+    getOrDefault(path, defaultValue) {
+        return this.get(path) ?? defaultValue;
+    }
+    get(path) {
+        return lodash_1.default.get(this.config, path);
+    }
+    getInstanceOperator(instanceId) {
+        return instanceManager_1.instanceManager.getInstanceOperator(this.systemId, instanceId, this.environment, false);
+    }
+    async getInstanceForConsumer(resourceName) {
+        const plan = await this.getPlan();
+        if (!plan) {
+            throw new Error('Could not find plan');
+        }
+        const instanceId = this.getInstanceId();
+        const connection = plan.spec.connections.find((connection) => connection.consumer.blockId === instanceId && connection.consumer.resourceName === resourceName);
+        if (!connection) {
+            throw new Error(`Could not find connection for consumer ${resourceName}`);
+        }
+        const instance = plan.spec.blocks.find((b) => b.id === connection.provider.blockId);
+        if (!instance) {
+            throw new Error(`Could not find instance ${connection.provider.blockId} in plan`);
+        }
+        const block = await this.getBlock(instance.block.ref);
+        if (!block) {
+            throw new Error(`Could not find block ${instance.block.ref} in plan`);
+        }
+        return {
+            instanceId: connection.provider.blockId,
+            connections: [connection],
+            block: block,
+        };
+    }
+    async getInstancesForProvider(resourceName) {
+        const plan = await this.getPlan();
+        if (!plan) {
+            throw new Error('Could not find plan');
+        }
+        const instanceId = this.getInstanceId();
+        const blockDetails = {};
+        const connections = plan.spec.connections.filter((connection) => connection.provider.blockId === instanceId && connection.provider.resourceName === resourceName);
+        for (const connection of connections) {
+            const blockInstanceId = connection.consumer.blockId;
+            if (blockDetails[blockInstanceId]) {
+                blockDetails[blockInstanceId].connections.push(connection);
+                continue;
+            }
+            const instance = plan.spec.blocks.find((b) => b.id === blockInstanceId);
+            if (!instance) {
+                throw new Error(`Could not find instance ${blockInstanceId} in plan`);
+            }
+            const block = await this.getBlock(instance.block.ref);
+            if (!block) {
+                throw new Error(`Could not find block ${instance.block.ref} in plan`);
+            }
+            blockDetails[blockInstanceId] = {
+                instanceId: blockInstanceId,
+                connections: [connection],
+                block: block,
+            };
+        }
+        return Object.values(blockDetails);
+    }
+    async getBlock(ref) {
+        const definition = await definitionsManager_1.definitionsManager.getDefinition(ref);
+        if (!definition) {
+            throw new Error(`Could not find definition for ${ref}`);
+        }
+        return definition.definition;
+    }
+    async getPlan() {
+        const definition = await definitionsManager_1.definitionsManager.getDefinition(this.systemId);
+        if (!definition) {
+            throw new Error(`Could not find plan ${this.systemId}`);
+        }
+        return definition.definition;
+    }
+}
+exports.InternalConfigProvider = InternalConfigProvider;
+async function createInternalConfigProvider(systemId, instanceId, info) {
+    const config = await configManager_1.configManager.getConfigForBlockInstance(systemId, instanceId);
+    return new InternalConfigProvider(systemId, instanceId, info, config);
+}
+exports.createInternalConfigProvider = createInternalConfigProvider;

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

@@ -2,17 +2,39 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { EntityList, LocalInstancePort } from '@kapeta/schemas';
-import { AnyMap } from '../types';
+import { EntityList, LocalInstance, LocalInstancePort } from '@kapeta/schemas';
+import { AnyMap, EnvironmentType } from '../types';
 export declare function getBlockInstanceContainerName(systemId: string, instanceId: string, blockType?: string): Promise<string>;
 export declare function toPortInfo(port: LocalInstancePort): LocalInstancePort | {
     port: number;
     type: string;
 };
+export declare function getOperatorInstancePorts(systemId: string, operatorId: string, local: LocalInstance): Promise<{
+    portType: string;
+    port: number | undefined;
+    hostPort: any;
+    protocol: string | undefined;
+}[]>;
+/**
+ * Gets the hostname where all services are available - including the cluster service.
+ *
+ * For docker this is the internal docker host - otherwise it's the local machine
+ * Assumed to be the same address as the cluster service outside docker.
+ */
+export declare function getRemoteHostForEnvironment(environment: EnvironmentType | undefined): string;
+/**
+ * Get the bind address for the given environment.
+ *
+ * Outside of docker we bind to 127.0.0.1 - inside we bind to everything (0.0.0.0)
+ */
+export declare function getBindAddressForEnvironment(environment: EnvironmentType | undefined, preferredHost?: string): string;
+/**
+ * Get the docker host IP address for port binding.
+ */
+export declare function getDockerHostIp(preferredHost?: string): string;
 export declare function getRemoteUrl(id: string, defautValue: string): any;
 export declare function readYML(path: string): any;
 export declare function isWindows(): boolean;
 export declare function isMac(): boolean;
 export declare function isLinux(): boolean;
-export declare function getBindHost(preferredHost?: string): string;
 export declare function getResolvedConfiguration(entities?: EntityList, config?: AnyMap, globalConfiguration?: AnyMap): AnyMap;

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

@@ -7,7 +7,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getResolvedConfiguration = exports.getBindHost = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = exports.getRemoteUrl = exports.toPortInfo = exports.getBlockInstanceContainerName = void 0;
+exports.getResolvedConfiguration = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = exports.getRemoteUrl = exports.getDockerHostIp = exports.getBindAddressForEnvironment = exports.getRemoteHostForEnvironment = exports.getOperatorInstancePorts = exports.toPortInfo = exports.getBlockInstanceContainerName = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const yaml_1 = __importDefault(require("yaml"));
 const md5_1 = __importDefault(require("md5"));
@@ -18,6 +18,8 @@ const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-co
 const definitionsManager_1 = require("../definitionsManager");
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const assetManager_1 = require("../assetManager");
+const serviceManager_1 = require("../serviceManager");
+const clusterService_1 = require("../clusterService");
 async function getBlockInstanceContainerName(systemId, instanceId, blockType) {
     if (!blockType) {
         const instance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
@@ -51,6 +53,49 @@ function toPortInfo(port) {
     return port;
 }
 exports.toPortInfo = toPortInfo;
+async function getOperatorInstancePorts(systemId, operatorId, local) {
+    const localPorts = local.ports ?? {};
+    const promises = Object.entries(localPorts).map(async ([portType, value]) => {
+        const portInfo = toPortInfo(value);
+        const hostPort = await serviceManager_1.serviceManager.ensureServicePort(systemId, operatorId, portType);
+        return {
+            portType,
+            port: portInfo.port,
+            hostPort,
+            protocol: portInfo.type,
+        };
+    });
+    return await Promise.all(promises);
+}
+exports.getOperatorInstancePorts = getOperatorInstancePorts;
+/**
+ * Gets the hostname where all services are available - including the cluster service.
+ *
+ * For docker this is the internal docker host - otherwise it's the local machine
+ * Assumed to be the same address as the cluster service outside docker.
+ */
+function getRemoteHostForEnvironment(environment) {
+    return environment === 'docker' ? types_1.DOCKER_HOST_INTERNAL : clusterService_1.clusterService.getClusterServiceHost();
+}
+exports.getRemoteHostForEnvironment = getRemoteHostForEnvironment;
+/**
+ * Get the bind address for the given environment.
+ *
+ * Outside of docker we bind to 127.0.0.1 - inside we bind to everything (0.0.0.0)
+ */
+function getBindAddressForEnvironment(environment, preferredHost = '127.0.0.1') {
+    return environment === 'docker' ? '0.0.0.0' : preferredHost;
+}
+exports.getBindAddressForEnvironment = getBindAddressForEnvironment;
+/**
+ * Get the docker host IP address for port binding.
+ */
+function getDockerHostIp(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.getDockerHostIp = getDockerHostIp;
 function getRemoteUrl(id, defautValue) {
     const remoteConfig = local_cluster_config_1.default.getClusterConfig().remote;
     return remoteConfig?.[id] ?? defautValue;
@@ -78,12 +123,6 @@ function isLinux() {
     return !isWindows() && !isMac();
 }
 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;
 function getResolvedConfiguration(entities, config, globalConfiguration) {
     if (!entities || !globalConfiguration) {
         return config || {};