@kapeta/local-cluster-service 0.37.0 → 0.39.0

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

@@ -3,11 +3,13 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 /// <reference types="node" />
+import { LogEntry } from './types';
+import { Task } from './taskManager';
 export declare class ProgressListener {
     private readonly systemId;
     private readonly instanceId;
     constructor(systemId?: string, instanceId?: string);
-    private emitLog;
+    protected emitLog(payload: Omit<LogEntry, 'time' | 'source'>): void;
     run(command: string, directory?: string): Promise<{
         exit: number;
         signal: NodeJS.Signals | null;
@@ -22,3 +24,8 @@ export declare class ProgressListener {
     info(msg: string, ...args: any[]): void;
     debug(msg: string, ...args: any[]): void;
 }
+export declare class TaskProgressListener extends ProgressListener {
+    private readonly task;
+    constructor(task: Task);
+    protected emitLog(payload: Omit<LogEntry, 'time' | 'source'>): void;
+}

package/dist/cjs/src/progressListener.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProgressListener = void 0;
+exports.TaskProgressListener = exports.ProgressListener = void 0;
 const nodejs_process_1 = require("@kapeta/nodejs-process");
 const socketManager_1 = require("./socketManager");
 const node_util_1 = require("node:util");
@@ -120,3 +120,14 @@ class ProgressListener {
     }
 }
 exports.ProgressListener = ProgressListener;
+class TaskProgressListener extends ProgressListener {
+    task;
+    constructor(task) {
+        super();
+        this.task = task;
+    }
+    emitLog(payload) {
+        this.task.addLog(payload.message, payload.level);
+    }
+}
+exports.TaskProgressListener = TaskProgressListener;

package/dist/cjs/src/repositoryManager.js

@@ -164,16 +164,17 @@ class RepositoryManager extends node_events_1.EventEmitter {
     async scheduleInstallation(refs) {
         //We make sure to only install one asset at a time - otherwise unexpected things might happen
         const createInstaller = (ref) => {
-            return async () => {
+            return async (task) => {
                 if (await definitionsManager_1.definitionsManager.exists(ref)) {
                     return;
                 }
+                const progressListener = new progressListener_1.TaskProgressListener(task);
                 //console.log(`Installing asset: ${ref}`);
                 //Auto-install missing asset
                 try {
                     //We change to a temp dir to avoid issues with the current working directory
                     process.chdir(node_os_1.default.tmpdir());
-                    await nodejs_registry_utils_1.Actions.install(new progressListener_1.ProgressListener(), [ref], {});
+                    await nodejs_registry_utils_1.Actions.install(progressListener, [ref], {});
                 }
                 catch (e) {
                     console.error(`Failed to install asset: ${ref}`, e);

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/taskManager.d.ts

@@ -2,6 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+import { LogLevel } from './types';
 export type TaskRunner<T> = (task: Task<T>) => Promise<T>;
 export declare enum TaskStatus {
     PENDING = "PENDING",
@@ -44,6 +45,7 @@ export declare class Task<T = void> implements TaskData<T> {
     set errorMessage(errorMessage: string | undefined);
     set metadata(metadata: TaskMetadata);
     emitUpdate(): void;
+    addLog(log: string, level?: LogLevel): void;
     wait(): Promise<T>;
     toData(): {
         id: string;

package/dist/cjs/src/taskManager.js

@@ -12,6 +12,7 @@ const socketManager_1 = require("./socketManager");
 const EVENT_TASK_UPDATED = 'task-updated';
 const EVENT_TASK_ADDED = 'task-added';
 const EVENT_TASK_REMOVED = 'task-removed';
+const EVENT_TASK_LOG = 'task-log';
 var TaskStatus;
 (function (TaskStatus) {
     TaskStatus["PENDING"] = "PENDING";
@@ -54,6 +55,14 @@ class Task {
     emitUpdate() {
         socketManager_1.socketManager.emitGlobal(EVENT_TASK_UPDATED, this.toData());
     }
+    addLog(log, level = 'INFO') {
+        socketManager_1.socketManager.emitGlobal(EVENT_TASK_LOG, {
+            id: this.id,
+            message: log,
+            level,
+            time: Date.now(),
+        });
+    }
     async wait() {
         return this.future.promise;
     }

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,31 +61,6 @@ export type ProcessInfo = {
     pid?: number | string | null;
     portType?: string;
 };
-export interface Health {
-    cmd: string;
-    interval?: number;
-    timeout?: number;
-    retries?: number;
-}
-export type PortInfo = {
-    port: number;
-    type: 'tcp' | 'udp';
-} | number | string;
-export type LocalImageOptions<Credentials = AnyMap, Options = AnyMap> = {
-    image: string;
-    ports: {
-        [key: string]: PortInfo;
-    };
-    credentials?: Credentials;
-    options?: Options;
-    cmd?: string;
-    env?: AnyMap;
-    health?: Health;
-    singleton?: boolean;
-    mounts?: {
-        [key: string]: string;
-    };
-};
 export type InstanceInfo = {
     systemId: string;
     instanceId: string;
@@ -102,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

@@ -19,7 +19,10 @@ const clusterService_1 = require("../clusterService");
 const types_1 = require("../types");
 const definitionsManager_1 = require("../definitionsManager");
 const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
 const taskManager_1 = require("../taskManager");
+const InternalConfigProvider_1 = require("./InternalConfigProvider");
+const config_mapper_1 = require("@kapeta/config-mapper");
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
 const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
 const KAPETA_INSTANCE_ID = 'KAPETA_INSTANCE_ID';
@@ -29,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) {
@@ -90,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';
@@ -113,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];
@@ -144,6 +144,7 @@ class BlockInstanceRunner {
         if (!assetVersion.definition.spec?.target?.kind) {
             throw new Error('Missing target kind in block definition');
         }
+        const realLocalPath = await fs_extra_1.default.realpath(baseDir);
         const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.kind);
         const providerVersion = await getProvider(kindUri);
         if (!providerVersion) {
@@ -158,10 +159,21 @@ class BlockInstanceRunner {
         if (!localContainer) {
             throw new Error(`Missing local container information from target: ${targetKindUri.id}`);
         }
-        const dockerImage = localContainer.image;
-        if (!dockerImage) {
+        let dockerImage = localContainer.image;
+        const isDockerImage = !localContainer.type || localContainer.type.toLowerCase() === 'docker';
+        const isDockerFile = Boolean(localContainer.type && localContainer.type.toLowerCase() === 'dockerfile');
+        if (isDockerImage && !dockerImage) {
             throw new Error(`Missing docker image information: ${JSON.stringify(localContainer)}`);
         }
+        if (isDockerFile) {
+            dockerImage = blockInfo.fullName + ':local';
+            const dockerFile = node_path_1.default.join(realLocalPath, localContainer.file ?? 'Dockerfile');
+            if (!fs_extra_1.default.existsSync(dockerFile)) {
+                throw new Error(`Dockerfile not found at: ${dockerFile}`);
+            }
+            const task = containerManager_1.containerManager.buildDockerImage(dockerFile, blockInfo.fullName + ':local');
+            await task.wait();
+        }
         const containerName = await (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id, targetKindUri.id);
         const startCmd = localContainer.handlers?.onCreate ? localContainer.handlers.onCreate : '';
         const dockerOpts = localContainer.options ?? {};
@@ -180,10 +192,13 @@ class BlockInstanceRunner {
         if (localContainer.healthcheck) {
             HealthCheck = containerManager_1.containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
-        const realLocalPath = await fs_extra_1.default.realpath(baseDir);
-        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,
@@ -298,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;
@@ -384,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 = {};
@@ -398,7 +410,7 @@ class BlockInstanceRunner {
             addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = '' + thisPort;
             PortBindings[dockerPort] = [
                 {
-                    HostIp: bindHost,
+                    HostIp: hostIp,
                     HostPort: `${publicPort}`,
                 },
             ];

package/dist/cjs/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/cjs/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/cjs/src/utils/commandLineUtils.d.ts

@@ -2,6 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+import { Task } from '../taskManager';
 export declare function hasCLI(): Promise<boolean>;
-export declare function ensureCLI(): Promise<import("../taskManager").Task<void> | null>;
+export declare function ensureCLI(): Promise<Task<void> | null>;
 export declare function ensureCLICommands(): Promise<void>;

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

@@ -15,10 +15,16 @@ async function ensureCLI() {
     if (await hasCLI()) {
         return null;
     }
-    return taskManager_1.taskManager.add(`cli:install`, () => {
+    return taskManager_1.taskManager.add(`cli:install`, (task) => {
         const process = (0, nodejs_process_1.spawn)('npm', ['install', '-g', '@kapeta/kap'], {
             shell: true,
         });
+        process.process.stdout?.on('data', (data) => {
+            task.addLog(data.toString(), 'INFO');
+        });
+        process.process.stderr?.on('data', (data) => {
+            task.addLog(data.toString(), 'ERROR');
+        });
         return process.wait();
     }, {
         name: `Installing Kapeta CLI`,

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

@@ -2,17 +2,39 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { EntityList } from '@kapeta/schemas';
-import { AnyMap, PortInfo } 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: PortInfo): {
+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;