@kapeta/local-cluster-service 0.41.1 → 0.42.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [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)
 
 

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/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/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

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.1",
+    "version": "0.42.0",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {
@@ -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/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 {

package/src/utils/BlockInstanceRunner.ts

@@ -5,8 +5,8 @@
 
 import FSExtra from 'fs-extra';
 import ClusterConfig, { DefinitionInfo } from '@kapeta/local-cluster-config';
-import { getDockerHostIp, getBlockInstanceContainerName, getOperatorInstancePorts, readYML, toPortInfo } from './utils';
-import { KapetaURI, parseKapetaUri, normalizeKapetaUri } from '@kapeta/nodejs-utils';
+import { getBlockInstanceContainerName, getDockerHostIp, getOperatorInstancePorts, readYML } from './utils';
+import { KapetaURI, normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { DEFAULT_PORT_TYPE, HTTP_PORT_TYPE, HTTP_PORTS, serviceManager } from '../serviceManager';
 import {
     COMPOSE_LABEL_PROJECT,
@@ -32,7 +32,7 @@ import Docker from 'dockerode';
 import OS from 'node:os';
 import Path from 'node:path';
 import { taskManager } from '../taskManager';
-import { LocalDevContainer, LocalInstance } from '@kapeta/schemas';
+import { EntityList, EntityType, LocalDevContainer, LocalInstance } from '@kapeta/schemas';
 import { createInternalConfigProvider, InternalConfigProvider } from './InternalConfigProvider';
 import {
     getConfigFilePath,
@@ -46,6 +46,8 @@ import {
     writeEnvConfigFile,
 } from '@kapeta/config-mapper';
 import crypto from 'crypto';
+import { configManager } from '../configManager';
+import _ from 'lodash';
 
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
 const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
@@ -121,11 +123,10 @@ export class BlockInstanceRunner {
      * Start a block
      *
      */
-    async start(blockRef: string, instanceId: string, configuration: AnyMap): Promise<ProcessInfo> {
+    async start(blockRef: string, instanceId: string): Promise<ProcessInfo> {
         return this._execute({
             ref: blockRef,
             id: instanceId,
-            configuration,
         });
     }
 
@@ -152,10 +153,18 @@ export class BlockInstanceRunner {
 
         const baseDir = ClusterConfig.getRepositoryAssetPath(blockUri.handle, blockUri.name, blockUri.version);
         const realBaseDir = await FSExtra.realpath(baseDir);
+
+        const config = await configManager.getConfigForBlockInstance(this._systemId, blockInstance.id);
+        const configSchema = (
+            assetVersion.definition.spec.configuration ? assetVersion.definition.spec.configuration : {}
+        ) as EntityList;
+        const fileMapping = configManager.rewriteFilePaths(configSchema, config);
+
         const internalConfigProvider = await createInternalConfigProvider(
             this._systemId,
             blockInstance.id,
-            assetVersion
+            assetVersion,
+            config
         );
 
         // Resolve the environment variables
@@ -189,9 +198,9 @@ export class BlockInstanceRunner {
             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) {
@@ -209,7 +218,8 @@ export class BlockInstanceRunner {
         blockInstance: BlockProcessParams,
         blockInfo: KapetaURI,
         env: StringMap,
-        assetVersion: DefinitionInfo
+        assetVersion: DefinitionInfo,
+        fileMapping: StringMap
     ): Promise<ProcessInfo> {
         const baseDir = ClusterConfig.getRepositoryAssetPath(blockInfo.handle, blockInfo.name, blockInfo.version);
 
@@ -299,14 +309,7 @@ export class BlockInstanceRunner {
             HealthCheck = containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
 
-        if (env[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 = `/${KAPETA_ENV_CONFIG_FILE}`;
-            Binds.push(`${toLocalBindVolume(env[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[KAPETA_CONFIG_ENV_VAR]);
-            env[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
@@ -366,11 +369,29 @@ export class BlockInstanceRunner {
         });
     }
 
+    private async prepareBinds(env: StringMap, Binds: string[], fileMapping: StringMap) {
+        if (env[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 = `/${KAPETA_ENV_CONFIG_FILE}`;
+            Binds.push(`${toLocalBindVolume(env[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[KAPETA_CONFIG_ENV_VAR]);
+            env[KAPETA_CONFIG_ENV_VAR] = localConfig;
+        }
+
+        if (fileMapping) {
+            Object.entries(fileMapping).forEach(([src, dst]) => {
+                Binds.push(`${toLocalBindVolume(src)}:${dst}:ro`);
+            });
+        }
+    }
+
     private async _startDockerProcess(
         blockInstance: BlockProcessParams,
         blockInfo: KapetaURI,
         env: StringMap,
-        assetVersion: DefinitionInfo
+        assetVersion: DefinitionInfo,
+        fileMapping: StringMap
     ) {
         const { versionFile } = ClusterConfig.getRepositoryAssetInfoPath(
             blockInfo.handle,
@@ -414,14 +435,7 @@ export class BlockInstanceRunner {
         const systemUri = parseKapetaUri(this._systemId);
 
         const Binds = [`${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`];
-        if (env[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 = `/${KAPETA_ENV_CONFIG_FILE}`;
-            Binds.push(`${toLocalBindVolume(env[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[KAPETA_CONFIG_ENV_VAR]);
-            env[KAPETA_CONFIG_ENV_VAR] = localConfig;
-        }
+        await this.prepareBinds(env, Binds, fileMapping);
 
         return this.ensureContainer({
             Image: dockerImage,
@@ -664,14 +678,20 @@ export class BlockInstanceRunner {
         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)
             ),
         ];
 
         for (const connectedBlockId of connectedBlockIds) {
-            const connectedBlockInstance = plan.spec.blocks.find((blockInstance) => blockInstance.id == connectedBlockId);
+            const connectedBlockInstance = plan.spec.blocks.find(
+                (blockInstance) => blockInstance.id == connectedBlockId
+            );
             if (!connectedBlockInstance) {
                 continue;
             }

package/src/utils/InternalConfigProvider.ts

@@ -207,8 +207,8 @@ export class InternalConfigProvider implements ConfigProvider {
 export async function createInternalConfigProvider(
     systemId: string,
     instanceId: string,
-    info: DefinitionInfo
+    info: DefinitionInfo,
+    config: AnyMap
 ): Promise<InternalConfigProvider> {
-    const config = await configManager.getConfigForBlockInstance(systemId, instanceId);
     return new InternalConfigProvider(systemId, instanceId, info, config);
 }