@kapeta/local-cluster-service 0.36.0 → 0.37.0

package/.vscode/launch.json

@@ -1,15 +1,19 @@
 {
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
         {
             "type": "node",
             "request": "launch",
-            "name": "Launch Program",
+            "name": "Debug Node.js (npm run dev)",
+            "runtimeExecutable": "npm",
+            "runtimeArgs": ["run-script", "dev"],
+            "restart": true,
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen",
             "skipFiles": ["<node_internals>/**"],
-            "program": "${workspaceFolder}/start.js"
+            "env": {
+                "NODE_ENV": "development"
+            }
         }
     ]
 }

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+# [0.37.0](https://github.com/kapetacom/local-cluster-service/compare/v0.36.1...v0.37.0) (2024-02-23)
+
+
+### Bug Fixes
+
+* Self review ([50bd377](https://github.com/kapetacom/local-cluster-service/commit/50bd377c41f132fd3f61afb1fc74b823bf60729f))
+* Start debugger as "npm run dev" ([44b745a](https://github.com/kapetacom/local-cluster-service/commit/44b745af75e333056f7b187680f43c786461eb1d))
+
+
+### Features
+
+* Add block-type-executabla ([7426433](https://github.com/kapetacom/local-cluster-service/commit/742643358022c0eb3b6065a42abba00e27dfc2e8))
+* Do not attempt to start instances of kind 'core/block-type-executable' ([9239eaf](https://github.com/kapetacom/local-cluster-service/commit/9239eafc117c98fa215b67e2dd99f5d8f18c2881))
+
+## [0.36.1](https://github.com/kapetacom/local-cluster-service/compare/v0.36.0...v0.36.1) (2024-02-07)
+
+
+### Bug Fixes
+
+* Ensure consistent naming for containers ([#124](https://github.com/kapetacom/local-cluster-service/issues/124)) ([f6041e7](https://github.com/kapetacom/local-cluster-service/commit/f6041e781797aa76a44dc9fb1f9f37c6d926a079))
+
 # [0.36.0](https://github.com/kapetacom/local-cluster-service/compare/v0.35.0...v0.36.0) (2024-02-06)
 
 

package/dist/cjs/src/assetManager.js

@@ -18,6 +18,7 @@ const repositoryManager_1 = require("./repositoryManager");
 const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
 const definitionsManager_1 = require("./definitionsManager");
 const taskManager_1 = require("./taskManager");
+const types_1 = require("./types");
 const cacheManager_1 = require("./cacheManager");
 const node_uuid_1 = __importDefault(require("node-uuid"));
 const node_os_1 = __importDefault(require("node:os"));
@@ -75,8 +76,9 @@ class AssetManager {
     async getAssets(assetKinds) {
         if (!assetKinds) {
             const blockTypeProviders = await definitionsManager_1.definitionsManager.getDefinitions([
-                'core/block-type',
-                'core/block-type-operator',
+                types_1.KIND_BLOCK_TYPE,
+                types_1.KIND_BLOCK_TYPE_OPERATOR,
+                types_1.KIND_BLOCK_TYPE_EXECUTABLE,
             ]);
             assetKinds = blockTypeProviders.map((p) => {
                 return `${p.definition.metadata.name}:${p.version}`;

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

@@ -45,7 +45,23 @@ export declare class InstanceManager {
     private requestInstanceStatus;
     private isSingletonOperator;
     private getKindForAssetRef;
+    /**
+     * Get the kind of an asset. Use the maxDepth parameter to specify how deep to look for the
+     * kind. For example, if maxDepth is 2, the method will look for the kind of the asset and then
+     * the kind of the kind.
+     * @param assetRef The asset reference
+     * @param maxDepth The maximum depth to look for the kind
+     * @returns The kind of the asset or null if not found
+     */
+    private getDeepKindForAssetRef;
     private isUsingKind;
     private getAllInstancesForKind;
+    /**
+     * Get the ids for all block instances except the ones of the specified kind
+     * @param systemId The plan reference id
+     * @param kind The kind to exclude. Can be a string or an array of strings
+     * @returns An array of block instance ids
+     */
+    private getAllInstancesExceptKind;
 }
 export declare const instanceManager: InstanceManager;

package/dist/cjs/src/instanceManager.js

@@ -230,11 +230,12 @@ class InstanceManager {
             throw new Error(`No blocks found in plan: ${systemId}`);
         }
         return taskManager_1.taskManager.add(`plan:start:${systemId}`, async () => {
-            let promises = [];
-            let errors = [];
-            for (let blockInstance of Object.values(plan.spec.blocks)) {
+            const promises = [];
+            const errors = [];
+            const instanceIds = await this.getAllInstancesExceptKind(systemId, types_1.KIND_BLOCK_TYPE_EXECUTABLE);
+            for (const instanceId of instanceIds) {
                 try {
-                    promises.push(this.start(systemId, blockInstance.id).then((taskOrInstance) => {
+                    promises.push(this.start(systemId, instanceId).then((taskOrInstance) => {
                         if (taskOrInstance instanceof taskManager_1.Task) {
                             return taskOrInstance.wait();
                         }
@@ -449,7 +450,7 @@ class InstanceManager {
                         // Definition not found
                         return Promise.resolve();
                     }
-                    if (operatorManager_1.KIND_RESOURCE_OPERATOR.toLowerCase() !== asset.definition.kind.toLowerCase()) {
+                    if (types_1.KIND_RESOURCE_OPERATOR.toLowerCase() !== asset.definition.kind.toLowerCase()) {
                         // Not an operator
                         return Promise.resolve();
                     }
@@ -776,7 +777,7 @@ class InstanceManager {
         if (!provider) {
             return false;
         }
-        if ((0, nodejs_utils_1.parseKapetaUri)(provider.kind).fullName === operatorManager_1.KIND_BLOCK_OPERATOR) {
+        if ((0, nodejs_utils_1.parseKapetaUri)(provider.kind).fullName === types_1.KIND_BLOCK_TYPE_OPERATOR) {
             const localConfig = provider.data.spec.local;
             return localConfig.singleton ?? false;
         }
@@ -789,6 +790,36 @@ class InstanceManager {
         }
         return block.data.kind;
     }
+    /**
+     * Get the kind of an asset. Use the maxDepth parameter to specify how deep to look for the
+     * kind. For example, if maxDepth is 2, the method will look for the kind of the asset and then
+     * the kind of the kind.
+     * @param assetRef The asset reference
+     * @param maxDepth The maximum depth to look for the kind
+     * @returns The kind of the asset or null if not found
+     */
+    async getDeepKindForAssetRef(assetRef, maxDepth) {
+        if (maxDepth <= 0) {
+            return null;
+        }
+        try {
+            const asset = await assetManager_1.assetManager.getAsset(assetRef);
+            if (!asset || !asset.data.kind) {
+                return null;
+            }
+            if (maxDepth === 1) {
+                return asset.data.kind;
+            }
+            else {
+                // Recurse with the kind of the current block and one less depth
+                return await this.getDeepKindForAssetRef(asset.data.kind, maxDepth - 1);
+            }
+        }
+        catch (error) {
+            console.error('Error fetching kind for assetRef:', assetRef, error);
+            return null;
+        }
+    }
     async isUsingKind(ref, kind) {
         const assetKind = await this.getKindForAssetRef(ref);
         if (!assetKind) {
@@ -809,6 +840,32 @@ class InstanceManager {
         }
         return out;
     }
+    /**
+     * Get the ids for all block instances except the ones of the specified kind
+     * @param systemId The plan reference id
+     * @param kind The kind to exclude. Can be a string or an array of strings
+     * @returns An array of block instance ids
+     */
+    async getAllInstancesExceptKind(systemId, kind) {
+        const plan = await assetManager_1.assetManager.getPlan(systemId);
+        if (!plan?.spec?.blocks) {
+            return [];
+        }
+        const out = [];
+        const excludedKinds = kind instanceof Array ? kind : [kind];
+        for (const block of plan.spec.blocks) {
+            const blockKindOfKind = await this.getDeepKindForAssetRef(block.block.ref, 2);
+            if (!blockKindOfKind) {
+                continue;
+            }
+            const shouldIncludeBlock = excludedKinds.some((excludedKind) => excludedKind === (0, nodejs_utils_1.parseKapetaUri)(blockKindOfKind).fullName) ===
+                false;
+            if (shouldIncludeBlock) {
+                out.push(block.id);
+            }
+        }
+        return out;
+    }
 }
 exports.InstanceManager = InstanceManager;
 exports.instanceManager = new InstanceManager();

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

@@ -5,8 +5,6 @@
 import { DefinitionInfo } from '@kapeta/local-cluster-config';
 import { ContainerInfo } from './containerManager';
 import { EnvironmentType, LocalImageOptions, OperatorInfo } from './types';
-export declare const KIND_RESOURCE_OPERATOR = "core/resource-type-operator";
-export declare const KIND_BLOCK_OPERATOR = "core/block-type-operator";
 declare class Operator {
     private readonly _data;
     constructor(data: DefinitionInfo);

package/dist/cjs/src/operatorManager.js

@@ -7,21 +7,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.operatorManager = exports.KIND_BLOCK_OPERATOR = exports.KIND_RESOURCE_OPERATOR = void 0;
+exports.operatorManager = void 0;
 const path_1 = __importDefault(require("path"));
 const md5_1 = __importDefault(require("md5"));
 const serviceManager_1 = require("./serviceManager");
 const storageService_1 = require("./storageService");
 const containerManager_1 = require("./containerManager");
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const types_1 = require("./types");
 const definitionsManager_1 = require("./definitionsManager");
 const utils_1 = require("./utils/utils");
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const lodash_1 = __importDefault(require("lodash"));
 const async_lock_1 = __importDefault(require("async-lock"));
 const taskManager_1 = require("./taskManager");
-exports.KIND_RESOURCE_OPERATOR = 'core/resource-type-operator';
-exports.KIND_BLOCK_OPERATOR = 'core/block-type-operator';
 const KIND_PLAN = 'core/plan';
 class Operator {
     _data;
@@ -52,7 +51,7 @@ class OperatorManager {
      * Get operator definition for resource type
      */
     async getOperator(fullName, version) {
-        const operators = await definitionsManager_1.definitionsManager.getDefinitions([exports.KIND_RESOURCE_OPERATOR, exports.KIND_BLOCK_OPERATOR]);
+        const operators = await definitionsManager_1.definitionsManager.getDefinitions([types_1.KIND_RESOURCE_OPERATOR, types_1.KIND_BLOCK_TYPE_OPERATOR]);
         const operator = operators.find((operator) => operator.definition &&
             operator.definition.metadata &&
             operator.definition.metadata.name &&

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

@@ -6,6 +6,10 @@ import express from 'express';
 import { Connection, Resource } from '@kapeta/schemas';
 import { StringBodyRequest } from './middleware/stringBody';
 import { KapetaRequest } from './middleware/kapeta';
+export declare const KIND_RESOURCE_OPERATOR = "core/resource-type-operator";
+export declare const KIND_BLOCK_TYPE = "core/block-type";
+export declare const KIND_BLOCK_TYPE_OPERATOR = "core/block-type-operator";
+export declare const KIND_BLOCK_TYPE_EXECUTABLE = "core/block-type-executable";
 export type StringMap = {
     [key: string]: string;
 };

package/dist/cjs/src/types.js

@@ -4,7 +4,11 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DesiredInstanceStatus = exports.InstanceStatus = exports.InstanceOwner = exports.InstanceType = void 0;
+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.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';
 var InstanceType;
 (function (InstanceType) {
     InstanceType["DOCKER"] = "docker";

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

@@ -19,7 +19,10 @@ export declare class BlockInstanceRunner {
     private _startLocalProcess;
     private _startDockerProcess;
     private _startOperatorProcess;
-    private getDockerPortBindings;
+    /**
+     * Get the port bindings for a non-operator block
+     */
+    private getServiceBlockPortBindings;
     private ensureContainer;
     private _handleContainer;
 }

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

@@ -20,7 +20,6 @@ const types_1 = require("../types");
 const definitionsManager_1 = require("../definitionsManager");
 const node_os_1 = __importDefault(require("node:os"));
 const taskManager_1 = require("../taskManager");
-const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
 const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
 const KAPETA_INSTANCE_ID = 'KAPETA_INSTANCE_ID';
@@ -41,16 +40,23 @@ async function getProvider(uri) {
     });
 }
 function resolvePortType(portType) {
-    if (serviceManager_1.HTTP_PORTS.includes(portType)) {
+    if (portType && serviceManager_1.HTTP_PORTS.includes(portType.toLowerCase())) {
         return serviceManager_1.HTTP_PORT_TYPE;
     }
     return portType;
 }
 exports.resolvePortType = resolvePortType;
-function getProviderPorts(assetVersion, providerVersion) {
+/**
+ * Get the port types for a non-operator block instance
+ */
+function getServiceProviderPorts(assetVersion, providerVersion) {
     const out = assetVersion.definition?.spec?.providers
+        ?.filter((provider) => {
+        // We only support HTTP provider ports for now. Need to figure out how to handle other types
+        return serviceManager_1.HTTP_PORTS.includes(provider.spec?.port?.type?.toLowerCase());
+    })
         ?.map((provider) => {
-        return resolvePortType(provider.spec?.port?.type);
+        return resolvePortType(provider.spec?.port?.type?.toLowerCase());
     })
         .filter((t) => !!t) ?? [];
     if (out.length === 0) {
@@ -108,12 +114,12 @@ class BlockInstanceRunner {
             throw new Error(`Kind not found: ${kindUri.id}`);
         }
         let processInfo;
-        if (providerVersion.definition.kind === KIND_BLOCK_TYPE_OPERATOR) {
+        if (providerVersion.definition.kind === types_1.KIND_BLOCK_TYPE_OPERATOR) {
             processInfo = await this._startOperatorProcess(blockInstance, blockUri, providerVersion, env);
         }
         else {
             //We need a port type to know how to connect to the block consistently
-            const portTypes = getProviderPorts(assetVersion, providerVersion);
+            const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
             if (blockUri.version === 'local') {
                 processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
             }
@@ -169,7 +175,7 @@ class BlockInstanceRunner {
         delete localContainer.HostConfig;
         delete localContainer.Labels;
         delete localContainer.Env;
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion, providerVersion);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion);
         let HealthCheck = undefined;
         if (localContainer.healthcheck) {
             HealthCheck = containerManager_1.containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
@@ -241,7 +247,7 @@ class BlockInstanceRunner {
         if (!providerVersion) {
             throw new Error(`Block type not found: ${kindUri.id}`);
         }
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion, providerVersion);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion);
         const containerName = await (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id, kindUri.id);
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
@@ -374,12 +380,15 @@ class BlockInstanceRunner {
         });
         return task.wait();
     }
-    async getDockerPortBindings(blockInstance, assetVersion, providerVersion) {
+    /**
+     * Get the port bindings for a non-operator block
+     */
+    async getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion) {
         const bindHost = (0, utils_1.getBindHost)();
         const ExposedPorts = {};
         const addonEnv = {};
         const PortBindings = {};
-        const portTypes = getProviderPorts(assetVersion, providerVersion);
+        const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
         let port = 80;
         const promises = portTypes.map(async (portType) => {
             const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);

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

@@ -12,10 +12,10 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const yaml_1 = __importDefault(require("yaml"));
 const md5_1 = __importDefault(require("md5"));
 const lodash_1 = __importDefault(require("lodash"));
+const types_1 = require("../types");
 const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
 const definitionsManager_1 = require("../definitionsManager");
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
-const operatorManager_1 = require("../operatorManager");
 const assetManager_1 = require("../assetManager");
 async function getBlockInstanceContainerName(systemId, instanceId, blockType) {
     if (!blockType) {
@@ -33,11 +33,11 @@ async function getBlockInstanceContainerName(systemId, instanceId, blockType) {
     if (!typeDefinition) {
         throw new Error(`Block type ${blockType} not found`);
     }
-    if ((0, nodejs_utils_1.parseKapetaUri)(typeDefinition.definition.kind).fullName === operatorManager_1.KIND_BLOCK_OPERATOR &&
+    if ((0, nodejs_utils_1.parseKapetaUri)(typeDefinition.definition.kind).fullName === types_1.KIND_BLOCK_TYPE_OPERATOR &&
         typeDefinition.definition.spec?.local?.singleton) {
-        return `kapeta-instance-operator-${(0, md5_1.default)(systemId + blockType)}`;
+        return `kapeta-instance-operator-${(0, md5_1.default)((0, nodejs_utils_1.normalizeKapetaUri)(systemId) + (0, nodejs_utils_1.normalizeKapetaUri)(blockType))}`;
     }
-    return `kapeta-block-instance-${(0, md5_1.default)(systemId + instanceId)}`;
+    return `kapeta-block-instance-${(0, md5_1.default)((0, nodejs_utils_1.normalizeKapetaUri)(systemId) + instanceId)}`;
 }
 exports.getBlockInstanceContainerName = getBlockInstanceContainerName;
 function toPortInfo(port) {

package/dist/esm/src/assetManager.js

@@ -18,6 +18,7 @@ const repositoryManager_1 = require("./repositoryManager");
 const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
 const definitionsManager_1 = require("./definitionsManager");
 const taskManager_1 = require("./taskManager");
+const types_1 = require("./types");
 const cacheManager_1 = require("./cacheManager");
 const node_uuid_1 = __importDefault(require("node-uuid"));
 const node_os_1 = __importDefault(require("node:os"));
@@ -75,8 +76,9 @@ class AssetManager {
     async getAssets(assetKinds) {
         if (!assetKinds) {
             const blockTypeProviders = await definitionsManager_1.definitionsManager.getDefinitions([
-                'core/block-type',
-                'core/block-type-operator',
+                types_1.KIND_BLOCK_TYPE,
+                types_1.KIND_BLOCK_TYPE_OPERATOR,
+                types_1.KIND_BLOCK_TYPE_EXECUTABLE,
             ]);
             assetKinds = blockTypeProviders.map((p) => {
                 return `${p.definition.metadata.name}:${p.version}`;

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

@@ -45,7 +45,23 @@ export declare class InstanceManager {
     private requestInstanceStatus;
     private isSingletonOperator;
     private getKindForAssetRef;
+    /**
+     * Get the kind of an asset. Use the maxDepth parameter to specify how deep to look for the
+     * kind. For example, if maxDepth is 2, the method will look for the kind of the asset and then
+     * the kind of the kind.
+     * @param assetRef The asset reference
+     * @param maxDepth The maximum depth to look for the kind
+     * @returns The kind of the asset or null if not found
+     */
+    private getDeepKindForAssetRef;
     private isUsingKind;
     private getAllInstancesForKind;
+    /**
+     * Get the ids for all block instances except the ones of the specified kind
+     * @param systemId The plan reference id
+     * @param kind The kind to exclude. Can be a string or an array of strings
+     * @returns An array of block instance ids
+     */
+    private getAllInstancesExceptKind;
 }
 export declare const instanceManager: InstanceManager;

package/dist/esm/src/instanceManager.js

@@ -230,11 +230,12 @@ class InstanceManager {
             throw new Error(`No blocks found in plan: ${systemId}`);
         }
         return taskManager_1.taskManager.add(`plan:start:${systemId}`, async () => {
-            let promises = [];
-            let errors = [];
-            for (let blockInstance of Object.values(plan.spec.blocks)) {
+            const promises = [];
+            const errors = [];
+            const instanceIds = await this.getAllInstancesExceptKind(systemId, types_1.KIND_BLOCK_TYPE_EXECUTABLE);
+            for (const instanceId of instanceIds) {
                 try {
-                    promises.push(this.start(systemId, blockInstance.id).then((taskOrInstance) => {
+                    promises.push(this.start(systemId, instanceId).then((taskOrInstance) => {
                         if (taskOrInstance instanceof taskManager_1.Task) {
                             return taskOrInstance.wait();
                         }
@@ -449,7 +450,7 @@ class InstanceManager {
                         // Definition not found
                         return Promise.resolve();
                     }
-                    if (operatorManager_1.KIND_RESOURCE_OPERATOR.toLowerCase() !== asset.definition.kind.toLowerCase()) {
+                    if (types_1.KIND_RESOURCE_OPERATOR.toLowerCase() !== asset.definition.kind.toLowerCase()) {
                         // Not an operator
                         return Promise.resolve();
                     }
@@ -776,7 +777,7 @@ class InstanceManager {
         if (!provider) {
             return false;
         }
-        if ((0, nodejs_utils_1.parseKapetaUri)(provider.kind).fullName === operatorManager_1.KIND_BLOCK_OPERATOR) {
+        if ((0, nodejs_utils_1.parseKapetaUri)(provider.kind).fullName === types_1.KIND_BLOCK_TYPE_OPERATOR) {
             const localConfig = provider.data.spec.local;
             return localConfig.singleton ?? false;
         }
@@ -789,6 +790,36 @@ class InstanceManager {
         }
         return block.data.kind;
     }
+    /**
+     * Get the kind of an asset. Use the maxDepth parameter to specify how deep to look for the
+     * kind. For example, if maxDepth is 2, the method will look for the kind of the asset and then
+     * the kind of the kind.
+     * @param assetRef The asset reference
+     * @param maxDepth The maximum depth to look for the kind
+     * @returns The kind of the asset or null if not found
+     */
+    async getDeepKindForAssetRef(assetRef, maxDepth) {
+        if (maxDepth <= 0) {
+            return null;
+        }
+        try {
+            const asset = await assetManager_1.assetManager.getAsset(assetRef);
+            if (!asset || !asset.data.kind) {
+                return null;
+            }
+            if (maxDepth === 1) {
+                return asset.data.kind;
+            }
+            else {
+                // Recurse with the kind of the current block and one less depth
+                return await this.getDeepKindForAssetRef(asset.data.kind, maxDepth - 1);
+            }
+        }
+        catch (error) {
+            console.error('Error fetching kind for assetRef:', assetRef, error);
+            return null;
+        }
+    }
     async isUsingKind(ref, kind) {
         const assetKind = await this.getKindForAssetRef(ref);
         if (!assetKind) {
@@ -809,6 +840,32 @@ class InstanceManager {
         }
         return out;
     }
+    /**
+     * Get the ids for all block instances except the ones of the specified kind
+     * @param systemId The plan reference id
+     * @param kind The kind to exclude. Can be a string or an array of strings
+     * @returns An array of block instance ids
+     */
+    async getAllInstancesExceptKind(systemId, kind) {
+        const plan = await assetManager_1.assetManager.getPlan(systemId);
+        if (!plan?.spec?.blocks) {
+            return [];
+        }
+        const out = [];
+        const excludedKinds = kind instanceof Array ? kind : [kind];
+        for (const block of plan.spec.blocks) {
+            const blockKindOfKind = await this.getDeepKindForAssetRef(block.block.ref, 2);
+            if (!blockKindOfKind) {
+                continue;
+            }
+            const shouldIncludeBlock = excludedKinds.some((excludedKind) => excludedKind === (0, nodejs_utils_1.parseKapetaUri)(blockKindOfKind).fullName) ===
+                false;
+            if (shouldIncludeBlock) {
+                out.push(block.id);
+            }
+        }
+        return out;
+    }
 }
 exports.InstanceManager = InstanceManager;
 exports.instanceManager = new InstanceManager();

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

@@ -5,8 +5,6 @@
 import { DefinitionInfo } from '@kapeta/local-cluster-config';
 import { ContainerInfo } from './containerManager';
 import { EnvironmentType, LocalImageOptions, OperatorInfo } from './types';
-export declare const KIND_RESOURCE_OPERATOR = "core/resource-type-operator";
-export declare const KIND_BLOCK_OPERATOR = "core/block-type-operator";
 declare class Operator {
     private readonly _data;
     constructor(data: DefinitionInfo);

package/dist/esm/src/operatorManager.js

@@ -7,21 +7,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.operatorManager = exports.KIND_BLOCK_OPERATOR = exports.KIND_RESOURCE_OPERATOR = void 0;
+exports.operatorManager = void 0;
 const path_1 = __importDefault(require("path"));
 const md5_1 = __importDefault(require("md5"));
 const serviceManager_1 = require("./serviceManager");
 const storageService_1 = require("./storageService");
 const containerManager_1 = require("./containerManager");
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const types_1 = require("./types");
 const definitionsManager_1 = require("./definitionsManager");
 const utils_1 = require("./utils/utils");
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const lodash_1 = __importDefault(require("lodash"));
 const async_lock_1 = __importDefault(require("async-lock"));
 const taskManager_1 = require("./taskManager");
-exports.KIND_RESOURCE_OPERATOR = 'core/resource-type-operator';
-exports.KIND_BLOCK_OPERATOR = 'core/block-type-operator';
 const KIND_PLAN = 'core/plan';
 class Operator {
     _data;
@@ -52,7 +51,7 @@ class OperatorManager {
      * Get operator definition for resource type
      */
     async getOperator(fullName, version) {
-        const operators = await definitionsManager_1.definitionsManager.getDefinitions([exports.KIND_RESOURCE_OPERATOR, exports.KIND_BLOCK_OPERATOR]);
+        const operators = await definitionsManager_1.definitionsManager.getDefinitions([types_1.KIND_RESOURCE_OPERATOR, types_1.KIND_BLOCK_TYPE_OPERATOR]);
         const operator = operators.find((operator) => operator.definition &&
             operator.definition.metadata &&
             operator.definition.metadata.name &&

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

@@ -6,6 +6,10 @@ import express from 'express';
 import { Connection, Resource } from '@kapeta/schemas';
 import { StringBodyRequest } from './middleware/stringBody';
 import { KapetaRequest } from './middleware/kapeta';
+export declare const KIND_RESOURCE_OPERATOR = "core/resource-type-operator";
+export declare const KIND_BLOCK_TYPE = "core/block-type";
+export declare const KIND_BLOCK_TYPE_OPERATOR = "core/block-type-operator";
+export declare const KIND_BLOCK_TYPE_EXECUTABLE = "core/block-type-executable";
 export type StringMap = {
     [key: string]: string;
 };

package/dist/esm/src/types.js

@@ -4,7 +4,11 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DesiredInstanceStatus = exports.InstanceStatus = exports.InstanceOwner = exports.InstanceType = void 0;
+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.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';
 var InstanceType;
 (function (InstanceType) {
     InstanceType["DOCKER"] = "docker";

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

@@ -19,7 +19,10 @@ export declare class BlockInstanceRunner {
     private _startLocalProcess;
     private _startDockerProcess;
     private _startOperatorProcess;
-    private getDockerPortBindings;
+    /**
+     * Get the port bindings for a non-operator block
+     */
+    private getServiceBlockPortBindings;
     private ensureContainer;
     private _handleContainer;
 }

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

@@ -20,7 +20,6 @@ const types_1 = require("../types");
 const definitionsManager_1 = require("../definitionsManager");
 const node_os_1 = __importDefault(require("node:os"));
 const taskManager_1 = require("../taskManager");
-const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
 const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
 const KAPETA_INSTANCE_ID = 'KAPETA_INSTANCE_ID';
@@ -41,16 +40,23 @@ async function getProvider(uri) {
     });
 }
 function resolvePortType(portType) {
-    if (serviceManager_1.HTTP_PORTS.includes(portType)) {
+    if (portType && serviceManager_1.HTTP_PORTS.includes(portType.toLowerCase())) {
         return serviceManager_1.HTTP_PORT_TYPE;
     }
     return portType;
 }
 exports.resolvePortType = resolvePortType;
-function getProviderPorts(assetVersion, providerVersion) {
+/**
+ * Get the port types for a non-operator block instance
+ */
+function getServiceProviderPorts(assetVersion, providerVersion) {
     const out = assetVersion.definition?.spec?.providers
+        ?.filter((provider) => {
+        // We only support HTTP provider ports for now. Need to figure out how to handle other types
+        return serviceManager_1.HTTP_PORTS.includes(provider.spec?.port?.type?.toLowerCase());
+    })
         ?.map((provider) => {
-        return resolvePortType(provider.spec?.port?.type);
+        return resolvePortType(provider.spec?.port?.type?.toLowerCase());
     })
         .filter((t) => !!t) ?? [];
     if (out.length === 0) {
@@ -108,12 +114,12 @@ class BlockInstanceRunner {
             throw new Error(`Kind not found: ${kindUri.id}`);
         }
         let processInfo;
-        if (providerVersion.definition.kind === KIND_BLOCK_TYPE_OPERATOR) {
+        if (providerVersion.definition.kind === types_1.KIND_BLOCK_TYPE_OPERATOR) {
             processInfo = await this._startOperatorProcess(blockInstance, blockUri, providerVersion, env);
         }
         else {
             //We need a port type to know how to connect to the block consistently
-            const portTypes = getProviderPorts(assetVersion, providerVersion);
+            const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
             if (blockUri.version === 'local') {
                 processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
             }
@@ -169,7 +175,7 @@ class BlockInstanceRunner {
         delete localContainer.HostConfig;
         delete localContainer.Labels;
         delete localContainer.Env;
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion, providerVersion);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion);
         let HealthCheck = undefined;
         if (localContainer.healthcheck) {
             HealthCheck = containerManager_1.containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
@@ -241,7 +247,7 @@ class BlockInstanceRunner {
         if (!providerVersion) {
             throw new Error(`Block type not found: ${kindUri.id}`);
         }
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion, providerVersion);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion);
         const containerName = await (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id, kindUri.id);
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
@@ -374,12 +380,15 @@ class BlockInstanceRunner {
         });
         return task.wait();
     }
-    async getDockerPortBindings(blockInstance, assetVersion, providerVersion) {
+    /**
+     * Get the port bindings for a non-operator block
+     */
+    async getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion) {
         const bindHost = (0, utils_1.getBindHost)();
         const ExposedPorts = {};
         const addonEnv = {};
         const PortBindings = {};
-        const portTypes = getProviderPorts(assetVersion, providerVersion);
+        const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
         let port = 80;
         const promises = portTypes.map(async (portType) => {
             const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);

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

@@ -12,10 +12,10 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const yaml_1 = __importDefault(require("yaml"));
 const md5_1 = __importDefault(require("md5"));
 const lodash_1 = __importDefault(require("lodash"));
+const types_1 = require("../types");
 const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
 const definitionsManager_1 = require("../definitionsManager");
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
-const operatorManager_1 = require("../operatorManager");
 const assetManager_1 = require("../assetManager");
 async function getBlockInstanceContainerName(systemId, instanceId, blockType) {
     if (!blockType) {
@@ -33,11 +33,11 @@ async function getBlockInstanceContainerName(systemId, instanceId, blockType) {
     if (!typeDefinition) {
         throw new Error(`Block type ${blockType} not found`);
     }
-    if ((0, nodejs_utils_1.parseKapetaUri)(typeDefinition.definition.kind).fullName === operatorManager_1.KIND_BLOCK_OPERATOR &&
+    if ((0, nodejs_utils_1.parseKapetaUri)(typeDefinition.definition.kind).fullName === types_1.KIND_BLOCK_TYPE_OPERATOR &&
         typeDefinition.definition.spec?.local?.singleton) {
-        return `kapeta-instance-operator-${(0, md5_1.default)(systemId + blockType)}`;
+        return `kapeta-instance-operator-${(0, md5_1.default)((0, nodejs_utils_1.normalizeKapetaUri)(systemId) + (0, nodejs_utils_1.normalizeKapetaUri)(blockType))}`;
     }
-    return `kapeta-block-instance-${(0, md5_1.default)(systemId + instanceId)}`;
+    return `kapeta-block-instance-${(0, md5_1.default)((0, nodejs_utils_1.normalizeKapetaUri)(systemId) + instanceId)}`;
 }
 exports.getBlockInstanceContainerName = getBlockInstanceContainerName;
 function toPortInfo(port) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.36.0",
+    "version": "0.37.0",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {
@@ -49,7 +49,7 @@
     "dependencies": {
         "@kapeta/codegen": "^1.2.1",
         "@kapeta/kaplang-core": "^1.9.3",
-        "@kapeta/local-cluster-config": ">= 0.3.2 <2",
+        "@kapeta/local-cluster-config": "^0.4.0",
         "@kapeta/nodejs-api-client": ">=0.1.3 <2",
         "@kapeta/nodejs-process": "<2",
         "@kapeta/nodejs-registry-utils": ">=0.9.4 <2",
@@ -85,8 +85,8 @@
         "yaml": "^1.6.0"
     },
     "devDependencies": {
-        "@kapeta/eslint-config": "^0.6.1",
-        "@kapeta/prettier-config": "^0.6.0",
+        "@kapeta/eslint-config": "^0.7.0",
+        "@kapeta/prettier-config": "^0.6.2",
         "@tsconfig/node18": "^18.2.0",
         "@types/async-lock": "^1.4.0",
         "@types/express": "^4.17.17",

package/src/assetManager.ts

@@ -15,7 +15,7 @@ import { BlockDefinition, BlockInstance, Plan } from '@kapeta/schemas';
 import { Actions } from '@kapeta/nodejs-registry-utils';
 import { definitionsManager } from './definitionsManager';
 import { taskManager } from './taskManager';
-import { SourceOfChange } from './types';
+import { KIND_BLOCK_TYPE_EXECUTABLE, KIND_BLOCK_TYPE_OPERATOR, KIND_BLOCK_TYPE, SourceOfChange } from './types';
 import { cacheManager } from './cacheManager';
 import uuid from 'node-uuid';
 import os from 'node:os';
@@ -94,8 +94,9 @@ class AssetManager {
     async getAssets(assetKinds?: string[]): Promise<EnrichedAsset[]> {
         if (!assetKinds) {
             const blockTypeProviders = await definitionsManager.getDefinitions([
-                'core/block-type',
-                'core/block-type-operator',
+                KIND_BLOCK_TYPE,
+                KIND_BLOCK_TYPE_OPERATOR,
+                KIND_BLOCK_TYPE_EXECUTABLE,
             ]);
             assetKinds = blockTypeProviders.map((p) => {
                 return `${p.definition.metadata.name}:${p.version}`;

package/src/instanceManager.ts

@@ -25,6 +25,9 @@ import {
     InstanceOwner,
     InstanceStatus,
     InstanceType,
+    KIND_BLOCK_TYPE_EXECUTABLE,
+    KIND_BLOCK_TYPE_OPERATOR,
+    KIND_RESOURCE_OPERATOR,
     LocalImageOptions,
     LogEntry,
     OperatorInstanceInfo,
@@ -32,7 +35,7 @@ import {
 } from './types';
 import { BlockDefinitionSpec, BlockInstance, Plan } from '@kapeta/schemas';
 import { getBlockInstanceContainerName, getResolvedConfiguration } from './utils/utils';
-import { KIND_BLOCK_OPERATOR, KIND_RESOURCE_OPERATOR, operatorManager } from './operatorManager';
+import { operatorManager } from './operatorManager';
 import { normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { definitionsManager } from './definitionsManager';
 import { Task, taskManager } from './taskManager';
@@ -313,12 +316,13 @@ export class InstanceManager {
         return taskManager.add(
             `plan:start:${systemId}`,
             async () => {
-                let promises: Promise<InstanceInfo>[] = [];
-                let errors = [];
-                for (let blockInstance of Object.values(plan.spec.blocks as BlockInstance[])) {
+                const promises: Promise<InstanceInfo>[] = [];
+                const errors = [];
+                const instanceIds = await this.getAllInstancesExceptKind(systemId, KIND_BLOCK_TYPE_EXECUTABLE);
+                for (const instanceId of instanceIds) {
                     try {
                         promises.push(
-                            this.start(systemId, blockInstance.id).then((taskOrInstance) => {
+                            this.start(systemId, instanceId).then((taskOrInstance) => {
                                 if (taskOrInstance instanceof Task) {
                                     return taskOrInstance.wait();
                                 }
@@ -1008,7 +1012,7 @@ export class InstanceManager {
             return false;
         }
 
-        if (parseKapetaUri(provider.kind).fullName === KIND_BLOCK_OPERATOR) {
+        if (parseKapetaUri(provider.kind).fullName === KIND_BLOCK_TYPE_OPERATOR) {
             const localConfig = provider.data.spec.local as LocalImageOptions;
             return localConfig.singleton ?? false;
         }
@@ -1025,6 +1029,37 @@ export class InstanceManager {
         return block.data.kind;
     }
 
+    /**
+     * Get the kind of an asset. Use the maxDepth parameter to specify how deep to look for the
+     * kind. For example, if maxDepth is 2, the method will look for the kind of the asset and then
+     * the kind of the kind.
+     * @param assetRef The asset reference
+     * @param maxDepth The maximum depth to look for the kind
+     * @returns The kind of the asset or null if not found
+     */
+    private async getDeepKindForAssetRef(assetRef: string, maxDepth: number): Promise<string | null> {
+        if (maxDepth <= 0) {
+            return null;
+        }
+
+        try {
+            const asset = await assetManager.getAsset(assetRef);
+            if (!asset || !asset.data.kind) {
+                return null;
+            }
+
+            if (maxDepth === 1) {
+                return asset.data.kind;
+            } else {
+                // Recurse with the kind of the current block and one less depth
+                return await this.getDeepKindForAssetRef(asset.data.kind, maxDepth - 1);
+            }
+        } catch (error) {
+            console.error('Error fetching kind for assetRef:', assetRef, error);
+            return null;
+        }
+    }
+
     private async isUsingKind(ref: string, kind: string): Promise<boolean> {
         const assetKind = await this.getKindForAssetRef(ref);
         if (!assetKind) {
@@ -1048,6 +1083,36 @@ export class InstanceManager {
 
         return out;
     }
+
+    /**
+     * Get the ids for all block instances except the ones of the specified kind
+     * @param systemId The plan reference id
+     * @param kind The kind to exclude. Can be a string or an array of strings
+     * @returns An array of block instance ids
+     */
+    private async getAllInstancesExceptKind(systemId: string, kind: string | string[]): Promise<string[]> {
+        const plan = await assetManager.getPlan(systemId);
+        if (!plan?.spec?.blocks) {
+            return [];
+        }
+        const out: string[] = [];
+        const excludedKinds = kind instanceof Array ? kind : [kind];
+        for (const block of plan.spec.blocks) {
+            const blockKindOfKind = await this.getDeepKindForAssetRef(block.block.ref, 2);
+            if (!blockKindOfKind) {
+                continue;
+            }
+
+            const shouldIncludeBlock =
+                excludedKinds.some((excludedKind) => excludedKind === parseKapetaUri(blockKindOfKind).fullName) ===
+                false;
+            if (shouldIncludeBlock) {
+                out.push(block.id);
+            }
+        }
+
+        return out;
+    }
 }
 
 export const instanceManager = new InstanceManager();

package/src/operatorManager.ts

@@ -16,7 +16,15 @@ import {
     containerManager,
 } from './containerManager';
 import FSExtra from 'fs-extra';
-import { AnyMap, EnvironmentType, LocalImageOptions, OperatorInfo, StringMap } from './types';
+import {
+    AnyMap,
+    EnvironmentType,
+    KIND_BLOCK_TYPE_OPERATOR,
+    KIND_RESOURCE_OPERATOR,
+    LocalImageOptions,
+    OperatorInfo,
+    StringMap,
+} from './types';
 import { BlockInstance, Resource } from '@kapeta/schemas';
 import { definitionsManager } from './definitionsManager';
 import { getBindHost, toPortInfo } from './utils/utils';
@@ -25,8 +33,6 @@ import _ from 'lodash';
 import AsyncLock from 'async-lock';
 import { taskManager } from './taskManager';
 
-export const KIND_RESOURCE_OPERATOR = 'core/resource-type-operator';
-export const KIND_BLOCK_OPERATOR = 'core/block-type-operator';
 const KIND_PLAN = 'core/plan';
 
 class Operator {
@@ -68,7 +74,7 @@ class OperatorManager {
      * Get operator definition for resource type
      */
     async getOperator(fullName: string, version: string) {
-        const operators = await definitionsManager.getDefinitions([KIND_RESOURCE_OPERATOR, KIND_BLOCK_OPERATOR]);
+        const operators = await definitionsManager.getDefinitions([KIND_RESOURCE_OPERATOR, KIND_BLOCK_TYPE_OPERATOR]);
 
         const operator: DefinitionInfo | undefined = operators.find(
             (operator) =>

package/src/types.ts

@@ -8,6 +8,11 @@ import { Connection, Resource } from '@kapeta/schemas';
 import { StringBodyRequest } from './middleware/stringBody';
 import { KapetaRequest } from './middleware/kapeta';
 
+export const KIND_RESOURCE_OPERATOR = 'core/resource-type-operator';
+export const KIND_BLOCK_TYPE = 'core/block-type';
+export const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
+export const KIND_BLOCK_TYPE_EXECUTABLE = 'core/block-type-executable';
+
 export type StringMap = { [key: string]: string };
 export type AnyMap = { [key: string]: any };
 export type SourceOfChange = 'user' | 'filesystem';

package/src/utils/BlockInstanceRunner.ts

@@ -18,13 +18,20 @@ import {
 } from '../containerManager';
 import { LogData } from './LogData';
 import { clusterService } from '../clusterService';
-import { AnyMap, BlockProcessParams, InstanceType, LocalImageOptions, ProcessInfo, StringMap } from '../types';
+import {
+    AnyMap,
+    BlockProcessParams,
+    InstanceType,
+    KIND_BLOCK_TYPE_OPERATOR,
+    LocalImageOptions,
+    ProcessInfo,
+    StringMap,
+} from '../types';
 import { definitionsManager } from '../definitionsManager';
 import Docker from 'dockerode';
 import OS from 'node:os';
 import { taskManager } from '../taskManager';
 
-const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
 const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
 const KAPETA_INSTANCE_ID = 'KAPETA_INSTANCE_ID';
@@ -48,17 +55,24 @@ async function getProvider(uri: KapetaURI) {
 }
 
 export function resolvePortType(portType: string) {
-    if (HTTP_PORTS.includes(portType)) {
+    if (portType && HTTP_PORTS.includes(portType.toLowerCase())) {
         return HTTP_PORT_TYPE;
     }
     return portType;
 }
 
-function getProviderPorts(assetVersion: DefinitionInfo, providerVersion: DefinitionInfo): string[] {
+/**
+ * Get the port types for a non-operator block instance
+ */
+function getServiceProviderPorts(assetVersion: DefinitionInfo, providerVersion: DefinitionInfo): string[] {
     const out =
         assetVersion.definition?.spec?.providers
+            ?.filter((provider: any) => {
+                // We only support HTTP provider ports for now. Need to figure out how to handle other types
+                return HTTP_PORTS.includes(provider.spec?.port?.type?.toLowerCase());
+            })
             ?.map((provider: any) => {
-                return resolvePortType(provider.spec?.port?.type);
+                return resolvePortType(provider.spec?.port?.type?.toLowerCase());
             })
             .filter((t: any) => !!t) ?? [];
 
@@ -137,7 +151,7 @@ export class BlockInstanceRunner {
             processInfo = await this._startOperatorProcess(blockInstance, blockUri, providerVersion, env);
         } else {
             //We need a port type to know how to connect to the block consistently
-            const portTypes = getProviderPorts(assetVersion, providerVersion);
+            const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
 
             if (blockUri.version === 'local') {
                 processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
@@ -217,7 +231,7 @@ export class BlockInstanceRunner {
         delete localContainer.Labels;
         delete localContainer.Env;
 
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(
             blockInstance,
             assetVersion,
             providerVersion
@@ -317,7 +331,7 @@ export class BlockInstanceRunner {
             throw new Error(`Block type not found: ${kindUri.id}`);
         }
 
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(
             blockInstance,
             assetVersion,
             providerVersion
@@ -497,7 +511,10 @@ export class BlockInstanceRunner {
         return task.wait();
     }
 
-    private async getDockerPortBindings(
+    /**
+     * Get the port bindings for a non-operator block
+     */
+    private async getServiceBlockPortBindings(
         blockInstance: BlockProcessParams,
         assetVersion: DefinitionInfo,
         providerVersion: DefinitionInfo
@@ -507,7 +524,7 @@ export class BlockInstanceRunner {
         const addonEnv: StringMap = {};
         const PortBindings: AnyMap = {};
 
-        const portTypes = getProviderPorts(assetVersion, providerVersion);
+        const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
         let port = 80;
         const promises = portTypes.map(async (portType) => {
             const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);

package/src/utils/utils.ts

@@ -8,11 +8,10 @@ import YAML from 'yaml';
 import md5 from 'md5';
 import { EntityList } from '@kapeta/schemas';
 import _ from 'lodash';
-import { AnyMap, PortInfo } from '../types';
+import { AnyMap, KIND_BLOCK_TYPE_OPERATOR, PortInfo } from '../types';
 import ClusterConfiguration from '@kapeta/local-cluster-config';
 import { definitionsManager } from '../definitionsManager';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import { KIND_BLOCK_OPERATOR } from '../operatorManager';
+import { normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { assetManager } from '../assetManager';
 
 export async function getBlockInstanceContainerName(systemId: string, instanceId: string, blockType?: string) {
@@ -32,13 +31,13 @@ export async function getBlockInstanceContainerName(systemId: string, instanceId
         throw new Error(`Block type ${blockType} not found`);
     }
     if (
-        parseKapetaUri(typeDefinition.definition.kind).fullName === KIND_BLOCK_OPERATOR &&
+        parseKapetaUri(typeDefinition.definition.kind).fullName === KIND_BLOCK_TYPE_OPERATOR &&
         typeDefinition.definition.spec?.local?.singleton
     ) {
-        return `kapeta-instance-operator-${md5(systemId + blockType)}`;
+        return `kapeta-instance-operator-${md5(normalizeKapetaUri(systemId) + normalizeKapetaUri(blockType))}`;
     }
 
-    return `kapeta-block-instance-${md5(systemId + instanceId)}`;
+    return `kapeta-block-instance-${md5(normalizeKapetaUri(systemId) + instanceId)}`;
 }
 
 export function toPortInfo(port: PortInfo) {