@kapeta/local-cluster-service 0.8.3 → 0.9.1

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

@@ -9,6 +9,7 @@ const serviceManager_1 = require("../serviceManager");
 const cors_1 = require("../middleware/cors");
 const kapeta_1 = require("../middleware/kapeta");
 const stringBody_1 = require("../middleware/stringBody");
+const types_1 = require("../types");
 const router = (0, express_promise_router_1.default)();
 router.use('/', cors_1.corsHandler);
 router.use('/', kapeta_1.kapetaHeaders);
@@ -28,10 +29,10 @@ router.get('/:systemId/instances', (req, res) => {
  * Start all instances in a plan
  */
 router.post('/:systemId/start', async (req, res) => {
-    const processes = await instanceManager_1.instanceManager.createProcessesForPlan(req.params.systemId);
+    const instances = await instanceManager_1.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 };
         }),
     });
@@ -49,7 +50,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_1.instanceManager.createProcess(req.params.systemId, req.params.instanceId);
+    const process = await instanceManager_1.instanceManager.start(req.params.systemId, req.params.instanceId);
     res.status(202).send({
         ok: true,
         pid: process.pid,
@@ -60,20 +61,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_1.instanceManager.stopProcess(req.params.systemId, req.params.instanceId);
+    await instanceManager_1.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_1.instanceManager.getProcessForInstance(req.params.systemId, req.params.instanceId);
-    if (!processInfo) {
+    const instanceInfo = instanceManager_1.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() ?? [],
     });
 });
 /**
@@ -106,7 +107,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;
@@ -116,19 +117,27 @@ router.put('/', async (req, res) => {
         if (oldInstance) {
             instance.pid = oldInstance.pid;
         }
-        instance.type = 'docker';
+        instance.type = types_1.InstanceType.DOCKER;
     }
-    else if (req.kapeta.environment === 'process') {
-        instance.type = 'process';
+    else {
+        // Coming from user starting the instance outside of kapeta
+        instance.type = types_1.InstanceType.LOCAL;
+        instance.owner = types_1.InstanceOwner.EXTERNAL;
+        instance.desiredStatus = types_1.DesiredInstanceStatus.EXTERNAL;
+    }
+    try {
+        await instanceManager_1.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_1.instanceManager.registerInstance(req.kapeta.systemId, req.kapeta.instanceId, instance);
-    res.status(202).send({ ok: true });
 });
 /**
  * Delete instance
  */
 router.delete('/', async (req, res) => {
-    await instanceManager_1.instanceManager.setInstanceAsStopped(req.kapeta.systemId, req.kapeta.instanceId);
+    await instanceManager_1.instanceManager.markAsStopped(req.kapeta.systemId, req.kapeta.instanceId);
     res.status(202).send({ ok: true });
 });
 exports.default = router;

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

@@ -1,11 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.kapetaHeaders = void 0;
+const utils_1 = require("../utils/utils");
 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 = (0, utils_1.normalizeKapetaUri)(blockRef);
