@kapeta/local-cluster-service 0.27.0 → 0.28.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.28.1](https://github.com/kapetacom/local-cluster-service/compare/v0.28.0...v0.28.1) (2023-12-12)
+
+
+### Bug Fixes
+
+* return all imported asset types from import endpoint [KAP-2187] ([#103](https://github.com/kapetacom/local-cluster-service/issues/103)) ([02ac22c](https://github.com/kapetacom/local-cluster-service/commit/02ac22c4a54db05b0e80943daba0b5496e5bb319))
+
+# [0.28.0](https://github.com/kapetacom/local-cluster-service/compare/v0.27.0...v0.28.0) (2023-11-15)
+
+
+### Features
+
+* Auto-upgrade providers every 10th minute ([#100](https://github.com/kapetacom/local-cluster-service/issues/100)) ([2c35569](https://github.com/kapetacom/local-cluster-service/commit/2c35569587f456374529bb1f9a9e8f5c03be2189))
+
 # [0.27.0](https://github.com/kapetacom/local-cluster-service/compare/v0.26.0...v0.27.0) (2023-11-13)
 
 

package/definitions.d.ts

@@ -13,12 +13,14 @@ declare module '@kapeta/nodejs-registry-utils' {
     export interface AssetVersion {
         content: Kind;
         dependencies: Dependency[];
+        version: string;
     }
 
     export class RegistryService {
         constructor(url: string);
 
         getVersion(fullName: string, version: string): Promise<AssetVersion>;
+        getLatestVersion(name): Promise<AssetVersion>;
     }
 
     export const Config: any;

package/dist/cjs/index.js

@@ -58,6 +58,7 @@ const DefaultProviderInstaller_1 = require("./src/utils/DefaultProviderInstaller
 const authManager_1 = require("./src/authManager");
 const codeGeneratorManager_1 = require("./src/codeGeneratorManager");
 const Sentry = __importStar(require("@sentry/node"));
+const assetManager_1 = require("./src/assetManager");
 Sentry.init({
     dsn: 'https://0b7cc946d82c591473d6f95fff5e210b@o4505820837249024.ingest.sentry.io/4506212692000768',
     enabled: process.env.NODE_ENV !== 'development',
@@ -231,6 +232,7 @@ exports.default = {
                 catch (e) {
                     console.error('Failed to install default providers.', e);
                 }
+                assetManager_1.assetManager.startUpgradeInterval();
                 resolve({ host, port, dockerStatus: containerManager_1.containerManager.isAlive() });
             });
             currentServer.host = host;

package/dist/cjs/src/api.js

@@ -10,13 +10,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const express_promise_router_1 = __importDefault(require("express-promise-router"));
 const cors_1 = require("./middleware/cors");
 const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
-const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
 const { createAPIRoute } = require('@kapeta/web-microfrontend/server');
 const packageJson = require('../package.json');
 const router = (0, express_promise_router_1.default)();
-const remoteServices = local_cluster_config_1.default.getClusterConfig().remoteServices ?? {};
 router.use('/', cors_1.corsHandler);
-router.use('/registry', createAPIRoute(remoteServices.registry ?? 'https://registry.kapeta.com', {
+router.use('/registry', createAPIRoute(nodejs_registry_utils_1.Config.data?.registry?.url ?? 'https://registry.kapeta.com', {
     nonce: false,
     userAgent: `KapetaDesktopCluster/${packageJson.version}`,
     tokenFetcher: () => {

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

@@ -16,6 +16,7 @@ export interface EnrichedAsset {
     ymlPath: string;
 }
 declare class AssetManager {
+    startUpgradeInterval(): void;
     /**
      *
      * @param {string[]} [assetKinds]
@@ -31,6 +32,8 @@ declare class AssetManager {
     importFile(filePath: string): Promise<EnrichedAsset[]>;
     unregisterAsset(ref: string): Promise<void>;
     installAsset(ref: string, wait?: boolean): Promise<import("./taskManager").Task<void>[] | undefined>;
+    private cleanupUnusedProviders;
+    private upgradeAllProviders;
     private maybeGenerateCode;
 }
 export declare const assetManager: AssetManager;

package/dist/cjs/src/assetManager.js

@@ -20,7 +20,9 @@ const definitionsManager_1 = require("./definitionsManager");
 const taskManager_1 = require("./taskManager");
 const cacheManager_1 = require("./cacheManager");
 const node_uuid_1 = __importDefault(require("node-uuid"));
+const node_os_1 = __importDefault(require("node:os"));
 const CACHE_TTL = 60 * 60 * 1000; // 1 hour
+const UPGRADE_CHECK_INTERVAL = 10 * 60 * 1000; // 10 minutes
 const toKey = (ref) => `assetManager:asset:${ref}`;
 function enrichAsset(asset) {
     return {
@@ -47,6 +49,21 @@ function parseRef(ref) {
     return [out[0].toLowerCase(), out[1].toLowerCase()];
 }
 class AssetManager {
+    startUpgradeInterval() {
+        console.debug('Checking for upgrades...');
+        this.upgradeAllProviders()
+            .then((task) => {
+            return task && task.wait();
+        })
+            .catch((e) => {
+            console.error('Failed to upgrade providers', e);
+        })
+            .finally(() => {
+            setTimeout(() => {
+                this.startUpgradeInterval();
+            }, UPGRADE_CHECK_INTERVAL);
+        });
+    }
     /**
      *
      * @param {string[]} [assetKinds]
@@ -166,7 +183,8 @@ class AssetManager {
             cacheManager_1.cacheManager.remove(key);
         });
         definitionsManager_1.definitionsManager.clearCache();
-        const assets = await this.getAssets();
+        // Get all possible asset kinds, to make sure we return the result if possible
+        const assets = await this.getAssets([]);
         return assets.filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
     }
     async unregisterAsset(ref) {
@@ -191,6 +209,44 @@ class AssetManager {
         definitionsManager_1.definitionsManager.clearCache();
         return await repositoryManager_1.repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, wait);
     }
+    async cleanupUnusedProviders() {
+        const unusedProviders = await repositoryManager_1.repositoryManager.getUnusedProviders();
+        if (unusedProviders.length < 1) {
+            return;
+        }
+        console.log('Cleaning up unused providers: ', unusedProviders);
+        await Promise.all(unusedProviders.map((ref) => {
+            return this.unregisterAsset(ref);
+        }));
+    }
+    async upgradeAllProviders() {
+        const providers = await definitionsManager_1.definitionsManager.getProviderDefinitions();
+        const names = providers.map((p) => p.definition.metadata.name);
+        const refs = await repositoryManager_1.repositoryManager.getUpdatableAssets(names);
+        if (refs.length < 1) {
+            await this.cleanupUnusedProviders();
+            return;
+        }
+        console.log('Installing updates', refs);
+        const updateAll = async () => {
+            try {
+                //We change to a temp dir to avoid issues with the current working directory
+                process.chdir(node_os_1.default.tmpdir());
+                await nodejs_registry_utils_1.Actions.install(new progressListener_1.ProgressListener(), refs, {});
+                await this.cleanupUnusedProviders();
+            }
+            catch (e) {
+                console.error(`Failed to update assets: ${refs.join(',')}`, e);
+                throw e;
+            }
+            cacheManager_1.cacheManager.flush();
+            definitionsManager_1.definitionsManager.clearCache();
+        };
+        return taskManager_1.taskManager.add(`asset:update`, updateAll, {
+            name: `Installing ${refs.length} updates`,
+            group: 'asset:update:check',
+        });
+    }
     async maybeGenerateCode(ref, ymlPath, block) {
         ref = (0, nodejs_utils_1.normalizeKapetaUri)(ref);
         if (await codeGeneratorManager_1.codeGeneratorManager.canGenerateCode(block)) {

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

@@ -11,6 +11,7 @@ declare class DefinitionsManager {
     exists(ref: string): Promise<boolean>;
     getProviderDefinitions(): Promise<DefinitionInfo[]>;
     getDefinition(ref: string): Promise<DefinitionInfo | undefined>;
+    getLatestDefinition(name: string): Promise<DefinitionInfo | undefined>;
     getVersions(assetName: string): Promise<DefinitionInfo[]>;
     clearCache(): void;
 }

package/dist/cjs/src/definitionsManager.js

@@ -136,6 +136,19 @@ class DefinitionsManager {
             return (0, nodejs_utils_1.parseKapetaUri)(`${d.definition.metadata.name}:${d.version}`).id === uri.id;
         });
     }
+    async getLatestDefinition(name) {
+        const definitions = await this.getDefinitions();
+        const allVersions = definitions.filter((d) => {
+            return d.version !== 'local' && d.definition.metadata.name === name;
+        });
+        if (allVersions.length === 0) {
+            return;
+        }
+        allVersions.sort((a, b) => {
+            return (0, nodejs_utils_1.parseVersion)(a.version).compareTo((0, nodejs_utils_1.parseVersion)(b.version)) * -1;
+        });
+        return allVersions[0];
+    }
     async getVersions(assetName) {
         const uri = (0, nodejs_utils_1.parseKapetaUri)(assetName);
         const definitions = await this.getDefinitions();

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

@@ -19,6 +19,15 @@ declare class RepositoryManager extends EventEmitter {
     setSourceOfChangeFor(file: string, source: SourceOfChange): Promise<void>;
     clearSourceOfChangeFor(file: string): Promise<void>;
     ensureDefaultProviders(): Promise<void>;
+    /**
+     * Will go through all available assets and get a list of
+     * providers that are not referenced anywhere.
+     *
+     * It will also make sure to not include the latest version of an asset.
+     *
+     */
+    getUnusedProviders(): Promise<string[]>;
+    getUpdatableAssets(allNames: string[]): Promise<string[]>;
     private scheduleInstallation;
     ensureAsset(handle: string, name: string, version: string, wait?: boolean): Promise<undefined | Task[]>;
 }

package/dist/cjs/src/repositoryManager.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.repositoryManager = void 0;
 const node_os_1 = __importDefault(require("node:os"));
 const socketManager_1 = require("./socketManager");
+const schemas_1 = require("@kapeta/schemas");
 const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
 const definitionsManager_1 = require("./definitionsManager");
 const taskManager_1 = require("./taskManager");
@@ -69,6 +70,97 @@ class RepositoryManager extends node_events_1.EventEmitter {
             socketManager_1.socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_END, {});
         });
     }
+    /**
+     * Will go through all available assets and get a list of
+     * providers that are not referenced anywhere.
+     *
+     * It will also make sure to not include the latest version of an asset.
+     *
+     */
+    async getUnusedProviders() {
+        const allDefinitions = await definitionsManager_1.definitionsManager.getDefinitions();
+        const blocks = [];
+        const plans = [];
+        const providerMap = new Map();
+        const providerVersions = {};
+        const unusedProviders = new Set();
+        allDefinitions.forEach((d) => {
+            if (d.definition.kind === 'core/plan') {
+                plans.push(d);
+                return;
+            }
+            if (d.definition.kind.startsWith('core/')) {
+                const ref = (0, nodejs_utils_1.normalizeKapetaUri)(`${d.definition.metadata.name}:${d.version}`);
+                providerMap.set(ref, d);
+                if (!providerVersions[d.definition.metadata.name]) {
+                    providerVersions[d.definition.metadata.name] = new Set();
+                }
+                providerVersions[d.definition.metadata.name].add(d.version);
+                unusedProviders.add(ref);
+                return;
+            }
+            blocks.push(d);
+        });
+        const latestVersions = {};
+        Object.entries(providerVersions).forEach(([name, versions]) => {
+            const versionArray = Array.from(versions);
+            versionArray.sort((a, b) => {
+                return (0, nodejs_utils_1.parseVersion)(a).compareTo((0, nodejs_utils_1.parseVersion)(b)) * -1;
+            });
+            latestVersions[name] = versionArray[0];
+        });
+        function markDependencyAsUsed(dep) {
+            const uri = (0, nodejs_utils_1.parseKapetaUri)(dep.name);
+            const ref = uri.toNormalizedString();
+            if (unusedProviders.has(ref)) {
+                unusedProviders.delete(ref);
+            }
+        }
+        plans.forEach((plan) => {
+            const dependencies = (0, schemas_1.resolveDependencies)(plan.definition);
+            dependencies.forEach(markDependencyAsUsed);
+        });
+        blocks.forEach((block) => {
+            const blockTypeKind = (0, nodejs_utils_1.normalizeKapetaUri)(block.definition.kind);
+            unusedProviders.delete(blockTypeKind);
+            const blockTypeProvider = providerMap.get(blockTypeKind);
+            if (!blockTypeProvider) {
+                console.warn('No provider found for block type', block.definition.kind);
+                return;
+            }
+            const dependencies = (0, schemas_1.resolveDependencies)(block.definition, blockTypeProvider.definition);
+            dependencies.forEach(markDependencyAsUsed);
+        });
+        return Array.from(unusedProviders).filter((ref) => {
+            const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
+            if (uri.version == 'local') {
+                // Don't delete local assets
+                return false;
+            }
+            // Don't delete the latest version of an asset
+            return latestVersions[uri.fullName] !== uri.version;
+        });
+    }
+    async getUpdatableAssets(allNames) {
+        const names = Array.from(new Set(allNames));
+        const currentVersions = await Promise.all(names.map((name) => definitionsManager_1.definitionsManager.getLatestDefinition(name).catch(() => undefined)));
+        const latestVersions = await Promise.all(names.map((name) => this._registryService.getLatestVersion(name).catch(() => undefined)));
+        return names
+            .map((name, index) => {
+            const currentVersion = currentVersions[index];
+            const latestVersion = latestVersions[index];
+            if (!currentVersion || !latestVersion) {
+                // Shouldn't happen unless the registry is down or an asset was deleted
+                return undefined;
+            }
+            const ref = (0, nodejs_utils_1.normalizeKapetaUri)(`${name}:${latestVersion.version}`);
+            if (currentVersion.version === latestVersion.version) {
+                return undefined;
+            }
+            return ref;
+        })
+            .filter((ref) => !!ref);
+    }
     async scheduleInstallation(refs) {
         //We make sure to only install one asset at a time - otherwise unexpected things might happen
         const createInstaller = (ref) => {

package/dist/esm/index.js

@@ -58,6 +58,7 @@ const DefaultProviderInstaller_1 = require("./src/utils/DefaultProviderInstaller
 const authManager_1 = require("./src/authManager");
 const codeGeneratorManager_1 = require("./src/codeGeneratorManager");
 const Sentry = __importStar(require("@sentry/node"));
+const assetManager_1 = require("./src/assetManager");
 Sentry.init({
     dsn: 'https://0b7cc946d82c591473d6f95fff5e210b@o4505820837249024.ingest.sentry.io/4506212692000768',
     enabled: process.env.NODE_ENV !== 'development',
@@ -231,6 +232,7 @@ exports.default = {
                 catch (e) {
                     console.error('Failed to install default providers.', e);
                 }
+                assetManager_1.assetManager.startUpgradeInterval();
                 resolve({ host, port, dockerStatus: containerManager_1.containerManager.isAlive() });
             });
             currentServer.host = host;

package/dist/esm/src/api.js

@@ -10,13 +10,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const express_promise_router_1 = __importDefault(require("express-promise-router"));
 const cors_1 = require("./middleware/cors");
 const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
-const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
 const { createAPIRoute } = require('@kapeta/web-microfrontend/server');
 const packageJson = require('../package.json');
 const router = (0, express_promise_router_1.default)();
-const remoteServices = local_cluster_config_1.default.getClusterConfig().remoteServices ?? {};
 router.use('/', cors_1.corsHandler);
-router.use('/registry', createAPIRoute(remoteServices.registry ?? 'https://registry.kapeta.com', {
+router.use('/registry', createAPIRoute(nodejs_registry_utils_1.Config.data?.registry?.url ?? 'https://registry.kapeta.com', {
     nonce: false,
     userAgent: `KapetaDesktopCluster/${packageJson.version}`,
     tokenFetcher: () => {

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

@@ -16,6 +16,7 @@ export interface EnrichedAsset {
     ymlPath: string;
 }
 declare class AssetManager {
+    startUpgradeInterval(): void;
     /**
      *
      * @param {string[]} [assetKinds]
@@ -31,6 +32,8 @@ declare class AssetManager {
     importFile(filePath: string): Promise<EnrichedAsset[]>;
     unregisterAsset(ref: string): Promise<void>;
     installAsset(ref: string, wait?: boolean): Promise<import("./taskManager").Task<void>[] | undefined>;
+    private cleanupUnusedProviders;
+    private upgradeAllProviders;
     private maybeGenerateCode;
 }
 export declare const assetManager: AssetManager;

package/dist/esm/src/assetManager.js

@@ -20,7 +20,9 @@ const definitionsManager_1 = require("./definitionsManager");
 const taskManager_1 = require("./taskManager");
 const cacheManager_1 = require("./cacheManager");
 const node_uuid_1 = __importDefault(require("node-uuid"));
+const node_os_1 = __importDefault(require("node:os"));
 const CACHE_TTL = 60 * 60 * 1000; // 1 hour
+const UPGRADE_CHECK_INTERVAL = 10 * 60 * 1000; // 10 minutes
 const toKey = (ref) => `assetManager:asset:${ref}`;
 function enrichAsset(asset) {
     return {
@@ -47,6 +49,21 @@ function parseRef(ref) {
     return [out[0].toLowerCase(), out[1].toLowerCase()];
 }
 class AssetManager {
+    startUpgradeInterval() {
+        console.debug('Checking for upgrades...');
+        this.upgradeAllProviders()
+            .then((task) => {
+            return task && task.wait();
+        })
+            .catch((e) => {
+            console.error('Failed to upgrade providers', e);
+        })
+            .finally(() => {
+            setTimeout(() => {
+                this.startUpgradeInterval();
+            }, UPGRADE_CHECK_INTERVAL);
+        });
+    }
     /**
      *
      * @param {string[]} [assetKinds]
@@ -166,7 +183,8 @@ class AssetManager {
             cacheManager_1.cacheManager.remove(key);
         });
         definitionsManager_1.definitionsManager.clearCache();
-        const assets = await this.getAssets();
+        // Get all possible asset kinds, to make sure we return the result if possible
+        const assets = await this.getAssets([]);
         return assets.filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
     }
     async unregisterAsset(ref) {
@@ -191,6 +209,44 @@ class AssetManager {
         definitionsManager_1.definitionsManager.clearCache();
         return await repositoryManager_1.repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, wait);
     }
+    async cleanupUnusedProviders() {
+        const unusedProviders = await repositoryManager_1.repositoryManager.getUnusedProviders();
+        if (unusedProviders.length < 1) {
+            return;
+        }
+        console.log('Cleaning up unused providers: ', unusedProviders);
+        await Promise.all(unusedProviders.map((ref) => {
+            return this.unregisterAsset(ref);
+        }));
+    }
+    async upgradeAllProviders() {
+        const providers = await definitionsManager_1.definitionsManager.getProviderDefinitions();
+        const names = providers.map((p) => p.definition.metadata.name);
+        const refs = await repositoryManager_1.repositoryManager.getUpdatableAssets(names);
+        if (refs.length < 1) {
+            await this.cleanupUnusedProviders();
+            return;
+        }
+        console.log('Installing updates', refs);
+        const updateAll = async () => {
+            try {
+                //We change to a temp dir to avoid issues with the current working directory
+                process.chdir(node_os_1.default.tmpdir());
+                await nodejs_registry_utils_1.Actions.install(new progressListener_1.ProgressListener(), refs, {});
+                await this.cleanupUnusedProviders();
+            }
+            catch (e) {
+                console.error(`Failed to update assets: ${refs.join(',')}`, e);
+                throw e;
+            }
+            cacheManager_1.cacheManager.flush();
+            definitionsManager_1.definitionsManager.clearCache();
+        };
+        return taskManager_1.taskManager.add(`asset:update`, updateAll, {
+            name: `Installing ${refs.length} updates`,
+            group: 'asset:update:check',
+        });
+    }
     async maybeGenerateCode(ref, ymlPath, block) {
         ref = (0, nodejs_utils_1.normalizeKapetaUri)(ref);
         if (await codeGeneratorManager_1.codeGeneratorManager.canGenerateCode(block)) {

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

@@ -11,6 +11,7 @@ declare class DefinitionsManager {
     exists(ref: string): Promise<boolean>;
     getProviderDefinitions(): Promise<DefinitionInfo[]>;
     getDefinition(ref: string): Promise<DefinitionInfo | undefined>;
+    getLatestDefinition(name: string): Promise<DefinitionInfo | undefined>;
     getVersions(assetName: string): Promise<DefinitionInfo[]>;
     clearCache(): void;
 }

package/dist/esm/src/definitionsManager.js

@@ -136,6 +136,19 @@ class DefinitionsManager {
             return (0, nodejs_utils_1.parseKapetaUri)(`${d.definition.metadata.name}:${d.version}`).id === uri.id;
         });
     }
+    async getLatestDefinition(name) {
+        const definitions = await this.getDefinitions();
+        const allVersions = definitions.filter((d) => {
+            return d.version !== 'local' && d.definition.metadata.name === name;
+        });
+        if (allVersions.length === 0) {
+            return;
+        }
+        allVersions.sort((a, b) => {
+            return (0, nodejs_utils_1.parseVersion)(a.version).compareTo((0, nodejs_utils_1.parseVersion)(b.version)) * -1;
+        });
+        return allVersions[0];
+    }
     async getVersions(assetName) {
         const uri = (0, nodejs_utils_1.parseKapetaUri)(assetName);
         const definitions = await this.getDefinitions();

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

@@ -19,6 +19,15 @@ declare class RepositoryManager extends EventEmitter {
     setSourceOfChangeFor(file: string, source: SourceOfChange): Promise<void>;
     clearSourceOfChangeFor(file: string): Promise<void>;
     ensureDefaultProviders(): Promise<void>;
+    /**
+     * Will go through all available assets and get a list of
+     * providers that are not referenced anywhere.
+     *
+     * It will also make sure to not include the latest version of an asset.
+     *
+     */
+    getUnusedProviders(): Promise<string[]>;
+    getUpdatableAssets(allNames: string[]): Promise<string[]>;
     private scheduleInstallation;
     ensureAsset(handle: string, name: string, version: string, wait?: boolean): Promise<undefined | Task[]>;
 }

package/dist/esm/src/repositoryManager.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.repositoryManager = void 0;
 const node_os_1 = __importDefault(require("node:os"));
 const socketManager_1 = require("./socketManager");
+const schemas_1 = require("@kapeta/schemas");
 const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
 const definitionsManager_1 = require("./definitionsManager");
 const taskManager_1 = require("./taskManager");
@@ -69,6 +70,97 @@ class RepositoryManager extends node_events_1.EventEmitter {
             socketManager_1.socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_END, {});
         });
     }
+    /**
+     * Will go through all available assets and get a list of
+     * providers that are not referenced anywhere.
+     *
+     * It will also make sure to not include the latest version of an asset.
+     *
+     */
+    async getUnusedProviders() {
+        const allDefinitions = await definitionsManager_1.definitionsManager.getDefinitions();
+        const blocks = [];
+        const plans = [];
+        const providerMap = new Map();
+        const providerVersions = {};
+        const unusedProviders = new Set();
+        allDefinitions.forEach((d) => {
+            if (d.definition.kind === 'core/plan') {
+                plans.push(d);
+                return;
+            }
+            if (d.definition.kind.startsWith('core/')) {
+                const ref = (0, nodejs_utils_1.normalizeKapetaUri)(`${d.definition.metadata.name}:${d.version}`);
+                providerMap.set(ref, d);
+                if (!providerVersions[d.definition.metadata.name]) {
+                    providerVersions[d.definition.metadata.name] = new Set();
+                }
+                providerVersions[d.definition.metadata.name].add(d.version);
+                unusedProviders.add(ref);
+                return;
+            }
+            blocks.push(d);
+        });
+        const latestVersions = {};
+        Object.entries(providerVersions).forEach(([name, versions]) => {
+            const versionArray = Array.from(versions);
+            versionArray.sort((a, b) => {
+                return (0, nodejs_utils_1.parseVersion)(a).compareTo((0, nodejs_utils_1.parseVersion)(b)) * -1;
+            });
+            latestVersions[name] = versionArray[0];
+        });
+        function markDependencyAsUsed(dep) {
+            const uri = (0, nodejs_utils_1.parseKapetaUri)(dep.name);
+            const ref = uri.toNormalizedString();
+            if (unusedProviders.has(ref)) {
+                unusedProviders.delete(ref);
+            }
+        }
+        plans.forEach((plan) => {
+            const dependencies = (0, schemas_1.resolveDependencies)(plan.definition);
+            dependencies.forEach(markDependencyAsUsed);
+        });
+        blocks.forEach((block) => {
+            const blockTypeKind = (0, nodejs_utils_1.normalizeKapetaUri)(block.definition.kind);
+            unusedProviders.delete(blockTypeKind);
+            const blockTypeProvider = providerMap.get(blockTypeKind);
+            if (!blockTypeProvider) {
+                console.warn('No provider found for block type', block.definition.kind);
+                return;
+            }
+            const dependencies = (0, schemas_1.resolveDependencies)(block.definition, blockTypeProvider.definition);
+            dependencies.forEach(markDependencyAsUsed);
+        });
+        return Array.from(unusedProviders).filter((ref) => {
+            const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
+            if (uri.version == 'local') {
+                // Don't delete local assets
+                return false;
+            }
+            // Don't delete the latest version of an asset
+            return latestVersions[uri.fullName] !== uri.version;
+        });
+    }
+    async getUpdatableAssets(allNames) {
+        const names = Array.from(new Set(allNames));
+        const currentVersions = await Promise.all(names.map((name) => definitionsManager_1.definitionsManager.getLatestDefinition(name).catch(() => undefined)));
+        const latestVersions = await Promise.all(names.map((name) => this._registryService.getLatestVersion(name).catch(() => undefined)));
+        return names
+            .map((name, index) => {
+            const currentVersion = currentVersions[index];
+            const latestVersion = latestVersions[index];
+            if (!currentVersion || !latestVersion) {
+                // Shouldn't happen unless the registry is down or an asset was deleted
+                return undefined;
+            }
+            const ref = (0, nodejs_utils_1.normalizeKapetaUri)(`${name}:${latestVersion.version}`);
+            if (currentVersion.version === latestVersion.version) {
+                return undefined;
+            }
+            return ref;
+        })
+            .filter((ref) => !!ref);
+    }
     async scheduleInstallation(refs) {
         //We make sure to only install one asset at a time - otherwise unexpected things might happen
         const createInstaller = (ref) => {

package/index.ts

@@ -32,6 +32,7 @@ import { defaultProviderInstaller } from './src/utils/DefaultProviderInstaller';
 import { authManager } from './src/authManager';
 import { codeGeneratorManager } from './src/codeGeneratorManager';
 import * as Sentry from '@sentry/node';
+import { assetManager } from './src/assetManager';
 
 Sentry.init({
     dsn: 'https://0b7cc946d82c591473d6f95fff5e210b@o4505820837249024.ingest.sentry.io/4506212692000768',
@@ -245,6 +246,8 @@ export default {
                     console.error('Failed to install default providers.', e);
                 }
 
+                assetManager.startUpgradeInterval();
+
                 resolve({ host, port, dockerStatus: containerManager.isAlive() });
             });
             currentServer.host = host;

package/package.json

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

package/src/api.ts

@@ -6,18 +6,17 @@
 import Router from 'express-promise-router';
 import { corsHandler } from './middleware/cors';
 import { KapetaAPI } from '@kapeta/nodejs-api-client';
-import ClusterConfiguration from '@kapeta/local-cluster-config';
+import { Config } from '@kapeta/nodejs-registry-utils';
 const { createAPIRoute } = require('@kapeta/web-microfrontend/server');
 const packageJson = require('../package.json');
 
 const router = Router();
 
-const remoteServices = ClusterConfiguration.getClusterConfig().remoteServices ?? {};
 router.use('/', corsHandler);
 
 router.use(
     '/registry',
-    createAPIRoute(remoteServices.registry ?? 'https://registry.kapeta.com', {
+    createAPIRoute(Config.data?.registry?.url ?? 'https://registry.kapeta.com', {
         nonce: false,
         userAgent: `KapetaDesktopCluster/${packageJson.version}`,
         tokenFetcher: () => {

package/src/assetManager.ts

@@ -18,8 +18,10 @@ import { taskManager } from './taskManager';
 import { SourceOfChange } from './types';
 import { cacheManager } from './cacheManager';
 import uuid from 'node-uuid';
+import os from 'node:os';
 
 const CACHE_TTL = 60 * 60 * 1000; // 1 hour
+const UPGRADE_CHECK_INTERVAL = 10 * 60 * 1000; // 10 minutes
 
 const toKey = (ref: string) => `assetManager:asset:${ref}`;
 
@@ -64,6 +66,22 @@ function parseRef(ref: string) {
 }
 
 class AssetManager {
+    public startUpgradeInterval() {
+        console.debug('Checking for upgrades...');
+        this.upgradeAllProviders()
+            .then((task) => {
+                return task && task.wait();
+            })
+            .catch((e) => {
+                console.error('Failed to upgrade providers', e);
+            })
+            .finally(() => {
+                setTimeout(() => {
+                    this.startUpgradeInterval();
+                }, UPGRADE_CHECK_INTERVAL);
+            });
+    }
+
     /**
      *
      * @param {string[]} [assetKinds]
@@ -226,7 +244,8 @@ class AssetManager {
 
         definitionsManager.clearCache();
 
-        const assets = await this.getAssets();
+        // Get all possible asset kinds, to make sure we return the result if possible
+        const assets = await this.getAssets([]);
 
         return assets.filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
     }
@@ -258,6 +277,52 @@ class AssetManager {
         return await repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, wait);
     }
 
+    private async cleanupUnusedProviders(): Promise<void> {
+        const unusedProviders = await repositoryManager.getUnusedProviders();
+        if (unusedProviders.length < 1) {
+            return;
+        }
+
+        console.log('Cleaning up unused providers: ', unusedProviders);
+        await Promise.all(
+            unusedProviders.map((ref) => {
+                return this.unregisterAsset(ref);
+            })
+        );
+    }
+
+    private async upgradeAllProviders() {
+        const providers = await definitionsManager.getProviderDefinitions();
+        const names = providers.map((p) => p.definition.metadata.name);
+
+        const refs = await repositoryManager.getUpdatableAssets(names);
+
+        if (refs.length < 1) {
+            await this.cleanupUnusedProviders();
+            return;
+        }
+
+        console.log('Installing updates', refs);
+        const updateAll = async () => {
+            try {
+                //We change to a temp dir to avoid issues with the current working directory
+                process.chdir(os.tmpdir());
+                await Actions.install(new ProgressListener(), refs, {});
+                await this.cleanupUnusedProviders();
+            } catch (e) {
+                console.error(`Failed to update assets: ${refs.join(',')}`, e);
+                throw e;
+            }
+            cacheManager.flush();
+            definitionsManager.clearCache();
+        };
+
+        return taskManager.add(`asset:update`, updateAll, {
+            name: `Installing ${refs.length} updates`,
+            group: 'asset:update:check',
+        });
+    }
+
     private async maybeGenerateCode(ref: string, ymlPath: string, block: Definition) {
         ref = normalizeKapetaUri(ref);
         if (await codeGeneratorManager.canGenerateCode(block)) {

package/src/definitionsManager.ts

@@ -4,7 +4,7 @@
  */
 
 import ClusterConfiguration, { DefinitionInfo } from '@kapeta/local-cluster-config';
-import { parseKapetaUri, normalizeKapetaUri } from '@kapeta/nodejs-utils';
+import { parseKapetaUri, normalizeKapetaUri, parseVersion } from '@kapeta/nodejs-utils';
 import { cacheManager, doCached } from './cacheManager';
 import { KapetaAPI } from '@kapeta/nodejs-api-client';
 import { Plan } from '@kapeta/schemas';
@@ -170,6 +170,23 @@ class DefinitionsManager {
         });
     }
 
+    public async getLatestDefinition(name: string) {
+        const definitions = await this.getDefinitions();
+        const allVersions = definitions.filter((d) => {
+            return d.version !== 'local' && d.definition.metadata.name === name;
+        });
+
+        if (allVersions.length === 0) {
+            return;
+        }
+
+        allVersions.sort((a, b) => {
+            return parseVersion(a.version).compareTo(parseVersion(b.version)) * -1;
+        });
+
+        return allVersions[0];
+    }
+
     public async getVersions(assetName: string) {
         const uri = parseKapetaUri(assetName);
         const definitions = await this.getDefinitions();

package/src/repositoryManager.ts

@@ -5,16 +5,17 @@
 
 import os from 'node:os';
 import { socketManager } from './socketManager';
-import { Dependency } from '@kapeta/schemas';
-import { Actions, Config, RegistryService } from '@kapeta/nodejs-registry-utils';
+import { DependencyReference, Dependency, resolveDependencies } from '@kapeta/schemas';
+import { Actions, AssetVersion, Config, RegistryService } from '@kapeta/nodejs-registry-utils';
 import { definitionsManager } from './definitionsManager';
 import { Task, taskManager } from './taskManager';
-import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
+import { normalizeKapetaUri, parseKapetaUri, parseVersion } from '@kapeta/nodejs-utils';
 import { ProgressListener } from './progressListener';
 import { RepositoryWatcher } from './RepositoryWatcher';
 import { SourceOfChange } from './types';
 import { cacheManager } from './cacheManager';
 import { EventEmitter } from 'node:events';
+import { DefinitionInfo } from '@kapeta/local-cluster-config';
 
 const EVENT_DEFAULT_PROVIDERS_START = 'default-providers-start';
 const EVENT_DEFAULT_PROVIDERS_END = 'default-providers-end';
@@ -77,6 +78,116 @@ class RepositoryManager extends EventEmitter {
         });
     }
 
+    /**
+     * Will go through all available assets and get a list of
+     * providers that are not referenced anywhere.
+     *
+     * It will also make sure to not include the latest version of an asset.
+     *
+     */
+    public async getUnusedProviders(): Promise<string[]> {
+        const allDefinitions: DefinitionInfo[] = await definitionsManager.getDefinitions();
+        const blocks: DefinitionInfo[] = [];
+        const plans: DefinitionInfo[] = [];
+        const providerMap = new Map<string, DefinitionInfo>();
+        const providerVersions: { [name: string]: Set<string> } = {};
+        const unusedProviders = new Set<string>();
+        allDefinitions.forEach((d) => {
+            if (d.definition.kind === 'core/plan') {
+                plans.push(d);
+                return;
+            }
+
+            if (d.definition.kind.startsWith('core/')) {
+                const ref = normalizeKapetaUri(`${d.definition.metadata.name}:${d.version}`);
+                providerMap.set(ref, d);
+                if (!providerVersions[d.definition.metadata.name]) {
+                    providerVersions[d.definition.metadata.name] = new Set<string>();
+                }
+                providerVersions[d.definition.metadata.name].add(d.version);
+                unusedProviders.add(ref);
+                return;
+            }
+            blocks.push(d);
+        });
+
+        const latestVersions: { [name: string]: string } = {};
+        Object.entries(providerVersions).forEach(([name, versions]) => {
+            const versionArray = Array.from(versions);
+            versionArray.sort((a, b) => {
+                return parseVersion(a).compareTo(parseVersion(b)) * -1;
+            });
+            latestVersions[name] = versionArray[0];
+        });
+
+        function markDependencyAsUsed(dep: DependencyReference) {
+            const uri = parseKapetaUri(dep.name);
+            const ref = uri.toNormalizedString();
+            if (unusedProviders.has(ref)) {
+                unusedProviders.delete(ref);
+            }
+        }
+
+        plans.forEach((plan) => {
+            const dependencies = resolveDependencies(plan.definition);
+            dependencies.forEach(markDependencyAsUsed);
+        });
+
+        blocks.forEach((block) => {
+            const blockTypeKind = normalizeKapetaUri(block.definition.kind);
+            unusedProviders.delete(blockTypeKind);
+            const blockTypeProvider = providerMap.get(blockTypeKind);
+            if (!blockTypeProvider) {
+                console.warn('No provider found for block type', block.definition.kind);
+                return;
+            }
+            const dependencies = resolveDependencies(block.definition, blockTypeProvider.definition);
+            dependencies.forEach(markDependencyAsUsed);
+        });
+
+        return Array.from(unusedProviders).filter((ref) => {
+            const uri = parseKapetaUri(ref);
+            if (uri.version == 'local') {
+                // Don't delete local assets
+                return false;
+            }
+
+            // Don't delete the latest version of an asset
+            return latestVersions[uri.fullName] !== uri.version;
+        });
+    }
+
+    public async getUpdatableAssets(allNames: string[]): Promise<string[]> {
+        const names = Array.from(new Set<string>(allNames));
+
+        const currentVersions = await Promise.all(
+            names.map((name) => definitionsManager.getLatestDefinition(name).catch(() => undefined))
+        );
+
+        const latestVersions = await Promise.all(
+            names.map((name) => this._registryService.getLatestVersion(name).catch(() => undefined))
+        );
+
+        return names
+            .map((name, index) => {
+                const currentVersion: DefinitionInfo | undefined = currentVersions[index];
+                const latestVersion: AssetVersion | undefined = latestVersions[index];
+                if (!currentVersion || !latestVersion) {
+                    // Shouldn't happen unless the registry is down or an asset was deleted
+                    return undefined;
+                }
+
+                const ref = normalizeKapetaUri(`${name}:${latestVersion.version}`);
+
+                if (currentVersion.version === latestVersion.version) {
+                    return undefined;
+                }
+
+                return ref;
+            })
+            .filter((ref) => !!ref) as string[];
+    }
+
     private async scheduleInstallation(refs: string[]): Promise<Task[]> {
         //We make sure to only install one asset at a time - otherwise unexpected things might happen
         const createInstaller = (ref: string) => {