@kapeta/local-cluster-service 0.20.4 → 0.21.1

package/dist/esm/src/operatorManager.js

@@ -6,13 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.operatorManager = exports.KIND_OPERATOR = void 0;
 const path_1 = __importDefault(require("path"));
 const md5_1 = __importDefault(require("md5"));
-const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 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 nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const lodash_1 = __importDefault(require("lodash"));
 const async_lock_1 = __importDefault(require("async-lock"));
 const taskManager_1 = require("./taskManager");
@@ -69,7 +69,7 @@ class OperatorManager {
      * Get information about a specific consumed resource
      */
     async getConsumerResourceInfo(systemId, fromServiceId, resourceType, portType, name, environment) {
-        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
         const plans = await definitionsManager_1.definitionsManager.getDefinitions(KIND_PLAN);
         const planUri = (0, nodejs_utils_1.parseKapetaUri)(systemId);
         const currentPlan = plans.find((plan) => plan.definition.metadata.name === planUri.fullName && plan.version === planUri.version);
@@ -117,7 +117,7 @@ class OperatorManager {
      * @return {Promise<ContainerInfo>}
      */
     async ensureResource(systemId, resourceType, version) {
-        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
         const key = `${systemId}#${resourceType}:${version}`;
         return await this.operatorLock.acquire(key, async () => {
             const operator = await this.getOperator(resourceType, version);

package/dist/esm/src/repositoryManager.js

@@ -9,7 +9,7 @@ const socketManager_1 = require("./socketManager");
 const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
 const definitionsManager_1 = require("./definitionsManager");
 const taskManager_1 = require("./taskManager");
-const utils_1 = require("./utils/utils");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const progressListener_1 = require("./progressListener");
 const RepositoryWatcher_1 = require("./RepositoryWatcher");
 const cacheManager_1 = require("./cacheManager");
@@ -96,7 +96,7 @@ class RepositoryManager extends node_events_1.EventEmitter {
             if (!ref) {
                 continue;
             }
-            ref = (0, utils_1.normalizeKapetaUri)(ref);
+            ref = (0, nodejs_utils_1.normalizeKapetaUri)(ref);
             if (await definitionsManager_1.definitionsManager.exists(ref)) {
                 continue;
             }

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

@@ -1,4 +1,5 @@
 import { EnvironmentType } from './types';
+export declare const DEFAULT_PORT_TYPE = "rest";
 declare class ServiceManager {
     private _systems;
     constructor();

package/dist/esm/src/serviceManager.js

@@ -3,12 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serviceManager = void 0;
+exports.serviceManager = exports.DEFAULT_PORT_TYPE = 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';
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+exports.DEFAULT_PORT_TYPE = 'rest';
 class ServiceManager {
     _systems;
     constructor() {
@@ -42,7 +42,7 @@ class ServiceManager {
         return `http://${host}:${port}/${path}`;
     }
     _ensureSystem(systemId) {
-        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
         if (!this._systems[systemId]) {
             this._systems[systemId] = {};
         }
@@ -55,10 +55,10 @@ class ServiceManager {
         }
         return system[serviceId];
     }
-    async ensureServicePort(systemId, blockInstanceId, portType = DEFAULT_PORT_TYPE) {
-        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
+    async ensureServicePort(systemId, blockInstanceId, portType = exports.DEFAULT_PORT_TYPE) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
         if (!portType) {
-            portType = DEFAULT_PORT_TYPE;
+            portType = exports.DEFAULT_PORT_TYPE;
         }
         const service = this._ensureService(systemId, blockInstanceId);
         if (!service[portType]) {
@@ -79,7 +79,7 @@ class ServiceManager {
      *
      */
     getConsumerAddress(systemId, consumerInstanceId, consumerResourceName, portType, environmentType) {
-        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
+        systemId = (0, nodejs_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);
@@ -93,7 +93,7 @@ class ServiceManager {
      *
      */
     async getProviderAddress(systemId, providerInstanceId, portType) {
-        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
         const port = await this.ensureServicePort(systemId, providerInstanceId, portType);
         return this._forLocal(port);
     }

package/dist/esm/src/socketManager.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.socketManager = exports.SocketManager = exports.EVENT_LOG = exports.EVENT_SYSTEM_LOG = exports.EVENT_INSTANCE_LOG = exports.EVENT_INSTANCE_EXITED = exports.EVENT_INSTANCE_CREATED = exports.EVENT_STATUS_CHANGED = void 0;
 const lodash_1 = __importDefault(require("lodash"));
-const utils_1 = require("./utils/utils");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const containerManager_1 = require("./containerManager");
 exports.EVENT_STATUS_CHANGED = 'status-changed';
 exports.EVENT_INSTANCE_CREATED = 'instance-created';
@@ -47,7 +47,7 @@ class SocketManager {
         this.io.emit(type, payload);
     }
     emitSystemEvent(systemId, type, payload) {
-        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
         try {
             const contextId = `system-events/${encodeURIComponent(systemId)}`;
             this.emit(contextId, type, payload);
@@ -57,7 +57,7 @@ class SocketManager {
         }
     }
     emitInstanceLog(systemId, instanceId, payload) {
-        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
         try {
             this.emit(`instance-logs/${encodeURIComponent(systemId)}/${encodeURIComponent(instanceId)}`, exports.EVENT_INSTANCE_LOG, payload);
         }

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

@@ -34,12 +34,19 @@ async function getProvider(uri) {
         return (0, nodejs_utils_1.parseKapetaUri)(ref).id === uri.id;
     });
 }
-function getProviderPorts(assetVersion) {
-    return (assetVersion.definition?.spec?.providers
+function getProviderPorts(assetVersion, providerVersion) {
+    const out = assetVersion.definition?.spec?.providers
         ?.map((provider) => {
         return provider.spec?.port?.type;
     })
-        .filter((t) => !!t) ?? []);
+        .filter((t) => !!t) ?? [];
+    if (out.length === 0) {
+        if (providerVersion.definition.spec?.defaultPort?.type) {
+            return [providerVersion.definition.spec?.defaultPort?.type];
+        }
+        return [serviceManager_1.DEFAULT_PORT_TYPE];
+    }
+    return out;
 }
 class BlockInstanceRunner {
     _systemId;
@@ -49,7 +56,7 @@ class BlockInstanceRunner {
          * @type {string}
          * @private
          */
-        this._systemId = (0, utils_1.normalizeKapetaUri)(systemId);
+        this._systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
     }
     /**
      * Start a block
@@ -92,7 +99,7 @@ class BlockInstanceRunner {
         }
         else {
             //We need a port type to know how to connect to the block consistently
-            const portTypes = getProviderPorts(assetVersion);
+            const portTypes = getProviderPorts(assetVersion, providerVersion);
             if (blockUri.version === 'local') {
                 processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
             }
@@ -117,14 +124,19 @@ class BlockInstanceRunner {
         if (!assetVersion.definition.spec?.target?.kind) {
             throw new Error('Missing target kind in block definition');
         }
-        const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.spec?.target?.kind);
-        const targetVersion = await getProvider(kindUri);
+        const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.kind);
+        const providerVersion = await getProvider(kindUri);
+        if (!providerVersion) {
+            throw new Error(`Block type not found: ${kindUri.id}`);
+        }
+        const targetKindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.spec?.target?.kind);
+        const targetVersion = await getProvider(targetKindUri);
         if (!targetVersion) {
-            throw new Error(`Target not found: ${kindUri.id}`);
+            throw new Error(`Target not found: ${targetKindUri.id}`);
         }
         const localContainer = targetVersion.definition.spec.local;
         if (!localContainer) {
-            throw new Error(`Missing local container information from target: ${kindUri.id}`);
+            throw new Error(`Missing local container information from target: ${targetKindUri.id}`);
         }
         const dockerImage = localContainer.image;
         if (!dockerImage) {
@@ -141,11 +153,15 @@ class BlockInstanceRunner {
         delete localContainer.HostConfig;
         delete localContainer.Labels;
         delete localContainer.Env;
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion, providerVersion);
         let HealthCheck = undefined;
         if (localContainer.healthcheck) {
             HealthCheck = containerManager_1.containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
+        const realLocalPath = node_fs_1.default.realpathSync(baseDir);
+        const Mounts = containerManager_1.containerManager.toDockerMounts({
+            [workingDir]: (0, containerManager_1.toLocalBindVolume)(realLocalPath)
+        });
         const systemUri = (0, nodejs_utils_1.parseKapetaUri)(this._systemId);
         return this.ensureContainer({
             ...dockerOpts,
@@ -173,10 +189,10 @@ class BlockInstanceRunner {
             HostConfig: {
                 ...customHostConfigs,
                 Binds: [
-                    `${(0, containerManager_1.toLocalBindVolume)(local_cluster_config_1.default.getKapetaBasedir())}:${homeDir}/.kapeta`,
-                    `${(0, containerManager_1.toLocalBindVolume)(baseDir)}:${workingDir}`,
+                    `${(0, containerManager_1.toLocalBindVolume)(local_cluster_config_1.default.getKapetaBasedir())}:${homeDir}/.kapeta`
                 ],
                 PortBindings,
+                Mounts
             },
         });
     }
@@ -194,7 +210,12 @@ class BlockInstanceRunner {
         if (!dockerImage) {
             throw new Error(`Missing docker image information: ${JSON.stringify(versionInfo?.artifact?.details)}`);
         }
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion);
+        const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.kind);
+        const providerVersion = await getProvider(kindUri);
+        if (!providerVersion) {
+            throw new Error(`Block type not found: ${kindUri.id}`);
+        }
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion, providerVersion);
         const containerName = (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id);
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
@@ -252,7 +273,8 @@ class BlockInstanceRunner {
         const PortBindings = {};
         let HealthCheck = undefined;
         let Mounts = [];
-        const promises = Object.entries(spec.local.ports).map(async ([portType, value]) => {
+        const localPorts = spec.local.ports;
+        const promises = Object.entries(localPorts).map(async ([portType, value]) => {
             const dockerPort = `${value.port}/${value.type}`;
             ExposedPorts[dockerPort] = {};
             addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = value.port;
@@ -315,12 +337,12 @@ class BlockInstanceRunner {
         }
         return out;
     }
-    async getDockerPortBindings(blockInstance, assetVersion) {
+    async getDockerPortBindings(blockInstance, assetVersion, providerVersion) {
         const bindHost = (0, utils_1.getBindHost)();
         const ExposedPorts = {};
         const addonEnv = {};
         const PortBindings = {};
-        const portTypes = getProviderPorts(assetVersion);
+        const portTypes = getProviderPorts(assetVersion, providerVersion);
         let port = 80;
         const promises = portTypes.map(async (portType) => {
             const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);

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

@@ -1,7 +1,6 @@
 import { EntityList } from '@kapeta/schemas';
 import { AnyMap } from '../types';
 export declare function getBlockInstanceContainerName(systemId: string, 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

@@ -3,27 +3,15 @@ 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.normalizeKapetaUri = exports.getBlockInstanceContainerName = void 0;
+exports.getResolvedConfiguration = exports.getBindHost = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = 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");
 const md5_1 = __importDefault(require("md5"));
 const lodash_1 = __importDefault(require("lodash"));
 function getBlockInstanceContainerName(systemId, instanceId) {
     return `kapeta-block-instance-${(0, md5_1.default)(systemId + 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 {

package/dist/esm/test/proxy/types/rest.test.js

@@ -4,42 +4,41 @@ const rest_1 = require("../../../src/proxy/types/rest");
 describe('getRestMethodId', () => {
     it('should match @Query in url', () => {
         const restResource = new TestResource();
-        const restMethodId = (0, rest_1.getRestMethodId)(restResource, "POST", "/names?name=Ib");
+        const restMethodId = (0, rest_1.getRestMethodId)(restResource, 'POST', '/names?name=Ib');
         expect(restMethodId).toBeDefined();
     });
 });
 class TestResource {
-    kind = "";
+    kind = '';
     metadata = new TestResourceMetaData();
     get spec() {
         return {
             methods: [
                 {
                     responseType: {
-                        ref: "Name[]"
+                        ref: 'Name[]',
                     },
-                    method: "GET",
-                    path: "/names",
-                    arguments: {}
+                    method: 'GET',
+                    path: '/names',
+                    arguments: {},
                 },
                 {
                     responseType: {
-                        ref: "Name"
+                        ref: 'Name',
                     },
-                    method: "POST",
-                    path: "/names",
+                    method: 'POST',
+                    path: '/names',
                     arguments: {
                         name: {
-                            type: "string",
-                            transport: "QUERY"
-                        }
-                    }
-                }
-            ]
+                            type: 'string',
+                            transport: 'QUERY',
+                        },
+                    },
+                },
+            ],
         };
     }
-    ;
 }
 class TestResourceMetaData {
-    name = "";
+    name = '';
 }

package/package.json

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

package/src/assetManager.ts

@@ -4,12 +4,11 @@ import YAML from 'yaml';
 import { Definition, DefinitionInfo } from '@kapeta/local-cluster-config';
 import { codeGeneratorManager } from './codeGeneratorManager';
 import { ProgressListener } from './progressListener';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
+import { normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { repositoryManager } from './repositoryManager';
 import { BlockDefinition, BlockInstance, Plan } from '@kapeta/schemas';
 import { Actions } from '@kapeta/nodejs-registry-utils';
 import { definitionsManager } from './definitionsManager';
-import { normalizeKapetaUri } from './utils/utils';
 import { taskManager } from './taskManager';
 import { SourceOfChange } from './types';
 import { cacheManager } from './cacheManager';

package/src/clusterService.ts

@@ -1,4 +1,4 @@
-import { normalizeKapetaUri } from './utils/utils';
+import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
 
 const net = require('net');
 const DEFAULT_SERVER_PORT = 35100;

package/src/codeGeneratorManager.ts

@@ -4,7 +4,7 @@ import { BlockDefinition } from '@kapeta/schemas';
 import { definitionsManager } from './definitionsManager';
 import { Definition } from '@kapeta/local-cluster-config';
 import { assetManager } from './assetManager';
-import { normalizeKapetaUri } from './utils/utils';
+import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
 import { repositoryManager } from './repositoryManager';
 
 const TARGET_KIND = 'core/language-target';

package/src/config/routes.ts

@@ -8,8 +8,6 @@ import { kapetaHeaders, KapetaRequest } from '../middleware/kapeta';
 import { stringBody } from '../middleware/stringBody';
 import { AnyMap, KapetaBodyRequest } from '../types';
 import { Response } from 'express';
-import { getResolvedConfiguration, normalizeKapetaUri } from '../utils/utils';
-import { assetManager } from '../assetManager';
 
 const router = Router();
 
@@ -122,10 +120,23 @@ router.get('/identity', async (req: KapetaRequest, res) => {
  * already called the endpoint the same port is returned.
  */
 router.get('/provides/:type', async (req: KapetaRequest, res) => {
-    //Get service port
-    res.send(
-        '' + (await serviceManager.ensureServicePort(req.kapeta!.systemId, req.kapeta!.instanceId, req.params.type))
-    );
+    if (req.kapeta!.environment === 'docker' && ['web', 'rest'].includes(req.params.type)) {
+        // Happens when starting a local container with no providers.
+        res.send('80');
+        return;
+    }
+
+    try {
+        const port = await serviceManager.ensureServicePort(
+            req.kapeta!.systemId,
+            req.kapeta!.instanceId,
+            req.params.type
+        );
+        res.send('' + port);
+    } catch (err: any) {
+        console.warn('Failed to resolve service port: ' + req.params.type, err);
+        res.status(400).send({ error: err.message });
+    }
 });
 
 /**

package/src/configManager.ts

@@ -2,8 +2,8 @@ import { EnrichedAsset } from './assetManager';
 import { BlockInstance } from '@kapeta/schemas';
 import { storageService } from './storageService';
 import { assetManager } from './assetManager';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import { getResolvedConfiguration, normalizeKapetaUri } from './utils/utils';
+import { normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
+import { getResolvedConfiguration } from './utils/utils';
 
 export const SYSTEM_ID = '$plan';
 type AnyMap = { [key: string]: any };

package/src/definitionsManager.ts

@@ -1,10 +1,9 @@
 import ClusterConfiguration, { DefinitionInfo } from '@kapeta/local-cluster-config';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
+import { parseKapetaUri, normalizeKapetaUri } from '@kapeta/nodejs-utils';
 import { cacheManager, doCached } from './cacheManager';
 import { KapetaAPI } from '@kapeta/nodejs-api-client';
 import { Plan } from '@kapeta/schemas';
 import FS from 'fs-extra';
-import { normalizeKapetaUri } from './utils/utils';
 import YAML from 'yaml';
 import { Actions } from '@kapeta/nodejs-registry-utils';
 import { ProgressListener } from './progressListener';

package/src/instanceManager.ts

@@ -3,7 +3,7 @@ import request from 'request';
 import AsyncLock from 'async-lock';
 import { BlockInstanceRunner } from './utils/BlockInstanceRunner';
 import { storageService } from './storageService';
-import { EVENT_INSTANCE_CREATED, EVENT_INSTANCE_EXITED, EVENT_STATUS_CHANGED, socketManager } from './socketManager';
+import { EVENT_INSTANCE_CREATED, EVENT_STATUS_CHANGED, socketManager } from './socketManager';
 import { serviceManager } from './serviceManager';
 import { assetManager } from './assetManager';
 import {
@@ -15,9 +15,9 @@ import {
 import { configManager } from './configManager';
 import { DesiredInstanceStatus, InstanceInfo, InstanceOwner, InstanceStatus, InstanceType, LogEntry } from './types';
 import { BlockDefinitionSpec, BlockInstance, Plan } from '@kapeta/schemas';
-import { getBlockInstanceContainerName, getResolvedConfiguration, normalizeKapetaUri } from './utils/utils';
+import { getBlockInstanceContainerName, getResolvedConfiguration } from './utils/utils';
 import { KIND_OPERATOR, operatorManager } from './operatorManager';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
+import { normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { definitionsManager } from './definitionsManager';
 import { Task, taskManager } from './taskManager';
 
@@ -222,10 +222,15 @@ export class InstanceManager {
                 if (info.type) {
                     instance.type = info.type;
                 }
+
                 if (healthUrl) {
                     instance.health = healthUrl;
                 }
 
+                if (info.portType) {
+                    instance.portType = info.portType;
+                }
+
                 socketManager.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
             } else {
                 //If instance was not found - then we're receiving an externally started instance

package/src/middleware/kapeta.ts

@@ -1,7 +1,6 @@
 import { NextFunction, Request, Response } from 'express';
 import { EnvironmentType } from '../types';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import { normalizeKapetaUri } from '../utils/utils';
+import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
 
 export interface KapetaRequest extends Request {
     kapeta?: {

package/src/networkManager.ts

@@ -1,7 +1,7 @@
 import { Connection } from '@kapeta/schemas';
 import uuid from 'node-uuid';
 import { SimpleRequest, SimpleResponse } from './types';
-import { normalizeKapetaUri } from './utils/utils';
+import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
 
 class NetworkManager {
     private _connections: { [systemId: string]: { [connectionId: string]: Traffic[] } };

package/src/operatorManager.ts

@@ -1,7 +1,6 @@
-import ClusterConfiguration, { DefinitionInfo } from '@kapeta/local-cluster-config';
+import { DefinitionInfo } from '@kapeta/local-cluster-config';
 import Path from 'path';
 import md5 from 'md5';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import { serviceManager } from './serviceManager';
 import { storageService } from './storageService';
 import {
@@ -15,7 +14,8 @@ import FSExtra from 'fs-extra';
 import { AnyMap, EnvironmentType, OperatorInfo, StringMap } from './types';
 import { BlockInstance, Resource } from '@kapeta/schemas';
 import { definitionsManager } from './definitionsManager';
-import { getBindHost, normalizeKapetaUri } from './utils/utils';
+import { getBindHost } from './utils/utils';
+import { parseKapetaUri, normalizeKapetaUri } from '@kapeta/nodejs-utils';
 import _ from 'lodash';
 import AsyncLock from 'async-lock';
 import { taskManager } from './taskManager';

package/src/repositoryManager.ts

@@ -4,7 +4,7 @@ import { Dependency } from '@kapeta/schemas';
 import { Actions, Config, RegistryService } from '@kapeta/nodejs-registry-utils';
 import { definitionsManager } from './definitionsManager';
 import { Task, taskManager } from './taskManager';
-import { normalizeKapetaUri } from './utils/utils';
+import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
 import { ProgressListener } from './progressListener';
 import { RepositoryWatcher } from './RepositoryWatcher';
 import { SourceOfChange } from './types';

package/src/serviceManager.ts

@@ -2,9 +2,9 @@ import _ from 'lodash';
 import { clusterService } from './clusterService';
 import { storageService } from './storageService';
 import { EnvironmentType } from './types';
-import { normalizeKapetaUri } from './utils/utils';
+import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
 
-const DEFAULT_PORT_TYPE = 'rest';
+export const DEFAULT_PORT_TYPE = 'rest';
 
 class ServiceManager {
     private _systems: any;

package/src/socketManager.ts

@@ -1,6 +1,6 @@
 import _ from 'lodash';
 import { Socket, Server } from 'socket.io';
-import { normalizeKapetaUri } from './utils/utils';
+import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
 import { LogEntry } from './types';
 import { containerManager } from './containerManager';
 export const EVENT_STATUS_CHANGED = 'status-changed';