@platforma-sdk/bootstrap 3.5.18 → 3.5.20

package/dist/core.cjs

@@ -0,0 +1,742 @@
+'use strict';
+
+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),
+            };
+        }
+        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}/main-bucket/?region=no-region`,
+            libraryURL: options?.libraryURL ?? `s3e://testuser:testpassword@localhost:${minioPort}/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}/main-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}/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,
+                }],
+        ]));
+        const envs = {
+            MINIO_IMAGE: 'quay.io/minio/minio',
+            MINIO_STORAGE: storageDir('minio'),
+            PL_IMAGE: image,
+            PL_AUTH_HTPASSWD_PATH: 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)
+            envs.PL_GRPC_ADDR = options.grpcAddr;
+        if (options?.grpcPort)
+            envs.PL_GRPC_PORT = options.grpcPort.toString();
+        if (options?.monitoringAddr)
+            envs.PL_MONITORING_ADDR = options.monitoringAddr;
+        if (options?.monitoringPort)
+            envs.PL_MONITORING_PORT = options.monitoringPort.toString();
+        if (options?.debugAddr)
+            envs.PL_DEBUG_ADDR = options.debugAddr;
+        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_AUTH_ENABLED'] = 'true';
+            }
+            if (options.auth.drivers) {
+                for (const drv of options.auth.drivers) {
+                    if (drv.driver === 'htpasswd') {
+                        envs['PL_AUTH_HTPASSWD_PATH'] = path.resolve(drv.path);
+                        drv.path = '/etc/platforma/users.htpasswd';
+                    }
+                }
+                envs['PL_AUTH_DRIVERS'] = JSON.stringify(options.auth.drivers);
+            }
+        }
+        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,
+                }],
+        ]));
+        const primary = plConfig.storageSettingsFromURL(options?.primaryStorageURL ?? `file:${primaryFSPath}`, '.');
+        const library = plConfig.storageSettingsFromURL(options?.libraryStorageURL ?? `file:${libraryFSPath}`, '.');
+        const envs = {
+            PL_IMAGE: image,
+            PL_AUTH_HTPASSWD_PATH: usersFSPath,
+            PL_LICENSE: options?.license,
+            PL_LICENSE_FILE: options?.licenseFile,
+            PL_LOG_LEVEL: '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)
+            envs.PL_GRPC_ADDR = options.grpcAddr;
+        if (options?.grpcPort)
+            envs.PL_GRPC_PORT = options.grpcPort.toString();
+        if (options?.monitoringAddr)
+            envs.PL_MONITORING_ADDR = options.monitoringAddr;
+        if (options?.monitoringPort)
+            envs.PL_MONITORING_PORT = options.monitoringPort.toString();
+        if (options?.debugAddr)
+            envs.PL_DEBUG_ADDR = options.debugAddr;
+        if (options?.debugPort)
+            envs.PL_DEBUG_PORT = options.debugPort.toString();
+        if (options?.auth) {
+            if (options.auth.enabled) {
+                envs['PL_AUTH_ENABLED'] = 'true';
+            }
+            if (options.auth.drivers) {
+                for (const drv of options.auth.drivers) {
+                    if (drv.driver === 'htpasswd') {
+                        envs['PL_AUTH_HTPASSWD_PATH'] = path.resolve(drv.path);
+                        drv.path = '/etc/platforma/users.htpasswd';
+                    }
+                }
+                envs['PL_AUTH_DRIVERS'] = JSON.stringify(options.auth.drivers);
+            }
+        }
+        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 = `
+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 = `
+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.
+
+You can provide the license directly using the '--license' flag
+or use the '--license-file' flag if the license is stored in a file.
+
+Alternatively, you can set it via the environment variables 'MI_LICENSE' or 'PL_LICENSE'.
+
+The license file can also be set with the variables 'MI_LICENSE_FILE' or 'PL_LICENSE_FILE',
+or stored in '$HOME/.pl.license'.
+
+You can obtain the license from "https://licensing.milaboratories.com".`);
+        throw new Error(`The license was not provided.`);
+    }
+    configureDockerStorage(storageID, storage) {
+        const envs = {};
+        const sType = storage.type;
+        storageID = storageID.toUpperCase();
+        switch (sType) {
+            case 'S3':
+                envs[`PL_DATA_${storageID}_TYPE`] = 'S3';
+                envs[`PL_DATA_${storageID}_S3_BUCKET`] = storage.bucketName;
+                if (storage.endpoint)
+                    envs[`PL_DATA_${storageID}_S3_ENDPOINT`] = storage.endpoint;
+                if (storage.presignEndpoint)
+                    envs[`PL_DATA_${storageID}_S3_PRESIGN_ENDPOINT`] = storage.presignEndpoint;
+                if (storage.region)
+                    envs[`PL_DATA_${storageID}_S3_REGION`] = storage.region;
+                if (storage.key)
+                    envs[`PL_DATA_${storageID}_S3_KEY`] = storage.key;
+                if (storage.secret)
+                    envs[`PL_DATA_${storageID}_S3_SECRET`] = storage.secret;
+                return envs;
+            case 'FS':
+                envs[`PL_DATA_${storageID}_TYPE`] = 'FS';
+                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');
+    }
+}
+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}'`);
+        }
+    }
+}
+
+exports.checkRunError = checkRunError;
+exports.default = Core;
+//# sourceMappingURL=core.cjs.map