@platforma-sdk/bootstrap 5.2.50 → 5.2.52

package/dist/core.cjs

@@ -1,761 +1,637 @@
-'use strict';
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+const require_util = require('./util.cjs');
+const require_package = require('./package.cjs');
+const require_state = require('./state.cjs');
+const require_run = require('./run.cjs');
+const require_compose = require('./templates/compose.cjs');
+const require_pl_config = require('./templates/pl-config.cjs');
+const require_platforma = require('./platforma.cjs');
+let node_os = require("node:os");
+node_os = require_runtime.__toESM(node_os);
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs);
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var fs = require('node:fs');
-var os = require('node:os');
-var path = require('node:path');
-var _package = require('./package.cjs');
-var run = require('./run.cjs');
-var compose = require('./templates/compose.cjs');
-var plConfig = require('./templates/pl-config.cjs');
-var platforma = require('./platforma.cjs');
-var state = require('./state.cjs');
-var util = require('./util.cjs');
-
-class Core {
-    logger;
-    constructor(logger) {
-        this.logger = logger;
-    }
-    startLast() {
-        const instance = state.currentInstance;
-        if (!instance) {
-            this.logger.error("failed to bring back Platforma Backend in the last started configuration: no last configuration found");
-            throw new Error("no previous run info found");
-        }
-        return this.startInstance(instance);
-    }
-    startInstance(instance) {
-        if (instance.runInfo) {
-            const runInfo = this.renderRunInfo(instance.runInfo);
-            this.logger.info(`Starting platforma backend instance '${instance.name}':\n${runInfo}`);
-        }
-        const result = run.runCommands(this.logger, instance.upCommands);
-        checkRunError(result.executed);
-        if (result.spawned.length > 0 && instance.type === "process") {
-            instance.pid = result.spawned[result.spawned.length - 1].pid;
-            state.setInstanceInfo(instance.name, instance);
-            this.logger.info(`instance '${instance.name}' started`);
-        }
-        state.currentInstanceName = instance.name;
-        return result.spawned;
-    }
-    stopInstance(instance) {
-        this.logger.info(`stopping platforma backend instance '${instance.name}'...`);
-        const result = run.runCommands(this.logger, instance.downCommands);
-        checkRunError(result.executed);
-        const iType = instance.type;
-        switch (iType) {
-            case "docker": {
-                return;
-            }
-            case "process": {
-                if (instance.pid && state.isInstanceActive(instance)) {
-                    process.kill(instance.pid);
-                }
-                return;
-            }
-            default:
-                util.assertNever();
-        }
-    }
-    switchInstance(instance) {
-        // Stop all other active instances before switching to new one;
-        for (const iName of state.instanceList) {
-            if (iName !== instance.name) {
-                const iToStop = state.getInstanceInfo(iName);
-                if (state.isInstanceActive(iToStop)) {
-                    this.stopInstance(iToStop);
-                }
-            }
-        }
-        return this.startInstance(instance);
-    }
-    createLocal(instanceName, options) {
-        let plBinaryPath = platforma.binaryPath(options?.version, "binaries", "platforma");
-        if (options?.sourcesPath) {
-            plBinaryPath = path.join(os.tmpdir(), "platforma-custom-build");
-        }
-        if (options?.binaryPath) {
-            plBinaryPath = options.binaryPath;
-        }
-        let configPath = options?.configPath;
-        const workdir = options?.workdir ?? (configPath ? process.cwd() : state.instanceDir(instanceName));
-        if (options?.primaryURL) {
-            options.configOptions = {
-                ...options.configOptions,
-                storages: {
-                    ...options.configOptions?.storages,
-                    primary: plConfig.storageSettingsFromURL(options.primaryURL, workdir, options.configOptions?.storages?.primary),
-                },
-            };
-        }
-        if (options?.libraryURL) {
-            options.configOptions = {
-                ...options.configOptions,
-                storages: {
-                    ...options.configOptions?.storages,
-                    library: plConfig.storageSettingsFromURL(options.libraryURL, workdir, options.configOptions?.storages?.library),
-                },
-            };
-        }
-        const configOptions = plConfig.loadDefaults(this.getLastJwt(), options?.configOptions);
-        this.logger.debug(`  checking license...`);
-        this.checkLicense(options?.configOptions?.license?.value, options?.configOptions?.license?.file);
-        const storageDirs = [
-            `${configOptions.localRoot}/packages`,
-            `${configOptions.localRoot}/packages-local`,
-            `${configOptions.localRoot}/blocks-local`,
-        ];
-        if (configOptions.storages.primary.type === "FS") {
-            storageDirs.push(configOptions.storages.primary.rootPath);
-        }
-        if (configOptions.storages.library.type === "FS") {
-            storageDirs.push(configOptions.storages.library.rootPath);
-            configOptions.hacks.libraryDownloadable = false;
-        }
-        if (configOptions.storages.work.type === "FS") {
-            storageDirs.push(configOptions.storages.work.rootPath);
-        }
-        this.logger.debug("  creating pl state directories...");
-        for (const dir of storageDirs) {
-            if (!fs.existsSync(dir)) {
-                this.logger.debug(`    '${dir}'`);
-                fs.mkdirSync(dir, { recursive: true });
-            }
-        }
-        for (const drv of configOptions.core.auth.drivers) {
-            if (drv.driver === "htpasswd") {
-                if (!fs.existsSync(drv.path)) {
-                    this.logger.debug(`  installing default 'users.htpasswd' to ${drv.path}...`);
-                    fs.copyFileSync(_package.assets("users.htpasswd"), drv.path);
-                }
-            }
-        }
-        if (!configPath) {
-            configPath = path.join(configOptions.localRoot, "config.yaml");
-            this.logger.debug(`  rendering configuration '${configPath}'...`);
-            fs.writeFileSync(configPath, plConfig.render(configOptions));
-        }
-        const upCommands = [];
-        if (options?.sourcesPath) {
-            upCommands.push({
-                cmd: "go",
-                args: ["build", "-o", plBinaryPath, "."],
-                workdir: path.resolve(options.sourcesPath, "cmd", "platforma"),
-                runOpts: {
-                    stdio: "inherit",
-                },
-            });
-        }
-        const runBinary = {
-            async: true,
-            cmd: plBinaryPath,
-            args: ["--quiet", "--config", configPath],
-            workdir: workdir,
-            runOpts: {
-                stdio: "inherit",
-            },
-        };
-        if (options?.configOptions?.numCpu) {
-            runBinary.runOpts.env = {
-                GOMAXPROCS: String(options?.configOptions?.numCpu),
-            };
-        }
-        // Process additional environment variables from CLI options
-        if (options?.backendCommands) {
-            if (!runBinary.runOpts.env) {
-                runBinary.runOpts.env = {};
-            }
-            for (const cmd of options.backendCommands) {
-                const equalIndex = cmd.indexOf("=");
-                if (equalIndex > 0) {
-                    const key = cmd.substring(0, equalIndex);
-                    const value = cmd.substring(equalIndex + 1);
-                    runBinary.runOpts.env[key] = value;
-                }
-                else {
-                    this.logger.warn(`Invalid environment variable format: ${cmd}. Expected format: KEY=VALUE`);
-                }
-            }
-        }
-        // Process additional backend commands
-        if (options?.backendCommands && options.backendCommands.length > 0) {
-            this.logger.debug(`Adding backend commands: ${options.backendCommands.join(" ")}`);
-            // Add commands as arguments to the binary
-            runBinary.args = [...runBinary.args, ...options.backendCommands];
-        }
-        upCommands.push(runBinary);
-        state.setInstanceInfo(instanceName, {
-            type: "process",
-            upCommands: upCommands,
-            downCommands: [],
-            cleanupCommands: [],
-            runInfo: {
-                configPath,
-                dbPath: configOptions.core.db.path,
-                apiAddr: configOptions.grpc.listen,
-                logPath: configOptions.log.path,
-                primary: configOptions.storages.primary,
-                work: configOptions.storages.work,
-                library: configOptions.storages.library,
-            },
-        });
-        return state.getInstanceInfo(instanceName);
-    }
-    createLocalS3(instanceName, options) {
-        this.logger.debug("creating platforma instance in 'local s3' mode...");
-        const minioPort = options?.minioPort ?? 9000;
-        const instance = this.createLocal(instanceName, {
-            ...options,
-            primaryURL: options?.primaryURL ??
-                `s3e://testuser:testpassword@localhost:${minioPort}/platforma-primary-bucket/?region=no-region`,
-            libraryURL: options?.libraryURL ??
-                `s3e://testuser:testpassword@localhost:${minioPort}/platforma-library-bucket/?region=no-region`,
-        });
-        const localRoot = options?.configOptions?.localRoot;
-        const minioRunCmd = this.createMinio(instanceName, {
-            minioPort: minioPort,
-            minioConsolePort: options?.minioConsolePort,
-            storage: localRoot ? path.join(localRoot, "minio") : undefined,
-        });
-        instance.upCommands = [minioRunCmd.start, ...instance.upCommands];
-        instance.downCommands = [minioRunCmd.stop, ...instance.downCommands];
-        instance.cleanupCommands = [minioRunCmd.cleanup, ...instance.cleanupCommands];
-        state.setInstanceInfo(instanceName, instance);
-        return instance;
-    }
-    createMinio(instanceName, options) {
-        this.logger.debug("  creating docker compose for minio service...");
-        const composeSrc = _package.assets("compose-backend.yaml");
-        const composeMinio = state.instanceDir(instanceName, "compose-minio.yaml");
-        compose.render(composeSrc, composeMinio, `pl-${instanceName}-minio`, new Map([["minio", {}]]), { dropVolumes: true });
-        const version = options?.version ? `:${options.version}` : "";
-        this.logger.debug(`    minio version: ${version}`);
-        const image = options?.image ?? `quay.io/minio/minio${version}`;
-        this.logger.debug(`    minio image: ${image}`);
-        const storage = options?.storage ?? state.instanceDir(instanceName, "minio");
-        util.ensureDir(storage, { mode: "0775" });
-        const minioPort = options?.minioPort ?? 9000;
-        const minioConsolePort = options?.minioConsolePort ?? 9001;
-        const envs = {
-            MINIO_IMAGE: image,
-            MINIO_STORAGE: path.resolve(storage),
-            MINIO_PORT: minioPort.toString(),
-            MINIO_CONSOLE_PORT: minioConsolePort.toString(),
-        };
-        return {
-            start: {
-                cmd: "docker",
-                args: [
-                    "compose",
-                    `--file=${composeMinio}`,
-                    "up",
-                    "--detach",
-                    "--remove-orphans",
-                    "--pull=missing",
-                ],
-                envs: envs,
-                workdir: state.instanceDir(instanceName),
-                runOpts: { stdio: "inherit" },
-            },
-            stop: {
-                cmd: "docker",
-                args: ["compose", `--file=${composeMinio}`, "down"],
-                envs: envs,
-                workdir: state.instanceDir(instanceName),
-                runOpts: { stdio: "inherit" },
-            },
-            cleanup: {
-                cmd: "docker",
-                args: ["compose", `--file=${composeMinio}`, "down", "--volumes", "--remove-orphans"],
-                envs: envs,
-                workdir: state.instanceDir(instanceName),
-                runOpts: { stdio: "inherit" },
-            },
-        };
-    }
-    createDockerS3(instanceName, localRoot, options) {
-        this.logger.debug("creating platforma instance in 'docker s3' mode...");
-        const composeS3Path = _package.assets("compose-backend.yaml");
-        const image = options?.image ?? _package.plImageTag(options?.version);
-        this.checkLicense(options?.license, options?.licenseFile);
-        const storagePath = (...s) => path.join(localRoot, ...s);
-        const storageDir = (s) => {
-            const p = storagePath(s);
-            util.ensureDir(p, { mode: "0775" });
-            return p;
-        };
-        const logFilePath = storagePath("logs", "platforma.log");
-        if (!fs.existsSync(logFilePath)) {
-            fs.mkdirSync(path.dirname(logFilePath), { recursive: true });
-            fs.writeFileSync(logFilePath, "");
-        }
-        const presignHost = options?.presignHost ?? "localhost";
-        const presignPort = options?.s3Port ?? 9000;
-        const primary = plConfig.storageSettingsFromURL(`s3e://testuser:testpassword@minio:${presignPort}/platforma-primary-bucket`);
-        if (primary.type !== "S3") {
-            throw new Error("primary storage must have 'S3' type in 'docker s3' configuration");
-        }
-        else {
-            primary.presignEndpoint = `http://${presignHost}:${presignPort}`;
-        }
-        const library = plConfig.storageSettingsFromURL(`s3e://testuser:testpassword@minio:${presignPort}/platforma-library-bucket`);
-        if (library.type !== "S3") {
-            throw new Error(`${library.type} storage type is not supported for library storage`);
-        }
-        else {
-            library.presignEndpoint = `http://${presignHost}:${presignPort}`;
-        }
-        const dbFSPath = storageDir("db");
-        const workFSPath = storageDir("work");
-        const usersFSPath = storagePath("users.htpasswd");
-        if (!fs.existsSync(usersFSPath)) {
-            fs.copyFileSync(_package.assets("users.htpasswd"), usersFSPath);
-        }
-        const composeDstPath = storagePath("compose.yaml");
-        if (fs.existsSync(composeDstPath)) {
-            this.logger.info(`replacing docker compose file ${composeDstPath}`);
-        }
-        const backendMounts = [];
-        for (const mnt of options?.customMounts ?? []) {
-            backendMounts.push({
-                hostPath: mnt.hostPath,
-                containerPath: mnt.containerPath ?? mnt.hostPath,
-            });
-        }
-        compose.render(composeS3Path, composeDstPath, `pl-${instanceName}`, new Map([
-            ["minio", {}],
-            [
-                "backend",
-                {
-                    platform: options?.platformOverride,
-                    mounts: backendMounts,
-                    commands: options?.backendCommands,
-                },
-            ],
-        ]));
-        const envs = {
-            MINIO_IMAGE: "quay.io/minio/minio",
-            MINIO_STORAGE: storageDir("minio"),
-            PL_IMAGE: image,
-            PL_AUTH_HTPASSWD: usersFSPath,
-            PL_LICENSE: options?.license,
-            PL_LICENSE_FILE: options?.licenseFile,
-            PL_LOG_LEVEL: options?.logLevel ?? "info",
-            PL_LOG_DIR: path.dirname(logFilePath),
-            PL_LOG_ROTATION_ENABLED: "true",
-            PL_RUNNER_WD_CACHE_ON_FAILURE: "1h",
-            PL_DATA_DB_ROOT: dbFSPath,
-            PL_DATA_PRIMARY_ROOT: storageDir("primary"),
-            PL_DATA_LIBRARY_ROOT: storageDir("library"),
-            PL_DATA_WORKDIR_ROOT: workFSPath,
-            // Mount packages storage as volume, because APFS is case-insensitive on Mac OS X and this breaks some pl software installation.
-            // PL_DATA_PACKAGE_ROOT: storageDir('packages'),
-            ...this.configureDockerStorage("primary", primary),
-            ...this.configureDockerStorage("library", library),
-        };
-        if (options?.grpcAddr) {
-            const addrParts = options.grpcAddr.split(":");
-            if (addrParts.length === 2) {
-                envs.PL_LISTEN_ADDRESS = addrParts[0];
-                envs.PL_LISTEN_PORT = addrParts[1];
-            }
-            else {
-                envs.PL_LISTEN_ADDRESS = options.grpcAddr;
-            }
-        }
-        else if (options?.grpcPort) {
-            envs.PL_LISTEN_PORT = options.grpcPort.toString();
-        }
-        if (options?.monitoringAddr) {
-            const addrParts = options.monitoringAddr.split(":");
-            if (addrParts.length === 2) {
-                envs.PL_MONITORING_IP = addrParts[0];
-                envs.PL_MONITORING_PORT = addrParts[1];
-            }
-            else {
-                envs.PL_MONITORING_IP = options.monitoringAddr;
-            }
-        }
-        else if (options?.monitoringPort) {
-            envs.PL_MONITORING_PORT = options.monitoringPort.toString();
-        }
-        if (options?.debugAddr) {
-            const addrParts = options.debugAddr.split(":");
-            if (addrParts.length === 2) {
-                envs.PL_DEBUG_IP = addrParts[0];
-                envs.PL_DEBUG_PORT = addrParts[1];
-            }
-            else {
-                envs.PL_DEBUG_IP = options.debugAddr;
-            }
-        }
-        else if (options?.debugPort) {
-            envs.PL_DEBUG_PORT = options.debugPort.toString();
-        }
-        if (options?.s3Port)
-            envs.MINIO_PORT = options.s3Port.toString();
-        if (options?.s3ConsolePort)
-            envs.MINIO_CONSOLE_PORT = options.s3ConsolePort.toString();
-        if (options?.auth) {
-            if (options.auth.enabled) {
-                envs["PL_NO_AUTH"] = "false";
-            }
-            else {
-                envs["PL_NO_AUTH"] = "true";
-            }
-            if (options.auth.drivers) {
-                for (const drv of options.auth.drivers) {
-                    if (drv.driver === "htpasswd") {
-                        envs["PL_AUTH_HTPASSWD"] = path.resolve(drv.path);
-                        drv.path = "/etc/platforma/users.htpasswd";
-                    }
-                }
-                envs["PL_AUTH_DRIVERS"] = JSON.stringify(options.auth.drivers);
-            }
-        }
-        // Process additional backend commands
-        if (options?.backendCommands && options.backendCommands.length > 0) {
-            this.logger.debug(`Adding backend commands: ${options.backendCommands.join(" ")}`);
-        }
-        state.setInstanceInfo(instanceName, {
-            type: "docker",
-            upCommands: [
-                {
-                    cmd: "docker",
-                    args: [
-                        "compose",
-                        `--file=${composeDstPath}`,
-                        "up",
-                        "--detach",
-                        "--remove-orphans",
-                        "--pull=missing",
-                    ],
-                    envs: envs,
-                    runOpts: { stdio: "inherit" },
-                },
-            ],
-            downCommands: [
-                {
-                    cmd: "docker",
-                    args: ["compose", `--file=${composeDstPath}`, "down"],
-                    envs: envs,
-                    runOpts: { stdio: "inherit" },
-                },
-            ],
-            cleanupCommands: [
-                {
-                    cmd: "docker",
-                    args: ["compose", `--file=${composeDstPath}`, "down", "--volumes", "--remove-orphans"],
-                    envs: envs,
-                    runOpts: { stdio: "inherit" },
-                },
-            ],
-            runInfo: {
-                apiPort: options?.grpcPort,
-                apiAddr: options?.grpcAddr,
-                logPath: logFilePath,
-                primary: primary,
-                work: { type: "FS", rootPath: workFSPath },
-                library: library,
-                dbPath: dbFSPath,
-            },
-        });
-        return state.getInstanceInfo(instanceName);
-    }
-    createDocker(instanceName, localRoot, options) {
-        this.logger.debug("creating platforma instance in 'docker' mode...");
-        const composeFSPath = _package.assets("compose-backend.yaml");
-        const image = options?.image ?? _package.plImageTag(options?.version);
-        this.checkLicense(options?.license, options?.licenseFile);
-        const storagePath = (...s) => path.join(localRoot, ...s);
-        const storageDir = (s) => {
-            const p = storagePath(s);
-            util.ensureDir(p, { mode: "0775" });
-            return p;
-        };
-        const logFilePath = storagePath("logs", "platforma.log");
-        if (!fs.existsSync(logFilePath)) {
-            fs.mkdirSync(path.dirname(logFilePath), { recursive: true });
-            fs.writeFileSync(logFilePath, "");
-        }
-        const dbFSPath = storageDir("db");
-        const primaryFSPath = storageDir("primary");
-        const libraryFSPath = storageDir("library");
-        const workFSPath = storageDir("work");
-        const usersFSPath = storagePath("users.htpasswd");
-        if (!fs.existsSync(usersFSPath)) {
-            fs.copyFileSync(_package.assets("users.htpasswd"), usersFSPath);
-        }
-        const composeDstPath = storagePath("compose.yaml");
-        if (fs.existsSync(composeDstPath)) {
-            this.logger.info(`replacing docker compose file ${composeDstPath}`);
-        }
-        const backendMounts = [];
-        for (const mnt of options?.customMounts ?? []) {
-            backendMounts.push({
-                hostPath: mnt.hostPath,
-                containerPath: mnt.containerPath ?? mnt.hostPath,
-            });
-        }
-        this.logger.debug(`Rendering docker compose file '${composeDstPath}' using '${composeFSPath}' as base template`);
-        compose.render(composeFSPath, composeDstPath, `pl-${instanceName}`, new Map([
-            [
-                "backend",
-                {
-                    platform: options?.platformOverride,
-                    mounts: backendMounts,
-                    commands: options?.backendCommands,
-                },
-            ],
-        ]));
-        const primary = plConfig.storageSettingsFromURL(options?.primaryStorageURL ?? `file:${primaryFSPath}`, ".");
-        const library = plConfig.storageSettingsFromURL(options?.libraryStorageURL ?? `file:${libraryFSPath}`, ".");
-        const envs = {
-            PL_IMAGE: image,
-            PL_AUTH_HTPASSWD: usersFSPath,
-            PL_LICENSE: options?.license,
-            PL_LICENSE_FILE: options?.licenseFile,
-            PL_LOG_LEVEL: options?.logLevel ?? "info",
-            PL_LOG_DIR: path.dirname(logFilePath),
-            PL_LOG_ROTATION_ENABLED: "true",
-            PL_RUNNER_WD_CACHE_ON_FAILURE: "1h",
-            PL_DATA_DB_ROOT: dbFSPath,
-            PL_DATA_PRIMARY_ROOT: primaryFSPath,
-            PL_DATA_LIBRARY_ROOT: libraryFSPath,
-            PL_DATA_WORKDIR_ROOT: workFSPath,
-            PL_DATA_PACKAGE_ROOT: storageDir("packages"),
-            ...this.configureDockerStorage("primary", primary),
-            ...this.configureDockerStorage("library", library),
-        };
-        if (options?.grpcAddr) {
-            const addrParts = options.grpcAddr.split(":");
-            if (addrParts.length === 2) {
-                envs.PL_LISTEN_ADDRESS = addrParts[0];
-                envs.PL_LISTEN_PORT = addrParts[1];
-            }
-            else {
-                envs.PL_LISTEN_ADDRESS = options.grpcAddr;
-            }
-        }
-        else if (options?.grpcPort) {
-            envs.PL_LISTEN_PORT = options.grpcPort.toString();
-        }
-        if (options?.monitoringAddr) {
-            const addrParts = options.monitoringAddr.split(":");
-            if (addrParts.length === 2) {
-                envs.PL_MONITORING_IP = addrParts[0];
-                envs.PL_MONITORING_PORT = addrParts[1];
-            }
-            else {
-                envs.PL_MONITORING_IP = options.monitoringAddr;
-            }
-        }
-        else if (options?.monitoringPort) {
-            envs.PL_MONITORING_PORT = options.monitoringPort.toString();
-        }
-        if (options?.debugAddr) {
-            const addrParts = options.debugAddr.split(":");
-            if (addrParts.length === 2) {
-                envs.PL_DEBUG_IP = addrParts[0];
-                envs.PL_DEBUG_PORT = addrParts[1];
-            }
-            else {
-                envs.PL_DEBUG_IP = options.debugAddr;
-            }
-        }
-        else if (options?.debugPort) {
-            envs.PL_DEBUG_PORT = options.debugPort.toString();
-        }
-        if (options?.auth) {
-            if (options.auth.enabled) {
-                envs["PL_NO_AUTH"] = "false";
-            }
-            else {
-                envs["PL_NO_AUTH"] = "true";
-            }
-            if (options.auth.drivers) {
-                for (const drv of options.auth.drivers) {
-                    if (drv.driver === "htpasswd") {
-                        envs["PL_AUTH_HTPASSWD"] = path.resolve(drv.path);
-                        drv.path = "/etc/platforma/users.htpasswd";
-                    }
-                }
-                envs["PL_AUTH_DRIVERS"] = JSON.stringify(options.auth.drivers);
-            }
-        }
-        // Process additional backend commands
-        if (options?.backendCommands && options.backendCommands.length > 0) {
-            this.logger.debug(`Adding backend commands: ${options.backendCommands.join(" ")}`);
-        }
-        state.setInstanceInfo(instanceName, {
-            type: "docker",
-            upCommands: [
-                {
-                    cmd: "docker",
-                    args: [
-                        "compose",
-                        `--file=${composeDstPath}`,
-                        "up",
-                        "--detach",
-                        "--remove-orphans",
-                        "--pull=missing",
-                    ],
-                    envs: envs,
-                    runOpts: { stdio: "inherit" },
-                },
-            ],
-            downCommands: [
-                {
-                    cmd: "docker",
-                    args: ["compose", `--file=${composeDstPath}`, "down"],
-                    envs: envs,
-                    runOpts: { stdio: "inherit" },
-                },
-            ],
-            cleanupCommands: [
-                {
-                    cmd: "docker",
-                    args: ["compose", `--file=${composeDstPath}`, "down", "--volumes", "--remove-orphans"],
-                    envs: envs,
-                    runOpts: { stdio: "inherit" },
-                },
-            ],
-            runInfo: {
-                apiPort: options?.grpcPort,
-                apiAddr: options?.grpcAddr,
-                logPath: logFilePath,
-                primary: primary,
-                work: { type: "FS", rootPath: workFSPath },
-                library: library,
-                dbPath: dbFSPath,
-            },
-        });
-        return state.getInstanceInfo(instanceName);
-    }
-    cleanupInstance(instanceName) {
-        const removeWarns = [];
-        const instancesToDrop = new Map();
-        let warnMessage = "";
-        if (instanceName) {
-            const instance = state.getInstanceInfo(instanceName);
-            instancesToDrop.set(instanceName, instance);
-            const iType = instance.type;
-            switch (iType) {
-                case "docker": {
-                    removeWarns.push(`docker service 'pl-${instanceName}', including all its volumes and data in '${state.instanceDir(instanceName)}' will be destroyed`);
-                    break;
-                }
-                case "process": {
-                    removeWarns.push(`directory '${state.instanceDir(instanceName)}' would be deleted`);
-                    if (instance.downCommands) {
-                        removeWarns.push(`associated docker service, including all volumes and data will be destroyed`);
-                    }
-                    break;
-                }
-                default:
-                    util.assertNever();
-            }
-            if (instanceName === state.currentInstanceName) {
-                removeWarns.push("last command run cache ('pl-dev start' shorthand will stop working until next full start command call)");
-            }
-            warnMessage = `
+//#region src/core.ts
+var Core = class {
+	constructor(logger) {
+		this.logger = logger;
+	}
+	startLast() {
+		const instance = require_state.default.currentInstance;
+		if (!instance) {
+			this.logger.error("failed to bring back Platforma Backend in the last started configuration: no last configuration found");
+			throw new Error("no previous run info found");
+		}
+		return this.startInstance(instance);
+	}
+	startInstance(instance) {
+		if (instance.runInfo) {
+			const runInfo = this.renderRunInfo(instance.runInfo);
+			this.logger.info(`Starting platforma backend instance '${instance.name}':\n${runInfo}`);
+		}
+		const result = require_run.runCommands(this.logger, instance.upCommands);
+		checkRunError(result.executed);
+		if (result.spawned.length > 0 && instance.type === "process") {
+			instance.pid = result.spawned[result.spawned.length - 1].pid;
+			require_state.default.setInstanceInfo(instance.name, instance);
+			this.logger.info(`instance '${instance.name}' started`);
+		}
+		require_state.default.currentInstanceName = instance.name;
+		return result.spawned;
+	}
+	stopInstance(instance) {
+		this.logger.info(`stopping platforma backend instance '${instance.name}'...`);
+		checkRunError(require_run.runCommands(this.logger, instance.downCommands).executed);
+		const iType = instance.type;
+		switch (iType) {
+			case "docker": return;
+			case "process":
+				if (instance.pid && require_state.default.isInstanceActive(instance)) process.kill(instance.pid);
+				return;
+			default: require_util.assertNever(iType);
+		}
+	}
+	switchInstance(instance) {
+		for (const iName of require_state.default.instanceList) if (iName !== instance.name) {
+			const iToStop = require_state.default.getInstanceInfo(iName);
+			if (require_state.default.isInstanceActive(iToStop)) this.stopInstance(iToStop);
+		}
+		return this.startInstance(instance);
+	}
+	createLocal(instanceName, options) {
+		let plBinaryPath = require_platforma.binaryPath(options?.version, "binaries", "platforma");
+		if (options?.sourcesPath) plBinaryPath = node_path.default.join(node_os.default.tmpdir(), "platforma-custom-build");
+		if (options?.binaryPath) plBinaryPath = options.binaryPath;
+		let configPath = options?.configPath;
+		const workdir = options?.workdir ?? (configPath ? process.cwd() : require_state.default.instanceDir(instanceName));
+		if (options?.primaryURL) options.configOptions = {
+			...options.configOptions,
+			storages: {
+				...options.configOptions?.storages,
+				primary: require_pl_config.storageSettingsFromURL(options.primaryURL, workdir, options.configOptions?.storages?.primary)
+			}
+		};
+		if (options?.libraryURL) options.configOptions = {
+			...options.configOptions,
+			storages: {
+				...options.configOptions?.storages,
+				library: require_pl_config.storageSettingsFromURL(options.libraryURL, workdir, options.configOptions?.storages?.library)
+			}
+		};
+		const configOptions = require_pl_config.loadDefaults(this.getLastJwt(), options?.configOptions);
+		this.logger.debug(`  checking license...`);
+		this.checkLicense(options?.configOptions?.license?.value, options?.configOptions?.license?.file);
+		const storageDirs = [
+			`${configOptions.localRoot}/packages`,
+			`${configOptions.localRoot}/packages-local`,
+			`${configOptions.localRoot}/blocks-local`
+		];
+		if (configOptions.storages.primary.type === "FS") storageDirs.push(configOptions.storages.primary.rootPath);
+		if (configOptions.storages.library.type === "FS") {
+			storageDirs.push(configOptions.storages.library.rootPath);
+			configOptions.hacks.libraryDownloadable = false;
+		}
+		if (configOptions.storages.work.type === "FS") storageDirs.push(configOptions.storages.work.rootPath);
+		this.logger.debug("  creating pl state directories...");
+		for (const dir of storageDirs) if (!node_fs.default.existsSync(dir)) {
+			this.logger.debug(`    '${dir}'`);
+			node_fs.default.mkdirSync(dir, { recursive: true });
+		}
+		for (const drv of configOptions.core.auth.drivers) if (drv.driver === "htpasswd") {
+			if (!node_fs.default.existsSync(drv.path)) {
+				this.logger.debug(`  installing default 'users.htpasswd' to ${drv.path}...`);
+				node_fs.default.copyFileSync(require_package.assets("users.htpasswd"), drv.path);
+			}
+		}
+		if (!configPath) {
+			configPath = node_path.default.join(configOptions.localRoot, "config.yaml");
+			this.logger.debug(`  rendering configuration '${configPath}'...`);
+			node_fs.default.writeFileSync(configPath, require_pl_config.render(configOptions));
+		}
+		const upCommands = [];
+		if (options?.sourcesPath) upCommands.push({
+			cmd: "go",
+			args: [
+				"build",
+				"-o",
+				plBinaryPath,
+				"."
+			],
+			workdir: node_path.default.resolve(options.sourcesPath, "cmd", "platforma"),
+			runOpts: { stdio: "inherit" }
+		});
+		const runBinary = {
+			async: true,
+			cmd: plBinaryPath,
+			args: [
+				"--quiet",
+				"--config",
+				configPath
+			],
+			workdir,
+			runOpts: { stdio: "inherit" }
+		};
+		if (options?.configOptions?.numCpu) runBinary.runOpts.env = { GOMAXPROCS: String(options?.configOptions?.numCpu) };
+		if (options?.backendCommands) {
+			if (!runBinary.runOpts.env) runBinary.runOpts.env = {};
+			for (const cmd of options.backendCommands) {
+				const equalIndex = cmd.indexOf("=");
+				if (equalIndex > 0) {
+					const key = cmd.substring(0, equalIndex);
+					const value = cmd.substring(equalIndex + 1);
+					runBinary.runOpts.env[key] = value;
+				} else this.logger.warn(`Invalid environment variable format: ${cmd}. Expected format: KEY=VALUE`);
+			}
+		}
+		if (options?.backendCommands && options.backendCommands.length > 0) {
+			this.logger.debug(`Adding backend commands: ${options.backendCommands.join(" ")}`);
+			runBinary.args = [...runBinary.args, ...options.backendCommands];
+		}
+		upCommands.push(runBinary);
+		require_state.default.setInstanceInfo(instanceName, {
+			type: "process",
+			upCommands,
+			downCommands: [],
+			cleanupCommands: [],
+			runInfo: {
+				configPath,
+				dbPath: configOptions.core.db.path,
+				apiAddr: configOptions.grpc.listen,
+				logPath: configOptions.log.path,
+				primary: configOptions.storages.primary,
+				work: configOptions.storages.work,
+				library: configOptions.storages.library
+			}
+		});
+		return require_state.default.getInstanceInfo(instanceName);
+	}
+	createLocalS3(instanceName, options) {
+		this.logger.debug("creating platforma instance in 'local s3' mode...");
+		const minioPort = options?.minioPort ?? 9e3;
+		const instance = this.createLocal(instanceName, {
+			...options,
+			primaryURL: options?.primaryURL ?? `s3e://testuser:testpassword@localhost:${minioPort}/platforma-primary-bucket/?region=no-region`,
+			libraryURL: options?.libraryURL ?? `s3e://testuser:testpassword@localhost:${minioPort}/platforma-library-bucket/?region=no-region`
+		});
+		const localRoot = options?.configOptions?.localRoot;
+		const minioRunCmd = this.createMinio(instanceName, {
+			minioPort,
+			minioConsolePort: options?.minioConsolePort,
+			storage: localRoot ? node_path.default.join(localRoot, "minio") : void 0
+		});
+		instance.upCommands = [minioRunCmd.start, ...instance.upCommands];
+		instance.downCommands = [minioRunCmd.stop, ...instance.downCommands];
+		instance.cleanupCommands = [minioRunCmd.cleanup, ...instance.cleanupCommands];
+		require_state.default.setInstanceInfo(instanceName, instance);
+		return instance;
+	}
+	createMinio(instanceName, options) {
+		this.logger.debug("  creating docker compose for minio service...");
+		const composeSrc = require_package.assets("compose-backend.yaml");
+		const composeMinio = require_state.default.instanceDir(instanceName, "compose-minio.yaml");
+		require_compose.render(composeSrc, composeMinio, `pl-${instanceName}-minio`, new Map([["minio", {}]]), { dropVolumes: true });
+		const version = options?.version ? `:${options.version}` : "";
+		this.logger.debug(`    minio version: ${version}`);
+		const image = options?.image ?? `quay.io/minio/minio${version}`;
+		this.logger.debug(`    minio image: ${image}`);
+		const storage = options?.storage ?? require_state.default.instanceDir(instanceName, "minio");
+		require_util.ensureDir(storage, { mode: "0775" });
+		const minioPort = options?.minioPort ?? 9e3;
+		const minioConsolePort = options?.minioConsolePort ?? 9001;
+		const envs = {
+			MINIO_IMAGE: image,
+			MINIO_STORAGE: node_path.default.resolve(storage),
+			MINIO_PORT: minioPort.toString(),
+			MINIO_CONSOLE_PORT: minioConsolePort.toString()
+		};
+		return {
+			start: {
+				cmd: "docker",
+				args: [
+					"compose",
+					`--file=${composeMinio}`,
+					"up",
+					"--detach",
+					"--remove-orphans",
+					"--pull=missing"
+				],
+				envs,
+				workdir: require_state.default.instanceDir(instanceName),
+				runOpts: { stdio: "inherit" }
+			},
+			stop: {
+				cmd: "docker",
+				args: [
+					"compose",
+					`--file=${composeMinio}`,
+					"down"
+				],
+				envs,
+				workdir: require_state.default.instanceDir(instanceName),
+				runOpts: { stdio: "inherit" }
+			},
+			cleanup: {
+				cmd: "docker",
+				args: [
+					"compose",
+					`--file=${composeMinio}`,
+					"down",
+					"--volumes",
+					"--remove-orphans"
+				],
+				envs,
+				workdir: require_state.default.instanceDir(instanceName),
+				runOpts: { stdio: "inherit" }
+			}
+		};
+	}
+	createDockerS3(instanceName, localRoot, options) {
+		this.logger.debug("creating platforma instance in 'docker s3' mode...");
+		const composeS3Path = require_package.assets("compose-backend.yaml");
+		const image = options?.image ?? require_package.plImageTag(options?.version);
+		this.checkLicense(options?.license, options?.licenseFile);
+		const storagePath = (...s) => node_path.default.join(localRoot, ...s);
+		const storageDir = (s) => {
+			const p = storagePath(s);
+			require_util.ensureDir(p, { mode: "0775" });
+			return p;
+		};
+		const logFilePath = storagePath("logs", "platforma.log");
+		if (!node_fs.default.existsSync(logFilePath)) {
+			node_fs.default.mkdirSync(node_path.default.dirname(logFilePath), { recursive: true });
+			node_fs.default.writeFileSync(logFilePath, "");
+		}
+		const presignHost = options?.presignHost ?? "localhost";
+		const presignPort = options?.s3Port ?? 9e3;
+		const primary = require_pl_config.storageSettingsFromURL(`s3e://testuser:testpassword@minio:${presignPort}/platforma-primary-bucket`);
+		if (primary.type !== "S3") throw new Error("primary storage must have 'S3' type in 'docker s3' configuration");
+		else primary.presignEndpoint = `http://${presignHost}:${presignPort}`;
+		const library = require_pl_config.storageSettingsFromURL(`s3e://testuser:testpassword@minio:${presignPort}/platforma-library-bucket`);
+		if (library.type !== "S3") throw new Error(`${library.type} storage type is not supported for library storage`);
+		else library.presignEndpoint = `http://${presignHost}:${presignPort}`;
+		const dbFSPath = storageDir("db");
+		const workFSPath = storageDir("work");
+		const usersFSPath = storagePath("users.htpasswd");
+		if (!node_fs.default.existsSync(usersFSPath)) node_fs.default.copyFileSync(require_package.assets("users.htpasswd"), usersFSPath);
+		const composeDstPath = storagePath("compose.yaml");
+		if (node_fs.default.existsSync(composeDstPath)) this.logger.info(`replacing docker compose file ${composeDstPath}`);
+		const backendMounts = [];
+		for (const mnt of options?.customMounts ?? []) backendMounts.push({
+			hostPath: mnt.hostPath,
+			containerPath: mnt.containerPath ?? mnt.hostPath
+		});
+		require_compose.render(composeS3Path, composeDstPath, `pl-${instanceName}`, new Map([["minio", {}], ["backend", {
+			platform: options?.platformOverride,
+			mounts: backendMounts,
+			commands: options?.backendCommands
+		}]]));
+		const envs = {
+			MINIO_IMAGE: "quay.io/minio/minio",
+			MINIO_STORAGE: storageDir("minio"),
+			PL_IMAGE: image,
+			PL_AUTH_HTPASSWD: usersFSPath,
+			PL_LICENSE: options?.license,
+			PL_LICENSE_FILE: options?.licenseFile,
+			PL_LOG_LEVEL: options?.logLevel ?? "info",
+			PL_LOG_DIR: node_path.default.dirname(logFilePath),
+			PL_LOG_ROTATION_ENABLED: "true",
+			PL_RUNNER_WD_CACHE_ON_FAILURE: "1h",
+			PL_DATA_DB_ROOT: dbFSPath,
+			PL_DATA_PRIMARY_ROOT: storageDir("primary"),
+			PL_DATA_LIBRARY_ROOT: storageDir("library"),
+			PL_DATA_WORKDIR_ROOT: workFSPath,
+			...this.configureDockerStorage("primary", primary),
+			...this.configureDockerStorage("library", library)
+		};
+		if (options?.grpcAddr) {
+			const addrParts = options.grpcAddr.split(":");
+			if (addrParts.length === 2) {
+				envs.PL_LISTEN_ADDRESS = addrParts[0];
+				envs.PL_LISTEN_PORT = addrParts[1];
+			} else envs.PL_LISTEN_ADDRESS = options.grpcAddr;
+		} else if (options?.grpcPort) envs.PL_LISTEN_PORT = options.grpcPort.toString();
+		if (options?.monitoringAddr) {
+			const addrParts = options.monitoringAddr.split(":");
+			if (addrParts.length === 2) {
+				envs.PL_MONITORING_IP = addrParts[0];
+				envs.PL_MONITORING_PORT = addrParts[1];
+			} else envs.PL_MONITORING_IP = options.monitoringAddr;
+		} else if (options?.monitoringPort) envs.PL_MONITORING_PORT = options.monitoringPort.toString();
+		if (options?.debugAddr) {
+			const addrParts = options.debugAddr.split(":");
+			if (addrParts.length === 2) {
+				envs.PL_DEBUG_IP = addrParts[0];
+				envs.PL_DEBUG_PORT = addrParts[1];
+			} else envs.PL_DEBUG_IP = options.debugAddr;
+		} else if (options?.debugPort) envs.PL_DEBUG_PORT = options.debugPort.toString();
+		if (options?.s3Port) envs.MINIO_PORT = options.s3Port.toString();
+		if (options?.s3ConsolePort) envs.MINIO_CONSOLE_PORT = options.s3ConsolePort.toString();
+		if (options?.auth) {
+			if (options.auth.enabled) envs["PL_NO_AUTH"] = "false";
+			else envs["PL_NO_AUTH"] = "true";
+			if (options.auth.drivers) {
+				for (const drv of options.auth.drivers) if (drv.driver === "htpasswd") {
+					envs["PL_AUTH_HTPASSWD"] = node_path.default.resolve(drv.path);
+					drv.path = "/etc/platforma/users.htpasswd";
+				}
+				envs["PL_AUTH_DRIVERS"] = JSON.stringify(options.auth.drivers);
+			}
+		}
+		if (options?.backendCommands && options.backendCommands.length > 0) this.logger.debug(`Adding backend commands: ${options.backendCommands.join(" ")}`);
+		require_state.default.setInstanceInfo(instanceName, {
+			type: "docker",
+			upCommands: [{
+				cmd: "docker",
+				args: [
+					"compose",
+					`--file=${composeDstPath}`,
+					"up",
+					"--detach",
+					"--remove-orphans",
+					"--pull=missing"
+				],
+				envs,
+				runOpts: { stdio: "inherit" }
+			}],
+			downCommands: [{
+				cmd: "docker",
+				args: [
+					"compose",
+					`--file=${composeDstPath}`,
+					"down"
+				],
+				envs,
+				runOpts: { stdio: "inherit" }
+			}],
+			cleanupCommands: [{
+				cmd: "docker",
+				args: [
+					"compose",
+					`--file=${composeDstPath}`,
+					"down",
+					"--volumes",
+					"--remove-orphans"
+				],
+				envs,
+				runOpts: { stdio: "inherit" }
+			}],
+			runInfo: {
+				apiPort: options?.grpcPort,
+				apiAddr: options?.grpcAddr,
+				logPath: logFilePath,
+				primary,
+				work: {
+					type: "FS",
+					rootPath: workFSPath
+				},
+				library,
+				dbPath: dbFSPath
+			}
+		});
+		return require_state.default.getInstanceInfo(instanceName);
+	}
+	createDocker(instanceName, localRoot, options) {
+		this.logger.debug("creating platforma instance in 'docker' mode...");
+		const composeFSPath = require_package.assets("compose-backend.yaml");
+		const image = options?.image ?? require_package.plImageTag(options?.version);
+		this.checkLicense(options?.license, options?.licenseFile);
+		const storagePath = (...s) => node_path.default.join(localRoot, ...s);
+		const storageDir = (s) => {
+			const p = storagePath(s);
+			require_util.ensureDir(p, { mode: "0775" });
+			return p;
+		};
+		const logFilePath = storagePath("logs", "platforma.log");
+		if (!node_fs.default.existsSync(logFilePath)) {
+			node_fs.default.mkdirSync(node_path.default.dirname(logFilePath), { recursive: true });
+			node_fs.default.writeFileSync(logFilePath, "");
+		}
+		const dbFSPath = storageDir("db");
+		const primaryFSPath = storageDir("primary");
+		const libraryFSPath = storageDir("library");
+		const workFSPath = storageDir("work");
+		const usersFSPath = storagePath("users.htpasswd");
+		if (!node_fs.default.existsSync(usersFSPath)) node_fs.default.copyFileSync(require_package.assets("users.htpasswd"), usersFSPath);
+		const composeDstPath = storagePath("compose.yaml");
+		if (node_fs.default.existsSync(composeDstPath)) this.logger.info(`replacing docker compose file ${composeDstPath}`);
+		const backendMounts = [];
+		for (const mnt of options?.customMounts ?? []) backendMounts.push({
+			hostPath: mnt.hostPath,
+			containerPath: mnt.containerPath ?? mnt.hostPath
+		});
+		this.logger.debug(`Rendering docker compose file '${composeDstPath}' using '${composeFSPath}' as base template`);
+		require_compose.render(composeFSPath, composeDstPath, `pl-${instanceName}`, new Map([["backend", {
+			platform: options?.platformOverride,
+			mounts: backendMounts,
+			commands: options?.backendCommands
+		}]]));
+		const primary = require_pl_config.storageSettingsFromURL(options?.primaryStorageURL ?? `file:${primaryFSPath}`, ".");
+		const library = require_pl_config.storageSettingsFromURL(options?.libraryStorageURL ?? `file:${libraryFSPath}`, ".");
+		const envs = {
+			PL_IMAGE: image,
+			PL_AUTH_HTPASSWD: usersFSPath,
+			PL_LICENSE: options?.license,
+			PL_LICENSE_FILE: options?.licenseFile,
+			PL_LOG_LEVEL: options?.logLevel ?? "info",
+			PL_LOG_DIR: node_path.default.dirname(logFilePath),
+			PL_LOG_ROTATION_ENABLED: "true",
+			PL_RUNNER_WD_CACHE_ON_FAILURE: "1h",
+			PL_DATA_DB_ROOT: dbFSPath,
+			PL_DATA_PRIMARY_ROOT: primaryFSPath,
+			PL_DATA_LIBRARY_ROOT: libraryFSPath,
+			PL_DATA_WORKDIR_ROOT: workFSPath,
+			PL_DATA_PACKAGE_ROOT: storageDir("packages"),
+			...this.configureDockerStorage("primary", primary),
+			...this.configureDockerStorage("library", library)
+		};
+		if (options?.grpcAddr) {
+			const addrParts = options.grpcAddr.split(":");
+			if (addrParts.length === 2) {
+				envs.PL_LISTEN_ADDRESS = addrParts[0];
+				envs.PL_LISTEN_PORT = addrParts[1];
+			} else envs.PL_LISTEN_ADDRESS = options.grpcAddr;
+		} else if (options?.grpcPort) envs.PL_LISTEN_PORT = options.grpcPort.toString();
+		if (options?.monitoringAddr) {
+			const addrParts = options.monitoringAddr.split(":");
+			if (addrParts.length === 2) {
+				envs.PL_MONITORING_IP = addrParts[0];
+				envs.PL_MONITORING_PORT = addrParts[1];
+			} else envs.PL_MONITORING_IP = options.monitoringAddr;
+		} else if (options?.monitoringPort) envs.PL_MONITORING_PORT = options.monitoringPort.toString();
+		if (options?.debugAddr) {
+			const addrParts = options.debugAddr.split(":");
+			if (addrParts.length === 2) {
+				envs.PL_DEBUG_IP = addrParts[0];
+				envs.PL_DEBUG_PORT = addrParts[1];
+			} else envs.PL_DEBUG_IP = options.debugAddr;
+		} else if (options?.debugPort) envs.PL_DEBUG_PORT = options.debugPort.toString();
+		if (options?.auth) {
+			if (options.auth.enabled) envs["PL_NO_AUTH"] = "false";
+			else envs["PL_NO_AUTH"] = "true";
+			if (options.auth.drivers) {
+				for (const drv of options.auth.drivers) if (drv.driver === "htpasswd") {
+					envs["PL_AUTH_HTPASSWD"] = node_path.default.resolve(drv.path);
+					drv.path = "/etc/platforma/users.htpasswd";
+				}
+				envs["PL_AUTH_DRIVERS"] = JSON.stringify(options.auth.drivers);
+			}
+		}
+		if (options?.backendCommands && options.backendCommands.length > 0) this.logger.debug(`Adding backend commands: ${options.backendCommands.join(" ")}`);
+		require_state.default.setInstanceInfo(instanceName, {
+			type: "docker",
+			upCommands: [{
+				cmd: "docker",
+				args: [
+					"compose",
+					`--file=${composeDstPath}`,
+					"up",
+					"--detach",
+					"--remove-orphans",
+					"--pull=missing"
+				],
+				envs,
+				runOpts: { stdio: "inherit" }
+			}],
+			downCommands: [{
+				cmd: "docker",
+				args: [
+					"compose",
+					`--file=${composeDstPath}`,
+					"down"
+				],
+				envs,
+				runOpts: { stdio: "inherit" }
+			}],
+			cleanupCommands: [{
+				cmd: "docker",
+				args: [
+					"compose",
+					`--file=${composeDstPath}`,
+					"down",
+					"--volumes",
+					"--remove-orphans"
+				],
+				envs,
+				runOpts: { stdio: "inherit" }
+			}],
+			runInfo: {
+				apiPort: options?.grpcPort,
+				apiAddr: options?.grpcAddr,
+				logPath: logFilePath,
+				primary,
+				work: {
+					type: "FS",
+					rootPath: workFSPath
+				},
+				library,
+				dbPath: dbFSPath
+			}
+		});
+		return require_state.default.getInstanceInfo(instanceName);
+	}
+	cleanupInstance(instanceName) {
+		const removeWarns = [];
+		const instancesToDrop = /* @__PURE__ */ new Map();
+		let warnMessage = "";
+		if (instanceName) {
+			const instance = require_state.default.getInstanceInfo(instanceName);
+			instancesToDrop.set(instanceName, instance);
+			const iType = instance.type;
+			switch (iType) {
+				case "docker":
+					removeWarns.push(`docker service 'pl-${instanceName}', including all its volumes and data in '${require_state.default.instanceDir(instanceName)}' will be destroyed`);
+					break;
+				case "process":
+					removeWarns.push(`directory '${require_state.default.instanceDir(instanceName)}' would be deleted`);
+					if (instance.downCommands) removeWarns.push(`associated docker service, including all volumes and data will be destroyed`);
+					break;
+				default: require_util.assertNever(iType);
+			}
+			if (instanceName === require_state.default.currentInstanceName) removeWarns.push("last command run cache ('pl-dev start' shorthand will stop working until next full start command call)");
+			warnMessage = `
 You are going to reset the state of platforma service '${instanceName}':
   - ${removeWarns.join("\n  - ")}
 `;
-        }
-        else {
-            for (const iName of state.instanceList) {
-                instancesToDrop.set(iName, state.getInstanceInfo(iName));
-            }
-            removeWarns.push("last command run cache ('pl-dev start' shorthand will stop working until next full start command call)", `all service configurations stored in: ${state.instanceDir()} (including all associated docker containers and volumes)`);
-            warnMessage = `
+		} else {
+			for (const iName of require_state.default.instanceList) instancesToDrop.set(iName, require_state.default.getInstanceInfo(iName));
+			removeWarns.push("last command run cache ('pl-dev start' shorthand will stop working until next full start command call)", `all service configurations stored in: ${require_state.default.instanceDir()} (including all associated docker containers and volumes)`);
+			warnMessage = `
 You are going to reset the state of all platforma services configured with pl-bootstrap package.
   - ${removeWarns.join("\n  - ")}
 `;
-        }
-        this.logger.warn(warnMessage);
-        if (!util.askYN("Are you sure?")) {
-            this.logger.info("Reset action was canceled");
-            return;
-        }
-        for (const [name, instance] of instancesToDrop.entries()) {
-            if (instance.cleanupCommands.length) {
-                this.logger.info(`Wiping instance ${name} services`);
-                const result = run.runCommands(this.logger, instance.cleanupCommands);
-                checkRunError(result.executed, `failed to wipe instance ${name} services`);
-            }
-            this.logger.info(`Destroying instance '${name}' data directory`);
-            fs.rmSync(state.instanceDir(name), { recursive: true, force: true });
-        }
-        if (!instanceName) {
-            this.logger.info(`Destroying state dir '${state.path()}'`);
-            fs.rmSync(state.path(), { recursive: true, force: true });
-        }
-        this.logger.info(`\nIf you want to remove all downloaded platforma binaries, delete '${state.binaries()}' dir manually\n`);
-    }
-    mergeLicenseEnvs(flags) {
-        if (flags.license === undefined) {
-            if ((process.env.MI_LICENSE ?? "") != "")
-                flags.license = process.env.MI_LICENSE;
-            else if ((process.env.PL_LICENSE ?? "") != "")
-                flags.license = process.env.PL_LICENSE;
-        }
-        // set 'license-file' only if license is still undefined
-        if (flags["license-file"] === undefined && flags.license === undefined) {
-            if ((process.env.MI_LICENSE_FILE ?? "") != "")
-                flags["license-file"] = process.env.MI_LICENSE_FILE;
-            else if ((process.env.PL_LICENSE_FILE ?? "") != "")
-                flags["license-file"] = process.env.PL_LICENSE_FILE;
-            else if (fs.existsSync(path.resolve(os.homedir(), ".pl.license")))
-                flags["license-file"] = path.resolve(os.homedir(), ".pl.license");
-        }
-    }
-    initAuthDriversList(flags, workdir) {
-        const authDrivers = [];
-        if (flags["auth-htpasswd-file"]) {
-            authDrivers.push({
-                driver: "htpasswd",
-                path: path.resolve(workdir, flags["auth-htpasswd-file"]),
-            });
-        }
-        if (Boolean(flags["auth-ldap-server"]) !== Boolean(flags["auth-ldap-default-dn"])) {
-            throw new Error("LDAP auth settings require both 'server' and 'default DN' options to be set");
-        }
-        if (flags["auth-ldap-server"]) {
-            authDrivers.push({
-                driver: "ldap",
-                serverUrl: flags["auth-ldap-server"],
-                defaultDN: flags["auth-ldap-default-dn"],
-            });
-        }
-        if (authDrivers.length === 0) {
-            return undefined;
-        }
-        return [{ driver: "jwt", key: this.getLastJwt() }, ...authDrivers];
-    }
-    /** Gets the last stored JWT secret key or generates it and stores in a file. */
-    getLastJwt() {
-        const jwtFile = state.path("auth.jwt");
-        const encoding = "utf-8";
-        let lastJwt = "";
-        if (fs.existsSync(jwtFile)) {
-            lastJwt = fs.readFileSync(jwtFile, { encoding });
-        }
-        if (lastJwt == "") {
-            lastJwt = util.randomStr(64);
-            fs.writeFileSync(jwtFile, lastJwt, { encoding });
-        }
-        return lastJwt;
-    }
-    checkLicense(value, file) {
-        if (value !== undefined && value != "")
-            return;
-        if (file !== undefined && file != "")
-            return;
-        this.logger.error(`A license for Platforma Backend must be set.
+		}
+		this.logger.warn(warnMessage);
+		if (!require_util.askYN("Are you sure?")) {
+			this.logger.info("Reset action was canceled");
+			return;
+		}
+		for (const [name, instance] of instancesToDrop.entries()) {
+			if (instance.cleanupCommands.length) {
+				this.logger.info(`Wiping instance ${name} services`);
+				checkRunError(require_run.runCommands(this.logger, instance.cleanupCommands).executed, `failed to wipe instance ${name} services`);
+			}
+			this.logger.info(`Destroying instance '${name}' data directory`);
+			node_fs.default.rmSync(require_state.default.instanceDir(name), {
+				recursive: true,
+				force: true
+			});
+		}
+		if (!instanceName) {
+			this.logger.info(`Destroying state dir '${require_state.default.path()}'`);
+			node_fs.default.rmSync(require_state.default.path(), {
+				recursive: true,
+				force: true
+			});
+		}
+		this.logger.info(`\nIf you want to remove all downloaded platforma binaries, delete '${require_state.default.binaries()}' dir manually\n`);
+	}
+	mergeLicenseEnvs(flags) {
+		if (flags.license === void 0) {
+			if ((process.env.MI_LICENSE ?? "") != "") flags.license = process.env.MI_LICENSE;
+			else if ((process.env.PL_LICENSE ?? "") != "") flags.license = process.env.PL_LICENSE;
+		}
+		if (flags["license-file"] === void 0 && flags.license === void 0) {
+			if ((process.env.MI_LICENSE_FILE ?? "") != "") flags["license-file"] = process.env.MI_LICENSE_FILE;
+			else if ((process.env.PL_LICENSE_FILE ?? "") != "") flags["license-file"] = process.env.PL_LICENSE_FILE;
+			else if (node_fs.default.existsSync(node_path.default.resolve(node_os.default.homedir(), ".pl.license"))) flags["license-file"] = node_path.default.resolve(node_os.default.homedir(), ".pl.license");
+		}
+	}
+	initAuthDriversList(flags, workdir) {
+		const authDrivers = [];
+		if (flags["auth-htpasswd-file"]) authDrivers.push({
+			driver: "htpasswd",
+			path: node_path.default.resolve(workdir, flags["auth-htpasswd-file"])
+		});
+		if (Boolean(flags["auth-ldap-server"]) !== Boolean(flags["auth-ldap-default-dn"])) throw new Error("LDAP auth settings require both 'server' and 'default DN' options to be set");
+		if (flags["auth-ldap-server"]) authDrivers.push({
+			driver: "ldap",
+			serverUrl: flags["auth-ldap-server"],
+			defaultDN: flags["auth-ldap-default-dn"]
+		});
+		if (authDrivers.length === 0) return;
+		return [{
+			driver: "jwt",
+			key: this.getLastJwt()
+		}, ...authDrivers];
+	}
+	/** Gets the last stored JWT secret key or generates it and stores in a file. */
+	getLastJwt() {
+		const jwtFile = require_state.default.path("auth.jwt");
+		const encoding = "utf-8";
+		let lastJwt = "";
+		if (node_fs.default.existsSync(jwtFile)) lastJwt = node_fs.default.readFileSync(jwtFile, { encoding });
+		if (lastJwt == "") {
+			lastJwt = require_util.randomStr(64);
+			node_fs.default.writeFileSync(jwtFile, lastJwt, { encoding });
+		}
+		return lastJwt;
+	}
+	checkLicense(value, file) {
+		if (value !== void 0 && value != "") return;
+		if (file !== void 0 && file != "") return;
+		this.logger.error(`A license for Platforma Backend must be set.
 
 You can provide the license directly using the '--license' flag
 or use the '--license-file' flag if the license is stored in a file.
@@ -766,137 +642,92 @@ The license file can also be set with the variables 'MI_LICENSE_FILE' or 'PL_LIC
 or stored in '$HOME/.pl.license'.
 
 You can obtain the license from "https://platforma.bio/getlicense".`);
-        throw new Error(`The license was not provided.`);
-    }
-    configureDockerStorage(storageID, storage) {
-        const envs = {};
-        const sType = storage.type;
-        storageID = storageID.toUpperCase();
-        switch (sType) {
-            case "S3":
-                switch (storageID) {
-                    case "PRIMARY": {
-                        // Construct the S3 URL for primary storage
-                        if (storage.endpoint && storage.bucketName) {
-                            envs["PL_PRIMARY_STORAGE_S3"] = `${storage.endpoint}${storage.bucketName}`;
-                        }
-                        if (storage.endpoint)
-                            envs["PL_PRIMARY_STORAGE_S3_ENDPOINT"] = storage.endpoint;
-                        if (storage.presignEndpoint)
-                            envs["PL_PRIMARY_STORAGE_S3_EXTERNAL_ENDPOINT"] = storage.presignEndpoint;
-                        if (storage.region)
-                            envs["PL_PRIMARY_STORAGE_S3_REGION"] = storage.region;
-                        if (storage.key)
-                            envs["PL_PRIMARY_STORAGE_S3_KEY"] = storage.key;
-                        if (storage.secret)
-                            envs["PL_PRIMARY_STORAGE_S3_SECRET"] = storage.secret;
-                        break;
-                    }
-                    case "LIBRARY": {
-                        // Construct the S3 URL for library storage
-                        if (storage.endpoint && storage.bucketName) {
-                            envs["PL_DATA_LIBRARY_S3_URL"] = `library=${storage.endpoint}${storage.bucketName}`;
-                        }
-                        if (storage.endpoint)
-                            envs["PL_DATA_LIBRARY_S3_ENDPOINT"] = `library=${storage.endpoint}`;
-                        if (storage.presignEndpoint)
-                            envs["PL_DATA_LIBRARY_S3_EXTERNAL_ENDPOINT"] = `library=${storage.presignEndpoint}`;
-                        if (storage.region)
-                            envs["PL_DATA_LIBRARY_S3_REGION"] = `library=${storage.region}`;
-                        if (storage.key)
-                            envs["PL_DATA_LIBRARY_S3_KEY"] = `library=${storage.key}`;
-                        if (storage.secret)
-                            envs["PL_DATA_LIBRARY_S3_SECRET"] = `library=${storage.secret}`;
-                        break;
-                    }
-                    default:
-                        throw new Error(`Unknown storage ID: ${storageID}`);
-                }
-                return envs;
-            case "FS":
-                switch (storageID) {
-                    case "PRIMARY":
-                        if (storage.rootPath)
-                            envs["PL_PRIMARY_STORAGE_FS"] = storage.rootPath;
-                        break;
-                    case "LIBRARY":
-                        if (storage.rootPath)
-                            envs["PL_DATA_LIBRARY_FS_PATH"] = storage.rootPath;
-                        break;
-                    default:
-                        throw new Error(`Unknown storage ID: ${storageID}`);
-                }
-                return envs;
-            default:
-                util.assertNever();
-        }
-        return {};
-    }
-    renderRunInfo(runInfo, indent = 10) {
-        const report = [];
-        const column = (t) => t.padStart(indent, " ");
-        if (runInfo.configPath) {
-            report.push(`${column("config")}: ${runInfo.configPath}`);
-        }
-        if (runInfo.apiAddr) {
-            report.push(`${column("API")}: ${runInfo.apiAddr}`);
-        }
-        else if (runInfo.apiPort) {
-            report.push(`${column("API")}: 127.0.0.1:${runInfo.apiPort.toString()}`);
-        }
-        else {
-            report.push(`${column("API")}: 127.0.0.1:6345`);
-        }
-        if (runInfo.logPath) {
-            report.push(`${column("log")}: ${runInfo.logPath}`);
-        }
-        const primaryType = runInfo.primary?.type;
-        switch (primaryType) {
-            case undefined:
-                break;
-            case "FS":
-                report.push(`${column("primary")}: ${runInfo.primary.rootPath}`);
-                break;
-            case "S3":
-                report.push(`${column("primary")}: S3 at '${runInfo.primary.endpoint ?? "AWS"}', bucket '${runInfo.primary.bucketName}', prefix: '${runInfo.primary.keyPrefix ?? ""}'`);
-                break;
-            default:
-                util.assertNever();
-        }
-        const libraryType = runInfo.library?.type;
-        switch (libraryType) {
-            case undefined:
-                break;
-            case "FS":
-                report.push(`${column("library")}: ${runInfo.library.rootPath}`);
-                break;
-            case "S3":
-                report.push(`${column("library")}: S3 at '${runInfo.library.endpoint ?? "AWS"}', bucket '${runInfo.library.bucketName}', prefix: '${runInfo.library.keyPrefix ?? ""}'`);
-                break;
-            default:
-                util.assertNever();
-        }
-        if (runInfo.work) {
-            report.push(`${column("workdirs")}: ${runInfo.work.rootPath}`);
-        }
-        if (runInfo.dbPath) {
-            report.push(`${column("db")}: ${runInfo.dbPath}`);
-        }
-        return report.join("\n");
-    }
-}
+		throw new Error(`The license was not provided.`);
+	}
+	configureDockerStorage(storageID, storage) {
+		const envs = {};
+		const sType = storage.type;
+		storageID = storageID.toUpperCase();
+		switch (sType) {
+			case "S3":
+				switch (storageID) {
+					case "PRIMARY":
+						if (storage.endpoint && storage.bucketName) envs["PL_PRIMARY_STORAGE_S3"] = `${storage.endpoint}${storage.bucketName}`;
+						if (storage.endpoint) envs["PL_PRIMARY_STORAGE_S3_ENDPOINT"] = storage.endpoint;
+						if (storage.presignEndpoint) envs["PL_PRIMARY_STORAGE_S3_EXTERNAL_ENDPOINT"] = storage.presignEndpoint;
+						if (storage.region) envs["PL_PRIMARY_STORAGE_S3_REGION"] = storage.region;
+						if (storage.key) envs["PL_PRIMARY_STORAGE_S3_KEY"] = storage.key;
+						if (storage.secret) envs["PL_PRIMARY_STORAGE_S3_SECRET"] = storage.secret;
+						break;
+					case "LIBRARY":
+						if (storage.endpoint && storage.bucketName) envs["PL_DATA_LIBRARY_S3_URL"] = `library=${storage.endpoint}${storage.bucketName}`;
+						if (storage.endpoint) envs["PL_DATA_LIBRARY_S3_ENDPOINT"] = `library=${storage.endpoint}`;
+						if (storage.presignEndpoint) envs["PL_DATA_LIBRARY_S3_EXTERNAL_ENDPOINT"] = `library=${storage.presignEndpoint}`;
+						if (storage.region) envs["PL_DATA_LIBRARY_S3_REGION"] = `library=${storage.region}`;
+						if (storage.key) envs["PL_DATA_LIBRARY_S3_KEY"] = `library=${storage.key}`;
+						if (storage.secret) envs["PL_DATA_LIBRARY_S3_SECRET"] = `library=${storage.secret}`;
+						break;
+					default: throw new Error(`Unknown storage ID: ${storageID}`);
+				}
+				return envs;
+			case "FS":
+				switch (storageID) {
+					case "PRIMARY":
+						if (storage.rootPath) envs["PL_PRIMARY_STORAGE_FS"] = storage.rootPath;
+						break;
+					case "LIBRARY":
+						if (storage.rootPath) envs["PL_DATA_LIBRARY_FS_PATH"] = storage.rootPath;
+						break;
+					default: throw new Error(`Unknown storage ID: ${storageID}`);
+				}
+				return envs;
+			default: require_util.assertNever(sType);
+		}
+		return {};
+	}
+	renderRunInfo(runInfo, indent = 10) {
+		const report = [];
+		const column = (t) => t.padStart(indent, " ");
+		if (runInfo.configPath) report.push(`${column("config")}: ${runInfo.configPath}`);
+		if (runInfo.apiAddr) report.push(`${column("API")}: ${runInfo.apiAddr}`);
+		else if (runInfo.apiPort) report.push(`${column("API")}: 127.0.0.1:${runInfo.apiPort.toString()}`);
+		else report.push(`${column("API")}: 127.0.0.1:6345`);
+		if (runInfo.logPath) report.push(`${column("log")}: ${runInfo.logPath}`);
+		const primaryType = runInfo.primary?.type;
+		switch (primaryType) {
+			case void 0: break;
+			case "FS":
+				report.push(`${column("primary")}: ${runInfo.primary.rootPath}`);
+				break;
+			case "S3":
+				report.push(`${column("primary")}: S3 at '${runInfo.primary.endpoint ?? "AWS"}', bucket '${runInfo.primary.bucketName}', prefix: '${runInfo.primary.keyPrefix ?? ""}'`);
+				break;
+			default: require_util.assertNever(primaryType);
+		}
+		const libraryType = runInfo.library?.type;
+		switch (libraryType) {
+			case void 0: break;
+			case "FS":
+				report.push(`${column("library")}: ${runInfo.library.rootPath}`);
+				break;
+			case "S3":
+				report.push(`${column("library")}: S3 at '${runInfo.library.endpoint ?? "AWS"}', bucket '${runInfo.library.bucketName}', prefix: '${runInfo.library.keyPrefix ?? ""}'`);
+				break;
+			default: require_util.assertNever(libraryType);
+		}
+		if (runInfo.work) report.push(`${column("workdirs")}: ${runInfo.work.rootPath}`);
+		if (runInfo.dbPath) report.push(`${column("db")}: ${runInfo.dbPath}`);
+		return report.join("\n");
+	}
+};
 function checkRunError(result, message) {
-    for (const buffer of result) {
-        if (buffer.error) {
-            throw buffer.error;
-        }
-        const msg = message ?? "failed to run command";
-        if (buffer.status !== 0) {
-            throw new Error(`${msg}, process exited with code '${buffer.status}'`);
-        }
-    }
+	for (const buffer of result) {
+		if (buffer.error) throw buffer.error;
+		const msg = message ?? "failed to run command";
+		if (buffer.status !== 0) throw new Error(`${msg}, process exited with code '${buffer.status}'`);
+	}
 }
 
-exports.checkRunError = checkRunError;
+//#endregion
 exports.default = Core;
-//# sourceMappingURL=core.cjs.map
+//# sourceMappingURL=core.cjs.map