@kapeta/local-cluster-service 0.34.2 → 0.35.0

package/.github/workflows/check-license.yml

@@ -15,4 +15,3 @@ jobs:
           holder: 'Kapeta Inc.'
           license: 'BUSL-1.1'
           sources: 'src/**/* test/*'
-

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.35.0](https://github.com/kapetacom/local-cluster-service/compare/v0.34.2...v0.35.0) (2024-01-31)
+
+
+### Features
+
+* Adds support for getting instance operator info ([#122](https://github.com/kapetacom/local-cluster-service/issues/122)) ([8fa18ac](https://github.com/kapetacom/local-cluster-service/commit/8fa18ac58226ce9776f79a64d3a99cf56456e834))
+
 ## [0.34.2](https://github.com/kapetacom/local-cluster-service/compare/v0.34.1...v0.34.2) (2024-01-22)
 
 

package/dist/cjs/src/config/routes.js

@@ -148,4 +148,13 @@ router.get('/consumes/resource/:resourceType/:portType/:name', async (req, res)
 router.get('/consumes/:resourceName/:type', (req, res) => {
     res.send(serviceManager_1.serviceManager.getConsumerAddress(req.kapeta.systemId, req.kapeta.instanceId, req.params.resourceName, req.params.type, req.kapeta.environment));
 });
+/**
+ * Used by services to information about a block operator
+ *
+ * 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);
+    res.send(operatorInfo);
+});
 exports.default = router;

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

@@ -5,7 +5,7 @@
 /// <reference types="node" />
 import FSExtra from 'fs-extra';
 import Docker from 'dockerode';
-import { InstanceInfo, LogEntry } from './types';
+import { Health, InstanceInfo, LogEntry } from './types';
 type StringMap = {
     [key: string]: string;
 };
@@ -26,12 +26,6 @@ export interface DockerMounts {
 }
 export type DockerContainerStatus = 'created' | 'running' | 'paused' | 'restarting' | 'removing' | 'exited' | 'dead';
 export type DockerContainerHealth = 'starting' | 'healthy' | 'unhealthy' | 'none';
-interface Health {
-    cmd: string;
-    interval?: number;
-    timeout?: number;
-    retries?: number;
-}
 export declare const CONTAINER_LABEL_PORT_PREFIX = "kapeta_port-";
 export declare const COMPOSE_LABEL_PROJECT = "com.docker.compose.project";
 export declare const COMPOSE_LABEL_SERVICE = "com.docker.compose.service";
@@ -50,7 +44,7 @@ declare class ContainerManager {
     isAlive(): boolean;
     getMountPoint(systemId: string, ref: string, mountName: string): string;
     createMounts(systemId: string, kind: string, mountOpts: StringMap | null | undefined): Promise<StringMap>;
-    createVolumes(systemId: string, kind: string, mountOpts: StringMap | null | undefined): Promise<DockerMounts[]>;
+    createVolumes(systemId: string, serviceId: string, mountOpts: StringMap | null | undefined): Promise<DockerMounts[]>;
     ping(): Promise<void>;
     docker(): Docker;
     getContainerByName(containerName: string): Promise<ContainerInfo | undefined>;

package/dist/cjs/src/containerManager.js

@@ -168,12 +168,12 @@ class ContainerManager {
         }
         return mounts;
     }
-    async createVolumes(systemId, kind, mountOpts) {
+    async createVolumes(systemId, serviceId, mountOpts) {
         const Mounts = [];
         if (mountOpts) {
             const mountOptList = Object.entries(mountOpts);
             for (const [mountName, containerPath] of mountOptList) {
-                const volumeName = `${systemId}_${kind}_${mountName}`.replace(/[^a-z0-9]/gi, '_');
+                const volumeName = `${systemId}_${serviceId}_${mountName}`.replace(/[^a-z0-9]/gi, '_');
                 Mounts.push({
                     Target: containerPath,
                     Source: volumeName,
@@ -182,7 +182,7 @@ class ContainerManager {
                     Consistency: 'consistent',
                     Labels: {
                         [exports.COMPOSE_LABEL_PROJECT]: systemId.replace(/[^a-z0-9]/gi, '_'),
-                        [exports.COMPOSE_LABEL_SERVICE]: kind.replace(/[^a-z0-9]/gi, '_'),
+                        [exports.COMPOSE_LABEL_SERVICE]: serviceId.replace(/[^a-z0-9]/gi, '_'),
                     },
                 });
             }
@@ -791,7 +791,7 @@ class ContainerInfo {
             if (!name.startsWith(exports.CONTAINER_LABEL_PORT_PREFIX)) {
                 return;
             }
-            const hostPort = name.substr(exports.CONTAINER_LABEL_PORT_PREFIX.length);
+            const hostPort = name.substring(exports.CONTAINER_LABEL_PORT_PREFIX.length);
             portTypes[hostPort] = portType;
         });
         lodash_1.default.forEach(inspectResult.HostConfig.PortBindings, (portBindings, containerPortSpec) => {

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

@@ -2,7 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { InstanceInfo, LogEntry } from './types';
+import { EnvironmentType, InstanceInfo, LogEntry, OperatorInstanceInfo } from './types';
 import { Task } from './taskManager';
 export declare class InstanceManager {
     private _interval;
@@ -27,6 +27,7 @@ export declare class InstanceManager {
     stop(systemId: string, instanceId: string): Promise<void>;
     private stopInner;
     stopAllForPlan(systemId: string): Task<void>;
+    getInstanceOperator(systemId: string, instanceId: string, environment?: EnvironmentType): Promise<OperatorInstanceInfo>;
     start(systemId: string, instanceId: string): Promise<InstanceInfo | Task<InstanceInfo>>;
     /**
      * Stops an instance but does not remove it from the list of active instances

package/dist/cjs/src/instanceManager.js

@@ -323,6 +323,48 @@ class InstanceManager {
             name: `Stopping plan ${systemId}`,
         });
     }
+    async getInstanceOperator(systemId, instanceId, environment) {
+        const blockInstance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
+        if (!blockInstance) {
+            throw new Error(`Instance not found: ${systemId}/${instanceId}`);
+        }
+        const blockRef = (0, nodejs_utils_1.normalizeKapetaUri)(blockInstance.block.ref);
+        const block = await assetManager_1.assetManager.getAsset(blockRef, true);
+        if (!block) {
+            throw new Error(`Block not found: ${blockRef}`);
+        }
+        const operatorDefinition = await definitionsManager_1.definitionsManager.getDefinition(block.kind);
+        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 portInfo = await container.getPorts();
+        if (!portInfo) {
+            throw new Error(`No ports found for instance: ${instanceId}`);
+        }
+        const hostname = serviceManager_1.serviceManager.getLocalHost(environment);
+        const ports = {};
+        Object.entries(portInfo).forEach(([key, value]) => {
+            ports[key] = {
+                protocol: value.protocol,
+                port: parseInt(value.hostPort),
+            };
+        });
+        return {
+            hostname,
+            ports,
+            credentials: localConfig.credentials,
+            options: localConfig.options,
+        };
+    }
     async start(systemId, instanceId) {
         return this.exclusive(systemId, instanceId, async () => {
             systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
@@ -333,7 +375,7 @@ class InstanceManager {
                 throw new Error('Block not found: ' + blockRef);
             }
             const existingInstance = this.getInstance(systemId, instanceId);
-            if (existingInstance) {
+            if (existingInstance && existingInstance.pid) {
                 if (existingInstance.status === types_1.InstanceStatus.READY) {
                     // Instance is already running
                     return existingInstance;

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

@@ -4,12 +4,12 @@
  */
 import { DefinitionInfo } from '@kapeta/local-cluster-config';
 import { ContainerInfo } from './containerManager';
-import { EnvironmentType, OperatorInfo } from './types';
+import { EnvironmentType, LocalImageOptions, OperatorInfo } from './types';
 export declare const KIND_OPERATOR = "core/resource-type-operator";
 declare class Operator {
     private readonly _data;
     constructor(data: DefinitionInfo);
-    getLocalData(): any;
+    getLocalData(): LocalImageOptions;
     getDefinitionInfo(): DefinitionInfo;
     getCredentials(): any;
 }

package/dist/cjs/src/operatorManager.js

@@ -137,13 +137,8 @@ class OperatorManager {
                 const portType = portTypes[i];
                 let containerPortInfo = operatorData.ports[portType];
                 const hostPort = await serviceManager_1.serviceManager.ensureServicePort(systemId, resourceType, portType);
-                if (typeof containerPortInfo === 'number' || typeof containerPortInfo === 'string') {
-                    containerPortInfo = { port: containerPortInfo, type: 'tcp' };
-                }
-                if (!containerPortInfo.type) {
-                    containerPortInfo.type = 'tcp';
-                }
-                const portId = containerPortInfo.port + '/' + containerPortInfo.type;
+                const portInfo = (0, utils_1.toPortInfo)(containerPortInfo);
+                const portId = portInfo.port + '/' + portInfo.type;
                 ports[portId] = {
                     type: portType,
                     hostPort,

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

@@ -9,6 +9,7 @@ export declare const HTTP_PORTS: string[];
 declare class ServiceManager {
     private _systems;
     constructor();
+    getLocalHost(environmentType?: EnvironmentType): string;
     _forLocal(port: string | number, path?: string, environmentType?: EnvironmentType): string;
     _ensureSystem(systemId: string): any;
     _ensureService(systemId: string, serviceId: string): any;

package/dist/cjs/src/serviceManager.js

@@ -31,22 +31,22 @@ class ServiceManager {
             });
         });
     }
-    _forLocal(port, path, environmentType) {
-        if (!path) {
-            path = '';
-        }
-        let host;
+    getLocalHost(environmentType) {
         if (environmentType === 'docker') {
             //We're inside a docker container, so we can use this special host name to access the host machine
-            host = 'host.docker.internal';
+            return 'host.docker.internal';
         }
-        else {
-            host = clusterService_1.clusterService.getClusterServiceHost();
+        return clusterService_1.clusterService.getClusterServiceHost();
+    }
+    _forLocal(port, path, environmentType) {
+        if (!path) {
+            path = '';
         }
+        const hostname = this.getLocalHost(environmentType);
         if (path.startsWith('/')) {
             path = path.substring(1);
         }
-        return `http://${host}:${port}/${path}`;
+        return `http://${hostname}:${port}/${path}`;
     }
     _ensureSystem(systemId) {
         systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);

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

@@ -56,6 +56,30 @@ 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;
+    mounts?: {
+        [key: string]: string;
+    };
+};
 export type InstanceInfo = {
     systemId: string;
     instanceId: string;
@@ -73,6 +97,21 @@ 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;

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

@@ -288,7 +288,8 @@ class BlockInstanceRunner {
         if (!spec?.local?.image) {
             throw new Error(`Provider did not have local image: ${providerRef}`);
         }
-        const dockerImage = spec?.local?.image;
+        const local = spec.local;
+        const dockerImage = local.image;
         //We only want 1 operator per operator type - across all local systems
         const containerName = (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id);
         const logs = new LogData_1.LogData();
@@ -298,11 +299,13 @@ class BlockInstanceRunner {
         const PortBindings = {};
         let HealthCheck = undefined;
         let Mounts = [];
-        const localPorts = spec.local.ports;
+        const localPorts = local.ports ?? {};
+        const labels = {};
         const promises = Object.entries(localPorts).map(async ([portType, value]) => {
-            const dockerPort = `${value.port}/${value.type}`;
+            const portInfo = (0, utils_1.toPortInfo)(value);
+            const dockerPort = `${portInfo.port}/${portInfo.type}`;
             ExposedPorts[dockerPort] = {};
-            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = value.port;
+            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = `${portInfo.port}`;
             const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
             PortBindings[dockerPort] = [
                 {
@@ -310,19 +313,19 @@ class BlockInstanceRunner {
                     HostPort: `${publicPort}`,
                 },
             ];
+            labels[containerManager_1.CONTAINER_LABEL_PORT_PREFIX + publicPort] = portType;
         });
         await Promise.all(promises);
-        if (spec.local?.env) {
-            Object.entries(spec.local.env).forEach(([key, value]) => {
+        if (local.env) {
+            Object.entries(local.env).forEach(([key, value]) => {
                 addonEnv[key] = value;
             });
         }
-        if (spec.local?.mounts) {
-            const mounts = await containerManager_1.containerManager.createMounts(this._systemId, blockUri.id, spec.local.mounts);
-            Mounts = containerManager_1.containerManager.toDockerMounts(mounts);
+        if (local.mounts) {
+            Mounts = await containerManager_1.containerManager.createVolumes(this._systemId, blockUri.id, local.mounts);
         }
-        if (spec.local?.health) {
-            HealthCheck = containerManager_1.containerManager.toDockerHealth(spec.local?.health);
+        if (local.health) {
+            HealthCheck = containerManager_1.containerManager.toDockerHealth(local.health);
         }
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
@@ -342,6 +345,7 @@ class BlockInstanceRunner {
                 Mounts,
             },
             Labels: {
+                ...labels,
                 instance: blockInstance.id,
                 [containerManager_1.COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
                 [containerManager_1.COMPOSE_LABEL_SERVICE]: blockUri.id.replace(/[^a-z0-9]/gi, '_'),
@@ -356,7 +360,7 @@ class BlockInstanceRunner {
                 }).map(([key, value]) => `${key}=${value}`),
             ],
         });
-        const portTypes = spec.local.ports ? Object.keys(spec.local.ports) : [];
+        const portTypes = local.ports ? Object.keys(local.ports) : [];
         if (portTypes.length > 0) {
             out.portType = portTypes[0];
         }

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

@@ -3,8 +3,12 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 import { EntityList } from '@kapeta/schemas';
-import { AnyMap } from '../types';
+import { AnyMap, PortInfo } from '../types';
 export declare function getBlockInstanceContainerName(systemId: string, instanceId: string): string;
+export declare function toPortInfo(port: PortInfo): {
+    port: number;
+    type: string;
+};
 export declare function getRemoteUrl(id: string, defautValue: string): any;
 export declare function readYML(path: string): any;
 export declare function isWindows(): boolean;

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.getBlockInstanceContainerName = void 0;
+exports.getResolvedConfiguration = exports.getBindHost = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = exports.getRemoteUrl = 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"));
@@ -17,6 +17,16 @@ function getBlockInstanceContainerName(systemId, instanceId) {
     return `kapeta-block-instance-${(0, md5_1.default)(systemId + instanceId)}`;
 }
 exports.getBlockInstanceContainerName = getBlockInstanceContainerName;
+function toPortInfo(port) {
+    if (typeof port === 'number' || typeof port === 'string') {
+        return { port: parseInt(`${port}`), type: 'tcp' };
+    }
+    if (!port.type) {
+        port.type = 'tcp';
+    }
+    return port;
+}
+exports.toPortInfo = toPortInfo;
 function getRemoteUrl(id, defautValue) {
     const remoteConfig = local_cluster_config_1.default.getClusterConfig().remote;
     return remoteConfig?.[id] ?? defautValue;

package/dist/esm/src/config/routes.js

@@ -148,4 +148,13 @@ router.get('/consumes/resource/:resourceType/:portType/:name', async (req, res)
 router.get('/consumes/:resourceName/:type', (req, res) => {
     res.send(serviceManager_1.serviceManager.getConsumerAddress(req.kapeta.systemId, req.kapeta.instanceId, req.params.resourceName, req.params.type, req.kapeta.environment));
 });
+/**
+ * Used by services to information about a block operator
+ *
+ * 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);
+    res.send(operatorInfo);
+});
 exports.default = router;

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

@@ -5,7 +5,7 @@
 /// <reference types="node" />
 import FSExtra from 'fs-extra';
 import Docker from 'dockerode';
-import { InstanceInfo, LogEntry } from './types';
+import { Health, InstanceInfo, LogEntry } from './types';
 type StringMap = {
     [key: string]: string;
 };
@@ -26,12 +26,6 @@ export interface DockerMounts {
 }
 export type DockerContainerStatus = 'created' | 'running' | 'paused' | 'restarting' | 'removing' | 'exited' | 'dead';
 export type DockerContainerHealth = 'starting' | 'healthy' | 'unhealthy' | 'none';
-interface Health {
-    cmd: string;
-    interval?: number;
-    timeout?: number;
-    retries?: number;
-}
 export declare const CONTAINER_LABEL_PORT_PREFIX = "kapeta_port-";
 export declare const COMPOSE_LABEL_PROJECT = "com.docker.compose.project";
 export declare const COMPOSE_LABEL_SERVICE = "com.docker.compose.service";
@@ -50,7 +44,7 @@ declare class ContainerManager {
     isAlive(): boolean;
     getMountPoint(systemId: string, ref: string, mountName: string): string;
     createMounts(systemId: string, kind: string, mountOpts: StringMap | null | undefined): Promise<StringMap>;
-    createVolumes(systemId: string, kind: string, mountOpts: StringMap | null | undefined): Promise<DockerMounts[]>;
+    createVolumes(systemId: string, serviceId: string, mountOpts: StringMap | null | undefined): Promise<DockerMounts[]>;
     ping(): Promise<void>;
     docker(): Docker;
     getContainerByName(containerName: string): Promise<ContainerInfo | undefined>;

package/dist/esm/src/containerManager.js

@@ -168,12 +168,12 @@ class ContainerManager {
         }
         return mounts;
     }
-    async createVolumes(systemId, kind, mountOpts) {
+    async createVolumes(systemId, serviceId, mountOpts) {
         const Mounts = [];
         if (mountOpts) {
             const mountOptList = Object.entries(mountOpts);
             for (const [mountName, containerPath] of mountOptList) {
-                const volumeName = `${systemId}_${kind}_${mountName}`.replace(/[^a-z0-9]/gi, '_');
+                const volumeName = `${systemId}_${serviceId}_${mountName}`.replace(/[^a-z0-9]/gi, '_');
                 Mounts.push({
                     Target: containerPath,
                     Source: volumeName,
@@ -182,7 +182,7 @@ class ContainerManager {
                     Consistency: 'consistent',
                     Labels: {
                         [exports.COMPOSE_LABEL_PROJECT]: systemId.replace(/[^a-z0-9]/gi, '_'),
-                        [exports.COMPOSE_LABEL_SERVICE]: kind.replace(/[^a-z0-9]/gi, '_'),
+                        [exports.COMPOSE_LABEL_SERVICE]: serviceId.replace(/[^a-z0-9]/gi, '_'),
                     },
                 });
             }
@@ -791,7 +791,7 @@ class ContainerInfo {
             if (!name.startsWith(exports.CONTAINER_LABEL_PORT_PREFIX)) {
                 return;
             }
-            const hostPort = name.substr(exports.CONTAINER_LABEL_PORT_PREFIX.length);
+            const hostPort = name.substring(exports.CONTAINER_LABEL_PORT_PREFIX.length);
             portTypes[hostPort] = portType;
         });
         lodash_1.default.forEach(inspectResult.HostConfig.PortBindings, (portBindings, containerPortSpec) => {

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

@@ -2,7 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { InstanceInfo, LogEntry } from './types';
+import { EnvironmentType, InstanceInfo, LogEntry, OperatorInstanceInfo } from './types';
 import { Task } from './taskManager';
 export declare class InstanceManager {
     private _interval;
@@ -27,6 +27,7 @@ export declare class InstanceManager {
     stop(systemId: string, instanceId: string): Promise<void>;
     private stopInner;
     stopAllForPlan(systemId: string): Task<void>;
+    getInstanceOperator(systemId: string, instanceId: string, environment?: EnvironmentType): Promise<OperatorInstanceInfo>;
     start(systemId: string, instanceId: string): Promise<InstanceInfo | Task<InstanceInfo>>;
     /**
      * Stops an instance but does not remove it from the list of active instances

package/dist/esm/src/instanceManager.js

@@ -323,6 +323,48 @@ class InstanceManager {
             name: `Stopping plan ${systemId}`,
         });
     }
+    async getInstanceOperator(systemId, instanceId, environment) {
+        const blockInstance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
+        if (!blockInstance) {
+            throw new Error(`Instance not found: ${systemId}/${instanceId}`);
+        }
+        const blockRef = (0, nodejs_utils_1.normalizeKapetaUri)(blockInstance.block.ref);
+        const block = await assetManager_1.assetManager.getAsset(blockRef, true);
+        if (!block) {
+            throw new Error(`Block not found: ${blockRef}`);
+        }
+        const operatorDefinition = await definitionsManager_1.definitionsManager.getDefinition(block.kind);
+        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 portInfo = await container.getPorts();
+        if (!portInfo) {
+            throw new Error(`No ports found for instance: ${instanceId}`);
+        }
+        const hostname = serviceManager_1.serviceManager.getLocalHost(environment);
+        const ports = {};
+        Object.entries(portInfo).forEach(([key, value]) => {
+            ports[key] = {
+                protocol: value.protocol,
+                port: parseInt(value.hostPort),
+            };
+        });
+        return {
+            hostname,
+            ports,
+            credentials: localConfig.credentials,
+            options: localConfig.options,
+        };
+    }
     async start(systemId, instanceId) {
         return this.exclusive(systemId, instanceId, async () => {
             systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
@@ -333,7 +375,7 @@ class InstanceManager {
                 throw new Error('Block not found: ' + blockRef);
             }
             const existingInstance = this.getInstance(systemId, instanceId);
-            if (existingInstance) {
+            if (existingInstance && existingInstance.pid) {
                 if (existingInstance.status === types_1.InstanceStatus.READY) {
                     // Instance is already running
                     return existingInstance;

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

@@ -4,12 +4,12 @@
  */
 import { DefinitionInfo } from '@kapeta/local-cluster-config';
 import { ContainerInfo } from './containerManager';
-import { EnvironmentType, OperatorInfo } from './types';
+import { EnvironmentType, LocalImageOptions, OperatorInfo } from './types';
 export declare const KIND_OPERATOR = "core/resource-type-operator";
 declare class Operator {
     private readonly _data;
     constructor(data: DefinitionInfo);
-    getLocalData(): any;
+    getLocalData(): LocalImageOptions;
     getDefinitionInfo(): DefinitionInfo;
     getCredentials(): any;
 }

package/dist/esm/src/operatorManager.js

@@ -137,13 +137,8 @@ class OperatorManager {
                 const portType = portTypes[i];
                 let containerPortInfo = operatorData.ports[portType];
                 const hostPort = await serviceManager_1.serviceManager.ensureServicePort(systemId, resourceType, portType);
-                if (typeof containerPortInfo === 'number' || typeof containerPortInfo === 'string') {
-                    containerPortInfo = { port: containerPortInfo, type: 'tcp' };
-                }
-                if (!containerPortInfo.type) {
-                    containerPortInfo.type = 'tcp';
-                }
-                const portId = containerPortInfo.port + '/' + containerPortInfo.type;
+                const portInfo = (0, utils_1.toPortInfo)(containerPortInfo);
+                const portId = portInfo.port + '/' + portInfo.type;
                 ports[portId] = {
                     type: portType,
                     hostPort,

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

@@ -9,6 +9,7 @@ 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

@@ -31,22 +31,22 @@ class ServiceManager {
             });
         });
     }
-    _forLocal(port, path, environmentType) {
-        if (!path) {
-            path = '';
-        }
-        let host;
+    getLocalHost(environmentType) {
         if (environmentType === 'docker') {
             //We're inside a docker container, so we can use this special host name to access the host machine
-            host = 'host.docker.internal';
+            return 'host.docker.internal';
         }
-        else {
-            host = clusterService_1.clusterService.getClusterServiceHost();
+        return clusterService_1.clusterService.getClusterServiceHost();
+    }
+    _forLocal(port, path, environmentType) {
+        if (!path) {
+            path = '';
         }
+        const hostname = this.getLocalHost(environmentType);
         if (path.startsWith('/')) {
             path = path.substring(1);
         }
-        return `http://${host}:${port}/${path}`;
+        return `http://${hostname}:${port}/${path}`;
     }
     _ensureSystem(systemId) {
         systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);

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

@@ -56,6 +56,30 @@ 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;
+    mounts?: {
+        [key: string]: string;
+    };
+};
 export type InstanceInfo = {
     systemId: string;
     instanceId: string;
@@ -73,6 +97,21 @@ 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;

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

@@ -288,7 +288,8 @@ class BlockInstanceRunner {
         if (!spec?.local?.image) {
             throw new Error(`Provider did not have local image: ${providerRef}`);
         }
-        const dockerImage = spec?.local?.image;
+        const local = spec.local;
+        const dockerImage = local.image;
         //We only want 1 operator per operator type - across all local systems
         const containerName = (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id);
         const logs = new LogData_1.LogData();
@@ -298,11 +299,13 @@ class BlockInstanceRunner {
         const PortBindings = {};
         let HealthCheck = undefined;
         let Mounts = [];
-        const localPorts = spec.local.ports;
+        const localPorts = local.ports ?? {};
+        const labels = {};
         const promises = Object.entries(localPorts).map(async ([portType, value]) => {
-            const dockerPort = `${value.port}/${value.type}`;
+            const portInfo = (0, utils_1.toPortInfo)(value);
+            const dockerPort = `${portInfo.port}/${portInfo.type}`;
             ExposedPorts[dockerPort] = {};
-            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = value.port;
+            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = `${portInfo.port}`;
             const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
             PortBindings[dockerPort] = [
                 {
@@ -310,19 +313,19 @@ class BlockInstanceRunner {
                     HostPort: `${publicPort}`,
                 },
             ];
+            labels[containerManager_1.CONTAINER_LABEL_PORT_PREFIX + publicPort] = portType;
         });
         await Promise.all(promises);
-        if (spec.local?.env) {
-            Object.entries(spec.local.env).forEach(([key, value]) => {
+        if (local.env) {
+            Object.entries(local.env).forEach(([key, value]) => {
                 addonEnv[key] = value;
             });
         }
-        if (spec.local?.mounts) {
-            const mounts = await containerManager_1.containerManager.createMounts(this._systemId, blockUri.id, spec.local.mounts);
-            Mounts = containerManager_1.containerManager.toDockerMounts(mounts);
+        if (local.mounts) {
+            Mounts = await containerManager_1.containerManager.createVolumes(this._systemId, blockUri.id, local.mounts);
         }
-        if (spec.local?.health) {
-            HealthCheck = containerManager_1.containerManager.toDockerHealth(spec.local?.health);
+        if (local.health) {
+            HealthCheck = containerManager_1.containerManager.toDockerHealth(local.health);
         }
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
@@ -342,6 +345,7 @@ class BlockInstanceRunner {
                 Mounts,
             },
             Labels: {
+                ...labels,
                 instance: blockInstance.id,
                 [containerManager_1.COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
                 [containerManager_1.COMPOSE_LABEL_SERVICE]: blockUri.id.replace(/[^a-z0-9]/gi, '_'),
@@ -356,7 +360,7 @@ class BlockInstanceRunner {
                 }).map(([key, value]) => `${key}=${value}`),
             ],
         });
-        const portTypes = spec.local.ports ? Object.keys(spec.local.ports) : [];
+        const portTypes = local.ports ? Object.keys(local.ports) : [];
         if (portTypes.length > 0) {
             out.portType = portTypes[0];
         }

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

@@ -3,8 +3,12 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 import { EntityList } from '@kapeta/schemas';
-import { AnyMap } from '../types';
+import { AnyMap, PortInfo } from '../types';
 export declare function getBlockInstanceContainerName(systemId: string, instanceId: string): string;
+export declare function toPortInfo(port: PortInfo): {
+    port: number;
+    type: string;
+};
 export declare function getRemoteUrl(id: string, defautValue: string): any;
 export declare function readYML(path: string): any;
 export declare function isWindows(): boolean;

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

@@ -7,7 +7,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getResolvedConfiguration = exports.getBindHost = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = exports.getRemoteUrl = exports.getBlockInstanceContainerName = void 0;
+exports.getResolvedConfiguration = exports.getBindHost = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = exports.getRemoteUrl = 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"));
@@ -17,6 +17,16 @@ function getBlockInstanceContainerName(systemId, instanceId) {
     return `kapeta-block-instance-${(0, md5_1.default)(systemId + instanceId)}`;
 }
 exports.getBlockInstanceContainerName = getBlockInstanceContainerName;
+function toPortInfo(port) {
+    if (typeof port === 'number' || typeof port === 'string') {
+        return { port: parseInt(`${port}`), type: 'tcp' };
+    }
+    if (!port.type) {
+        port.type = 'tcp';
+    }
+    return port;
+}
+exports.toPortInfo = toPortInfo;
 function getRemoteUrl(id, defautValue) {
     const remoteConfig = local_cluster_config_1.default.getClusterConfig().remote;
     return remoteConfig?.[id] ?? defautValue;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.34.2",
+    "version": "0.35.0",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {

package/src/config/routes.ts

@@ -181,4 +181,19 @@ router.get('/consumes/:resourceName/:type', (req: KapetaRequest, res) => {
     );
 });
 
+/**
+ * Used by services to information about a block operator
+ *
+ * If the remote service is not already running it will be started
+ */
+router.get('/operator/:instanceId', async (req: KapetaRequest, res) => {
+    const operatorInfo = await instanceManager.getInstanceOperator(
+        req.kapeta!.systemId,
+        req.params.instanceId,
+        req.kapeta!.environment
+    );
+
+    res.send(operatorInfo);
+});
+
 export default router;

package/src/containerManager.ts

@@ -14,7 +14,7 @@ import ClusterConfiguration from '@kapeta/local-cluster-config';
 import uuid from 'node-uuid';
 import md5 from 'md5';
 import { getBlockInstanceContainerName } from './utils/utils';
-import { InstanceInfo, LogEntry, LogSource } from './types';
+import { Health, InstanceInfo, LogEntry, LogSource } from './types';
 import { KapetaAPI } from '@kapeta/nodejs-api-client';
 import { taskManager, Task } from './taskManager';
 import { EventEmitter } from 'node:events';
@@ -76,13 +76,6 @@ interface JSONMessage<T = string> {
     aux?: any;
 }
 
-interface Health {
-    cmd: string;
-    interval?: number;
-    timeout?: number;
-    retries?: number;
-}
-
 export const CONTAINER_LABEL_PORT_PREFIX = 'kapeta_port-';
 const NANO_SECOND = 1000000;
 const HEALTH_CHECK_INTERVAL = 3000;
@@ -255,7 +248,7 @@ class ContainerManager {
 
     async createVolumes(
         systemId: string,
-        kind: string,
+        serviceId: string,
         mountOpts: StringMap | null | undefined
     ): Promise<DockerMounts[]> {
         const Mounts: DockerMounts[] = [];
@@ -263,7 +256,7 @@ class ContainerManager {
         if (mountOpts) {
             const mountOptList = Object.entries(mountOpts);
             for (const [mountName, containerPath] of mountOptList) {
-                const volumeName = `${systemId}_${kind}_${mountName}`.replace(/[^a-z0-9]/gi, '_');
+                const volumeName = `${systemId}_${serviceId}_${mountName}`.replace(/[^a-z0-9]/gi, '_');
 
                 Mounts.push({
                     Target: containerPath,
@@ -273,7 +266,7 @@ class ContainerManager {
                     Consistency: 'consistent',
                     Labels: {
                         [COMPOSE_LABEL_PROJECT]: systemId.replace(/[^a-z0-9]/gi, '_'),
-                        [COMPOSE_LABEL_SERVICE]: kind.replace(/[^a-z0-9]/gi, '_'),
+                        [COMPOSE_LABEL_SERVICE]: serviceId.replace(/[^a-z0-9]/gi, '_'),
                     },
                 });
             }
@@ -997,7 +990,7 @@ export class ContainerInfo {
                 return;
             }
 
-            const hostPort = name.substr(CONTAINER_LABEL_PORT_PREFIX.length);
+            const hostPort = name.substring(CONTAINER_LABEL_PORT_PREFIX.length);
 
             portTypes[hostPort] = portType;
         });

package/src/instanceManager.ts

@@ -18,7 +18,19 @@ import {
     HEALTH_CHECK_TIMEOUT,
 } from './containerManager';
 import { configManager } from './configManager';
-import { DesiredInstanceStatus, InstanceInfo, InstanceOwner, InstanceStatus, InstanceType, LogEntry } from './types';
+import {
+    DesiredInstanceStatus,
+    EnvironmentType,
+    InstanceInfo,
+    InstanceOwner,
+    InstanceStatus,
+    InstanceType,
+    LocalImageOptions,
+    LogEntry,
+    OperatorInfo,
+    OperatorInstanceInfo,
+    OperatorInstancePort,
+} from './types';
 import { BlockDefinitionSpec, BlockInstance, Plan } from '@kapeta/schemas';
 import { getBlockInstanceContainerName, getResolvedConfiguration } from './utils/utils';
 import { KIND_OPERATOR, operatorManager } from './operatorManager';
@@ -414,6 +426,62 @@ export class InstanceManager {
         );
     }
 
+    public async getInstanceOperator(
+        systemId: string,
+        instanceId: string,
+        environment?: EnvironmentType
+    ): Promise<OperatorInstanceInfo> {
+        const blockInstance = await assetManager.getBlockInstance(systemId, instanceId);
+        if (!blockInstance) {
+            throw new Error(`Instance not found: ${systemId}/${instanceId}`);
+        }
+        const blockRef = normalizeKapetaUri(blockInstance.block.ref);
+        const block = await assetManager.getAsset(blockRef, true);
+        if (!block) {
+            throw new Error(`Block not found: ${blockRef}`);
+        }
+
+        const operatorDefinition = await definitionsManager.getDefinition(block.kind);
+
+        if (!operatorDefinition?.definition.spec.local) {
+            throw new Error(`Operator block has no local definition: ${blockRef}`);
+        }
+
+        const localConfig = operatorDefinition.definition.spec.local as LocalImageOptions;
+
+        let instance = await this.start(systemId, instanceId);
+        if (instance instanceof Task) {
+            instance = await instance.wait();
+        }
+
+        const container = await containerManager.get(instance.pid as string);
+        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}`);
+        }
+
+        const hostname = serviceManager.getLocalHost(environment);
+        const ports: { [key: string]: OperatorInstancePort } = {};
+
+        Object.entries(portInfo).forEach(([key, value]) => {
+            ports[key] = {
+                protocol: value.protocol,
+                port: parseInt(value.hostPort),
+            };
+        });
+
+        return {
+            hostname,
+            ports,
+            credentials: localConfig.credentials,
+            options: localConfig.options,
+        };
+    }
+
     public async start(systemId: string, instanceId: string): Promise<InstanceInfo | Task<InstanceInfo>> {
         return this.exclusive(systemId, instanceId, async () => {
             systemId = normalizeKapetaUri(systemId);
@@ -427,7 +495,7 @@ export class InstanceManager {
 
             const existingInstance = this.getInstance(systemId, instanceId);
 
-            if (existingInstance) {
+            if (existingInstance && existingInstance.pid) {
                 if (existingInstance.status === InstanceStatus.READY) {
                     // Instance is already running
                     return existingInstance;
@@ -481,8 +549,8 @@ export class InstanceManager {
                         return Promise.resolve();
                     }
                     // Check if the operator has a local definition, if not we skip it since we can't start it
-                    if(!asset.definition.spec.local) {
-                        console.log('Skipping operator since it as no local definition: %s', consumer.kind)
+                    if (!asset.definition.spec.local) {
+                        console.log('Skipping operator since it as no local definition: %s', consumer.kind);
                         return Promise.resolve();
                     }
                     console.log('Ensuring resource: %s in %s', consumerUri.id, systemId);

package/src/operatorManager.ts

@@ -16,10 +16,10 @@ import {
     containerManager,
 } from './containerManager';
 import FSExtra from 'fs-extra';
-import { AnyMap, EnvironmentType, OperatorInfo, StringMap } from './types';
+import { AnyMap, EnvironmentType, LocalImageOptions, OperatorInfo, StringMap } from './types';
 import { BlockInstance, Resource } from '@kapeta/schemas';
 import { definitionsManager } from './definitionsManager';
-import { getBindHost } from './utils/utils';
+import { getBindHost, toPortInfo } from './utils/utils';
 import { parseKapetaUri, normalizeKapetaUri } from '@kapeta/nodejs-utils';
 import _ from 'lodash';
 import AsyncLock from 'async-lock';
@@ -34,7 +34,7 @@ class Operator {
         this._data = data;
     }
 
-    getLocalData() {
+    getLocalData(): LocalImageOptions {
         return this._data.definition.spec.local;
     }
 
@@ -187,16 +187,8 @@ class OperatorManager {
                 const portType = portTypes[i];
                 let containerPortInfo = operatorData.ports[portType];
                 const hostPort = await serviceManager.ensureServicePort(systemId, resourceType, portType);
-
-                if (typeof containerPortInfo === 'number' || typeof containerPortInfo === 'string') {
-                    containerPortInfo = { port: containerPortInfo, type: 'tcp' };
-                }
-
-                if (!containerPortInfo.type) {
-                    containerPortInfo.type = 'tcp';
-                }
-
-                const portId = containerPortInfo.port + '/' + containerPortInfo.type;
+                const portInfo = toPortInfo(containerPortInfo);
+                const portId = portInfo.port + '/' + portInfo.type;
 
                 ports[portId] = {
                     type: portType,

package/src/serviceManager.ts

@@ -34,22 +34,25 @@ class ServiceManager {
         });
     }
 
+    public getLocalHost(environmentType?: 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.getClusterServiceHost();
+    }
+
     _forLocal(port: string | number, path?: string, environmentType?: EnvironmentType) {
         if (!path) {
             path = '';
         }
-        let host;
-        if (environmentType === 'docker') {
-            //We're inside a docker container, so we can use this special host name to access the host machine
-            host = 'host.docker.internal';
-        } else {
-            host = clusterService.getClusterServiceHost();
-        }
+        const hostname = this.getLocalHost(environmentType);
 
         if (path.startsWith('/')) {
             path = path.substring(1);
         }
-        return `http://${host}:${port}/${path}`;
+        return `http://${hostname}:${port}/${path}`;
     }
 
     _ensureSystem(systemId: string) {

package/src/types.ts

@@ -61,6 +61,26 @@ export type ProcessInfo = {
     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;
+    mounts?: { [key: string]: string };
+};
+
 export type InstanceInfo = {
     systemId: string;
     instanceId: string;
@@ -86,6 +106,21 @@ interface ResourceRef {
 
 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;

package/src/utils/BlockInstanceRunner.ts

@@ -5,19 +5,20 @@
 
 import FSExtra from 'fs-extra';
 import ClusterConfig, { DefinitionInfo } from '@kapeta/local-cluster-config';
-import { getBindHost, getBlockInstanceContainerName, readYML } from './utils';
+import { getBindHost, getBlockInstanceContainerName, readYML, toPortInfo } from './utils';
 import { KapetaURI, parseKapetaUri, normalizeKapetaUri } from '@kapeta/nodejs-utils';
 import { DEFAULT_PORT_TYPE, HTTP_PORT_TYPE, HTTP_PORTS, serviceManager } from '../serviceManager';
 import {
     COMPOSE_LABEL_PROJECT,
     COMPOSE_LABEL_SERVICE,
+    CONTAINER_LABEL_PORT_PREFIX,
     containerManager,
     DockerMounts,
     toLocalBindVolume,
 } from '../containerManager';
 import { LogData } from './LogData';
 import { clusterService } from '../clusterService';
-import { AnyMap, BlockProcessParams, InstanceType, ProcessInfo, StringMap } from '../types';
+import { AnyMap, BlockProcessParams, InstanceType, LocalImageOptions, ProcessInfo, StringMap } from '../types';
 import { definitionsManager } from '../definitionsManager';
 import Docker from 'dockerode';
 import OS from 'node:os';
@@ -384,7 +385,9 @@ export class BlockInstanceRunner {
             throw new Error(`Provider did not have local image: ${providerRef}`);
         }
 
-        const dockerImage = spec?.local?.image;
+        const local = spec.local as LocalImageOptions;
+
+        const dockerImage = local.image;
 
         //We only want 1 operator per operator type - across all local systems
         const containerName = getBlockInstanceContainerName(this._systemId, blockInstance.id);
@@ -397,11 +400,13 @@ export class BlockInstanceRunner {
         const PortBindings: AnyMap = {};
         let HealthCheck = undefined;
         let Mounts: DockerMounts[] = [];
-        const localPorts = spec.local.ports as { [p: string]: { port: string; type: string } };
+        const localPorts = local.ports ?? {};
+        const labels: { [key: string]: string } = {};
         const promises = Object.entries(localPorts).map(async ([portType, value]) => {
-            const dockerPort = `${value.port}/${value.type}`;
+            const portInfo = toPortInfo(value);
+            const dockerPort = `${portInfo.port}/${portInfo.type}`;
             ExposedPorts[dockerPort] = {};
-            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = value.port;
+            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = `${portInfo.port}`;
             const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
             PortBindings[dockerPort] = [
                 {
@@ -409,23 +414,24 @@ export class BlockInstanceRunner {
                     HostPort: `${publicPort}`,
                 },
             ];
+
+            labels[CONTAINER_LABEL_PORT_PREFIX + publicPort] = portType;
         });
 
         await Promise.all(promises);
 
-        if (spec.local?.env) {
-            Object.entries(spec.local.env).forEach(([key, value]) => {
+        if (local.env) {
+            Object.entries(local.env).forEach(([key, value]) => {
                 addonEnv[key] = value as string;
             });
         }
 
-        if (spec.local?.mounts) {
-            const mounts = await containerManager.createMounts(this._systemId, blockUri.id, spec.local.mounts);
-            Mounts = containerManager.toDockerMounts(mounts);
+        if (local.mounts) {
+            Mounts = await containerManager.createVolumes(this._systemId, blockUri.id, local.mounts);
         }
 
-        if (spec.local?.health) {
-            HealthCheck = containerManager.toDockerHealth(spec.local?.health);
+        if (local.health) {
+            HealthCheck = containerManager.toDockerHealth(local.health);
         }
 
         // For windows we need to default to root
@@ -447,6 +453,7 @@ export class BlockInstanceRunner {
                 Mounts,
             },
             Labels: {
+                ...labels,
                 instance: blockInstance.id,
                 [COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
                 [COMPOSE_LABEL_SERVICE]: blockUri.id.replace(/[^a-z0-9]/gi, '_'),
@@ -462,7 +469,7 @@ export class BlockInstanceRunner {
             ],
         });
 
-        const portTypes = spec.local.ports ? Object.keys(spec.local.ports) : [];
+        const portTypes = local.ports ? Object.keys(local.ports) : [];
         if (portTypes.length > 0) {
             out.portType = portTypes[0];
         }

package/src/utils/utils.ts

@@ -5,17 +5,28 @@
 
 import FS from 'node:fs';
 import YAML from 'yaml';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import md5 from 'md5';
 import { EntityList } from '@kapeta/schemas';
 import _ from 'lodash';
-import { AnyMap } from '../types';
+import { AnyMap, PortInfo } from '../types';
 import ClusterConfiguration from '@kapeta/local-cluster-config';
 
 export function getBlockInstanceContainerName(systemId: string, instanceId: string) {
     return `kapeta-block-instance-${md5(systemId + instanceId)}`;
 }
 
+export function toPortInfo(port: PortInfo) {
+    if (typeof port === 'number' || typeof port === 'string') {
+        return { port: parseInt(`${port}`), type: 'tcp' };
+    }
+
+    if (!port.type) {
+        port.type = 'tcp';
+    }
+
+    return port;
+}
+
 export function getRemoteUrl(id: string, defautValue: string) {
     const remoteConfig = ClusterConfiguration.getClusterConfig().remote;
     return remoteConfig?.[id] ?? defautValue;