@kapeta/local-cluster-service 0.31.0 → 0.32.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.32.1](https://github.com/kapetacom/local-cluster-service/compare/v0.32.0...v0.32.1) (2023-12-23)
+
+
+### Bug Fixes
+
+* Several smaller fixes ([4036345](https://github.com/kapetacom/local-cluster-service/commit/40363457597d36c97481e94e646a6b45d113bb09))
+
+# [0.32.0](https://github.com/kapetacom/local-cluster-service/compare/v0.31.0...v0.32.0) (2023-12-20)
+
+
+### Features
+
+* Adds AI routes for generating plans from prompts ([#102](https://github.com/kapetacom/local-cluster-service/issues/102)) ([db73996](https://github.com/kapetacom/local-cluster-service/commit/db739965cd8c58252651e0522b11c062f00488af))
+
 # [0.31.0](https://github.com/kapetacom/local-cluster-service/compare/v0.30.1...v0.31.0) (2023-12-18)
 
 

package/dist/cjs/index.js

@@ -49,6 +49,7 @@ const routes_8 = __importDefault(require("./src/providers/routes"));
 const routes_9 = __importDefault(require("./src/attachments/routes"));
 const routes_10 = __importDefault(require("./src/tasks/routes"));
 const api_1 = __importDefault(require("./src/api"));
+const routes_11 = __importDefault(require("./src/ai/routes"));
 const utils_1 = require("./src/utils/utils");
 const request_1 = __importDefault(require("request"));
 const repositoryManager_1 = require("./src/repositoryManager");
@@ -87,6 +88,7 @@ function createServer() {
     app.use('/attachments', routes_9.default);
     app.use('/tasks', routes_10.default);
     app.use('/api', api_1.default);
+    app.use('/ai', routes_11.default);
     app.get('/status', async (req, res) => {
         res.send({
             ok: true,

package/dist/cjs/src/RepositoryWatcher.js

@@ -20,6 +20,24 @@ const cacheManager_1 = require("./cacheManager");
 const node_events_1 = require("node:events");
 const assetManager_1 = require("./assetManager");
 const KAPETA_YML_RX = /^kapeta.ya?ml$/;
+let definitions;
+let definitionTimeout;
+function getDefinitionsDebounced() {
+    if (definitionTimeout) {
+        clearTimeout(definitionTimeout);
+        definitionTimeout = undefined;
+    }
+    if (!definitions) {
+        definitions = local_cluster_config_1.default.getDefinitions();
+    }
+    else {
+        definitionTimeout = setTimeout(() => {
+            definitionTimeout = undefined;
+            definitions = undefined;
+        }, 500);
+    }
+    return definitions;
+}
 class RepositoryWatcher extends node_events_1.EventEmitter {
     watcher;
     disabled = false;
@@ -186,7 +204,7 @@ class RepositoryWatcher extends node_events_1.EventEmitter {
     }
     async checkForChange(assetIdentity, sourceOfChange) {
         const ymlPath = node_path_1.default.join(this.getRepositoryPath(assetIdentity), 'kapeta.yml');
-        const newDefinitions = local_cluster_config_1.default.getDefinitions();
+        const newDefinitions = getDefinitionsDebounced();
         const newDefinition = newDefinitions.find((d) => d.ymlPath === ymlPath);
         let currentDefinition = this.allDefinitions.find((d) => d.ymlPath === ymlPath);
         const ymlExists = await this.exists(ymlPath);
@@ -265,11 +283,17 @@ class RepositoryWatcher extends node_events_1.EventEmitter {
             }
             catch (e) { }
             if (symbolicLink) {
-                const realPath = node_path_1.default.join(await fs_extra_1.default.realpath(path), 'kapeta.yml');
-                if (await this.exists(realPath)) {
-                    //console.log('Watching symlink target %s => %s', path, realPath);
-                    this.watcher?.add(realPath);
-                    this.symbolicLinks[path] = realPath;
+                try {
+                    const realPath = node_path_1.default.join(await fs_extra_1.default.realpath(path), 'kapeta.yml');
+                    if (await this.exists(realPath)) {
+                        //console.log('Watching symlink target %s => %s', path, realPath);
+                        this.watcher?.add(realPath);
+                        this.symbolicLinks[path] = realPath;
+                    }
+                }
+                catch (e) {
+                    // Remove the symlink - it's broken
+                    await fs_extra_1.default.remove(path);
                 }
             }
         }

package/dist/cjs/src/ai/aiClient.d.ts

@@ -0,0 +1,20 @@
+import { PlanContext } from './transform';
+export type PromptResult = {
+    explanation: string;
+    response: string;
+    context?: PlanContext;
+};
+export interface AIMessage {
+    content: string;
+    role: 'user' | 'assistant';
+}
+export interface AIRequest {
+    messages: AIMessage[];
+}
+declare class AIClient {
+    private readonly _baseUrl;
+    constructor();
+    sendPrompt(handle: string, body: AIRequest): Promise<PromptResult>;
+}
+export declare const aiClient: AIClient;
+export {};

package/dist/cjs/src/ai/aiClient.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiClient = void 0;
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+const request_1 = __importDefault(require("request"));
+const transform_1 = require("./transform");
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const utils_1 = require("../utils/utils");
+class AIClient {
+    _baseUrl;
+    constructor() {
+        this._baseUrl = (0, utils_1.getRemoteUrl)('ai-service', 'https://ai.kapeta.com');
+    }
+    async sendPrompt(handle, body) {
+        const url = `${this._baseUrl}/v1/plan?type=chat`;
+        const headers = {};
+        const api = new nodejs_api_client_1.KapetaAPI();
+        if (api.hasToken()) {
+            headers['Authorization'] = `Bearer ${await api.getAccessToken()}`;
+        }
+        const options = {
+            url,
+            method: 'POST',
+            json: true,
+            body,
+            headers,
+        };
+        return new Promise((resolve, reject) => {
+            (0, request_1.default)(options, async (error, response, application) => {
+                if (error) {
+                    console.error(error);
+                    reject(error);
+                }
+                if (response.statusCode !== 200) {
+                    console.log('Prompt failed', response.statusCode, response.body);
+                    reject(new Error(`Invalid response code: ${response.statusCode}`));
+                    return;
+                }
+                try {
+                    if (application?.name) {
+                        const planContext = await (0, transform_1.transformToPlan)(handle, application);
+                        resolve({
+                            explanation: application.explanation,
+                            response: application.response ?? application.explanation ?? 'Plan was generated',
+                            context: planContext,
+                        });
+                    }
+                    else {
+                        resolve({
+                            explanation: application.explanation,
+                            response: application.response ??
+                                application.explanation ??
+                                'I did not understand your request. Please rephrase.',
+                        });
+                    }
+                }
+                catch (err) {
+                    console.error(err);
+                    resolve({
+                        explanation: '',
+                        response: 'I did not understand your request. Please rephrase.',
+                    });
+                }
+            });
+        });
+    }
+}
+exports.aiClient = new AIClient();

package/dist/cjs/src/ai/routes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;

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

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const cors_1 = require("../middleware/cors");
+const stringBody_1 = require("../middleware/stringBody");
+const aiClient_1 = require("./aiClient");
+const yaml_1 = __importDefault(require("yaml"));
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
+router.use('/', stringBody_1.stringBody);
+router.post('/prompt/:handle', async (req, res) => {
+    const handle = req.params.handle;
+    try {
+        const aiRequest = JSON.parse(req.stringBody ?? '{}');
+        const result = await aiClient_1.aiClient.sendPrompt(handle, aiRequest);
+        if (req.accepts('application/yaml')) {
+            res.set('Content-Type', 'application/yaml');
+            res.send(yaml_1.default.stringify(result));
+        }
+        else {
+            res.json(result);
+        }
+    }
+    catch (err) {
+        console.error('Failed to send prompt', err);
+        res.status(400).send({ error: err.message });
+        return;
+    }
+});
+exports.default = router;

package/dist/cjs/src/ai/transform.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { BlockDefinition, Plan } from '@kapeta/schemas';
+import { Application } from './types';
+export type PlanContext = {
+    plan: Plan;
+    blocks: BlockDefinition[];
+};
+export declare const transformToPlan: (handle: string, application: Application) => Promise<PlanContext>;

package/dist/cjs/src/ai/transform.js

@@ -0,0 +1,239 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformToPlan = void 0;
+const definitionsManager_1 = require("../definitionsManager");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const node_uuid_1 = __importDefault(require("node-uuid"));
+async function getFreeName(name) {
+    let currentName = name;
+    let iteration = 1;
+    do {
+        const found = await definitionsManager_1.definitionsManager.getLatestDefinition(currentName);
+        if (!found) {
+            return currentName;
+        }
+        currentName = name + '_' + iteration++;
+    } while (true);
+}
+const transformToPlan = async (handle, application) => {
+    const blockTypeService = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/block-type-service');
+    const blockTypeFrontend = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/block-type-frontend');
+    const mongoDbResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-mongodb');
+    const postgresResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-postgresql');
+    const webPageResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-web-page');
+    const webFragmentResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-web-fragment');
+    const restApiResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-rest-api');
+    const restClientResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-rest-client');
+    const javaLanguage = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/language-target-java-spring-boot');
+    const nodejsLanguage = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/language-target-nodejs');
+    const reactLanguage = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/language-target-react-ts');
+    if (!blockTypeService ||
+        !blockTypeFrontend ||
+        !mongoDbResource ||
+        !postgresResource ||
+        !javaLanguage ||
+        !nodejsLanguage ||
+        !reactLanguage ||
+        !webPageResource ||
+        !restApiResource ||
+        !restClientResource ||
+        !webFragmentResource) {
+        throw new Error('Missing definitions');
+    }
+    const plan = {
+        kind: 'core/plan',
+        metadata: {
+            name: await getFreeName(`${handle}/${application.name}`),
+            title: application.title,
+            description: application.description,
+            visibility: 'private',
+        },
+        spec: {
+            blocks: [],
+            connections: [],
+        },
+    };
+    const blocks = [];
+    const addToPlan = (ref, name) => {
+        const top = 100 + Math.floor(plan.spec.blocks.length / 3) * 300;
+        const left = 200 + (plan.spec.blocks.length % 3) * 450;
+        plan.spec.blocks.push({
+            block: {
+                ref,
+            },
+            name,
+            id: node_uuid_1.default.v4(),
+            dimensions: {
+                top,
+                left,
+                width: -1,
+                height: -1,
+            },
+        });
+    };
+    const nameMapper = new Map();
+    for (const backend of application.backends) {
+        const blockName = `${handle}/${backend.name}`;
+        const blockRealName = await getFreeName(blockName);
+        nameMapper.set(blockName, blockRealName);
+        const language = backend.targetLanguage === 'java' ? javaLanguage : nodejsLanguage;
+        const databaseInfo = backend.databases?.[0];
+        const database = databaseInfo?.type === 'mongodb' ? mongoDbResource : postgresResource;
+        const blockRef = (0, nodejs_utils_1.normalizeKapetaUri)(blockRealName + ':local');
+        let targetOptions = {};
+        if (backend.targetLanguage === 'java') {
+            targetOptions = {
+                basePackage: `${handle}.${application.name}`.toLowerCase().replace(/-/g, '_'),
+                groupId: `${handle}.${application.name}`.toLowerCase().replace(/-/g, '_'),
+                artifactId: backend.name.toLowerCase().replace(/-/g, '_'),
+            };
+        }
+        blocks.push({
+            kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${blockTypeService.definition.metadata.name}:${blockTypeService.version}`),
+            metadata: {
+                name: blockRealName,
+                title: backend.title,
+                description: backend.description,
+                visibility: 'private',
+            },
+            spec: {
+                target: {
+                    kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${language.definition.metadata.name}:${language.version}`),
+                    options: targetOptions,
+                },
+                consumers: [
+                    {
+                        kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${database.definition.metadata.name}:${database.version}`),
+                        metadata: {
+                            name: (databaseInfo?.name ?? 'main').replace(/-/g, ''),
+                        },
+                        spec: {
+                            port: {
+                                type: database.definition.spec.ports[0].type,
+                            },
+                        },
+                    },
+                ],
+                providers: [
+                    {
+                        kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${restApiResource.definition.metadata.name}:${restApiResource.version}`),
+                        metadata: {
+                            name: 'main',
+                        },
+                        spec: {
+                            port: {
+                                type: restApiResource.definition.spec.ports[0].type,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        addToPlan(blockRef, backend.name);
+    }
+    for (const frontend of application.frontends) {
+        const blockName = `${handle}/${frontend.name}`;
+        const blockRealName = await getFreeName(blockName);
+        nameMapper.set(blockName, blockRealName);
+        const language = reactLanguage;
+        const blockRef = (0, nodejs_utils_1.normalizeKapetaUri)(blockRealName + ':local');
+        blocks.push({
+            kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${blockTypeFrontend.definition.metadata.name}:${blockTypeFrontend.version}`),
+            metadata: {
+                name: blockRealName,
+                title: frontend.title,
+                description: frontend.description,
+                visibility: 'private',
+            },
+            spec: {
+                target: {
+                    kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${language.definition.metadata.name}:${language.version}`),
+                    options: {},
+                },
+                consumers: [],
+                providers: [
+                    {
+                        kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${webPageResource.definition.metadata.name}:${webPageResource.version}`),
+                        metadata: {
+                            name: 'main',
+                        },
+                        spec: {
+                            port: {
+                                type: webPageResource.definition.spec.ports[0].type,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        addToPlan(blockRef, frontend.name);
+    }
+    application.connections?.forEach((connection) => {
+        const fullProviderName = nameMapper.get(`${handle}/${connection.provider.name}`);
+        const fullConsumerName = nameMapper.get(`${handle}/${connection.consumer.name}`);
+        const consumerResourceName = connection.provider.name;
+        const providerRef = (0, nodejs_utils_1.normalizeKapetaUri)(`${fullProviderName}:local`);
+        const consumerRef = (0, nodejs_utils_1.normalizeKapetaUri)(`${fullConsumerName}:local`);
+        const instanceProvider = plan.spec.blocks.find((b) => b.block.ref === providerRef);
+        const instanceConsumer = plan.spec.blocks.find((b) => b.block.ref === consumerRef);
+        const consumerBlock = blocks.find((block) => block.metadata.name === fullConsumerName);
+        const providerBlock = blocks.find((block) => block.metadata.name === fullProviderName);
+        if (!consumerBlock) {
+            throw new Error('Missing consumer block: ' + fullConsumerName);
+        }
+        if (!providerBlock) {
+            throw new Error('Missing provider block: ' + fullProviderName);
+        }
+        const portType = (0, nodejs_utils_1.parseKapetaUri)(providerBlock.kind).fullName === 'kapeta/block-type-service' ? 'rest' : 'web';
+        if (portType === 'rest') {
+            consumerBlock.spec.consumers.push({
+                kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${restClientResource.definition.metadata.name}:${restClientResource.version}`),
+                metadata: {
+                    name: consumerResourceName,
+                },
+                spec: {
+                    port: {
+                        type: 'rest',
+                    },
+                },
+            });
+        }
+        else {
+            consumerBlock.spec.consumers.push({
+                kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${webFragmentResource.definition.metadata.name}:${webFragmentResource.version}`),
+                metadata: {
+                    name: consumerResourceName,
+                },
+                spec: {
+                    port: {
+                        type: 'web',
+                    },
+                },
+            });
+        }
+        plan.spec.connections.push({
+            provider: {
+                blockId: instanceProvider.id,
+                resourceName: 'main',
+                port: {
+                    type: portType,
+                },
+            },
+            consumer: {
+                blockId: instanceConsumer.id,
+                resourceName: consumerResourceName,
+                port: {
+                    type: portType,
+                },
+            },
+        });
+    });
+    return {
+        plan,
+        blocks,
+    };
+};
+exports.transformToPlan = transformToPlan;

package/dist/cjs/src/ai/types.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+export interface Database {
+    name: string;
+    type: 'mongodb' | 'postgres';
+}
+export interface BackendService {
+    name: string;
+    title: string;
+    description: string;
+    targetLanguage: 'java' | 'node';
+    databases: Database[] | null;
+}
+export interface FrontendService {
+    name: string;
+    title: string;
+    description: string;
+    targetLanguage: 'react';
+}
+export interface Endpoint {
+    type: 'backend' | 'frontend';
+    name: string;
+}
+export interface Connection {
+    provider: Endpoint;
+    consumer: Endpoint;
+}
+export interface Application {
+    kind: 'core/plan';
+    name: string;
+    title: string;
+    description: string;
+    backends: BackendService[];
+    frontends: FrontendService[];
+    connections: Connection[];
+    explanation: string;
+    response: string;
+}

package/dist/cjs/src/ai/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/src/assetManager.js

@@ -24,10 +24,13 @@ 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 filterExists(asset) {
+    return fs_extra_1.default.existsSync(asset.path);
+}
 function enrichAsset(asset) {
     return {
         ref: `kapeta://${asset.definition.metadata.name}:${asset.version}`,
-        editable: asset.version === 'local',
+        editable: asset.version === 'local', //Only local versions are editable
         exists: true,
         version: asset.version,
         kind: asset.definition.kind,
@@ -81,7 +84,7 @@ class AssetManager {
             assetKinds.push('core/plan');
         }
         const assets = await definitionsManager_1.definitionsManager.getDefinitions(assetKinds);
-        return assets.map(enrichAsset);
+        return assets.filter(filterExists).map(enrichAsset);
     }
     async getPlans() {
         return this.getAssets(['core/plan']);

package/dist/cjs/src/codeGeneratorManager.js

@@ -58,13 +58,14 @@ class CodeGeneratorManager {
         });
     }
     async canGenerateCode(yamlContent) {
-        if (!yamlContent.spec.target?.kind) {
+        if (!yamlContent.spec?.target?.kind || !yamlContent.kind) {
             //Not all block types have targets
             return false;
         }
+        const kindUri = (0, nodejs_utils_1.parseKapetaUri)(yamlContent.kind);
         const blockTypes = await definitionsManager_1.definitionsManager.getDefinitions(BLOCK_TYPE_KIND);
-        const blockTypeKinds = blockTypes.map((blockType) => blockType.definition.metadata.name.toLowerCase() + ':' + blockType.version);
-        return !!(yamlContent && yamlContent.kind && blockTypeKinds.indexOf(yamlContent.kind.toLowerCase()) > -1);
+        const blockTypeKinds = blockTypes.map((blockType) => (0, nodejs_utils_1.parseKapetaUri)(blockType.definition.metadata.name).fullName);
+        return blockTypeKinds.includes(kindUri.fullName);
     }
     async generate(yamlFile, yamlContent) {
         if (!yamlContent.spec.target?.kind) {

package/dist/cjs/src/containerManager.js

@@ -98,11 +98,17 @@ class ContainerManager {
             ];
         for (const opts of connectOptions) {
             try {
+                const testClient = new dockerode_1.default({
+                    ...opts,
+                    timeout: 1000, // 1 secs should be enough for a ping
+                });
+                await testClient.ping();
+                // If we get here - we have a working connection
+                // Now create a client with a longer timeout for all other operations
                 const client = new dockerode_1.default({
                     ...opts,
                     timeout: 15 * 60 * 1000, //15 minutes should be enough for any operation
                 });
-                await client.ping();
                 this._docker = client;
                 const versionInfo = await client.version();
                 this._version = versionInfo.Server?.Version ?? versionInfo.Version;

package/dist/cjs/src/definitionsManager.js

@@ -131,9 +131,9 @@ class DefinitionsManager {
         const definitions = await this.getDefinitions();
         return definitions.find((d) => {
             if (!uri.version) {
-                return d.definition.metadata.name === uri.fullName;
+                return d.definition.metadata.name.toLowerCase() === uri.fullName.toLowerCase();
             }
-            return (0, nodejs_utils_1.parseKapetaUri)(`${d.definition.metadata.name}:${d.version}`).id === uri.id;
+            return (0, nodejs_utils_1.parseKapetaUri)(`${d.definition.metadata.name}:${d.version}`).equals(uri);
         });
     }
     async getLatestDefinition(name) {

package/dist/cjs/src/instanceManager.js

@@ -25,7 +25,7 @@ const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const definitionsManager_1 = require("./definitionsManager");
 const taskManager_1 = require("./taskManager");
 const CHECK_INTERVAL = 5000;
-const DEFAULT_HEALTH_PORT_TYPE = 'rest';
+const DEFAULT_HEALTH_PORT_TYPE = 'http';
 const MIN_TIME_RUNNING = 30000; //If something didnt run for more than 30 secs - it failed
 class InstanceManager {
     _interval = undefined;
@@ -198,7 +198,7 @@ class InstanceManager {
     }
     getHealthUrl(info, address) {
         let healthUrl = null;
-        let health = info.health;
+        let health = info.health ?? '/.kapeta/health';
         if (health) {
             if (health.startsWith('/')) {
                 health = health.substring(1);

package/dist/cjs/src/repositoryManager.js

@@ -183,7 +183,7 @@ class RepositoryManager extends node_events_1.EventEmitter {
                 if (await definitionsManager_1.definitionsManager.exists(ref)) {
                     return;
                 }
-                throw new Error(`Failed to install asset: ${ref}`);
+                throw new Error(`Failed to find asset after installation: ${ref}. Please try again`);
             };
         };
         const tasks = [];

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

@@ -5,6 +5,7 @@
 import { EntityList } from '@kapeta/schemas';
 import { AnyMap } from '../types';
 export declare function getBlockInstanceContainerName(systemId: string, instanceId: string): string;
+export declare function getRemoteUrl(id: string, defautValue: string): any;
 export declare function readYML(path: string): any;
 export declare function isWindows(): boolean;
 export declare function isMac(): boolean;