@kapeta/local-cluster-service 0.8.2 → 0.9.0

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

@@ -4,6 +4,7 @@ import { serviceManager } from '../serviceManager';
 import { corsHandler } from '../middleware/cors';
 import { kapetaHeaders } from '../middleware/kapeta';
 import { stringBody } from '../middleware/stringBody';
+import { DesiredInstanceStatus, InstanceOwner, InstanceType } from '../types';
 const router = Router();
 router.use('/', corsHandler);
 router.use('/', kapetaHeaders);
@@ -23,10 +24,10 @@ router.get('/:systemId/instances', (req, res) => {
  * Start all instances in a plan
  */
 router.post('/:systemId/start', async (req, res) => {
-    const processes = await instanceManager.createProcessesForPlan(req.params.systemId);
+    const instances = await instanceManager.startAllForPlan(req.params.systemId);
     res.status(202).send({
         ok: true,
-        processes: processes.map((p) => {
+        processes: instances.map((p) => {
             return { pid: p.pid, type: p.type };
         }),
     });
@@ -44,7 +45,7 @@ router.post('/:systemId/stop', async (req, res) => {
  * Start single instance in a plan
  */
 router.post('/:systemId/:instanceId/start', async (req, res) => {
-    const process = await instanceManager.createProcess(req.params.systemId, req.params.instanceId);
+    const process = await instanceManager.start(req.params.systemId, req.params.instanceId);
     res.status(202).send({
         ok: true,
         pid: process.pid,
@@ -55,20 +56,20 @@ router.post('/:systemId/:instanceId/start', async (req, res) => {
  * Stop single instance in a plan
  */
 router.post('/:systemId/:instanceId/stop', async (req, res) => {
-    await instanceManager.stopProcess(req.params.systemId, req.params.instanceId);
+    await instanceManager.stop(req.params.systemId, req.params.instanceId);
     res.status(202).send({ ok: true });
 });
 /**
  * Get logs for instance in a plan
  */
 router.get('/:systemId/:instanceId/logs', (req, res) => {
-    const processInfo = instanceManager.getProcessForInstance(req.params.systemId, req.params.instanceId);
-    if (!processInfo) {
+    const instanceInfo = instanceManager.getInstance(req.params.systemId, req.params.instanceId);
+    if (!instanceInfo) {
         res.status(404).send({ ok: false });
         return;
     }
     res.status(202).send({
-        logs: processInfo.logs(),
+        logs: instanceInfo.internal?.logs() ?? [],
     });
 });
 /**
@@ -101,7 +102,7 @@ router.use('/', (req, res, next) => {
     next();
 });
 /**
- * Updates the full configuration for a given service.
+ * Updates the full configuration for a given instance.
  */
 router.put('/', async (req, res) => {
     let instance = req.stringBody ? JSON.parse(req.stringBody) : null;
@@ -111,19 +112,27 @@ router.put('/', async (req, res) => {
         if (oldInstance) {
             instance.pid = oldInstance.pid;
         }
-        instance.type = 'docker';
+        instance.type = InstanceType.DOCKER;
     }
-    else if (req.kapeta.environment === 'process') {
-        instance.type = 'process';
+    else {
+        // Coming from user starting the instance outside of kapeta
+        instance.type = InstanceType.LOCAL;
+        instance.owner = InstanceOwner.EXTERNAL;
+        instance.desiredStatus = DesiredInstanceStatus.EXTERNAL;
+    }
+    try {
+        await instanceManager.registerInstanceFromSDK(req.kapeta.systemId, req.kapeta.instanceId, instance);
+        res.status(202).send({ ok: true });
+    }
+    catch (e) {
+        res.status(400).send({ error: e.message });
     }
-    await instanceManager.registerInstance(req.kapeta.systemId, req.kapeta.instanceId, instance);
-    res.status(202).send({ ok: true });
 });
 /**
  * Delete instance
  */
 router.delete('/', async (req, res) => {
-    await instanceManager.setInstanceAsStopped(req.kapeta.systemId, req.kapeta.instanceId);
+    await instanceManager.markAsStopped(req.kapeta.systemId, req.kapeta.instanceId);
     res.status(202).send({ ok: true });
 });
 export default router;

package/dist/esm/src/middleware/kapeta.js

@@ -1,8 +1,15 @@
+import { normalizeKapetaUri } from '../utils/utils';
 export function kapetaHeaders(req, res, next) {
     let blockRef = req.headers['x-kapeta-block'];
     let systemId = req.headers['x-kapeta-system'];
     let instanceId = req.headers['x-kapeta-instance'];
     let environment = req.headers['x-kapeta-environment'];
+    if (blockRef) {
+        blockRef = normalizeKapetaUri(blockRef);
+    }
+    if (systemId) {
+        systemId = normalizeKapetaUri(systemId);
+    }
     req.kapeta = {
         blockRef,
         instanceId,

package/dist/esm/src/networkManager.js

@@ -1,4 +1,5 @@
 import uuid from 'node-uuid';
+import { normalizeKapetaUri } from './utils/utils';
 class NetworkManager {
     _connections;
     _sources;
@@ -17,6 +18,7 @@ class NetworkManager {
         this._targets = {};
     }
     _ensureSystem(systemId) {
+        systemId = normalizeKapetaUri(systemId);
         if (!this._connections[systemId]) {
             this._connections[systemId] = {};
         }
@@ -28,6 +30,7 @@ class NetworkManager {
         }
     }
     _ensureConnection(systemId, connectionId) {
+        systemId = normalizeKapetaUri(systemId);
         this._ensureSystem(systemId);
         if (!this._connections[systemId][connectionId]) {
             this._connections[systemId][connectionId] = [];
@@ -35,6 +38,7 @@ class NetworkManager {
         return this._connections[systemId][connectionId];
     }
     _ensureSource(systemId, sourceBlockInstanceId) {
+        systemId = normalizeKapetaUri(systemId);
         this._ensureSystem(systemId);
         if (!this._sources[systemId][sourceBlockInstanceId]) {
             this._sources[systemId][sourceBlockInstanceId] = [];
@@ -42,6 +46,7 @@ class NetworkManager {
         return this._sources[systemId][sourceBlockInstanceId];
     }
     _ensureTarget(systemId, targetBlockInstanceId) {
+        systemId = normalizeKapetaUri(systemId);
         this._ensureSystem(systemId);
         if (!this._targets[systemId][targetBlockInstanceId]) {
             this._targets[systemId][targetBlockInstanceId] = [];
@@ -49,6 +54,7 @@ class NetworkManager {
         return this._targets[systemId][targetBlockInstanceId];
     }
     addRequest(systemId, connection, request, consumerMethodId, providerMethodId) {
+        systemId = normalizeKapetaUri(systemId);
         const traffic = new Traffic(connection, request, consumerMethodId, providerMethodId);
         this._ensureConnection(systemId, traffic.connectionId).push(traffic);
         this._ensureSource(systemId, connection.provider.blockId).push(traffic);

package/dist/esm/src/operatorManager.js

@@ -1,4 +1,3 @@
-import ClusterConfiguration from '@kapeta/local-cluster-config';
 import Path from 'path';
 import md5 from 'md5';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
@@ -6,6 +5,8 @@ import { serviceManager } from './serviceManager';
 import { storageService } from './storageService';
 import { containerManager } from './containerManager';
 import FSExtra from 'fs-extra';
+import { definitionsManager } from './definitionsManager';
+import { normalizeKapetaUri } from './utils/utils';
 const KIND_OPERATOR = 'core/resource-type-operator';
 class Operator {
     _data;
@@ -36,7 +37,7 @@ class OperatorManager {
      * @return {Operator}
      */
     getOperator(resourceType, version) {
-        const operators = ClusterConfiguration.getDefinitions(KIND_OPERATOR);
+        const operators = definitionsManager.getDefinitions(KIND_OPERATOR);
         const operator = operators.find((operator) => operator.definition &&
             operator.definition.metadata &&
             operator.definition.metadata.name &&
@@ -54,7 +55,8 @@ class OperatorManager {
      * Get information about a specific consumed resource
      */
     async getConsumerResourceInfo(systemId, fromServiceId, resourceType, portType, name, environment) {
-        const plans = ClusterConfiguration.getDefinitions('core/plan');
+        systemId = normalizeKapetaUri(systemId);
+        const plans = definitionsManager.getDefinitions('core/plan');
         const planUri = parseKapetaUri(systemId);
         const currentPlan = plans.find((plan) => plan.definition.metadata.name === planUri.fullName && plan.version === planUri.version);
         if (!currentPlan) {
@@ -65,7 +67,9 @@ class OperatorManager {
             throw new Error(`Unknown instance: ${fromServiceId} in plan ${systemId}`);
         }
         const blockUri = parseKapetaUri(currentInstance.block.ref);
-        const blockDefinition = ClusterConfiguration.getDefinitions().find((definition) => definition.version === blockUri.version && definition.definition.metadata.name === blockUri.fullName);
+        const blockDefinition = definitionsManager
+            .getDefinitions()
+            .find((definition) => definition.version === blockUri.version && definition.definition.metadata.name === blockUri.fullName);
         if (!blockDefinition) {
             throw new Error(`Unknown block: ${currentInstance.block.ref} in plan ${systemId}`);
         }

package/dist/esm/src/providerManager.js

@@ -1,14 +1,14 @@
 import Path from 'path';
 import FSExtra from 'fs-extra';
 import { repositoryManager } from './repositoryManager';
-import ClusterConfiguration from '@kapeta/local-cluster-config';
+import { definitionsManager } from './definitionsManager';
 class ProviderManager {
     _webAssetCache;
     constructor() {
         this._webAssetCache = {};
     }
     getWebProviders() {
-        return ClusterConfiguration.getProviderDefinitions().filter((providerDefinition) => providerDefinition.hasWeb);
+        return definitionsManager.getProviderDefinitions().filter((providerDefinition) => providerDefinition.hasWeb);
     }
     async getAsset(handle, name, version, sourceMap = false) {
         const fullName = `${handle}/${name}`;
@@ -31,7 +31,7 @@ class ProviderManager {
         return null;
     }
 }
-const providerDefinitions = ClusterConfiguration.getProviderDefinitions();
+const providerDefinitions = definitionsManager.getProviderDefinitions();
 if (providerDefinitions.length > 0) {
     console.log('## Loaded the following providers ##');
     providerDefinitions.forEach((providerDefinition) => {

package/dist/esm/src/repositoryManager.js

@@ -8,6 +8,7 @@ import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import { socketManager } from './socketManager';
 import { progressListener } from './progressListener';
 import { Actions, Config, RegistryService } from '@kapeta/nodejs-registry-utils';
+import { definitionsManager } from './definitionsManager';
 const INSTALL_ATTEMPTED = {};
 class RepositoryManager {
     changeEventsEnabled;
@@ -83,6 +84,7 @@ class RepositoryManager {
                 };
                 allDefinitions = newDefinitions;
                 socketManager.emit(`assets`, 'changed', payload);
+                definitionsManager.clearCache();
             });
         }
         catch (e) {
@@ -173,7 +175,7 @@ class RepositoryManager {
             //TODO: Get dependencies for local asset
             return;
         }
-        const definitions = ClusterConfiguration.getDefinitions();
+        const definitions = definitionsManager.getDefinitions();
         const installedAsset = definitions.find((d) => d.definition.metadata.name === fullName && d.version === version);
         if (installedAsset && this._cache[ref] === true) {
             return;
@@ -204,8 +206,10 @@ class RepositoryManager {
         else {
             //Ensure dependencies are installed
             const refs = assetVersion.dependencies.map((dep) => dep.name);
-            console.log(`Auto-installing dependencies: ${refs.join(', ')}`);
-            await this._install(refs);
+            if (refs.length > 0) {
+                console.log(`Auto-installing dependencies: ${refs.join(', ')}`);
+                await this._install(refs);
+            }
         }
     }
 }

package/dist/esm/src/serviceManager.js

@@ -1,6 +1,7 @@
 import _ from 'lodash';
 import { clusterService } from './clusterService';
 import { storageService } from './storageService';
+import { normalizeKapetaUri } from './utils/utils';
 const DEFAULT_PORT_TYPE = 'rest';
 class ServiceManager {
     _systems;
@@ -35,6 +36,7 @@ class ServiceManager {
         return `http://${host}:${port}/${path}`;
     }
     _ensureSystem(systemId) {
+        systemId = normalizeKapetaUri(systemId);
         if (!this._systems[systemId]) {
             this._systems[systemId] = {};
         }
@@ -48,6 +50,7 @@ class ServiceManager {
         return system[serviceId];
     }
     async ensureServicePort(systemId, blockInstanceId, portType = DEFAULT_PORT_TYPE) {
+        systemId = normalizeKapetaUri(systemId);
         if (!portType) {
             portType = DEFAULT_PORT_TYPE;
         }
@@ -70,6 +73,7 @@ class ServiceManager {
      *
      */
     getConsumerAddress(systemId, consumerInstanceId, consumerResourceName, portType, environmentType) {
+        systemId = normalizeKapetaUri(systemId);
         const port = clusterService.getClusterServicePort();
         const path = clusterService.getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType);
         return this._forLocal(port, path, environmentType);
@@ -83,6 +87,7 @@ class ServiceManager {
      *
      */
     async getProviderAddress(systemId, providerInstanceId, portType) {
+        systemId = normalizeKapetaUri(systemId);
         const port = await this.ensureServicePort(systemId, providerInstanceId, portType);
         return this._forLocal(port);
     }

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

@@ -24,29 +24,55 @@ export interface BlockProcessParams {
     ref: string;
     configuration?: AnyMap;
 }
-export type ProcessType = 'docker' | 'local';
-export interface ProcessDetails {
-    pid: number | string;
-    type: ProcessType;
-    portType?: string;
+export declare enum InstanceType {
+    DOCKER = "docker",
+    LOCAL = "local",
+    UNKNOWN = "unknown"
+}
+export declare enum InstanceOwner {
+    INTERNAL = "internal",
+    EXTERNAL = "external"
+}
+export declare enum InstanceStatus {
+    STOPPED = "stopped",
+    STARTING = "starting",
+    BUSY = "busy",
+    READY = "ready",
+    STOPPING = "stopping",
+    UNHEALTHY = "unhealthy",
+    FAILED = "failed"
+}
+export declare enum DesiredInstanceStatus {
+    STOP = "stop",
+    RUN = "run",
+    EXTERNAL = "external"
+}
+export type ProcessInfo = {
+    type: InstanceType;
+    pid?: number | string | null;
     output: EventEmitter;
+    portType?: string;
     logs: () => LogEntry[];
     stop: () => Promise<void> | void;
-}
-export interface ProcessInfo extends ProcessDetails {
-    id: string;
-    ref: string;
-    name: string;
-}
+};
 export type InstanceInfo = {
     systemId: string;
     instanceId: string;
+    ref: string;
+    name: string;
+    type: InstanceType;
+    owner: InstanceOwner;
+    status: InstanceStatus;
+    desiredStatus: DesiredInstanceStatus;
     address?: string;
+    startedAt?: number;
     health?: string | null;
-    status: string;
     pid?: number | string | null;
-    type: ProcessType;
     portType?: string;
+    internal?: {
+        output: EventEmitter;
+        logs: () => LogEntry[];
+    };
 };
 interface ResourceRef {
     blockId: string;

package/dist/esm/src/types.js

@@ -1 +1,27 @@
-export {};
+export var InstanceType;
+(function (InstanceType) {
+    InstanceType["DOCKER"] = "docker";
+    InstanceType["LOCAL"] = "local";
+    InstanceType["UNKNOWN"] = "unknown";
+})(InstanceType || (InstanceType = {}));
+export var InstanceOwner;
+(function (InstanceOwner) {
+    InstanceOwner["INTERNAL"] = "internal";
+    InstanceOwner["EXTERNAL"] = "external";
+})(InstanceOwner || (InstanceOwner = {}));
+export var InstanceStatus;
+(function (InstanceStatus) {
+    InstanceStatus["STOPPED"] = "stopped";
+    InstanceStatus["STARTING"] = "starting";
+    InstanceStatus["BUSY"] = "busy";
+    InstanceStatus["READY"] = "ready";
+    InstanceStatus["STOPPING"] = "stopping";
+    InstanceStatus["UNHEALTHY"] = "unhealthy";
+    InstanceStatus["FAILED"] = "failed";
+})(InstanceStatus || (InstanceStatus = {}));
+export var DesiredInstanceStatus;
+(function (DesiredInstanceStatus) {
+    DesiredInstanceStatus["STOP"] = "stop";
+    DesiredInstanceStatus["RUN"] = "run";
+    DesiredInstanceStatus["EXTERNAL"] = "external";
+})(DesiredInstanceStatus || (DesiredInstanceStatus = {}));

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

@@ -1,9 +1,9 @@
 import { DefinitionInfo } from '@kapeta/local-cluster-config';
 import { KapetaURI } from '@kapeta/nodejs-utils';
-import { AnyMap, BlockProcessParams, ProcessDetails, ProcessInfo, StringMap } from '../types';
+import { AnyMap, BlockProcessParams, ProcessInfo, StringMap } from '../types';
 export declare class BlockInstanceRunner {
     private readonly _systemId;
-    constructor(planReference: string);
+    constructor(systemId: string);
     /**
      * Start a block
      *
@@ -25,5 +25,5 @@ export declare class BlockInstanceRunner {
      * @return {Promise<ProcessDetails>}
      * @private
      */
-    _startOperatorProcess(blockInstance: BlockProcessParams, blockUri: KapetaURI, providerDefinition: DefinitionInfo, env: StringMap): Promise<ProcessDetails>;
+    _startOperatorProcess(blockInstance: BlockProcessParams, blockUri: KapetaURI, providerDefinition: DefinitionInfo, env: StringMap): Promise<ProcessInfo>;
 }

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

@@ -1,13 +1,14 @@
 import FS from 'node:fs';
 import ClusterConfig from '@kapeta/local-cluster-config';
-import { getBindHost, readYML } from './utils';
+import { getBindHost, getBlockInstanceContainerName, normalizeKapetaUri, readYML } from './utils';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import { serviceManager } from '../serviceManager';
 import { containerManager, toLocalBindVolume } from '../containerManager';
 import { LogData } from './LogData';
 import EventEmitter from 'events';
-import md5 from 'md5';
 import { clusterService } from '../clusterService';
+import { InstanceType } from '../types';
+import { definitionsManager } from '../definitionsManager';
 const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
 const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
@@ -22,7 +23,7 @@ const DOCKER_ENV_VARS = [
     `KAPETA_ENVIRONMENT_TYPE=docker`,
 ];
 function getProvider(uri) {
-    return ClusterConfig.getProviderDefinitions().find((provider) => {
+    return definitionsManager.getProviderDefinitions().find((provider) => {
         const ref = `${provider.definition.metadata.name}:${provider.version}`;
         return parseKapetaUri(ref).id === uri.id;
     });
@@ -36,13 +37,13 @@ function getProviderPorts(assetVersion) {
 }
 export class BlockInstanceRunner {
     _systemId;
-    constructor(planReference) {
+    constructor(systemId) {
         /**
          *
          * @type {string}
          * @private
          */
-        this._systemId = planReference ?? '';
+        this._systemId = normalizeKapetaUri(systemId);
     }
     /**
      * Start a block
@@ -70,7 +71,7 @@ export class BlockInstanceRunner {
         if (!blockUri.version) {
             blockUri.version = 'local';
         }
-        const assetVersion = ClusterConfig.getDefinitions().find((definitions) => {
+        const assetVersion = definitionsManager.getDefinitions().find((definitions) => {
             const ref = `${definitions.definition.metadata.name}:${definitions.version}`;
             return parseKapetaUri(ref).id === blockUri.id;
         });
@@ -82,28 +83,24 @@ export class BlockInstanceRunner {
         if (!providerVersion) {
             throw new Error(`Kind not found: ${kindUri.id}`);
         }
-        let processDetails;
+        let processInfo;
         if (providerVersion.definition.kind === KIND_BLOCK_TYPE_OPERATOR) {
-            processDetails = await this._startOperatorProcess(blockInstance, blockUri, providerVersion, env);
+            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);
             if (blockUri.version === 'local') {
-                processDetails = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
+                processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
             }
             else {
-                processDetails = await this._startDockerProcess(blockInstance, blockUri, env);
+                processInfo = await this._startDockerProcess(blockInstance, blockUri, env);
             }
             if (portTypes.length > 0) {
-                processDetails.portType = portTypes[0];
+                processInfo.portType = portTypes[0];
             }
         }
-        return {
-            name: blockUri.id,
-            ...blockInstance,
-            ...processDetails,
-        };
+        return processInfo;
     }
     /**
      * Starts local process
@@ -130,13 +127,14 @@ export class BlockInstanceRunner {
         if (!dockerImage) {
             throw new Error(`Missing docker image information: ${JSON.stringify(localContainer)}`);
         }
-        const containerName = `kapeta-block-instance-${blockInstance.id}`;
+        const containerName = getBlockInstanceContainerName(blockInstance.id);
         const logs = new LogData();
         logs.addLog(`Starting block ${blockInstance.ref}`);
-        let container = (await containerManager.getContainerByName(containerName)) ?? null;
+        const containerInfo = await containerManager.getContainerByName(containerName);
+        let container = containerInfo?.native;
         console.log('Starting dev container', containerName);
         if (container) {
-            console.log(`Container already exists. Deleting...`);
+            console.log(`Dev container already exists. Deleting...`);
             try {
                 await container.delete({
                     force: true,
@@ -145,7 +143,7 @@ export class BlockInstanceRunner {
             catch (e) {
                 throw new Error('Failed to delete existing container: ' + e.message);
             }
-            container = null;
+            container = undefined;
         }
         logs.addLog(`Creating new container for block: ${containerName}`);
         console.log('Creating new dev container', containerName, dockerImage);
@@ -178,6 +176,7 @@ export class BlockInstanceRunner {
         if (localContainer.healthcheck) {
             HealthCheck = containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
+        console.log('Starting dev container', containerName, dockerImage);
         container = await containerManager.startContainer({
             Image: dockerImage,
             name: containerName,
@@ -247,7 +246,7 @@ export class BlockInstanceRunner {
             outputEvents.emit('exit', data?.State?.ExitCode ?? 0);
         });
         return {
-            type: 'docker',
+            type: InstanceType.DOCKER,
             pid: container.id,
             output: outputEvents,
             stop: async () => {
@@ -282,9 +281,10 @@ export class BlockInstanceRunner {
         if (!dockerImage) {
             throw new Error(`Missing docker image information: ${JSON.stringify(versionInfo?.artifact?.details)}`);
         }
-        const containerName = `kapeta-block-instance-${blockInstance.id}`;
+        const containerName = getBlockInstanceContainerName(blockInstance.id);
         const logs = new LogData();
-        let container = await containerManager.getContainerByName(containerName);
+        const containerInfo = await containerManager.getContainerByName(containerName);
+        let container = containerInfo?.native;
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
         if (container) {
@@ -311,9 +311,7 @@ export class BlockInstanceRunner {
                     ...Object.entries(env).map(([key, value]) => `${key}=${value}`),
                 ],
                 HostConfig: {
-                    Binds: [
-                        `${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`,
-                    ],
+                    Binds: [`${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`],
                 },
             });
             try {
@@ -352,9 +350,10 @@ export class BlockInstanceRunner {
         catch (e) {
             console.warn('Failed to pull image. Continuing...', e);
         }
-        const containerName = `kapeta-block-instance-${md5(blockInstance.id)}`;
+        const containerName = getBlockInstanceContainerName(blockInstance.id);
         const logs = new LogData();
-        let container = (await containerManager.getContainerByName(containerName)) ?? null;
+        const containerInfo = await containerManager.getContainerByName(containerName);
+        let container = containerInfo?.native;
         if (container) {
             const containerData = container.data;
             if (containerData.State === 'running') {
@@ -367,7 +366,7 @@ export class BlockInstanceRunner {
                         await container.delete();
                     }
                     catch (e) { }
-                    container = null;
+                    container = undefined;
                 }
                 else {
                     logs.addLog(`Found existing container for block: ${containerName}. Starting now`);
@@ -380,7 +379,7 @@ export class BlockInstanceRunner {
                             await container.delete();
                         }
                         catch (e) { }
-                        container = null;
+                        container = undefined;
                     }
                 }
             }

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

@@ -1,3 +1,5 @@
+export declare function getBlockInstanceContainerName(instanceId: string): string;
+export declare function normalizeKapetaUri(uri: string): string;
 export declare function readYML(path: string): any;
 export declare function isWindows(): boolean;
 export declare function isMac(): boolean;

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

@@ -1,5 +1,19 @@
 import FS from 'node:fs';
 import YAML from 'yaml';
+import { parseKapetaUri } from '@kapeta/nodejs-utils';
+export function getBlockInstanceContainerName(instanceId) {
+    return `kapeta-block-instance-${instanceId}`;
+}
+export function normalizeKapetaUri(uri) {
+    if (!uri) {
+        return '';
+    }
+    const uriObj = parseKapetaUri(uri);
+    if (!uriObj.version) {
+        return `kapeta://${parseKapetaUri(uri).fullName}`;
+    }
+    return `kapeta://${parseKapetaUri(uri).id}`;
+}
 export function readYML(path) {
     const rawYaml = FS.readFileSync(path);
     try {
@@ -19,7 +33,7 @@ export function isLinux() {
     return !isWindows() && !isMac();
 }
 export function getBindHost(preferredHost = '127.0.0.1') {
-    // On Linux we need to bind to 0.0.0.0 to be able to connect to it from docker containers. 
+    // On Linux we need to bind to 0.0.0.0 to be able to connect to it from docker containers.
     // TODO: This might pose a security risk - so we should authenticate all requests using a shared secret/nonce that we pass around.
     return isLinux() ? '0.0.0.0' : preferredHost;
 }