@kapeta/local-cluster-service 0.41.0 → 0.42.0

package/dist/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.41.0",
+    "version": "0.42.0",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {
@@ -50,7 +50,7 @@
     "dependencies": {
         "@kapeta/codegen": "^1.3.0",
         "@kapeta/config-mapper": "^1.2.0",
-        "@kapeta/local-cluster-config": "^0.4.1",
+        "@kapeta/local-cluster-config": "^0.4.2",
         "@kapeta/nodejs-api-client": ">=0.2.0 <2",
         "@kapeta/nodejs-process": "^1.2.0",
         "@kapeta/nodejs-registry-utils": ">=0.11.1 <2",
@@ -73,6 +73,7 @@
         "md5": "2.2.1",
         "node-cache": "^5.1.2",
         "node-uuid": "^1.4.8",
+        "parse-data-uri": "^0.2.0",
         "qs": "^6.11.2",
         "request": "2.88.2",
         "socket.io": "^4.5.2",

package/src/assetManager.ts

@@ -36,11 +36,16 @@ export interface EnrichedAsset {
     ymlPath: string;
 }
 
-function filterExists(asset: DefinitionInfo): boolean {
-    return FS.existsSync(asset.path) && FS.existsSync(asset.ymlPath);
-}
-
 function enrichAsset(asset: DefinitionInfo): EnrichedAsset {
+    let exists = true;
+    let path = asset.path;
+    let ymlPath = asset.ymlPath;
+    try {
+        path = FS.realpathSync(path);
+        ymlPath = FS.realpathSync(ymlPath);
+    } catch (e) {
+        exists = false;
+    }
     return {
         ref: `kapeta://${asset.definition.metadata.name}:${asset.version}`,
         editable: asset.version === 'local', //Only local versions are editable
@@ -48,8 +53,8 @@ function enrichAsset(asset: DefinitionInfo): EnrichedAsset {
         version: asset.version,
         kind: asset.definition.kind,
         data: asset.definition,
-        path: FS.realpathSync(asset.path),
-        ymlPath: FS.realpathSync(asset.ymlPath),
+        path,
+        ymlPath,
     };
 }
 
@@ -106,7 +111,7 @@ class AssetManager {
 
         const assets = await definitionsManager.getDefinitions(assetKinds);
 
-        return assets.filter(filterExists).map(enrichAsset);
+        return assets.map(enrichAsset).filter((a) => a.exists);
     }
 
     async getPlans(): Promise<EnrichedAsset[]> {
@@ -159,9 +164,13 @@ class AssetManager {
         }
 
         if (definitionInfo) {
-            const asset = enrichAsset(definitionInfo);
-            cacheManager.set(cacheKey, asset, CACHE_TTL);
-            return asset;
+            try {
+                const asset = enrichAsset(definitionInfo);
+                cacheManager.set(cacheKey, asset, CACHE_TTL);
+                return asset;
+            } catch (e) {
+                console.error('Failed to enrich asset', e);
+            }
         }
 
         return undefined;

package/src/config/routes.ts

@@ -13,6 +13,9 @@ import { kapetaHeaders, KapetaRequest } from '../middleware/kapeta';
 import { stringBody } from '../middleware/stringBody';
 import { AnyMap, KapetaBodyRequest } from '../types';
 import { Response } from 'express';
+import { assetManager } from '../assetManager';
+import { definitionsManager } from '../definitionsManager';
+import { EntityList } from '@kapeta/schemas';
 
 const router = Router();
 
@@ -27,7 +30,11 @@ router.get('/instance', async (req: KapetaBodyRequest, res: Response) => {
     try {
         let config: AnyMap = {};
         if (req.kapeta!.instanceId) {
-            config = await configManager.getConfigForBlockInstance(req.kapeta!.systemId, req.kapeta!.instanceId);
+            config = await configManager.getConfigForBlockInstance(
+                req.kapeta!.systemId,
+                req.kapeta!.instanceId,
+                req.kapeta?.environment === 'docker'
+            );
         } else {
             config = configManager.getConfigForSystem(req.kapeta!.systemId);
         }
@@ -51,7 +58,26 @@ router.put('/instance', async (req: KapetaBodyRequest, res) => {
         }
 
         if (req.kapeta!.instanceId) {
-            configManager.setConfigForSection(req.kapeta!.systemId, req.kapeta!.instanceId, config);
+            const blockInstance = await 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.getDefinition(blockInstance.block.ref);
+            if (!blockDefinition) {
+                throw new Error(`Block definition not found: ${blockInstance.block.ref}`);
+            }
+
+            let configEntityList: EntityList = {};
+            if (blockDefinition.definition.spec.configuration) {
+                configEntityList = blockDefinition.definition.spec.configuration as EntityList;
+            }
+
+            await configManager.setConfigForBlockInstance(
+                req.kapeta!.systemId,
+                req.kapeta!.instanceId,
+                configEntityList,
+                config
+            );
             //Restart the instance if it is running after config change
             await instanceManager.prepareForRestart(req.kapeta!.systemId, req.kapeta!.instanceId);
         } else {

package/src/configManager.ts

@@ -3,12 +3,18 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { EnrichedAsset } from './assetManager';
-import { BlockInstance } from '@kapeta/schemas';
+import { assetManager, EnrichedAsset } from './assetManager';
+import { BlockInstance, EntityList, EntityType } from '@kapeta/schemas';
 import { storageService } from './storageService';
-import { assetManager } from './assetManager';
 import { normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { getResolvedConfiguration } from './utils/utils';
+import parseDataUri from 'parse-data-uri';
+import ClusterConfiguration from '@kapeta/local-cluster-config';
+import Path from 'path';
+import uuid from 'node-uuid';
+import FS from 'fs-extra';
+import { EnvironmentType, StringMap } from './types';
+import _ from 'lodash';
 
 export const SYSTEM_ID = '$plan';
 type AnyMap = { [key: string]: any };
@@ -46,18 +52,68 @@ class ConfigManager {
         return this._forSystem(systemId);
     }
 
-    async getConfigForBlockInstance(systemId: string, instanceId: string) {
+    async getConfigForBlockInstance(systemId: string, instanceId: string, rewritePaths = false) {
         const blockInstance = await assetManager.getBlockInstance(systemId, instanceId);
         const blockAsset = await 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 getResolvedConfiguration(
-            blockAsset.data.spec.configuration,
-            instanceConfig,
-            blockInstance.defaultConfiguration
+        const config = _.cloneDeep(
+            getResolvedConfiguration(
+                blockAsset.data.spec.configuration,
+                instanceConfig,
+                blockInstance.defaultConfiguration
+            )
         );
+
+        if (rewritePaths) {
+            this.rewriteFilePaths(blockAsset.data.spec.configuration, config);
+        }
+
+        return config;
+    }
+
+    public rewriteFilePaths(configSchema: EntityList, config: AnyMap, toBaseDir: string = '/files') {
+        const fileMap: StringMap = {};
+
+        if (!configSchema || !configSchema.types) {
+            return fileMap;
+        }
+
+        const fromBaseDir = this.getFilesBaseDir();
+
+        for (const entity of configSchema.types) {
+            if (entity.type !== 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: string, sectionId: string, config: AnyMap) {
@@ -68,6 +124,63 @@ class ConfigManager {
         storageService.put('config', systemId, systemConfig);
     }
 
+    public getFilesBaseDir() {
+        return Path.join(ClusterConfiguration.getKapetaBasedir(), 'files');
+    }
+
+    private async saveFile(value: Buffer) {
+        const filename = uuid.v4();
+        const basePath = this.getFilesBaseDir();
+        await FS.mkdirp(basePath);
+        const filepath = Path.join(basePath, filename);
+        await FS.writeFile(filepath, value);
+        return filepath;
+    }
+
+    async setConfigForBlockInstance(
+        systemId: string,
+        instanceId: string,
+        configEntityList: EntityList,
+        config: AnyMap
+    ) {
+        systemId = normalizeKapetaUri(systemId);
+        let systemConfig = this._forSystem(systemId);
+        let configValue = config || {};
+        if (configEntityList.types) {
+            for (let entity of configEntityList.types) {
+                if (entity.type !== 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 = parseDataUri(innerValues[key]);
+                        innerValues[key] = await this.saveFile(data.data);
+                    }
+                }
+            }
+        }
+
+        systemConfig[instanceId] = configValue;
+
+        storageService.put('config', systemId, systemConfig);
+    }
+
     getConfigForSection(systemId: string, sectionId: string) {
         systemId = normalizeKapetaUri(systemId);
         const systemConfig = this._forSystem(systemId);

package/src/instanceManager.ts

@@ -665,15 +665,13 @@ export class InstanceManager {
                 }
             }
 
-            const resolvedConfig = await configManager.getConfigForBlockInstance(systemId, instanceId);
-
             const task = taskManager.add(
                 `instance:start:${systemId}:${instanceId}`,
                 async () => {
                     const runner = new BlockInstanceRunner(systemId);
                     const startTime = Date.now();
                     try {
-                        const processInfo = await runner.start(blockRef, instanceId, resolvedConfig);
+                        const processInfo = await runner.start(blockRef, instanceId);
 
                         instance.status = InstanceStatus.STARTING;
 

package/src/types.ts

@@ -33,7 +33,6 @@ export interface LogEntry {
 export interface BlockProcessParams {
     id: string;
     ref: string;
-    configuration?: AnyMap;
 }
 
 export enum InstanceType {