@kapeta/local-cluster-service 0.17.0 → 0.19.0

package/dist/esm/src/definitionsManager.js

@@ -3,36 +3,120 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.definitionsManager = void 0;
+exports.definitionsManager = exports.SAMPLE_PLAN_NAME = void 0;
 const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const cacheManager_1 = require("./cacheManager");
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const utils_1 = require("./utils/utils");
+const yaml_1 = __importDefault(require("yaml"));
+const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
+const progressListener_1 = require("./progressListener");
+const path_1 = __importDefault(require("path"));
+exports.SAMPLE_PLAN_NAME = 'kapeta/sample-nodejs-plan';
+function applyHandleChange(definition, targetHandle) {
+    const originalUri = (0, nodejs_utils_1.parseKapetaUri)(definition.definition.metadata.name);
+    definition.definition.metadata.name = `${targetHandle}/${originalUri.name}`;
+    return definition;
+}
+function normalizeFilters(kindFilter) {
+    let resolvedFilters = [];
+    if (kindFilter) {
+        if (Array.isArray(kindFilter)) {
+            resolvedFilters = [...kindFilter];
+        }
+        else {
+            resolvedFilters = [kindFilter];
+        }
+    }
+    return resolvedFilters.map((k) => k.toLowerCase());
+}
 class DefinitionsManager {
-    getHash(kindFilter) {
-        if (kindFilter) {
-            if (Array.isArray(kindFilter)) {
-                return kindFilter.join(',');
+    async resolveDefinitionsAndSamples() {
+        const definitions = local_cluster_config_1.default.getDefinitions();
+        const samplePlan = definitions.find((d) => d.version === 'local' && d.definition.metadata.name === exports.SAMPLE_PLAN_NAME);
+        if (!samplePlan) {
+            return definitions;
+        }
+        // We will only rewrite the sample plan once since we change the handle to be the users handle
+        const api = new nodejs_api_client_1.KapetaAPI();
+        if (!api.hasToken()) {
+            // Not logged in yet, so we can't rewrite the sample plan
+            return definitions;
+        }
+        const profile = await api.getCurrentIdentity();
+        if (!profile) {
+            // Not logged in yet, so we can't rewrite the sample plan
+            return definitions;
+        }
+        console.log('Rewriting sample plan to use handle %s', profile.handle);
+        applyHandleChange(samplePlan, profile.handle);
+        const planDef = samplePlan.definition;
+        const blockRefs = new Set();
+        planDef.spec.blocks.forEach((b) => {
+            const blockUri = (0, nodejs_utils_1.parseKapetaUri)(b.block.ref);
+            if (blockUri.version === 'local') {
+                blockRefs.add(blockUri.id);
+                b.block.ref = (0, utils_1.normalizeKapetaUri)(`${profile.handle}/${blockUri.name}:local`);
             }
-            return kindFilter;
+        });
+        // Rewrite all blocks that are referenced by the sample plan
+        const rewrittenBlocks = Array.from(blockRefs)
+            .map((ref) => definitions.find((d) => (0, utils_1.normalizeKapetaUri)(d.definition.metadata.name + ':' + d.version) === (0, utils_1.normalizeKapetaUri)(ref)))
+            .filter((d) => d !== undefined)
+            .map((d) => applyHandleChange(d, profile.handle));
+        // Persist the rewritten assets
+        const progressListener = new progressListener_1.ProgressListener();
+        const rewrittenAssets = [samplePlan, ...rewrittenBlocks];
+        const originalRefs = [`${exports.SAMPLE_PLAN_NAME}:local`, ...Array.from(blockRefs)];
+        // Store the original paths on the assets - we'll need them later
+        for (const asset of rewrittenAssets) {
+            asset.path = await fs_extra_1.default.readlink(asset.path);
+            asset.ymlPath = path_1.default.join(asset.path, path_1.default.basename(asset.ymlPath));
+        }
+        // Uninstall the original assets
+        // This removes the symlinks
+        console.log('Uninstalling original assets', originalRefs);
+        try {
+            await nodejs_registry_utils_1.Actions.uninstall(progressListener, originalRefs);
+        }
+        catch (err) {
+            console.warn('Failed to uninstall original assets', err);
         }
-        return 'none';
+        for (const asset of rewrittenAssets) {
+            console.log('Updating %s ', asset.ymlPath);
+            await fs_extra_1.default.writeFile(asset.ymlPath, yaml_1.default.stringify(asset.definition));
+            console.log('Linking %s ', asset.path);
+            await nodejs_registry_utils_1.Actions.link(progressListener, asset.path);
+        }
+        console.log('Rewrite done for sample plan');
+        // Return the rewritten definitions
+        return local_cluster_config_1.default.getDefinitions();
     }
-    getFullKey(kindFilter) {
-        return `definitionsManager:${this.getHash(kindFilter)}`;
+    applyFilters(definitions, kindFilter) {
+        if (kindFilter.length === 0) {
+            return definitions;
+        }
+        return definitions.filter((d) => {
+            return kindFilter.includes(d.definition.kind.toLowerCase());
+        });
     }
-    getDefinitions(kindFilter) {
-        const key = this.getFullKey(kindFilter);
-        return (0, cacheManager_1.doCached)(key, () => local_cluster_config_1.default.getDefinitions(kindFilter));
+    async getDefinitions(kindFilter) {
+        kindFilter = normalizeFilters(kindFilter);
+        const definitions = await (0, cacheManager_1.doCached)('definitionsManager:all', () => this.resolveDefinitionsAndSamples());
+        return this.applyFilters(definitions, kindFilter);
     }
-    exists(ref) {
-        return !!this.getDefinition(ref);
+    async exists(ref) {
+        return !!(await this.getDefinition(ref));
     }
-    getProviderDefinitions() {
-        return (0, cacheManager_1.doCached)('providers', () => local_cluster_config_1.default.getProviderDefinitions());
+    async getProviderDefinitions() {
+        return (0, cacheManager_1.doCached)('definitionsManager:providers', () => local_cluster_config_1.default.getProviderDefinitions());
     }
-    getDefinition(ref) {
+    async getDefinition(ref) {
         const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
-        return this.getDefinitions().find((d) => {
+        const definitions = await this.getDefinitions();
+        return definitions.find((d) => {
             if (!uri.version) {
                 return d.definition.metadata.name === uri.fullName;
             }

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

@@ -7,7 +7,7 @@ export declare class InstanceManager {
     constructor();
     private checkInstancesLater;
     getInstances(): InstanceInfo[];
-    getInstancesForPlan(systemId: string): InstanceInfo[];
+    getInstancesForPlan(systemId: string): Promise<InstanceInfo[]>;
     getInstance(systemId: string, instanceId: string): InstanceInfo | undefined;
     private exclusive;
     getLogs(systemId: string, instanceId: string): Promise<LogEntry[]>;

package/dist/esm/src/instanceManager.js

@@ -47,12 +47,12 @@ class InstanceManager {
         }
         return [...this._instances];
     }
-    getInstancesForPlan(systemId) {
+    async getInstancesForPlan(systemId) {
         if (!this._instances) {
             return [];
         }
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
-        const planInfo = definitionsManager_1.definitionsManager.getDefinition(systemId);
+        const planInfo = await definitionsManager_1.definitionsManager.getDefinition(systemId);
         if (!planInfo) {
             return [];
         }
@@ -362,9 +362,9 @@ class InstanceManager {
             await this.saveInternalInstance(instance);
             const blockSpec = blockAsset.data.spec;
             if (blockSpec.consumers) {
-                const promises = blockSpec.consumers.map((consumer) => {
+                const promises = blockSpec.consumers.map(async (consumer) => {
                     const consumerUri = (0, nodejs_utils_1.parseKapetaUri)(consumer.kind);
-                    const asset = definitionsManager_1.definitionsManager.getDefinition(consumer.kind);
+                    const asset = await definitionsManager_1.definitionsManager.getDefinition(consumer.kind);
                     if (!asset) {
                         // Definition not found
                         return Promise.resolve();
@@ -422,11 +422,6 @@ class InstanceManager {
                         errorMessage: e.message ?? 'Failed to start - Check logs for details.',
                     });
                     socketManager_1.socketManager.emitInstanceLog(systemId, instanceId, logs[0]);
-                    socketManager_1.socketManager.emitInstanceEvent(systemId, blockInstance.id, socketManager_1.EVENT_INSTANCE_EXITED, {
-                        error: `Failed to start instance: ${e.message}`,
-                        status: socketManager_1.EVENT_INSTANCE_EXITED,
-                        instanceId: blockInstance.id,
-                    });
                     return out;
                 }
             }, {
@@ -486,6 +481,7 @@ class InstanceManager {
                     try {
                         const plan = await assetManager_1.assetManager.getAsset(instance.systemId, true, false);
                         if (!plan) {
+                            console.log('Plan not found - reset to stop', instance.ref, instance.systemId);
                             instance.desiredStatus = types_1.DesiredInstanceStatus.STOP;
                             changed = true;
                             return;
@@ -493,12 +489,14 @@ class InstanceManager {
                         const planData = plan.data;
                         const planInstance = planData?.spec?.blocks?.find((b) => b.id === instance.instanceId);
                         if (!planInstance || !planInstance?.block?.ref) {
+                            console.log('Plan instance not found - reset to stop', instance.ref, instance.systemId);
                             instance.desiredStatus = types_1.DesiredInstanceStatus.STOP;
                             changed = true;
                             return;
                         }
                         const blockDef = await assetManager_1.assetManager.getAsset(instance.ref, true, false);
                         if (!blockDef) {
+                            console.log('Block definition not found - reset to stop', instance.ref, instance.systemId);
                             instance.desiredStatus = types_1.DesiredInstanceStatus.STOP;
                             changed = true;
                             return;
@@ -676,6 +674,3 @@ class InstanceManager {
 }
 exports.InstanceManager = InstanceManager;
 exports.instanceManager = new InstanceManager();
-process.on('exit', async () => {
-    await exports.instanceManager.stopAll();
-});

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

@@ -23,8 +23,8 @@ router.get('/', (req, res) => {
 /**
  * Get all instances
  */
-router.get('/:systemId/instances', (req, res) => {
-    res.send(instanceManager_1.instanceManager.getInstancesForPlan(req.params.systemId));
+router.get('/:systemId/instances', async (req, res) => {
+    res.send(await instanceManager_1.instanceManager.getInstancesForPlan(req.params.systemId));
 });
 /**
  * Get single instance in a plan

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

@@ -21,7 +21,7 @@ declare class OperatorManager {
      * @param {string} version
      * @return {Operator}
      */
-    getOperator(resourceType: string, version: string): Operator;
+    getOperator(resourceType: string, version: string): Promise<Operator>;
     /**
      * Get information about a specific consumed resource
      */

package/dist/esm/src/operatorManager.js

@@ -17,6 +17,7 @@ const lodash_1 = __importDefault(require("lodash"));
 const async_lock_1 = __importDefault(require("async-lock"));
 const taskManager_1 = require("./taskManager");
 exports.KIND_OPERATOR = 'core/resource-type-operator';
+const KIND_PLAN = 'core/plan';
 class Operator {
     _data;
     constructor(data) {
@@ -49,8 +50,8 @@ class OperatorManager {
      * @param {string} version
      * @return {Operator}
      */
-    getOperator(resourceType, version) {
-        const operators = definitionsManager_1.definitionsManager.getDefinitions(exports.KIND_OPERATOR);
+    async getOperator(resourceType, version) {
+        const operators = await definitionsManager_1.definitionsManager.getDefinitions(exports.KIND_OPERATOR);
         const operator = operators.find((operator) => operator.definition &&
             operator.definition.metadata &&
             operator.definition.metadata.name &&
@@ -69,7 +70,7 @@ class OperatorManager {
      */
     async getConsumerResourceInfo(systemId, fromServiceId, resourceType, portType, name, environment) {
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
-        const plans = definitionsManager_1.definitionsManager.getDefinitions('core/plan');
+        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);
         if (!currentPlan) {
@@ -79,10 +80,7 @@ class OperatorManager {
         if (!currentInstance) {
             throw new Error(`Unknown instance: ${fromServiceId} in plan ${systemId}`);
         }
-        const blockUri = (0, nodejs_utils_1.parseKapetaUri)(currentInstance.block.ref);
-        const blockDefinition = definitionsManager_1.definitionsManager
-            .getDefinitions()
-            .find((definition) => definition.version === blockUri.version && definition.definition.metadata.name === blockUri.fullName);
+        const blockDefinition = await definitionsManager_1.definitionsManager.getDefinition(currentInstance.block.ref);
         if (!blockDefinition) {
             throw new Error(`Unknown block: ${currentInstance.block.ref} in plan ${systemId}`);
         }
@@ -91,7 +89,7 @@ class OperatorManager {
             throw new Error(`Unknown resource: ${name} in block ${currentInstance.block.ref} in plan ${systemId}`);
         }
         const kindUri = (0, nodejs_utils_1.parseKapetaUri)(blockResource.kind);
-        const operator = this.getOperator(resourceType, kindUri.version);
+        const operator = await this.getOperator(resourceType, kindUri.version);
         const credentials = operator.getCredentials();
         const container = await this.ensureResource(systemId, resourceType, kindUri.version);
         const portInfo = await container.getPort(portType);
@@ -122,7 +120,7 @@ class OperatorManager {
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         const key = `${systemId}#${resourceType}:${version}`;
         return await this.operatorLock.acquire(key, async () => {
-            const operator = this.getOperator(resourceType, version);
+            const operator = await this.getOperator(resourceType, version);
             const operatorData = operator.getLocalData();
             const portTypes = Object.keys(operatorData.ports);
             portTypes.sort();

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

@@ -1,5 +1,6 @@
+import { DefinitionInfo } from '@kapeta/local-cluster-config';
 declare class ProviderManager {
-    getWebProviders(): import("@kapeta/local-cluster-config").DefinitionInfo[];
+    getWebProviders(): Promise<DefinitionInfo[]>;
     getProviderWebJS(handle: string, name: string, version: string, sourceMap?: boolean): Promise<unknown>;
 }
 export declare const providerManager: ProviderManager;

package/dist/esm/src/providerManager.js

@@ -11,8 +11,9 @@ const cacheManager_1 = require("./cacheManager");
 const request_1 = __importDefault(require("request"));
 const PROVIDER_FILE_BASE = 'https://providers.kapeta.com/files';
 class ProviderManager {
-    getWebProviders() {
-        return definitionsManager_1.definitionsManager.getProviderDefinitions().filter((providerDefinition) => providerDefinition.hasWeb);
+    async getWebProviders() {
+        const providers = await definitionsManager_1.definitionsManager.getProviderDefinitions();
+        return providers.filter((providerDefinition) => providerDefinition.hasWeb);
     }
     async getProviderWebJS(handle, name, version, sourceMap = false) {
         const fullName = `${handle}/${name}`;
@@ -22,7 +23,8 @@ class ProviderManager {
         if (file && (await fs_extra_1.default.pathExists(file))) {
             return fs_extra_1.default.readFile(file, 'utf8');
         }
-        const installedProvider = this.getWebProviders().find((providerDefinition) => {
+        const providers = await this.getWebProviders();
+        const installedProvider = providers.find((providerDefinition) => {
             return providerDefinition.definition.metadata.name === fullName && providerDefinition.version === version;
         });
         if (installedProvider) {
@@ -57,16 +59,22 @@ class ProviderManager {
         });
     }
 }
-const providerDefinitions = definitionsManager_1.definitionsManager.getProviderDefinitions();
-if (providerDefinitions.length > 0) {
-    console.log('## Loaded the following providers ##');
-    providerDefinitions.forEach((providerDefinition) => {
-        console.log(' - %s[%s:%s]', providerDefinition.definition.kind, providerDefinition.definition.metadata.name, providerDefinition.version);
-        console.log('   from %s', providerDefinition.path);
-    });
-    console.log('##');
-}
-else {
-    console.log('## No providers found ##');
-}
+definitionsManager_1.definitionsManager
+    .getProviderDefinitions()
+    .then((providerDefinitions) => {
+    if (providerDefinitions.length > 0) {
+        console.log('## Loaded the following providers ##');
+        providerDefinitions.forEach((providerDefinition) => {
+            console.log(' - %s[%s:%s]', providerDefinition.definition.kind, providerDefinition.definition.metadata.name, providerDefinition.version);
+            console.log('   from %s', providerDefinition.path);
+        });
+        console.log('##');
+    }
+    else {
+        console.log('## No providers found ##');
+    }
+})
+    .catch((e) => {
+    console.error('Failed to load providers', e);
+});
 exports.providerManager = new ProviderManager();

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

@@ -12,8 +12,8 @@ declare class RepositoryManager {
      */
     setSourceOfChangeFor(file: string, source: SourceOfChange): Promise<void>;
     clearSourceOfChangeFor(file: string): Promise<void>;
-    ensureDefaultProviders(): void;
-    private _install;
+    ensureDefaultProviders(): Promise<void>;
+    private scheduleInstallation;
     ensureAsset(handle: string, name: string, version: string, wait?: boolean): Promise<undefined | Task[]>;
 }
 export declare const repositoryManager: RepositoryManager;

package/dist/esm/src/repositoryManager.js

@@ -53,18 +53,18 @@ class RepositoryManager {
     clearSourceOfChangeFor(file) {
         return this.watcher.clearSourceOfChangeFor(file);
     }
-    ensureDefaultProviders() {
+    async ensureDefaultProviders() {
         socketManager_1.socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_START, { providers: DEFAULT_PROVIDERS });
-        const tasks = this._install(DEFAULT_PROVIDERS);
+        const tasks = await this.scheduleInstallation(DEFAULT_PROVIDERS);
         Promise.allSettled(tasks.map((t) => t.wait())).then(() => {
             socketManager_1.socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_END, {});
         });
     }
-    _install(refs) {
+    async scheduleInstallation(refs) {
         //We make sure to only install one asset at a time - otherwise unexpected things might happen
         const createInstaller = (ref) => {
             return async () => {
-                if (definitionsManager_1.definitionsManager.exists(ref)) {
+                if (await definitionsManager_1.definitionsManager.exists(ref)) {
                     return;
                 }
                 //console.log(`Installing asset: ${ref}`);
@@ -89,7 +89,7 @@ class RepositoryManager {
                 continue;
             }
             ref = (0, utils_1.normalizeKapetaUri)(ref);
-            if (definitionsManager_1.definitionsManager.exists(ref)) {
+            if (await definitionsManager_1.definitionsManager.exists(ref)) {
                 continue;
             }
             const task = taskManager_1.taskManager.add(`asset:install:${ref}`, createInstaller(ref), {
@@ -107,8 +107,7 @@ class RepositoryManager {
             //TODO: Get dependencies for local asset
             return;
         }
-        const definitions = definitionsManager_1.definitionsManager.getDefinitions();
-        const installedAsset = definitions.find((d) => d.definition.metadata.name === fullName && d.version === version);
+        const installedAsset = await definitionsManager_1.definitionsManager.getDefinition(`${fullName}:${version}`);
         let assetVersion;
         try {
             assetVersion = await this._registryService.getVersion(fullName, version);
@@ -125,13 +124,13 @@ class RepositoryManager {
         }
         let tasks = undefined;
         if (!installedAsset) {
-            tasks = this._install([ref]);
+            tasks = await this.scheduleInstallation([ref]);
         }
         else {
             //Ensure dependencies are installed
             const refs = assetVersion.dependencies.map((dep) => dep.name);
             if (refs.length > 0) {
-                tasks = this._install(refs);
+                tasks = await this.scheduleInstallation(refs);
             }
         }
         if (tasks && wait) {

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

@@ -19,10 +19,10 @@ export declare class SocketManager {
     emitInstanceLog(systemId: string, instanceId: string, payload: LogEntry): void;
     emitSystemLog(systemId: string, payload: LogEntry): void;
     emitGlobalLog(payload: LogEntry): void;
-    emitInstanceEvent(systemId: string, instanceId: string, type: string, payload: any): void;
     private _bindIO;
     private _handleSocketCreated;
     private _bindSocket;
-    private _handleSocketDestroyed;
+    private handleJoinRoom;
+    private handleLeaveRoom;
 }
 export declare const socketManager: SocketManager;

package/dist/esm/src/socketManager.js

@@ -6,6 +6,7 @@ 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 containerManager_1 = require("./containerManager");
 exports.EVENT_STATUS_CHANGED = 'status-changed';
 exports.EVENT_INSTANCE_CREATED = 'instance-created';
 exports.EVENT_INSTANCE_EXITED = 'instance-exited';
@@ -48,30 +49,28 @@ class SocketManager {
     emitSystemEvent(systemId, type, payload) {
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         try {
-            exports.socketManager.emit(`${systemId}/instances`, type, payload);
+            const contextId = `system-events/${encodeURIComponent(systemId)}`;
+            this.emit(contextId, type, payload);
         }
         catch (e) {
             console.warn('Failed to emit instance event: %s', e.message);
         }
     }
     emitInstanceLog(systemId, instanceId, payload) {
-        this.emitInstanceEvent(systemId, instanceId, exports.EVENT_INSTANCE_LOG, payload);
-    }
-    emitSystemLog(systemId, payload) {
-        this.emitSystemEvent(systemId, exports.EVENT_SYSTEM_LOG, payload);
-    }
-    emitGlobalLog(payload) {
-        this.emitGlobal(exports.EVENT_LOG, payload);
-    }
-    emitInstanceEvent(systemId, instanceId, type, payload) {
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         try {
-            exports.socketManager.emit(`${systemId}/instances/${instanceId}`, type, payload);
+            this.emit(`instance-logs/${encodeURIComponent(systemId)}/${encodeURIComponent(instanceId)}`, exports.EVENT_INSTANCE_LOG, payload);
         }
         catch (e) {
             console.warn('Failed to emit instance event: %s', e.message);
         }
     }
+    emitSystemLog(systemId, payload) {
+        this.emitSystemEvent(systemId, exports.EVENT_SYSTEM_LOG, payload);
+    }
+    emitGlobalLog(payload) {
+        this.emitGlobal(exports.EVENT_LOG, payload);
+    }
     _bindIO() {
         this.io.on('connection', (socket) => this._handleSocketCreated(socket));
     }
@@ -80,16 +79,42 @@ class SocketManager {
         this._sockets.push(socket);
     }
     _bindSocket(socket) {
-        socket.on('disconnect', () => this._handleSocketDestroyed(socket));
+        socket.on('disconnect', () => {
+            lodash_1.default.pull(this._sockets, socket);
+            socket.rooms.forEach((roomId) => {
+                this.handleLeaveRoom(roomId);
+            });
+        });
         socket.on('join', (id) => {
             socket.join(id);
+            this.handleJoinRoom(id);
         });
         socket.on('leave', (id) => {
             socket.leave(id);
+            this.handleLeaveRoom(id);
         });
     }
-    _handleSocketDestroyed(socket) {
-        lodash_1.default.pull(this._sockets, socket);
+    handleJoinRoom(id) {
+        if (id.startsWith('instance-logs/')) {
+            let [, systemId, instanceId] = id.split(/\//g);
+            systemId = decodeURIComponent(systemId);
+            instanceId = decodeURIComponent(instanceId);
+            console.log('Start listening for logs', systemId, instanceId);
+            containerManager_1.containerManager
+                .ensureLogListening(systemId, instanceId, (log) => {
+                this.emitInstanceLog(systemId, instanceId, log);
+            })
+                .catch((e) => { });
+        }
+    }
+    handleLeaveRoom(id) {
+        if (id.startsWith('instance-logs/')) {
+            let [, systemId, instanceId] = id.split(/\//g);
+            systemId = decodeURIComponent(systemId);
+            instanceId = decodeURIComponent(instanceId);
+            console.log('Stop listening for logs', systemId, instanceId);
+            containerManager_1.containerManager.stopLogListening(systemId, instanceId).catch((e) => { });
+        }
     }
 }
 exports.SocketManager = SocketManager;

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

@@ -27,8 +27,9 @@ const DOCKER_ENV_VARS = [
     `KAPETA_LOCAL_CLUSTER_HOST=host.docker.internal`,
     `KAPETA_ENVIRONMENT_TYPE=docker`,
 ];
-function getProvider(uri) {
-    return definitionsManager_1.definitionsManager.getProviderDefinitions().find((provider) => {
+async function getProvider(uri) {
+    const providers = await definitionsManager_1.definitionsManager.getProviderDefinitions();
+    return providers.find((provider) => {
         const ref = `${provider.definition.metadata.name}:${provider.version}`;
         return (0, nodejs_utils_1.parseKapetaUri)(ref).id === uri.id;
     });
@@ -76,15 +77,12 @@ class BlockInstanceRunner {
         if (!blockUri.version) {
             blockUri.version = 'local';
         }
-        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;
-        });
+        const assetVersion = await definitionsManager_1.definitionsManager.getDefinition(blockUri.id);
         if (!assetVersion) {
             throw new Error(`Block definition not found: ${blockUri.id}`);
         }
         const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.kind);
-        const providerVersion = getProvider(kindUri);
+        const providerVersion = await getProvider(kindUri);
         if (!providerVersion) {
             throw new Error(`Kind not found: ${kindUri.id}`);
         }
@@ -120,7 +118,7 @@ class BlockInstanceRunner {
             throw new Error('Missing target kind in block definition');
         }
         const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.spec?.target?.kind);
-        const targetVersion = getProvider(kindUri);
+        const targetVersion = await getProvider(kindUri);
         if (!targetVersion) {
             throw new Error(`Target not found: ${kindUri.id}`);
         }

package/index.ts

@@ -23,6 +23,7 @@ import request from 'request';
 import { repositoryManager } from './src/repositoryManager';
 import { ensureCLI } from './src/utils/commandLineUtils';
 import { defaultProviderInstaller } from './src/utils/DefaultProviderInstaller';
+import { authManager } from './src/authManager';
 
 export type LocalClusterService = HTTP.Server & { host?: string; port?: number };
 
@@ -147,6 +148,7 @@ export default {
         }
 
         await clusterService.init();
+        await authManager.listenForChanges();
 
         currentServer = createServer();
 
@@ -177,7 +179,7 @@ export default {
 
             const bindHost = getBindHost(host);
 
-            currentServer.listen(port, bindHost, () => {
+            currentServer.listen(port, bindHost, async () => {
                 try {
                     ensureCLI().catch((e: any) => console.error('Failed to install CLI.', e));
                 } catch (e: any) {
@@ -186,7 +188,7 @@ export default {
 
                 try {
                     // Start installation process for all default providers
-                    repositoryManager.ensureDefaultProviders();
+                    await repositoryManager.ensureDefaultProviders();
                 } catch (e: any) {
                     console.error('Failed to install default providers.', e);
                 }

package/package.json

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