@kapeta/local-cluster-service 0.41.0 → 0.42.0

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+# [0.42.0](https://github.com/kapetacom/local-cluster-service/compare/v0.41.1...v0.42.0) (2024-04-18)
+
+
+### Features
+
+* Add support for file config values ([#141](https://github.com/kapetacom/local-cluster-service/issues/141)) ([437eb75](https://github.com/kapetacom/local-cluster-service/commit/437eb75a1c5c94979cca4fedae6a2d1756f0043d))
+
+## [0.41.1](https://github.com/kapetacom/local-cluster-service/compare/v0.41.0...v0.41.1) (2024-04-16)
+
+
+### Bug Fixes
+
+* better missing file handling [CORE-2685] ([1baf002](https://github.com/kapetacom/local-cluster-service/commit/1baf002c18c6acc92a4f6ca1bff37cda9270e487))
+* bump local-cluster-config w/ improved error handling ([f9a945f](https://github.com/kapetacom/local-cluster-service/commit/f9a945f7761e472e45bc55839b40e563c5298719))
+
 # [0.41.0](https://github.com/kapetacom/local-cluster-service/compare/v0.40.6...v0.41.0) (2024-04-12)
 
 

package/definitions.d.ts

@@ -7,6 +7,10 @@ declare module 'recursive-watch' {
     export default function watch(path: string, callback: (filename: string) => void): () => void;
 }
 
+declare module 'parse-data-uri' {
+    export default function parseDataUri(uri: string): { data: Buffer; mediaType: string };
+}
+
 declare module '@kapeta/nodejs-registry-utils' {
     import { Dependency, Kind } from '@kapeta/schemas';
 

package/dist/cjs/src/assetManager.js

@@ -25,10 +25,17 @@ 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) && fs_extra_1.default.existsSync(asset.ymlPath);
-}
 function enrichAsset(asset) {
+    let exists = true;
+    let path = asset.path;
+    let ymlPath = asset.ymlPath;
+    try {
+        path = fs_extra_1.default.realpathSync(path);
+        ymlPath = fs_extra_1.default.realpathSync(ymlPath);
+    }
+    catch (e) {
+        exists = false;
+    }
     return {
         ref: `kapeta://${asset.definition.metadata.name}:${asset.version}`,
         editable: asset.version === 'local', //Only local versions are editable
@@ -36,8 +43,8 @@ function enrichAsset(asset) {
         version: asset.version,
         kind: asset.definition.kind,
         data: asset.definition,
-        path: fs_extra_1.default.realpathSync(asset.path),
-        ymlPath: fs_extra_1.default.realpathSync(asset.ymlPath),
+        path,
+        ymlPath,
     };
 }
 function compareRefs(a, b) {
@@ -86,7 +93,7 @@ class AssetManager {
             assetKinds.push('core/plan');
         }
         const assets = await definitionsManager_1.definitionsManager.getDefinitions(assetKinds);
-        return assets.filter(filterExists).map(enrichAsset);
+        return assets.map(enrichAsset).filter((a) => a.exists);
     }
     async getPlans() {
         return this.getAssets(['core/plan']);
@@ -124,9 +131,14 @@ class AssetManager {
             throw new Error('Asset not found: ' + ref);
         }
         if (definitionInfo) {
-            const asset = enrichAsset(definitionInfo);
-            cacheManager_1.cacheManager.set(cacheKey, asset, CACHE_TTL);
-            return asset;
+            try {
+                const asset = enrichAsset(definitionInfo);
+                cacheManager_1.cacheManager.set(cacheKey, asset, CACHE_TTL);
+                return asset;
+            }
+            catch (e) {
+                console.error('Failed to enrich asset', e);
+            }
         }
         return undefined;
     }

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

@@ -15,6 +15,8 @@ const instanceManager_1 = require("../instanceManager");
 const cors_1 = require("../middleware/cors");
 const kapeta_1 = require("../middleware/kapeta");
 const stringBody_1 = require("../middleware/stringBody");
+const assetManager_1 = require("../assetManager");
+const definitionsManager_1 = require("../definitionsManager");
 const router = (0, express_promise_router_1.default)();
 router.use('/', cors_1.corsHandler);
 router.use('/', kapeta_1.kapetaHeaders);
@@ -26,7 +28,7 @@ router.get('/instance', async (req, res) => {
     try {
         let config = {};
         if (req.kapeta.instanceId) {
-            config = await configManager_1.configManager.getConfigForBlockInstance(req.kapeta.systemId, req.kapeta.instanceId);
+            config = await configManager_1.configManager.getConfigForBlockInstance(req.kapeta.systemId, req.kapeta.instanceId, req.kapeta?.environment === 'docker');
         }
         else {
             config = configManager_1.configManager.getConfigForSystem(req.kapeta.systemId);
@@ -49,7 +51,19 @@ router.put('/instance', async (req, res) => {
             config = {};
         }
         if (req.kapeta.instanceId) {
-            configManager_1.configManager.setConfigForSection(req.kapeta.systemId, req.kapeta.instanceId, config);
+            const blockInstance = await assetManager_1.assetManager.getBlockInstance(req.kapeta.systemId, req.kapeta.instanceId);
+            if (!blockInstance) {
+                throw new Error(`Block instance not found: ${req.kapeta.instanceId} in plan ${req.kapeta.systemId}`);
+            }
+            const blockDefinition = await definitionsManager_1.definitionsManager.getDefinition(blockInstance.block.ref);
+            if (!blockDefinition) {
+                throw new Error(`Block definition not found: ${blockInstance.block.ref}`);
+            }
+            let configEntityList = {};
+            if (blockDefinition.definition.spec.configuration) {
+                configEntityList = blockDefinition.definition.spec.configuration;
+            }
+            await configManager_1.configManager.setConfigForBlockInstance(req.kapeta.systemId, req.kapeta.instanceId, configEntityList, config);
             //Restart the instance if it is running after config change
             await instanceManager_1.instanceManager.prepareForRestart(req.kapeta.systemId, req.kapeta.instanceId);
         }

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

@@ -2,6 +2,8 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+import { EntityList } from '@kapeta/schemas';
+import { StringMap } from './types';
 export declare const SYSTEM_ID = "$plan";
 type AnyMap = {
     [key: string]: any;
@@ -16,8 +18,12 @@ declare class ConfigManager {
     _forSystem(systemId: string): any;
     setConfigForSystem(systemId: string, config: AnyMap): void;
     getConfigForSystem(systemId: string): AnyMap;
-    getConfigForBlockInstance(systemId: string, instanceId: string): Promise<import("./types").AnyMap>;
+    getConfigForBlockInstance(systemId: string, instanceId: string, rewritePaths?: boolean): Promise<import("./types").AnyMap>;
+    rewriteFilePaths(configSchema: EntityList, config: AnyMap, toBaseDir?: string): StringMap;
     setConfigForSection(systemId: string, sectionId: string, config: AnyMap): void;
+    getFilesBaseDir(): string;
+    private saveFile;
+    setConfigForBlockInstance(systemId: string, instanceId: string, configEntityList: EntityList, config: AnyMap): Promise<void>;
     getConfigForSection(systemId: string, sectionId: string): any;
     /**
      * Try to identify the plan and instance in a plan automatically based on the block reference

package/dist/cjs/src/configManager.js

@@ -3,12 +3,22 @@
  * 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 });
 exports.configManager = exports.SYSTEM_ID = void 0;
-const storageService_1 = require("./storageService");
 const assetManager_1 = require("./assetManager");
+const schemas_1 = require("@kapeta/schemas");
+const storageService_1 = require("./storageService");
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const utils_1 = require("./utils/utils");
+const parse_data_uri_1 = __importDefault(require("parse-data-uri"));
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const path_1 = __importDefault(require("path"));
+const node_uuid_1 = __importDefault(require("node-uuid"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const lodash_1 = __importDefault(require("lodash"));
 exports.SYSTEM_ID = '$plan';
 class ConfigManager {
     _config;
@@ -31,14 +41,49 @@ class ConfigManager {
         systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
         return this._forSystem(systemId);
     }
-    async getConfigForBlockInstance(systemId, instanceId) {
+    async getConfigForBlockInstance(systemId, instanceId, rewritePaths = false) {
         const blockInstance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
         const blockAsset = await assetManager_1.assetManager.getAsset(blockInstance.block.ref, true);
         if (!blockAsset) {
             throw new Error(`Block definition not found: ${blockInstance.block.ref}`);
         }
         const instanceConfig = this.getConfigForSection(systemId, instanceId);
-        return (0, utils_1.getResolvedConfiguration)(blockAsset.data.spec.configuration, instanceConfig, blockInstance.defaultConfiguration);
+        const config = lodash_1.default.cloneDeep((0, utils_1.getResolvedConfiguration)(blockAsset.data.spec.configuration, instanceConfig, blockInstance.defaultConfiguration));
+        if (rewritePaths) {
+            this.rewriteFilePaths(blockAsset.data.spec.configuration, config);
+        }
+        return config;
+    }
+    rewriteFilePaths(configSchema, config, toBaseDir = '/files') {
+        const fileMap = {};
+        if (!configSchema || !configSchema.types) {
+            return fileMap;
+        }
+        const fromBaseDir = this.getFilesBaseDir();
+        for (const entity of configSchema.types) {
+            if (entity.type !== schemas_1.EntityType.Dto) {
+                continue;
+            }
+            if (!entity.properties || !config[entity.name]) {
+                continue;
+            }
+            const innerValue = config[entity.name];
+            for (const key in entity.properties) {
+                const prop = entity.properties[key];
+                if (prop.type !== 'file') {
+                    continue;
+                }
+                const value = innerValue[key];
+                if (!value || !value.startsWith(fromBaseDir)) {
+                    continue;
+                }
+                const src = value;
+                const dst = toBaseDir + '/' + value.substring(fromBaseDir.length + 1);
+                fileMap[src] = dst;
+                innerValue[key] = dst;
+            }
+        }
+        return fileMap;
     }
     setConfigForSection(systemId, sectionId, config) {
         systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
@@ -46,6 +91,47 @@ class ConfigManager {
         systemConfig[sectionId] = config || {};
         storageService_1.storageService.put('config', systemId, systemConfig);
     }
+    getFilesBaseDir() {
+        return path_1.default.join(local_cluster_config_1.default.getKapetaBasedir(), 'files');
+    }
+    async saveFile(value) {
+        const filename = node_uuid_1.default.v4();
+        const basePath = this.getFilesBaseDir();
+        await fs_extra_1.default.mkdirp(basePath);
+        const filepath = path_1.default.join(basePath, filename);
+        await fs_extra_1.default.writeFile(filepath, value);
+        return filepath;
+    }
+    async setConfigForBlockInstance(systemId, instanceId, configEntityList, config) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        let systemConfig = this._forSystem(systemId);
+        let configValue = config || {};
+        if (configEntityList.types) {
+            for (let entity of configEntityList.types) {
+                if (entity.type !== schemas_1.EntityType.Dto) {
+                    continue;
+                }
+                if (!configValue[entity.name] || !entity.properties) {
+                    continue;
+                }
+                const innerValues = configValue[entity.name];
+                for (let key in innerValues) {
+                    if (!entity.properties[key]) {
+                        continue;
+                    }
+                    if (entity.properties[key].type === 'file' &&
+                        typeof innerValues[key] === 'string' &&
+                        innerValues[key].startsWith('data:')) {
+                        // This was a file upload - save the file to disk and replace value with path
+                        const data = (0, parse_data_uri_1.default)(innerValues[key]);
+                        innerValues[key] = await this.saveFile(data.data);
+                    }
+                }
+            }
+        }
+        systemConfig[instanceId] = configValue;
+        storageService_1.storageService.put('config', systemId, systemConfig);
+    }
     getConfigForSection(systemId, sectionId) {
         systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
         const systemConfig = this._forSystem(systemId);

package/dist/cjs/src/instanceManager.js

@@ -17,7 +17,6 @@ const socketManager_1 = require("./socketManager");
 const serviceManager_1 = require("./serviceManager");
 const assetManager_1 = require("./assetManager");
 const containerManager_1 = require("./containerManager");
-const configManager_1 = require("./configManager");
 const types_1 = require("./types");
 const utils_1 = require("./utils/utils");
 const operatorManager_1 = require("./operatorManager");
@@ -501,12 +500,11 @@ class InstanceManager {
                     return existingInstance;
                 }
             }
-            const resolvedConfig = await configManager_1.configManager.getConfigForBlockInstance(systemId, instanceId);
             const task = taskManager_1.taskManager.add(`instance:start:${systemId}:${instanceId}`, async () => {
                 const runner = new BlockInstanceRunner_1.BlockInstanceRunner(systemId);
                 const startTime = Date.now();
                 try {
-                    const processInfo = await runner.start(blockRef, instanceId, resolvedConfig);
+                    const processInfo = await runner.start(blockRef, instanceId);
                     instance.status = types_1.InstanceStatus.STARTING;
                     return this.saveInternalInstance({
                         ...instance,

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

@@ -31,7 +31,6 @@ export interface LogEntry {
 export interface BlockProcessParams {
     id: string;
     ref: string;
-    configuration?: AnyMap;
 }
 export declare enum InstanceType {
     DOCKER = "docker",

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

@@ -2,7 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { AnyMap, ProcessInfo } from '../types';
+import { ProcessInfo } from '../types';
 export declare function resolvePortType(portType: string): string;
 export declare class BlockInstanceRunner {
     private readonly _systemId;
@@ -11,12 +11,13 @@ export declare class BlockInstanceRunner {
      * Start a block
      *
      */
-    start(blockRef: string, instanceId: string, configuration: AnyMap): Promise<ProcessInfo>;
+    start(blockRef: string, instanceId: string): Promise<ProcessInfo>;
     private _execute;
     /**
      * Starts local process
      */
     private _startLocalProcess;
+    private prepareBinds;
     private _startDockerProcess;
     private _startOperatorProcess;
     /**

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

@@ -24,6 +24,7 @@ const taskManager_1 = require("../taskManager");
 const InternalConfigProvider_1 = require("./InternalConfigProvider");
 const config_mapper_1 = require("@kapeta/config-mapper");
 const crypto_1 = __importDefault(require("crypto"));
+const configManager_1 = require("../configManager");
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
 const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
 const KAPETA_INSTANCE_ID = 'KAPETA_INSTANCE_ID';
@@ -89,11 +90,10 @@ class BlockInstanceRunner {
      * Start a block
      *
      */
-    async start(blockRef, instanceId, configuration) {
+    async start(blockRef, instanceId) {
         return this._execute({
             ref: blockRef,
             id: instanceId,
-            configuration,
         });
     }
     async _execute(blockInstance) {
@@ -112,7 +112,10 @@ class BlockInstanceRunner {
         }
         const baseDir = local_cluster_config_1.default.getRepositoryAssetPath(blockUri.handle, blockUri.name, blockUri.version);
         const realBaseDir = await fs_extra_1.default.realpath(baseDir);
-        const internalConfigProvider = await (0, InternalConfigProvider_1.createInternalConfigProvider)(this._systemId, blockInstance.id, assetVersion);
+        const config = await configManager_1.configManager.getConfigForBlockInstance(this._systemId, blockInstance.id);
+        const configSchema = (assetVersion.definition.spec.configuration ? assetVersion.definition.spec.configuration : {});
+        const fileMapping = configManager_1.configManager.rewriteFilePaths(configSchema, config);
+        const internalConfigProvider = await (0, InternalConfigProvider_1.createInternalConfigProvider)(this._systemId, blockInstance.id, assetVersion, config);
         // Resolve the environment variables
         const blockVariables = await (0, config_mapper_1.resolveKapetaVariables)(realBaseDir, internalConfigProvider);
         const variables = await this.appendConnectedBlockOperatorEnv(internalConfigProvider, blockInstance, blockVariables);
@@ -133,10 +136,10 @@ class BlockInstanceRunner {
             //We need a port type to know how to connect to the block consistently
             const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
             if (blockUri.version === 'local') {
-                processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
+                processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion, fileMapping);
             }
             else {
-                processInfo = await this._startDockerProcess(blockInstance, blockUri, env, assetVersion);
+                processInfo = await this._startDockerProcess(blockInstance, blockUri, env, assetVersion, fileMapping);
             }
             if (portTypes.length > 0) {
                 processInfo.portType = portTypes[0];
@@ -147,7 +150,7 @@ class BlockInstanceRunner {
     /**
      * Starts local process
      */
-    async _startLocalProcess(blockInstance, blockInfo, env, assetVersion) {
+    async _startLocalProcess(blockInstance, blockInfo, env, assetVersion, fileMapping) {
         const baseDir = local_cluster_config_1.default.getRepositoryAssetPath(blockInfo.handle, blockInfo.name, blockInfo.version);
         if (!fs_extra_1.default.existsSync(baseDir)) {
             throw new Error(`Local block not registered correctly - expected symlink here: ${baseDir}.\n` +
@@ -211,14 +214,7 @@ class BlockInstanceRunner {
         if (localContainer.healthcheck) {
             HealthCheck = containerManager_1.containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
-        if (env[config_mapper_1.KAPETA_CONFIG_ENV_VAR]) {
-            // If we have a config file, we need to bind it to the container and adjust the env var
-            const localConfig = `/${config_mapper_1.KAPETA_ENV_CONFIG_FILE}`;
-            Binds.push(`${(0, containerManager_1.toLocalBindVolume)(env[config_mapper_1.KAPETA_CONFIG_ENV_VAR])}:${localConfig}:ro`);
-            // We also provide the hash to detect changes to the config file
-            env['KAPETA_CONFIG_HASH'] = await this.getFileHash(env[config_mapper_1.KAPETA_CONFIG_ENV_VAR]);
-            env[config_mapper_1.KAPETA_CONFIG_ENV_VAR] = localConfig;
-        }
+        await this.prepareBinds(env, Binds, fileMapping);
         const Mounts = isDockerImage
             ? // For docker images we mount the local directory to the working directory
                 containerManager_1.containerManager.toDockerMounts({
@@ -271,7 +267,22 @@ class BlockInstanceRunner {
             },
         });
     }
-    async _startDockerProcess(blockInstance, blockInfo, env, assetVersion) {
+    async prepareBinds(env, Binds, fileMapping) {
+        if (env[config_mapper_1.KAPETA_CONFIG_ENV_VAR]) {
+            // If we have a config file, we need to bind it to the container and adjust the env var
+            const localConfig = `/${config_mapper_1.KAPETA_ENV_CONFIG_FILE}`;
+            Binds.push(`${(0, containerManager_1.toLocalBindVolume)(env[config_mapper_1.KAPETA_CONFIG_ENV_VAR])}:${localConfig}:ro`);
+            // We also provide the hash to detect changes to the config file
+            env['KAPETA_CONFIG_HASH'] = await this.getFileHash(env[config_mapper_1.KAPETA_CONFIG_ENV_VAR]);
+            env[config_mapper_1.KAPETA_CONFIG_ENV_VAR] = localConfig;
+        }
+        if (fileMapping) {
+            Object.entries(fileMapping).forEach(([src, dst]) => {
+                Binds.push(`${(0, containerManager_1.toLocalBindVolume)(src)}:${dst}:ro`);
+            });
+        }
+    }
+    async _startDockerProcess(blockInstance, blockInfo, env, assetVersion, fileMapping) {
         const { versionFile } = local_cluster_config_1.default.getRepositoryAssetInfoPath(blockInfo.handle, blockInfo.name, blockInfo.version);
         const versionYml = versionFile;
         if (!fs_extra_1.default.existsSync(versionYml)) {
@@ -296,14 +307,7 @@ class BlockInstanceRunner {
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
         const systemUri = (0, nodejs_utils_1.parseKapetaUri)(this._systemId);
         const Binds = [`${(0, containerManager_1.toLocalBindVolume)(local_cluster_config_1.default.getKapetaBasedir())}:${innerHome}`];
-        if (env[config_mapper_1.KAPETA_CONFIG_ENV_VAR]) {
-            // If we have a config file, we need to bind it to the container and adjust the env var
-            const localConfig = `/${config_mapper_1.KAPETA_ENV_CONFIG_FILE}`;
-            Binds.push(`${(0, containerManager_1.toLocalBindVolume)(env[config_mapper_1.KAPETA_CONFIG_ENV_VAR])}:${localConfig}:ro`);
-            // We also provide the hash to detect changes to the config file
-            env['KAPETA_CONFIG_HASH'] = await this.getFileHash(env[config_mapper_1.KAPETA_CONFIG_ENV_VAR]);
-            env[config_mapper_1.KAPETA_CONFIG_ENV_VAR] = localConfig;
-        }
+        await this.prepareBinds(env, Binds, fileMapping);
         return this.ensureContainer({
             Image: dockerImage,
             name: containerName,
@@ -486,7 +490,8 @@ class BlockInstanceRunner {
         const plan = await internalConfigProvider.getPlan();
         const connectedBlockIds = [
             ...new Set(plan.spec.connections
-                .filter((connection) => connection.provider.blockId == blockInstance.id || connection.consumer.blockId == blockInstance.id)
+                .filter((connection) => connection.provider.blockId == blockInstance.id ||
+                connection.consumer.blockId == blockInstance.id)
                 .flatMap((connection) => [connection.provider.blockId, connection.consumer.blockId])
                 .filter((blockId) => blockId !== blockInstance.id)),
         ];

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

@@ -35,4 +35,4 @@ export declare class InternalConfigProvider implements ConfigProvider {
     getBlock(ref: any): Promise<Definition>;
     getPlan(): Promise<Plan>;
 }
-export declare function createInternalConfigProvider(systemId: string, instanceId: string, info: DefinitionInfo): Promise<InternalConfigProvider>;
+export declare function createInternalConfigProvider(systemId: string, instanceId: string, info: DefinitionInfo, config: AnyMap): Promise<InternalConfigProvider>;

package/dist/cjs/src/utils/InternalConfigProvider.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createInternalConfigProvider = exports.InternalConfigProvider = void 0;
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
-const configManager_1 = require("../configManager");
 const lodash_1 = __importDefault(require("lodash"));
 const serviceManager_1 = require("../serviceManager");
 const operatorManager_1 = require("../operatorManager");
@@ -139,8 +138,7 @@ class InternalConfigProvider {
     }
 }
 exports.InternalConfigProvider = InternalConfigProvider;
-async function createInternalConfigProvider(systemId, instanceId, info) {
-    const config = await configManager_1.configManager.getConfigForBlockInstance(systemId, instanceId);
+async function createInternalConfigProvider(systemId, instanceId, info, config) {
     return new InternalConfigProvider(systemId, instanceId, info, config);
 }
 exports.createInternalConfigProvider = createInternalConfigProvider;

package/dist/esm/src/assetManager.js

@@ -25,10 +25,17 @@ 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) && fs_extra_1.default.existsSync(asset.ymlPath);
-}
 function enrichAsset(asset) {
+    let exists = true;
+    let path = asset.path;
+    let ymlPath = asset.ymlPath;
+    try {
+        path = fs_extra_1.default.realpathSync(path);
+        ymlPath = fs_extra_1.default.realpathSync(ymlPath);
+    }
+    catch (e) {
+        exists = false;
+    }
     return {
         ref: `kapeta://${asset.definition.metadata.name}:${asset.version}`,
         editable: asset.version === 'local', //Only local versions are editable
@@ -36,8 +43,8 @@ function enrichAsset(asset) {
         version: asset.version,
         kind: asset.definition.kind,
         data: asset.definition,
-        path: fs_extra_1.default.realpathSync(asset.path),
-        ymlPath: fs_extra_1.default.realpathSync(asset.ymlPath),
+        path,
+        ymlPath,
     };
 }
 function compareRefs(a, b) {
@@ -86,7 +93,7 @@ class AssetManager {
             assetKinds.push('core/plan');
         }
         const assets = await definitionsManager_1.definitionsManager.getDefinitions(assetKinds);
-        return assets.filter(filterExists).map(enrichAsset);
+        return assets.map(enrichAsset).filter((a) => a.exists);
     }
     async getPlans() {
         return this.getAssets(['core/plan']);
@@ -124,9 +131,14 @@ class AssetManager {
             throw new Error('Asset not found: ' + ref);
         }
         if (definitionInfo) {
-            const asset = enrichAsset(definitionInfo);
-            cacheManager_1.cacheManager.set(cacheKey, asset, CACHE_TTL);
-            return asset;
+            try {
+                const asset = enrichAsset(definitionInfo);
+                cacheManager_1.cacheManager.set(cacheKey, asset, CACHE_TTL);
+                return asset;
+            }
+            catch (e) {
+                console.error('Failed to enrich asset', e);
+            }
         }
         return undefined;
     }

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

@@ -15,6 +15,8 @@ const instanceManager_1 = require("../instanceManager");
 const cors_1 = require("../middleware/cors");
 const kapeta_1 = require("../middleware/kapeta");
 const stringBody_1 = require("../middleware/stringBody");
+const assetManager_1 = require("../assetManager");
+const definitionsManager_1 = require("../definitionsManager");
 const router = (0, express_promise_router_1.default)();
 router.use('/', cors_1.corsHandler);
 router.use('/', kapeta_1.kapetaHeaders);
@@ -26,7 +28,7 @@ router.get('/instance', async (req, res) => {
     try {
         let config = {};
         if (req.kapeta.instanceId) {
-            config = await configManager_1.configManager.getConfigForBlockInstance(req.kapeta.systemId, req.kapeta.instanceId);
+            config = await configManager_1.configManager.getConfigForBlockInstance(req.kapeta.systemId, req.kapeta.instanceId, req.kapeta?.environment === 'docker');
         }
         else {
             config = configManager_1.configManager.getConfigForSystem(req.kapeta.systemId);
@@ -49,7 +51,19 @@ router.put('/instance', async (req, res) => {
             config = {};
         }
         if (req.kapeta.instanceId) {
-            configManager_1.configManager.setConfigForSection(req.kapeta.systemId, req.kapeta.instanceId, config);
+            const blockInstance = await assetManager_1.assetManager.getBlockInstance(req.kapeta.systemId, req.kapeta.instanceId);
+            if (!blockInstance) {
+                throw new Error(`Block instance not found: ${req.kapeta.instanceId} in plan ${req.kapeta.systemId}`);
+            }
+            const blockDefinition = await definitionsManager_1.definitionsManager.getDefinition(blockInstance.block.ref);
+            if (!blockDefinition) {
+                throw new Error(`Block definition not found: ${blockInstance.block.ref}`);
+            }
+            let configEntityList = {};
+            if (blockDefinition.definition.spec.configuration) {
+                configEntityList = blockDefinition.definition.spec.configuration;
+            }
+            await configManager_1.configManager.setConfigForBlockInstance(req.kapeta.systemId, req.kapeta.instanceId, configEntityList, config);
             //Restart the instance if it is running after config change
             await instanceManager_1.instanceManager.prepareForRestart(req.kapeta.systemId, req.kapeta.instanceId);
         }

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

@@ -2,6 +2,8 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+import { EntityList } from '@kapeta/schemas';
+import { StringMap } from './types';
 export declare const SYSTEM_ID = "$plan";
 type AnyMap = {
     [key: string]: any;
@@ -16,8 +18,12 @@ declare class ConfigManager {
     _forSystem(systemId: string): any;
     setConfigForSystem(systemId: string, config: AnyMap): void;
     getConfigForSystem(systemId: string): AnyMap;
-    getConfigForBlockInstance(systemId: string, instanceId: string): Promise<import("./types").AnyMap>;
+    getConfigForBlockInstance(systemId: string, instanceId: string, rewritePaths?: boolean): Promise<import("./types").AnyMap>;
+    rewriteFilePaths(configSchema: EntityList, config: AnyMap, toBaseDir?: string): StringMap;
     setConfigForSection(systemId: string, sectionId: string, config: AnyMap): void;
+    getFilesBaseDir(): string;
+    private saveFile;
+    setConfigForBlockInstance(systemId: string, instanceId: string, configEntityList: EntityList, config: AnyMap): Promise<void>;
     getConfigForSection(systemId: string, sectionId: string): any;
     /**
      * Try to identify the plan and instance in a plan automatically based on the block reference