@kapeta/local-cluster-service 0.37.0 → 0.39.0

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/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/esm/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/esm/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/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/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/esm/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/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,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/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

@@ -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/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>;