+    }
+    if (systemId) {
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
+    }
     req.kapeta = {
         blockRef,
         instanceId,

package/dist/cjs/src/networkManager.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.networkManager = void 0;
 const node_uuid_1 = __importDefault(require("node-uuid"));
+const utils_1 = require("./utils/utils");
 class NetworkManager {
     _connections;
     _sources;
@@ -23,6 +24,7 @@ class NetworkManager {
         this._targets = {};
     }
     _ensureSystem(systemId) {
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         if (!this._connections[systemId]) {
             this._connections[systemId] = {};
         }
@@ -34,6 +36,7 @@ class NetworkManager {
         }
     }
     _ensureConnection(systemId, connectionId) {
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         this._ensureSystem(systemId);
         if (!this._connections[systemId][connectionId]) {
             this._connections[systemId][connectionId] = [];
@@ -41,6 +44,7 @@ class NetworkManager {
         return this._connections[systemId][connectionId];
     }
     _ensureSource(systemId, sourceBlockInstanceId) {
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         this._ensureSystem(systemId);
         if (!this._sources[systemId][sourceBlockInstanceId]) {
             this._sources[systemId][sourceBlockInstanceId] = [];
@@ -48,6 +52,7 @@ class NetworkManager {
         return this._sources[systemId][sourceBlockInstanceId];
     }
     _ensureTarget(systemId, targetBlockInstanceId) {
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         this._ensureSystem(systemId);
         if (!this._targets[systemId][targetBlockInstanceId]) {
             this._targets[systemId][targetBlockInstanceId] = [];
@@ -55,6 +60,7 @@ class NetworkManager {
         return this._targets[systemId][targetBlockInstanceId];
     }
     addRequest(systemId, connection, request, consumerMethodId, providerMethodId) {
+        systemId = (0, utils_1.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/cjs/src/operatorManager.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.operatorManager = void 0;
-const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
 const path_1 = __importDefault(require("path"));
 const md5_1 = __importDefault(require("md5"));
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
@@ -12,6 +11,8 @@ const serviceManager_1 = require("./serviceManager");
 const storageService_1 = require("./storageService");
 const containerManager_1 = require("./containerManager");
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const definitionsManager_1 = require("./definitionsManager");
+const utils_1 = require("./utils/utils");
 const KIND_OPERATOR = 'core/resource-type-operator';
 class Operator {
     _data;
@@ -42,7 +43,7 @@ class OperatorManager {
      * @return {Operator}
      */
     getOperator(resourceType, version) {
-        const operators = local_cluster_config_1.default.getDefinitions(KIND_OPERATOR);
+        const operators = definitionsManager_1.definitionsManager.getDefinitions(KIND_OPERATOR);
         const operator = operators.find((operator) => operator.definition &&
             operator.definition.metadata &&
             operator.definition.metadata.name &&
@@ -60,7 +61,8 @@ class OperatorManager {
      * Get information about a specific consumed resource
      */
     async getConsumerResourceInfo(systemId, fromServiceId, resourceType, portType, name, environment) {
-        const plans = local_cluster_config_1.default.getDefinitions('core/plan');
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
+        const plans = definitionsManager_1.definitionsManager.getDefinitions('core/plan');
         const planUri = (0, nodejs_utils_1.parseKapetaUri)(systemId);
         const currentPlan = plans.find((plan) => plan.definition.metadata.name === planUri.fullName && plan.version === planUri.version);
         if (!currentPlan) {
@@ -71,7 +73,9 @@ class OperatorManager {
             throw new Error(`Unknown instance: ${fromServiceId} in plan ${systemId}`);
         }
         const blockUri = (0, nodejs_utils_1.parseKapetaUri)(currentInstance.block.ref);
-        const blockDefinition = local_cluster_config_1.default.getDefinitions().find((definition) => definition.version === blockUri.version && definition.definition.metadata.name === blockUri.fullName);
+        const blockDefinition = definitionsManager_1.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/cjs/src/providerManager.js

@@ -7,14 +7,14 @@ exports.providerManager = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const repositoryManager_1 = require("./repositoryManager");
-const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const definitionsManager_1 = require("./definitionsManager");
 class ProviderManager {
     _webAssetCache;
     constructor() {
         this._webAssetCache = {};
     }
     getWebProviders() {
-        return local_cluster_config_1.default.getProviderDefinitions().filter((providerDefinition) => providerDefinition.hasWeb);
+        return definitionsManager_1.definitionsManager.getProviderDefinitions().filter((providerDefinition) => providerDefinition.hasWeb);
     }
     async getAsset(handle, name, version, sourceMap = false) {
         const fullName = `${handle}/${name}`;
@@ -37,7 +37,7 @@ class ProviderManager {
         return null;
     }
 }
-const providerDefinitions = local_cluster_config_1.default.getProviderDefinitions();
+const providerDefinitions = definitionsManager_1.definitionsManager.getProviderDefinitions();
 if (providerDefinitions.length > 0) {
     console.log('## Loaded the following providers ##');
     providerDefinitions.forEach((providerDefinition) => {

package/dist/cjs/src/repositoryManager.js

@@ -14,6 +14,7 @@ const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const socketManager_1 = require("./socketManager");
 const progressListener_1 = require("./progressListener");
 const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
+const definitionsManager_1 = require("./definitionsManager");
 const INSTALL_ATTEMPTED = {};
 class RepositoryManager {
     changeEventsEnabled;
@@ -89,6 +90,7 @@ class RepositoryManager {
                 };
                 allDefinitions = newDefinitions;
                 socketManager_1.socketManager.emit(`assets`, 'changed', payload);
+                definitionsManager_1.definitionsManager.clearCache();
             });
         }
         catch (e) {
@@ -179,7 +181,7 @@ class RepositoryManager {
             //TODO: Get dependencies for local asset
             return;
         }
-        const definitions = local_cluster_config_1.default.getDefinitions();
+        const definitions = definitionsManager_1.definitionsManager.getDefinitions();
         const installedAsset = definitions.find((d) => d.definition.metadata.name === fullName && d.version === version);
         if (installedAsset && this._cache[ref] === true) {
             return;
@@ -210,8 +212,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/cjs/src/serviceManager.js

@@ -7,6 +7,7 @@ exports.serviceManager = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const clusterService_1 = require("./clusterService");
 const storageService_1 = require("./storageService");
+const utils_1 = require("./utils/utils");
 const DEFAULT_PORT_TYPE = 'rest';
 class ServiceManager {
     _systems;
@@ -41,6 +42,7 @@ class ServiceManager {
         return `http://${host}:${port}/${path}`;
     }
     _ensureSystem(systemId) {
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         if (!this._systems[systemId]) {
             this._systems[systemId] = {};
         }
@@ -54,6 +56,7 @@ class ServiceManager {
         return system[serviceId];
     }
     async ensureServicePort(systemId, blockInstanceId, portType = DEFAULT_PORT_TYPE) {
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         if (!portType) {
             portType = DEFAULT_PORT_TYPE;
         }
@@ -76,6 +79,7 @@ class ServiceManager {
      *
      */
     getConsumerAddress(systemId, consumerInstanceId, consumerResourceName, portType, environmentType) {
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         const port = clusterService_1.clusterService.getClusterServicePort();
         const path = clusterService_1.clusterService.getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType);
         return this._forLocal(port, path, environmentType);
@@ -89,6 +93,7 @@ class ServiceManager {
      *
      */
     async getProviderAddress(systemId, providerInstanceId, portType) {
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         const port = await this.ensureServicePort(systemId, providerInstanceId, portType);
         return this._forLocal(port);
     }

package/dist/cjs/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/cjs/src/types.js

@@ -1,2 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DesiredInstanceStatus = exports.InstanceStatus = exports.InstanceOwner = exports.InstanceType = void 0;
+var InstanceType;
+(function (InstanceType) {
+    InstanceType["DOCKER"] = "docker";
+    InstanceType["LOCAL"] = "local";
+    InstanceType["UNKNOWN"] = "unknown";
+})(InstanceType || (exports.InstanceType = InstanceType = {}));
+var InstanceOwner;
+(function (InstanceOwner) {
+    InstanceOwner["INTERNAL"] = "internal";
+    InstanceOwner["EXTERNAL"] = "external";
+})(InstanceOwner || (exports.InstanceOwner = InstanceOwner = {}));
+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 || (exports.InstanceStatus = InstanceStatus = {}));
+var DesiredInstanceStatus;
+(function (DesiredInstanceStatus) {
+    DesiredInstanceStatus["STOP"] = "stop";
+    DesiredInstanceStatus["RUN"] = "run";
+    DesiredInstanceStatus["EXTERNAL"] = "external";
+})(DesiredInstanceStatus || (exports.DesiredInstanceStatus = DesiredInstanceStatus = {}));

package/dist/cjs/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/cjs/src/utils/BlockInstanceRunner.js

@@ -12,8 +12,9 @@ const serviceManager_1 = require("../serviceManager");
 const containerManager_1 = require("../containerManager");
 const LogData_1 = require("./LogData");
 const events_1 = __importDefault(require("events"));
-const md5_1 = __importDefault(require("md5"));
 const clusterService_1 = require("../clusterService");
+const types_1 = require("../types");
+const definitionsManager_1 = require("../definitionsManager");
 const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
 const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
@@ -28,7 +29,7 @@ const DOCKER_ENV_VARS = [
     `KAPETA_ENVIRONMENT_TYPE=docker`,
 ];
 function getProvider(uri) {
-    return local_cluster_config_1.default.getProviderDefinitions().find((provider) => {
+    return definitionsManager_1.definitionsManager.getProviderDefinitions().find((provider) => {
         const ref = `${provider.definition.metadata.name}:${provider.version}`;
         return (0, nodejs_utils_1.parseKapetaUri)(ref).id === uri.id;
     });
@@ -42,13 +43,13 @@ function getProviderPorts(assetVersion) {
 }
 class BlockInstanceRunner {
     _systemId;
-    constructor(planReference) {
+    constructor(systemId) {
         /**
          *
          * @type {string}
          * @private
          */
-        this._systemId = planReference ?? '';
+        this._systemId = (0, utils_1.normalizeKapetaUri)(systemId);
     }
     /**
      * Start a block
@@ -76,7 +77,7 @@ class BlockInstanceRunner {
         if (!blockUri.version) {
             blockUri.version = 'local';
         }
-        const assetVersion = local_cluster_config_1.default.getDefinitions().find((definitions) => {
+        const assetVersion = definitionsManager_1.definitionsManager.getDefinitions().find((definitions) => {
             const ref = `${definitions.definition.metadata.name}:${definitions.version}`;
             return (0, nodejs_utils_1.parseKapetaUri)(ref).id === blockUri.id;
         });
@@ -88,28 +89,24 @@ 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
@@ -136,22 +133,24 @@ class BlockInstanceRunner {
         if (!dockerImage) {
             throw new Error(`Missing docker image information: ${JSON.stringify(localContainer)}`);
         }
-        const containerName = `kapeta-block-instance-${blockInstance.id}`;
+        const containerName = (0, utils_1.getBlockInstanceContainerName)(blockInstance.id);
         const logs = new LogData_1.LogData();
         logs.addLog(`Starting block ${blockInstance.ref}`);
-        let container = (await containerManager_1.containerManager.getContainerByName(containerName)) ?? null;
+        let containerInfo = await containerManager_1.containerManager.getContainerByName(containerName);
+        let container = containerInfo?.native;
         console.log('Starting dev container', containerName);
-        if (container) {
-            console.log(`Container already exists. Deleting...`);
+        if (containerInfo) {
+            console.log(`Dev container already exists. Deleting...`);
             try {
-                await container.delete({
+                await containerInfo.remove({
                     force: true,
                 });
             }
             catch (e) {
                 throw new Error('Failed to delete existing container: ' + e.message);
             }
-            container = null;
+            container = undefined;
+            containerInfo = undefined;
         }
         logs.addLog(`Creating new container for block: ${containerName}`);
         console.log('Creating new dev container', containerName, dockerImage);
@@ -184,6 +183,7 @@ class BlockInstanceRunner {
         if (localContainer.healthcheck) {
             HealthCheck = containerManager_1.containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
+        console.log('Starting dev container', containerName, dockerImage);
         container = await containerManager_1.containerManager.startContainer({
             Image: dockerImage,
             name: containerName,
@@ -246,14 +246,14 @@ class BlockInstanceRunner {
             const data = status.data;
             if (deleteOnExit) {
                 try {
-                    await container.delete();
+                    await containerManager_1.containerManager.remove(container);
                 }
                 catch (e) { }
             }
             outputEvents.emit('exit', data?.State?.ExitCode ?? 0);
         });
         return {
-            type: 'docker',
+            type: types_1.InstanceType.DOCKER,
             pid: container.id,
             output: outputEvents,
             stop: async () => {
@@ -263,7 +263,7 @@ class BlockInstanceRunner {
                 try {
                     await localContainer.stop();
                     if (deleteOnExit) {
-                        await localContainer.delete();
+                        await containerManager_1.containerManager.remove(localContainer);
                     }
                 }
                 catch (e) { }
@@ -288,9 +288,10 @@ 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 = (0, utils_1.getBlockInstanceContainerName)(blockInstance.id);
         const logs = new LogData_1.LogData();
-        let container = await containerManager_1.containerManager.getContainerByName(containerName);
+        const containerInfo = await containerManager_1.containerManager.getContainerByName(containerName);
+        let container = containerInfo?.native;
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
         if (container) {
@@ -356,9 +357,10 @@ class BlockInstanceRunner {
         catch (e) {
             console.warn('Failed to pull image. Continuing...', e);
         }
-        const containerName = `kapeta-block-instance-${(0, md5_1.default)(blockInstance.id)}`;
+        const containerName = (0, utils_1.getBlockInstanceContainerName)(blockInstance.id);
         const logs = new LogData_1.LogData();
-        let container = (await containerManager_1.containerManager.getContainerByName(containerName)) ?? null;
+        const containerInfo = await containerManager_1.containerManager.getContainerByName(containerName);
+        let container = containerInfo?.native;
         if (container) {
             const containerData = container.data;
             if (containerData.State === 'running') {
@@ -368,10 +370,10 @@ class BlockInstanceRunner {
                 if (containerData.State?.ExitCode > 0) {
                     logs.addLog(`Container exited with code: ${containerData.State.ExitCode}. Deleting...`);
                     try {
-                        await container.delete();
+                        await containerManager_1.containerManager.remove(container);
                     }
                     catch (e) { }
-                    container = null;
+                    container = undefined;
                 }
                 else {
                     logs.addLog(`Found existing container for block: ${containerName}. Starting now`);
@@ -381,10 +383,10 @@ class BlockInstanceRunner {
                     catch (e) {
                         console.warn('Failed to start container. Deleting...', e);
                         try {
-                            await container.delete();
+                            await containerManager_1.containerManager.remove(container);
                         }
                         catch (e) { }
-                        container = null;
+                        container = undefined;
                     }
                 }
             }

package/dist/cjs/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/cjs/src/utils/utils.js

@@ -3,9 +3,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBindHost = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = void 0;
+exports.getBindHost = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = exports.normalizeKapetaUri = exports.getBlockInstanceContainerName = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const yaml_1 = __importDefault(require("yaml"));
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+function getBlockInstanceContainerName(instanceId) {
+    return `kapeta-block-instance-${instanceId}`;
+}
+exports.getBlockInstanceContainerName = getBlockInstanceContainerName;
+function normalizeKapetaUri(uri) {
+    if (!uri) {
+        return '';
+    }
+    const uriObj = (0, nodejs_utils_1.parseKapetaUri)(uri);
+    if (!uriObj.version) {
+        return `kapeta://${(0, nodejs_utils_1.parseKapetaUri)(uri).fullName}`;
+    }
+    return `kapeta://${(0, nodejs_utils_1.parseKapetaUri)(uri).id}`;
+}
+exports.normalizeKapetaUri = normalizeKapetaUri;
 function readYML(path) {
     const rawYaml = node_fs_1.default.readFileSync(path);
     try {