@kapeta/local-cluster-service 0.38.0 → 0.39.1

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/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/cjs/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 || {};

package/dist/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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
      *