@platforma-sdk/bootstrap 5.2.41 → 5.2.43

package/dist/core.js

@@ -17,8 +17,8 @@ class Core {
     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');
+            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);
     }
@@ -29,7 +29,7 @@ class Core {
         }
         const result = runCommands(this.logger, instance.upCommands);
         checkRunError(result.executed);
-        if (result.spawned.length > 0 && instance.type === 'process') {
+        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`);
@@ -43,10 +43,10 @@ class Core {
         checkRunError(result.executed);
         const iType = instance.type;
         switch (iType) {
-            case 'docker': {
+            case "docker": {
                 return;
             }
-            case 'process': {
+            case "process": {
                 if (instance.pid && state.isInstanceActive(instance)) {
                     process.kill(instance.pid);
                 }
@@ -69,9 +69,9 @@ class Core {
         return this.startInstance(instance);
     }
     createLocal(instanceName, options) {
-        let plBinaryPath = binaryPath(options?.version, 'binaries', 'platforma');
+        let plBinaryPath = binaryPath(options?.version, "binaries", "platforma");
         if (options?.sourcesPath) {
-            plBinaryPath = path.join(os__default.tmpdir(), 'platforma-custom-build');
+            plBinaryPath = path.join(os__default.tmpdir(), "platforma-custom-build");
         }
         if (options?.binaryPath) {
             plBinaryPath = options.binaryPath;
@@ -104,17 +104,17 @@ class Core {
             `${configOptions.localRoot}/packages-local`,
             `${configOptions.localRoot}/blocks-local`,
         ];
-        if (configOptions.storages.primary.type === 'FS') {
+        if (configOptions.storages.primary.type === "FS") {
             storageDirs.push(configOptions.storages.primary.rootPath);
         }
-        if (configOptions.storages.library.type === 'FS') {
+        if (configOptions.storages.library.type === "FS") {
             storageDirs.push(configOptions.storages.library.rootPath);
             configOptions.hacks.libraryDownloadable = false;
         }
-        if (configOptions.storages.work.type === 'FS') {
+        if (configOptions.storages.work.type === "FS") {
             storageDirs.push(configOptions.storages.work.rootPath);
         }
-        this.logger.debug('  creating pl state directories...');
+        this.logger.debug("  creating pl state directories...");
         for (const dir of storageDirs) {
             if (!fs__default.existsSync(dir)) {
                 this.logger.debug(`    '${dir}'`);
@@ -122,36 +122,36 @@ class Core {
             }
         }
         for (const drv of configOptions.core.auth.drivers) {
-            if (drv.driver === 'htpasswd') {
+            if (drv.driver === "htpasswd") {
                 if (!fs__default.existsSync(drv.path)) {
                     this.logger.debug(`  installing default 'users.htpasswd' to ${drv.path}...`);
-                    fs__default.copyFileSync(assets('users.htpasswd'), drv.path);
+                    fs__default.copyFileSync(assets("users.htpasswd"), drv.path);
                 }
             }
         }
         if (!configPath) {
-            configPath = path.join(configOptions.localRoot, 'config.yaml');
+            configPath = path.join(configOptions.localRoot, "config.yaml");
             this.logger.debug(`  rendering configuration '${configPath}'...`);
             fs__default.writeFileSync(configPath, render(configOptions));
         }
         const upCommands = [];
         if (options?.sourcesPath) {
             upCommands.push({
-                cmd: 'go',
-                args: ['build', '-o', plBinaryPath, '.'],
-                workdir: path.resolve(options.sourcesPath, 'cmd', 'platforma'),
+                cmd: "go",
+                args: ["build", "-o", plBinaryPath, "."],
+                workdir: path.resolve(options.sourcesPath, "cmd", "platforma"),
                 runOpts: {
-                    stdio: 'inherit',
+                    stdio: "inherit",
                 },
             });
         }
         const runBinary = {
             async: true,
             cmd: plBinaryPath,
-            args: ['--quiet', '--config', configPath],
+            args: ["--quiet", "--config", configPath],
             workdir: workdir,
             runOpts: {
-                stdio: 'inherit',
+                stdio: "inherit",
             },
         };
         if (options?.configOptions?.numCpu) {
@@ -165,7 +165,7 @@ class Core {
                 runBinary.runOpts.env = {};
             }
             for (const cmd of options.backendCommands) {
-                const equalIndex = cmd.indexOf('=');
+                const equalIndex = cmd.indexOf("=");
                 if (equalIndex > 0) {
                     const key = cmd.substring(0, equalIndex);
                     const value = cmd.substring(equalIndex + 1);
@@ -178,13 +178,13 @@ class Core {
         }
         // Process additional backend commands
         if (options?.backendCommands && options.backendCommands.length > 0) {
-            this.logger.debug(`Adding backend commands: ${options.backendCommands.join(' ')}`);
+            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',
+            type: "process",
             upCommands: upCommands,
             downCommands: [],
             cleanupCommands: [],
@@ -201,47 +201,38 @@ class Core {
         return state.getInstanceInfo(instanceName);
     }
     createLocalS3(instanceName, options) {
-        this.logger.debug('creating platforma instance in \'local s3\' mode...');
+        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`,
+            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,
+            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,
-        ];
+        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 = assets('compose-backend.yaml');
-        const composeMinio = state.instanceDir(instanceName, 'compose-minio.yaml');
-        render$1(composeSrc, composeMinio, `pl-${instanceName}-minio`, new Map([
-            ['minio', {}],
-        ]), { dropVolumes: true });
-        const version = options?.version ? `:${options.version}` : '';
+        this.logger.debug("  creating docker compose for minio service...");
+        const composeSrc = assets("compose-backend.yaml");
+        const composeMinio = state.instanceDir(instanceName, "compose-minio.yaml");
+        render$1(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');
-        ensureDir(storage, { mode: '0775' });
+        const storage = options?.storage ?? state.instanceDir(instanceName, "minio");
+        ensureDir(storage, { mode: "0775" });
         const minioPort = options?.minioPort ?? 9000;
         const minioConsolePort = options?.minioConsolePort ?? 9001;
         const envs = {
@@ -252,67 +243,74 @@ class Core {
         };
         return {
             start: {
-                cmd: 'docker',
-                args: ['compose', `--file=${composeMinio}`, 'up', '--detach', '--remove-orphans', '--pull=missing'],
+                cmd: "docker",
+                args: [
+                    "compose",
+                    `--file=${composeMinio}`,
+                    "up",
+                    "--detach",
+                    "--remove-orphans",
+                    "--pull=missing",
+                ],
                 envs: envs,
                 workdir: state.instanceDir(instanceName),
-                runOpts: { stdio: 'inherit' },
+                runOpts: { stdio: "inherit" },
             },
             stop: {
-                cmd: 'docker',
-                args: ['compose', `--file=${composeMinio}`, 'down'],
+                cmd: "docker",
+                args: ["compose", `--file=${composeMinio}`, "down"],
                 envs: envs,
                 workdir: state.instanceDir(instanceName),
-                runOpts: { stdio: 'inherit' },
+                runOpts: { stdio: "inherit" },
             },
             cleanup: {
-                cmd: 'docker',
-                args: ['compose', `--file=${composeMinio}`, 'down', '--volumes', '--remove-orphans'],
+                cmd: "docker",
+                args: ["compose", `--file=${composeMinio}`, "down", "--volumes", "--remove-orphans"],
                 envs: envs,
                 workdir: state.instanceDir(instanceName),
-                runOpts: { stdio: 'inherit' },
+                runOpts: { stdio: "inherit" },
             },
         };
     }
     createDockerS3(instanceName, localRoot, options) {
-        this.logger.debug('creating platforma instance in \'docker s3\' mode...');
-        const composeS3Path = assets('compose-backend.yaml');
+        this.logger.debug("creating platforma instance in 'docker s3' mode...");
+        const composeS3Path = assets("compose-backend.yaml");
         const image = options?.image ?? plImageTag(options?.version);
         this.checkLicense(options?.license, options?.licenseFile);
         const storagePath = (...s) => path.join(localRoot, ...s);
         const storageDir = (s) => {
             const p = storagePath(s);
-            ensureDir(p, { mode: '0775' });
+            ensureDir(p, { mode: "0775" });
             return p;
         };
-        const logFilePath = storagePath('logs', 'platforma.log');
+        const logFilePath = storagePath("logs", "platforma.log");
         if (!fs__default.existsSync(logFilePath)) {
             fs__default.mkdirSync(path.dirname(logFilePath), { recursive: true });
-            fs__default.writeFileSync(logFilePath, '');
+            fs__default.writeFileSync(logFilePath, "");
         }
-        const presignHost = options?.presignHost ?? 'localhost';
+        const presignHost = options?.presignHost ?? "localhost";
         const presignPort = options?.s3Port ?? 9000;
         const primary = 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');
+        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 = storageSettingsFromURL(`s3e://testuser:testpassword@minio:${presignPort}/platforma-library-bucket`);
-        if (library.type !== 'S3') {
+        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');
+        const dbFSPath = storageDir("db");
+        const workFSPath = storageDir("work");
+        const usersFSPath = storagePath("users.htpasswd");
         if (!fs__default.existsSync(usersFSPath)) {
-            fs__default.copyFileSync(assets('users.htpasswd'), usersFSPath);
+            fs__default.copyFileSync(assets("users.htpasswd"), usersFSPath);
         }
-        const composeDstPath = storagePath('compose.yaml');
+        const composeDstPath = storagePath("compose.yaml");
         if (fs__default.existsSync(composeDstPath)) {
             this.logger.info(`replacing docker compose file ${composeDstPath}`);
         }
@@ -324,35 +322,38 @@ class Core {
             });
         }
         render$1(composeS3Path, composeDstPath, `pl-${instanceName}`, new Map([
-            ['minio', {}],
-            ['backend', {
+            ["minio", {}],
+            [
+                "backend",
+                {
                     platform: options?.platformOverride,
                     mounts: backendMounts,
                     commands: options?.backendCommands,
-                }],
+                },
+            ],
         ]));
         const envs = {
-            MINIO_IMAGE: 'quay.io/minio/minio',
-            MINIO_STORAGE: storageDir('minio'),
+            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_LEVEL: options?.logLevel ?? "info",
             PL_LOG_DIR: path.dirname(logFilePath),
-            PL_LOG_ROTATION_ENABLED: 'true',
-            PL_RUNNER_WD_CACHE_ON_FAILURE: '1h',
+            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_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),
+            ...this.configureDockerStorage("primary", primary),
+            ...this.configureDockerStorage("library", library),
         };
         if (options?.grpcAddr) {
-            const addrParts = options.grpcAddr.split(':');
+            const addrParts = options.grpcAddr.split(":");
             if (addrParts.length === 2) {
                 envs.PL_LISTEN_ADDRESS = addrParts[0];
                 envs.PL_LISTEN_PORT = addrParts[1];
@@ -365,7 +366,7 @@ class Core {
             envs.PL_LISTEN_PORT = options.grpcPort.toString();
         }
         if (options?.monitoringAddr) {
-            const addrParts = options.monitoringAddr.split(':');
+            const addrParts = options.monitoringAddr.split(":");
             if (addrParts.length === 2) {
                 envs.PL_MONITORING_IP = addrParts[0];
                 envs.PL_MONITORING_PORT = addrParts[1];
@@ -378,7 +379,7 @@ class Core {
             envs.PL_MONITORING_PORT = options.monitoringPort.toString();
         }
         if (options?.debugAddr) {
-            const addrParts = options.debugAddr.split(':');
+            const addrParts = options.debugAddr.split(":");
             if (addrParts.length === 2) {
                 envs.PL_DEBUG_IP = addrParts[0];
                 envs.PL_DEBUG_PORT = addrParts[1];
@@ -396,51 +397,64 @@ class Core {
             envs.MINIO_CONSOLE_PORT = options.s3ConsolePort.toString();
         if (options?.auth) {
             if (options.auth.enabled) {
-                envs['PL_NO_AUTH'] = 'false';
+                envs["PL_NO_AUTH"] = "false";
             }
             else {
-                envs['PL_NO_AUTH'] = 'true';
+                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';
+                    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);
+                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(' ')}`);
+            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'],
+            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'],
+                    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'],
+                    runOpts: { stdio: "inherit" },
+                },
+            ],
+            cleanupCommands: [
+                {
+                    cmd: "docker",
+                    args: ["compose", `--file=${composeDstPath}`, "down", "--volumes", "--remove-orphans"],
                     envs: envs,
-                    runOpts: { stdio: 'inherit' },
-                }],
+                    runOpts: { stdio: "inherit" },
+                },
+            ],
             runInfo: {
                 apiPort: options?.grpcPort,
                 apiAddr: options?.grpcAddr,
                 logPath: logFilePath,
                 primary: primary,
-                work: { type: 'FS', rootPath: workFSPath },
+                work: { type: "FS", rootPath: workFSPath },
                 library: library,
                 dbPath: dbFSPath,
             },
@@ -448,30 +462,30 @@ class Core {
         return state.getInstanceInfo(instanceName);
     }
     createDocker(instanceName, localRoot, options) {
-        this.logger.debug('creating platforma instance in \'docker\' mode...');
-        const composeFSPath = assets('compose-backend.yaml');
+        this.logger.debug("creating platforma instance in 'docker' mode...");
+        const composeFSPath = assets("compose-backend.yaml");
         const image = options?.image ?? plImageTag(options?.version);
         this.checkLicense(options?.license, options?.licenseFile);
         const storagePath = (...s) => path.join(localRoot, ...s);
         const storageDir = (s) => {
             const p = storagePath(s);
-            ensureDir(p, { mode: '0775' });
+            ensureDir(p, { mode: "0775" });
             return p;
         };
-        const logFilePath = storagePath('logs', 'platforma.log');
+        const logFilePath = storagePath("logs", "platforma.log");
         if (!fs__default.existsSync(logFilePath)) {
             fs__default.mkdirSync(path.dirname(logFilePath), { recursive: true });
-            fs__default.writeFileSync(logFilePath, '');
+            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');
+        const dbFSPath = storageDir("db");
+        const primaryFSPath = storageDir("primary");
+        const libraryFSPath = storageDir("library");
+        const workFSPath = storageDir("work");
+        const usersFSPath = storagePath("users.htpasswd");
         if (!fs__default.existsSync(usersFSPath)) {
-            fs__default.copyFileSync(assets('users.htpasswd'), usersFSPath);
+            fs__default.copyFileSync(assets("users.htpasswd"), usersFSPath);
         }
-        const composeDstPath = storagePath('compose.yaml');
+        const composeDstPath = storagePath("compose.yaml");
         if (fs__default.existsSync(composeDstPath)) {
             this.logger.info(`replacing docker compose file ${composeDstPath}`);
         }
@@ -484,33 +498,36 @@ class Core {
         }
         this.logger.debug(`Rendering docker compose file '${composeDstPath}' using '${composeFSPath}' as base template`);
         render$1(composeFSPath, composeDstPath, `pl-${instanceName}`, new Map([
-            ['backend', {
+            [
+                "backend",
+                {
                     platform: options?.platformOverride,
                     mounts: backendMounts,
                     commands: options?.backendCommands,
-                }],
+                },
+            ],
         ]));
-        const primary = storageSettingsFromURL(options?.primaryStorageURL ?? `file:${primaryFSPath}`, '.');
-        const library = storageSettingsFromURL(options?.libraryStorageURL ?? `file:${libraryFSPath}`, '.');
+        const primary = storageSettingsFromURL(options?.primaryStorageURL ?? `file:${primaryFSPath}`, ".");
+        const library = 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_LEVEL: options?.logLevel ?? "info",
             PL_LOG_DIR: path.dirname(logFilePath),
-            PL_LOG_ROTATION_ENABLED: 'true',
-            PL_RUNNER_WD_CACHE_ON_FAILURE: '1h',
+            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),
+            PL_DATA_PACKAGE_ROOT: storageDir("packages"),
+            ...this.configureDockerStorage("primary", primary),
+            ...this.configureDockerStorage("library", library),
         };
         if (options?.grpcAddr) {
-            const addrParts = options.grpcAddr.split(':');
+            const addrParts = options.grpcAddr.split(":");
             if (addrParts.length === 2) {
                 envs.PL_LISTEN_ADDRESS = addrParts[0];
                 envs.PL_LISTEN_PORT = addrParts[1];
@@ -523,7 +540,7 @@ class Core {
             envs.PL_LISTEN_PORT = options.grpcPort.toString();
         }
         if (options?.monitoringAddr) {
-            const addrParts = options.monitoringAddr.split(':');
+            const addrParts = options.monitoringAddr.split(":");
             if (addrParts.length === 2) {
                 envs.PL_MONITORING_IP = addrParts[0];
                 envs.PL_MONITORING_PORT = addrParts[1];
@@ -536,7 +553,7 @@ class Core {
             envs.PL_MONITORING_PORT = options.monitoringPort.toString();
         }
         if (options?.debugAddr) {
-            const addrParts = options.debugAddr.split(':');
+            const addrParts = options.debugAddr.split(":");
             if (addrParts.length === 2) {
                 envs.PL_DEBUG_IP = addrParts[0];
                 envs.PL_DEBUG_PORT = addrParts[1];
@@ -550,51 +567,64 @@ class Core {
         }
         if (options?.auth) {
             if (options.auth.enabled) {
-                envs['PL_NO_AUTH'] = 'false';
+                envs["PL_NO_AUTH"] = "false";
             }
             else {
-                envs['PL_NO_AUTH'] = 'true';
+                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';
+                    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);
+                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(' ')}`);
+            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'],
+            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'],
+                    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'],
+                    runOpts: { stdio: "inherit" },
+                },
+            ],
+            cleanupCommands: [
+                {
+                    cmd: "docker",
+                    args: ["compose", `--file=${composeDstPath}`, "down", "--volumes", "--remove-orphans"],
                     envs: envs,
-                    runOpts: { stdio: 'inherit' },
-                }],
+                    runOpts: { stdio: "inherit" },
+                },
+            ],
             runInfo: {
                 apiPort: options?.grpcPort,
                 apiAddr: options?.grpcAddr,
                 logPath: logFilePath,
                 primary: primary,
-                work: { type: 'FS', rootPath: workFSPath },
+                work: { type: "FS", rootPath: workFSPath },
                 library: library,
                 dbPath: dbFSPath,
             },
@@ -604,17 +634,17 @@ class Core {
     cleanupInstance(instanceName) {
         const removeWarns = [];
         const instancesToDrop = new Map();
-        let warnMessage = '';
+        let warnMessage = "";
         if (instanceName) {
             const instance = state.getInstanceInfo(instanceName);
             instancesToDrop.set(instanceName, instance);
             const iType = instance.type;
             switch (iType) {
-                case 'docker': {
+                case "docker": {
                     removeWarns.push(`docker service 'pl-${instanceName}', including all its volumes and data in '${state.instanceDir(instanceName)}' will be destroyed`);
                     break;
                 }
-                case 'process': {
+                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`);
@@ -625,26 +655,26 @@ class Core {
                     assertNever();
             }
             if (instanceName === state.currentInstanceName) {
-                removeWarns.push('last command run cache (\'pl-dev start\' shorthand will stop working until next full start command call)');
+                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  - ')}
+  - ${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)`);
+            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  - ')}
+  - ${removeWarns.join("\n  - ")}
 `;
         }
         this.logger.warn(warnMessage);
-        if (!askYN('Are you sure?')) {
-            this.logger.info('Reset action was canceled');
+        if (!askYN("Are you sure?")) {
+            this.logger.info("Reset action was canceled");
             return;
         }
         for (const [name, instance] of instancesToDrop.entries()) {
@@ -664,62 +694,62 @@ You are going to reset the state of all platforma services configured with pl-bo
     }
     mergeLicenseEnvs(flags) {
         if (flags.license === undefined) {
-            if ((process.env.MI_LICENSE ?? '') != '')
+            if ((process.env.MI_LICENSE ?? "") != "")
                 flags.license = process.env.MI_LICENSE;
-            else if ((process.env.PL_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__default.existsSync(path.resolve(os__default.homedir(), '.pl.license')))
-                flags['license-file'] = path.resolve(os__default.homedir(), '.pl.license');
+        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__default.existsSync(path.resolve(os__default.homedir(), ".pl.license")))
+                flags["license-file"] = path.resolve(os__default.homedir(), ".pl.license");
         }
     }
     initAuthDriversList(flags, workdir) {
         const authDrivers = [];
-        if (flags['auth-htpasswd-file']) {
+        if (flags["auth-htpasswd-file"]) {
             authDrivers.push({
-                driver: 'htpasswd',
-                path: path.resolve(workdir, flags['auth-htpasswd-file']),
+                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 (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']) {
+        if (flags["auth-ldap-server"]) {
             authDrivers.push({
-                driver: 'ldap',
-                serverUrl: flags['auth-ldap-server'],
-                defaultDN: flags['auth-ldap-default-dn'],
+                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];
+        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 = '';
+        const jwtFile = state.path("auth.jwt");
+        const encoding = "utf-8";
+        let lastJwt = "";
         if (fs__default.existsSync(jwtFile)) {
             lastJwt = fs__default.readFileSync(jwtFile, { encoding });
         }
-        if (lastJwt == '') {
+        if (lastJwt == "") {
             lastJwt = randomStr(64);
             fs__default.writeFileSync(jwtFile, lastJwt, { encoding });
         }
         return lastJwt;
     }
     checkLicense(value, file) {
-        if (value !== undefined && value != '')
+        if (value !== undefined && value != "")
             return;
-        if (file !== undefined && file != '')
+        if (file !== undefined && file != "")
             return;
         this.logger.error(`A license for Platforma Backend must be set.
 
@@ -739,55 +769,55 @@ You can obtain the license from "https://platforma.bio/getlicense".`);
         const sType = storage.type;
         storageID = storageID.toUpperCase();
         switch (sType) {
-            case 'S3':
+            case "S3":
                 switch (storageID) {
-                    case 'PRIMARY': {
+                    case "PRIMARY": {
                         // Construct the S3 URL for primary storage
                         if (storage.endpoint && storage.bucketName) {
-                            envs['PL_PRIMARY_STORAGE_S3'] = `${storage.endpoint}${storage.bucketName}`;
+                            envs["PL_PRIMARY_STORAGE_S3"] = `${storage.endpoint}${storage.bucketName}`;
                         }
                         if (storage.endpoint)
-                            envs['PL_PRIMARY_STORAGE_S3_ENDPOINT'] = storage.endpoint;
+                            envs["PL_PRIMARY_STORAGE_S3_ENDPOINT"] = storage.endpoint;
                         if (storage.presignEndpoint)
-                            envs['PL_PRIMARY_STORAGE_S3_EXTERNAL_ENDPOINT'] = storage.presignEndpoint;
+                            envs["PL_PRIMARY_STORAGE_S3_EXTERNAL_ENDPOINT"] = storage.presignEndpoint;
                         if (storage.region)
-                            envs['PL_PRIMARY_STORAGE_S3_REGION'] = storage.region;
+                            envs["PL_PRIMARY_STORAGE_S3_REGION"] = storage.region;
                         if (storage.key)
-                            envs['PL_PRIMARY_STORAGE_S3_KEY'] = storage.key;
+                            envs["PL_PRIMARY_STORAGE_S3_KEY"] = storage.key;
                         if (storage.secret)
-                            envs['PL_PRIMARY_STORAGE_S3_SECRET'] = storage.secret;
+                            envs["PL_PRIMARY_STORAGE_S3_SECRET"] = storage.secret;
                         break;
                     }
-                    case 'LIBRARY': {
+                    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}`;
+                            envs["PL_DATA_LIBRARY_S3_URL"] = `library=${storage.endpoint}${storage.bucketName}`;
                         }
                         if (storage.endpoint)
-                            envs['PL_DATA_LIBRARY_S3_ENDPOINT'] = `library=${storage.endpoint}`;
+                            envs["PL_DATA_LIBRARY_S3_ENDPOINT"] = `library=${storage.endpoint}`;
                         if (storage.presignEndpoint)
-                            envs['PL_DATA_LIBRARY_S3_EXTERNAL_ENDPOINT'] = `library=${storage.presignEndpoint}`;
+                            envs["PL_DATA_LIBRARY_S3_EXTERNAL_ENDPOINT"] = `library=${storage.presignEndpoint}`;
                         if (storage.region)
-                            envs['PL_DATA_LIBRARY_S3_REGION'] = `library=${storage.region}`;
+                            envs["PL_DATA_LIBRARY_S3_REGION"] = `library=${storage.region}`;
                         if (storage.key)
-                            envs['PL_DATA_LIBRARY_S3_KEY'] = `library=${storage.key}`;
+                            envs["PL_DATA_LIBRARY_S3_KEY"] = `library=${storage.key}`;
                         if (storage.secret)
-                            envs['PL_DATA_LIBRARY_S3_SECRET'] = `library=${storage.secret}`;
+                            envs["PL_DATA_LIBRARY_S3_SECRET"] = `library=${storage.secret}`;
                         break;
                     }
                     default:
                         throw new Error(`Unknown storage ID: ${storageID}`);
                 }
                 return envs;
-            case 'FS':
+            case "FS":
                 switch (storageID) {
-                    case 'PRIMARY':
+                    case "PRIMARY":
                         if (storage.rootPath)
-                            envs['PL_PRIMARY_STORAGE_FS'] = storage.rootPath;
+                            envs["PL_PRIMARY_STORAGE_FS"] = storage.rootPath;
                         break;
-                    case 'LIBRARY':
+                    case "LIBRARY":
                         if (storage.rootPath)
-                            envs['PL_DATA_LIBRARY_FS_PATH'] = storage.rootPath;
+                            envs["PL_DATA_LIBRARY_FS_PATH"] = storage.rootPath;
                         break;
                     default:
                         throw new Error(`Unknown storage ID: ${storageID}`);
@@ -800,31 +830,31 @@ You can obtain the license from "https://platforma.bio/getlicense".`);
     }
     renderRunInfo(runInfo, indent = 10) {
         const report = [];
-        const column = (t) => t.padStart(indent, ' ');
+        const column = (t) => t.padStart(indent, " ");
         if (runInfo.configPath) {
-            report.push(`${column('config')}: ${runInfo.configPath}`);
+            report.push(`${column("config")}: ${runInfo.configPath}`);
         }
         if (runInfo.apiAddr) {
-            report.push(`${column('API')}: ${runInfo.apiAddr}`);
+            report.push(`${column("API")}: ${runInfo.apiAddr}`);
         }
         else if (runInfo.apiPort) {
-            report.push(`${column('API')}: 127.0.0.1:${runInfo.apiPort.toString()}`);
+            report.push(`${column("API")}: 127.0.0.1:${runInfo.apiPort.toString()}`);
         }
         else {
-            report.push(`${column('API')}: 127.0.0.1:6345`);
+            report.push(`${column("API")}: 127.0.0.1:6345`);
         }
         if (runInfo.logPath) {
-            report.push(`${column('log')}: ${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}`);
+            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 ?? ''}'`);
+            case "S3":
+                report.push(`${column("primary")}: S3 at '${runInfo.primary.endpoint ?? "AWS"}', bucket '${runInfo.primary.bucketName}', prefix: '${runInfo.primary.keyPrefix ?? ""}'`);
                 break;
             default:
                 assertNever();
@@ -833,22 +863,22 @@ You can obtain the license from "https://platforma.bio/getlicense".`);
         switch (libraryType) {
             case undefined:
                 break;
-            case 'FS':
-                report.push(`${column('library')}: ${runInfo.library.rootPath}`);
+            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 ?? ''}'`);
+            case "S3":
+                report.push(`${column("library")}: S3 at '${runInfo.library.endpoint ?? "AWS"}', bucket '${runInfo.library.bucketName}', prefix: '${runInfo.library.keyPrefix ?? ""}'`);
                 break;
             default:
                 assertNever();
         }
         if (runInfo.work) {
-            report.push(`${column('workdirs')}: ${runInfo.work.rootPath}`);
+            report.push(`${column("workdirs")}: ${runInfo.work.rootPath}`);
         }
         if (runInfo.dbPath) {
-            report.push(`${column('db')}: ${runInfo.dbPath}`);
+            report.push(`${column("db")}: ${runInfo.dbPath}`);
         }
-        return report.join('\n');
+        return report.join("\n");
     }
 }
 function checkRunError(result, message) {
@@ -856,7 +886,7 @@ function checkRunError(result, message) {
         if (buffer.error) {
             throw buffer.error;
         }
-        const msg = message ?? 'failed to run command';
+        const msg = message ?? "failed to run command";
         if (buffer.status !== 0) {
             throw new Error(`${msg}, process exited with code '${buffer.status}'`);
         }