@milaboratories/pl-deployments 2.15.17 → 2.15.19

package/dist/ssh/pl.cjs

@@ -1,650 +1,563 @@
-'use strict';
-
-var ssh = require('./ssh.cjs');
-var tsHelpers = require('@milaboratories/ts-helpers');
-var pl_binary_download = require('../common/pl_binary_download.cjs');
-var upath = require('upath');
-var pl_paths = require('./pl_paths.cjs');
-var pl_version = require('../common/pl_version.cjs');
-var plHttp = require('@milaboratories/pl-http');
-var net = require('node:net');
-var plConfig = require('@milaboratories/pl-config');
-var supervisord = require('./supervisord.cjs');
-var connection_info = require('./connection_info.cjs');
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_pl_binary_download = require('../common/pl_binary_download.cjs');
+const require_pl_version = require('../common/pl_version.cjs');
+const require_ssh = require('./ssh.cjs');
+const require_pl_paths = require('./pl_paths.cjs');
+const require_supervisord = require('./supervisord.cjs');
+const require_connection_info = require('./connection_info.cjs');
+let _milaboratories_ts_helpers = require("@milaboratories/ts-helpers");
+let upath = require("upath");
+upath = require_runtime.__toESM(upath);
+let _milaboratories_pl_http = require("@milaboratories/pl-http");
+let node_net = require("node:net");
+node_net = require_runtime.__toESM(node_net);
+let _milaboratories_pl_config = require("@milaboratories/pl-config");
 
+//#region src/ssh/pl.ts
 const minRequiredGlibcVersion = 2.28;
-class SshPl {
-    logger;
-    sshClient;
-    username;
-    initState = { step: "init" };
-    constructor(logger, sshClient, username) {
-        this.logger = logger;
-        this.sshClient = sshClient;
-        this.username = username;
-    }
-    info() {
-        return {
-            username: this.username,
-            initState: this.initState,
-        };
-    }
-    static async init(logger, config) {
-        try {
-            const sshClient = await ssh.SshClient.init(logger, config);
-            return new SshPl(logger, sshClient, tsHelpers.notEmpty(config.username));
-        }
-        catch (e) {
-            logger.error(`Connection error in SshClient.init: ${e}`);
-            throw e;
-        }
-    }
-    cleanUp() {
-        this.sshClient.close();
-    }
-    /** Provides an info if the platforma and minio are running along with the debug info. */
-    async isAlive() {
-        const arch = await this.getArch();
-        const remoteHome = await this.getUserHomeDirectory();
-        return await supervisord.supervisorStatus(this.logger, this.sshClient, remoteHome, arch.arch);
-    }
-    /** Starts all the services on the server.
-     * Idempotent semantic: we could call it several times. */
-    async start(shouldUseMinio) {
-        const arch = await this.getArch();
-        const remoteHome = await this.getUserHomeDirectory();
-        try {
-            if (!supervisord.isAllAlive(await this.isAlive(), shouldUseMinio)) {
-                await supervisord.supervisorCtlStart(this.sshClient, remoteHome, arch.arch);
-                // We are waiting for Platforma to run to ensure that it has started.
-                return await this.checkIsAliveWithInterval(shouldUseMinio);
-            }
-        }
-        catch (e) {
-            let msg = `SshPl.start: ${e}`;
-            let logs = "";
-            try {
-                logs = await this.sshClient.readFile(pl_paths.platformaCliLogs(remoteHome));
-                msg += `, platforma cli logs: ${logs}`;
-            }
-            catch (e) {
-                msg += `, Can not read platforma cli logs: ${e}`;
-            }
-            this.logger.error(msg);
-            throw new Error(msg);
-        }
-    }
-    /** Stops all the services on the server.
-     * Idempotent semantic: we could call it several times. */
-    async stop() {
-        const arch = await this.getArch();
-        const remoteHome = await this.getUserHomeDirectory();
-        try {
-            const alive = await this.isAlive();
-            if (supervisord.isSupervisordRunning(alive)) {
-                await supervisord.supervisorStop(this.sshClient, remoteHome, arch.arch);
-                // Check if Minio is running by looking at the alive status
-                const shouldUseMinio = alive.minio === true;
-                return await this.checkIsAliveWithInterval(shouldUseMinio, 1000, 15, false);
-            }
-        }
-        catch (e) {
-            const msg = `PlSsh.stop: ${e}`;
-            this.logger.error(msg);
-            throw new Error(msg);
-        }
-    }
-    /** Stops the services, deletes a directory with the state and closes SSH connection. */
-    async reset() {
-        await this.stopAndClean();
-        this.cleanUp();
-        return true;
-    }
-    /** Stops platforma and deletes its state. */
-    async stopAndClean() {
-        const remoteHome = await this.getUserHomeDirectory();
-        this.logger.info(`pl.reset: Stop Platforma on the server`);
-        await this.stop();
-        this.logger.info(`pl.reset: Deleting Platforma workDir ${pl_paths.workDir(remoteHome)} on the server`);
-        await this.sshClient.deleteFolder(pl_paths.workDir(remoteHome));
-    }
-    /** Downloads binaries and untar them on the server,
-     * generates all the configs, creates necessary dirs,
-     * and finally starts all the services. */
-    async platformaInit(options) {
-        const state = { localWorkdir: options.localWorkdir, step: "init" };
-        const { onProgress } = options;
-        // merge options with default ops.
-        const ops = {
-            ...defaultSshPlConfig,
-            ...options,
-        };
-        state.plBinaryOps = ops.plBinary;
-        try {
-            await this.doStepDetectArch(state, onProgress);
-            await this.doStepDetectHome(state, onProgress);
-            const needRestartPlatforma = await this.doStepReadExistedConfig(state, ops, onProgress);
-            if (!needRestartPlatforma) {
-                await onProgress?.("Platforma is already running. Skipping initialization.");
-                return state.existedSettings;
-            }
-            await this.doStepStopExistedPlatforma(state, onProgress);
-            await this.doStepCheckDbLock(state, onProgress);
-            await onProgress?.("Installation platforma...");
-            await this.doStepDownloadBinaries(state, onProgress, ops);
-            await this.doStepFetchPorts(state);
-            await this.doStepGenerateNewConfig(state, onProgress, ops);
-            await this.doStepCreateFoldersAndSaveFiles(state, onProgress);
-            await this.doStepConfigureSupervisord(state, onProgress);
-            await this.doStepSaveNewConnectionInfo(state, onProgress, ops);
-            await this.doStepStartPlatforma(state, onProgress);
-            return state.connectionInfo;
-        }
-        catch (e) {
-            const msg = `SshPl.platformaInit: ${e}, state: ${JSON.stringify(this.removeSensitiveData(state))}`;
-            this.logger.error(msg);
-            throw new Error(msg);
-        }
-    }
-    async doStepStopExistedPlatforma(state, onProgress) {
-        state.step = "stopExistedPlatforma";
-        if (!supervisord.isAllAlive(state.alive, state.shouldUseMinio ?? false)) {
-            return;
-        }
-        await onProgress?.("Stopping services...");
-        await this.stop();
-    }
-    removeSensitiveData(state) {
-        const stateCopy = { ...state };
-        stateCopy.generatedConfig = {
-            ...stateCopy.generatedConfig,
-            filesToCreate: { skipped: "sanitized" },
-        };
-        return stateCopy;
-    }
-    async doStepStartPlatforma(state, onProgress) {
-        state.step = "startPlatforma";
-        await onProgress?.("Starting Platforma on the server...");
-        await this.start(state.shouldUseMinio ?? false);
-        state.started = true;
-        this.initState = state;
-        await onProgress?.("Platforma has been started successfully.");
-    }
-    async doStepSaveNewConnectionInfo(state, onProgress, ops) {
-        state.step = "saveNewConnectionInfo";
-        const config = state.generatedConfig;
-        await onProgress?.("Saving connection information...");
-        state.connectionInfo = connection_info.newConnectionInfo(config.plUser, config.plPassword, state.ports, tsHelpers.notEmpty(ops.useGlobalAccess), ops.plBinary.version, state.shouldUseMinio ?? false);
-        await this.sshClient.writeFileOnTheServer(pl_paths.connectionInfo(state.remoteHome), connection_info.stringifyConnectionInfo(state.connectionInfo));
-        await onProgress?.("Connection information saved.");
-    }
-    async doStepCheckDbLock(state, onProgress) {
-        const removeLockFile = async (lockFilePath) => {
-            try {
-                await this.sshClient.exec(`rm -f ${lockFilePath}`);
-                this.logger.info(`Removed stale lock file ${lockFilePath}`);
-            }
-            catch (e) {
-                const msg = `Failed to remove stale lock file ${lockFilePath}: ${e}`;
-                this.logger.error(msg);
-                throw new Error(msg);
-            }
-        };
-        state.step = "checkDbLock";
-        await onProgress?.("Checking for DB lock...");
-        const lockFilePath = pl_paths.platformaDbLock(state.remoteHome);
-        const lockFileExists = await this.sshClient.checkFileExists(lockFilePath);
-        if (!lockFileExists) {
-            await onProgress?.("No DB lock found. Proceeding...");
-            return;
-        }
-        this.logger.info(`DB lock file found at ${lockFilePath}. Checking which process holds it...`);
-        const lockProcessInfo = await this.findLockHolder(lockFilePath);
-        if (!lockProcessInfo) {
-            this.logger.warn("Lock file exists but no process is holding it. Removing stale lock file...");
-            await removeLockFile(lockFilePath);
-            return;
-        }
-        this.logger.info(`Found process ${lockProcessInfo.pid} (user: ${lockProcessInfo.user}) holding DB lock`);
-        if (lockProcessInfo.user !== this.username) {
-            const msg = `DB lock is held by process ${lockProcessInfo.pid} ` +
-                `owned by user '${lockProcessInfo.user}', but current user is '${this.username}'. ` +
-                "Cannot kill process owned by different user.";
-            this.logger.error(msg);
-            throw new Error(msg);
-        }
-        this.logger.info(`Process ${lockProcessInfo.pid} belongs to current user ${this.username}. Killing it...`);
-        await this.killRemoteProcess(lockProcessInfo.pid);
-        this.logger.info("Process holding DB lock has been terminated.");
-        // Verify lock file is gone or can be removed
-        const lockStillExists = await this.sshClient.checkFileExists(lockFilePath);
-        if (lockStillExists) {
-            await removeLockFile(lockFilePath);
-        }
-    }
-    async doStepConfigureSupervisord(state, onProgress) {
-        await onProgress?.("Writing supervisord configuration...");
-        state.step = "configureSupervisord";
-        const config = state.generatedConfig;
-        let supervisorConfig;
-        if (state.shouldUseMinio) {
-            supervisorConfig = supervisord.generateSupervisordConfigWithMinio(config.minioConfig.storageDir, config.minioConfig.envs, await this.getFreePortForPlatformaOnServer(state.remoteHome, state.arch), config.workingDir, config.plConfig.configPath, state.binPaths.minioRelPath, state.binPaths.downloadedPl);
-        }
-        else {
-            supervisorConfig = supervisord.generateSupervisordConfig(await this.getFreePortForPlatformaOnServer(state.remoteHome, state.arch), config.workingDir, config.plConfig.configPath, state.binPaths.downloadedPl);
-        }
-        const writeResult = await this.sshClient.writeFileOnTheServer(pl_paths.supervisorConf(state.remoteHome), supervisorConfig);
-        if (!writeResult) {
-            throw new Error(`Can not write supervisord config on the server ${pl_paths.workDir(state.remoteHome)}`);
-        }
-        await onProgress?.("Supervisord configuration written.");
-    }
-    async doStepCreateFoldersAndSaveFiles(state, onProgress) {
-        state.step = "createFoldersAndSaveFiles";
-        const config = state.generatedConfig;
-        await onProgress?.("Generating folder structure...");
-        for (const [filePath, content] of Object.entries(config.filesToCreate)) {
-            await this.sshClient.writeFileOnTheServer(filePath, content);
-            this.logger.info(`Created file ${filePath}`);
-        }
-        for (const dir of config.dirsToCreate) {
-            await this.sshClient.ensureRemoteDirCreated(dir);
-            this.logger.info(`Created directory ${dir}`);
-        }
-        await onProgress?.("Folder structure created.");
-    }
-    async doStepGenerateNewConfig(state, onProgress, ops) {
-        state.step = "generateNewConfig";
-        await onProgress?.("Generating new config...");
-        const config = await plConfig.generateSshPlConfigs({
-            logger: this.logger,
-            workingDir: pl_paths.workDir(state.remoteHome),
-            portsMode: {
-                type: "customWithMinio",
-                ports: {
-                    debug: state.ports.debug.remote,
-                    grpc: state.ports.grpc.remote,
-                    http: state.ports.http.remote,
-                    minio: state.ports.minioPort.remote,
-                    minioConsole: state.ports.minioConsolePort.remote,
-                    monitoring: state.ports.monitoring.remote,
-                    httpLocal: state.ports.http.local,
-                    grpcLocal: state.ports.grpc.local,
-                    minioLocal: state.ports.minioPort.local,
-                },
-            },
-            licenseMode: ops.license,
-            useGlobalAccess: tsHelpers.notEmpty(ops.useGlobalAccess),
-            plConfigPostprocessing: ops.plConfigPostprocessing,
-            useMinio: state.shouldUseMinio ?? false,
-        });
-        state.generatedConfig = { ...config };
-        await onProgress?.("New config generated");
-    }
-    async doStepFetchPorts(state) {
-        state.step = "fetchPorts";
-        state.ports = await this.fetchPorts(state.remoteHome, state.arch);
-        if (!state.ports.debug.remote ||
-            !state.ports.grpc.remote ||
-            !state.ports.minioPort.remote ||
-            !state.ports.minioConsolePort.remote ||
-            !state.ports.monitoring.remote ||
-            !state.ports.http?.remote) {
-            throw new Error(`SshPl.platformaInit: remote ports are not defined`);
-        }
-    }
-    async doStepDownloadBinaries(state, onProgress, ops) {
-        state.step = "downloadBinaries";
-        await onProgress?.("Downloading and uploading required binaries...");
-        const glibcVersion = await getGlibcVersion(this.logger, this.sshClient);
-        if (glibcVersion < minRequiredGlibcVersion)
-            throw new Error(`glibc version ${glibcVersion} is too old. Version ${minRequiredGlibcVersion} or higher is required for Platforma.`);
-        const downloadRes = await this.downloadBinariesAndUploadToTheServer(ops.localWorkdir, ops.plBinary, state.remoteHome, state.arch, state.shouldUseMinio ?? false, ops.proxy);
-        await onProgress?.("All required binaries have been downloaded and uploaded.");
-        state.binPaths = { ...downloadRes, history: undefined };
-        state.downloadedBinaries = downloadRes.history;
-    }
-    async doStepDetectArch(state, onProgress) {
-        state.step = "detectArch";
-        await onProgress?.("Detecting server architecture...");
-        state.arch = await this.getArch();
-        await onProgress?.("Server architecture detected.");
-    }
-    async doStepDetectHome(state, onProgress) {
-        state.step = "detectHome";
-        await onProgress?.("Fetching user home directory...");
-        state.remoteHome = await this.getUserHomeDirectory();
-        await onProgress?.("User home directory retrieved.");
-    }
-    async doStepReadExistedConfig(state, ops, onProgress) {
-        state.step = "checkAlive";
-        await onProgress?.("Checking platform status...");
-        state.alive = await this.isAlive();
-        if (!state.alive?.platforma) {
-            return true;
-        }
-        await onProgress?.("All required services are running.");
-        state.existedSettings = await this.readExistedConfig(state.remoteHome);
-        if (!state.existedSettings) {
-            throw new Error(`SshPl.platformaInit: platforma is alive but existed settings are not found`);
-        }
-        const sameGA = state.existedSettings.useGlobalAccess == ops.useGlobalAccess;
-        const samePlVersion = state.existedSettings.plVersion == ops.plBinary.version;
-        state.needRestart = !(sameGA && samePlVersion);
-        this.logger.info(`SshPl.platformaInit: need restart? ${state.needRestart}`);
-        state.shouldUseMinio = state.existedSettings.minioIsUsed;
-        if (state.shouldUseMinio) {
-            this.logger.info(`SshPl.platformaInit: minio is used`);
-        }
-        else {
-            this.logger.info(`SshPl.platformaInit: minio is not used`);
-        }
-        if (!state.needRestart) {
-            await onProgress?.("Server setup completed.");
-            return false;
-        }
-        await onProgress?.("Stopping services...");
-        await this.stop();
-        return true;
-    }
-    async downloadBinariesAndUploadToTheServer(localWorkdir, plBinary, remoteHome, arch, shouldUseMinio, proxy) {
-        const state = [];
-        const dispatcher = plHttp.defaultHttpDispatcher(proxy);
-        try {
-            const pl = await this.downloadAndUntar(localWorkdir, remoteHome, arch, "pl", `pl-${plBinary.version}`, dispatcher);
-            state.push(pl);
-            const supervisor = await this.downloadAndUntar(localWorkdir, remoteHome, arch, "supervisord", pl_paths.supervisordDirName, dispatcher);
-            state.push(supervisor);
-            const minioPath = pl_paths.minioBin(remoteHome, arch.arch);
-            if (shouldUseMinio) {
-                const minio = await this.downloadAndUntar(localWorkdir, remoteHome, arch, "minio", pl_paths.minioDirName, dispatcher);
-                state.push(minio);
-                await this.sshClient.chmod(minioPath, 0o750);
-            }
-            return {
-                history: state,
-                minioRelPath: shouldUseMinio ? minioPath : undefined,
-                downloadedPl: pl_paths.platformaBin(remoteHome, arch.arch),
-            };
-        }
-        catch (e) {
-            const msg = `SshPl.downloadBinariesAndUploadToServer: ${e}, state: ${JSON.stringify(state)}`;
-            this.logger.error(msg);
-            throw e;
-        }
-        finally {
-            await dispatcher.close();
-        }
-    }
-    async findLockHolderWithLsof(lockFilePath) {
-        try {
-            const { stdout } = await this.sshClient.exec(`lsof ${lockFilePath} 2>/dev/null || true`);
-            const output = stdout.trim();
-            if (!output) {
-                return null;
-            }
-            // Example:
-            // COMMAND     PID    USER   FD   TYPE DEVICE SIZE/OFF     NODE NAME
-            // platforma 11628 rfiskov   10u   REG   1,16        0 66670038 ./LOCK
-            const lines = output.split("\n");
-            if (lines.length <= 1) {
-                return null;
-            }
-            const parts = lines[1].trim().split(/\s+/);
-            if (parts.length < 3) {
-                return null;
-            }
-            const pid = Number.parseInt(parts[1], 10);
-            const user = parts[2];
-            return Number.isNaN(pid) || !user ? null : { pid, user };
-        }
-        catch (e) {
-            this.logger.warn(`Failed to use lsof to check lock: ${e}`);
-            return null;
-        }
-    }
-    async findLockHolderWithFuser(lockFilePath) {
-        try {
-            const { stdout } = await this.sshClient.exec(`fuser ${lockFilePath} 2>/dev/null || true`);
-            const output = stdout.trim();
-            if (!output) {
-                return null;
-            }
-            // Example: ./LOCK: 11628
-            const match = output.match(/: (\d+)/);
-            if (!match) {
-                return null;
-            }
-            const pid = Number.parseInt(match[1], 10);
-            if (Number.isNaN(pid)) {
-                return null;
-            }
-            try {
-                const psResult = await this.sshClient.exec(`ps -o user= -p ${pid} 2>/dev/null || true`);
-                const user = psResult.stdout.trim();
-                return user ? { pid, user } : null;
-            }
-            catch (e) {
-                this.logger.warn(`Failed to get user for PID ${pid}: ${e}`);
-                return null;
-            }
-        }
-        catch (e) {
-            this.logger.warn(`Failed to use fuser to check lock: ${e}`);
-            return null;
-        }
-    }
-    async findLockHolder(lockFilePath) {
-        const viaLsof = await this.findLockHolderWithLsof(lockFilePath);
-        if (viaLsof) {
-            return viaLsof;
-        }
-        return this.findLockHolderWithFuser(lockFilePath);
-    }
-    async killRemoteProcess(pid) {
-        this.logger.info(`Killing process ${pid}...`);
-        try {
-            // Try graceful termination first
-            await this.sshClient.exec(`kill ${pid} 2>/dev/null || true`);
-            await tsHelpers.sleep(1000);
-            // Check if process still exists
-            try {
-                await this.sshClient.exec(`kill -0 ${pid} 2>/dev/null`);
-                // Process still exists, force kill
-                this.logger.warn(`Process ${pid} still alive after SIGTERM, forcing kill...`);
-                await this.sshClient.exec(`kill -9 ${pid} 2>/dev/null || true`);
-                await tsHelpers.sleep(500);
-            }
-            catch {
-                // Process is dead, nothing to do
-            }
-        }
-        catch (e) {
-            const msg = `Failed to kill process ${pid}: ${e}`;
-            this.logger.error(msg);
-            throw new Error(msg);
-        }
-    }
-    /** We have to extract pl in the remote server,
-     * because Windows doesn't support symlinks
-     * that are found in Linux pl binaries tgz archive.
-     * For this reason, we extract all to the remote server.
-     * It requires `tar` to be installed on the server
-     * (it's not installed for Rocky Linux for example). */
-    async downloadAndUntar(localWorkdir, remoteHome, arch, softwareName, tgzName, dispatcher) {
-        const state = {};
-        state.binBasePath = pl_paths.binariesDir(remoteHome);
-        await this.sshClient.ensureRemoteDirCreated(state.binBasePath);
-        state.binBasePathCreated = true;
-        let downloadBinaryResult = null;
-        const attempts = 5;
-        for (let i = 1; i <= attempts; i++) {
-            try {
-                downloadBinaryResult = await pl_binary_download.downloadBinaryNoExtract({
-                    logger: this.logger,
-                    baseDir: localWorkdir,
-                    softwareName,
-                    tgzName,
-                    arch: arch.arch,
-                    platform: arch.platform,
-                    dispatcher,
-                });
-                break;
-            }
-            catch (e) {
-                await tsHelpers.sleep(300);
-                if (i == attempts) {
-                    throw new Error(`downloadAndUntar: ${attempts} attempts, last error: ${e}`);
-                }
-            }
-        }
-        state.downloadResult = tsHelpers.notEmpty(downloadBinaryResult);
-        state.localArchivePath = upath.resolve(state.downloadResult.archivePath);
-        state.remoteDir = upath.join(state.binBasePath, state.downloadResult.baseName);
-        state.remoteArchivePath = state.remoteDir + ".tgz";
-        await this.sshClient.ensureRemoteDirCreated(state.remoteDir);
-        await this.sshClient.uploadFile(state.localArchivePath, state.remoteArchivePath);
-        state.uploadDone = true;
-        try {
-            await this.sshClient.exec("hash tar");
-        }
-        catch {
-            throw new Error(`tar is not installed on the server. Please install it before running Platforma.`);
-        }
-        // TODO: Create a proper archive to avoid xattr warnings
-        const untarResult = await this.sshClient.exec(`tar --warning=no-all -xvf ${state.remoteArchivePath} --directory=${state.remoteDir}`);
-        if (untarResult.stderr)
-            throw new Error(`downloadAndUntar: untar: stderr occurred: ${untarResult.stderr}, stdout: ${untarResult.stdout}`);
-        state.untarDone = true;
-        return state;
-    }
-    async needDownload(remoteHome, arch) {
-        const checkPathSupervisor = pl_paths.supervisorBin(remoteHome, arch.arch);
-        const checkPathMinio = pl_paths.minioDir(remoteHome, arch.arch);
-        const checkPathPlatforma = pl_paths.platformaBin(remoteHome, arch.arch);
-        if (!(await this.sshClient.checkFileExists(checkPathPlatforma)) ||
-            !(await this.sshClient.checkFileExists(checkPathMinio)) ||
-            !(await this.sshClient.checkFileExists(checkPathSupervisor))) {
-            return true;
-        }
-        return false;
-    }
-    async checkIsAliveWithInterval(shouldUseMinio, interval = 1000, count = 15, shouldStart = true) {
-        const maxMs = count * interval;
-        let total = 0;
-        let alive = await this.isAlive();
-        while (shouldStart ? !supervisord.isAllAlive(alive, shouldUseMinio) : supervisord.isAllAlive(alive, shouldUseMinio)) {
-            await tsHelpers.sleep(interval);
-            total += interval;
-            if (total > maxMs) {
-                throw new Error(`isAliveWithInterval: The process did not ${shouldStart ? "started" : "stopped"} after ${maxMs} ms. Live status: ${JSON.stringify(alive)}`);
-            }
-            alive = await this.isAlive();
-        }
-    }
-    async readExistedConfig(remoteHome) {
-        const connectionInfo = await this.sshClient.readFile(pl_paths.connectionInfo(remoteHome));
-        return connection_info.parseConnectionInfo(connectionInfo);
-    }
-    async fetchPorts(remoteHome, arch) {
-        const ports = {
-            grpc: {
-                local: await plConfig.getFreePort(),
-                remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch),
-            },
-            monitoring: {
-                local: await plConfig.getFreePort(),
-                remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch),
-            },
-            debug: {
-                local: await plConfig.getFreePort(),
-                remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch),
-            },
-            http: {
-                local: await plConfig.getFreePort(),
-                remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch),
-            },
-            minioPort: {
-                local: await plConfig.getFreePort(),
-                remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch),
-            },
-            minioConsolePort: {
-                local: await plConfig.getFreePort(),
-                remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch),
-            },
-        };
-        return ports;
-    }
-    async getLocalFreePort() {
-        return new Promise((res) => {
-            const srv = net.createServer();
-            srv.listen(0, () => {
-                const port = srv.address().port;
-                srv.close((_) => res(port));
-            });
-        });
-    }
-    async getFreePortForPlatformaOnServer(remoteHome, arch) {
-        const freePortBin = pl_paths.platformaFreePortBin(remoteHome, arch.arch);
-        const { stdout, stderr } = await this.sshClient.exec(`${freePortBin}`);
-        if (stderr) {
-            throw new Error(`getFreePortForPlatformaOnServer: stderr is not empty: ${stderr}, stdout: ${stdout}`);
-        }
-        return +stdout;
-    }
-    async getArch() {
-        const { stdout, stderr } = await this.sshClient.exec("uname -s && uname -m");
-        if (stderr)
-            throw new Error(`getArch: stderr is not empty: ${stderr}, stdout: ${stdout}`);
-        const arr = stdout.split("\n");
-        return {
-            platform: arr[0],
-            arch: arr[1],
-        };
-    }
-    async getUserHomeDirectory() {
-        const { stdout, stderr } = await this.sshClient.exec("echo $HOME");
-        if (stderr) {
-            const home = `/home/${this.username}`;
-            console.warn(`getUserHomeDirectory: stderr is not empty: ${stderr}, stdout: ${stdout}, will get a default home: ${home}`);
-            return home;
-        }
-        return stdout.trim();
-    }
-}
+var SshPl = class SshPl {
+	initState = { step: "init" };
+	constructor(logger, sshClient, username) {
+		this.logger = logger;
+		this.sshClient = sshClient;
+		this.username = username;
+	}
+	info() {
+		return {
+			username: this.username,
+			initState: this.initState
+		};
+	}
+	static async init(logger, config) {
+		try {
+			return new SshPl(logger, await require_ssh.SshClient.init(logger, config), (0, _milaboratories_ts_helpers.notEmpty)(config.username));
+		} catch (e) {
+			logger.error(`Connection error in SshClient.init: ${e}`);
+			throw e;
+		}
+	}
+	cleanUp() {
+		this.sshClient.close();
+	}
+	/** Provides an info if the platforma and minio are running along with the debug info. */
+	async isAlive() {
+		const arch = await this.getArch();
+		const remoteHome = await this.getUserHomeDirectory();
+		return await require_supervisord.supervisorStatus(this.logger, this.sshClient, remoteHome, arch.arch);
+	}
+	/** Starts all the services on the server.
+	* Idempotent semantic: we could call it several times. */
+	async start(shouldUseMinio) {
+		const arch = await this.getArch();
+		const remoteHome = await this.getUserHomeDirectory();
+		try {
+			if (!require_supervisord.isAllAlive(await this.isAlive(), shouldUseMinio)) {
+				await require_supervisord.supervisorCtlStart(this.sshClient, remoteHome, arch.arch);
+				return await this.checkIsAliveWithInterval(shouldUseMinio);
+			}
+		} catch (e) {
+			let msg = `SshPl.start: ${e}`;
+			let logs = "";
+			try {
+				logs = await this.sshClient.readFile(require_pl_paths.platformaCliLogs(remoteHome));
+				msg += `, platforma cli logs: ${logs}`;
+			} catch (e) {
+				msg += `, Can not read platforma cli logs: ${e}`;
+			}
+			this.logger.error(msg);
+			throw new Error(msg);
+		}
+	}
+	/** Stops all the services on the server.
+	* Idempotent semantic: we could call it several times. */
+	async stop() {
+		const arch = await this.getArch();
+		const remoteHome = await this.getUserHomeDirectory();
+		try {
+			const alive = await this.isAlive();
+			if (require_supervisord.isSupervisordRunning(alive)) {
+				await require_supervisord.supervisorStop(this.sshClient, remoteHome, arch.arch);
+				const shouldUseMinio = alive.minio === true;
+				return await this.checkIsAliveWithInterval(shouldUseMinio, 1e3, 15, false);
+			}
+		} catch (e) {
+			const msg = `PlSsh.stop: ${e}`;
+			this.logger.error(msg);
+			throw new Error(msg);
+		}
+	}
+	/** Stops the services, deletes a directory with the state and closes SSH connection. */
+	async reset() {
+		await this.stopAndClean();
+		this.cleanUp();
+		return true;
+	}
+	/** Stops platforma and deletes its state. */
+	async stopAndClean() {
+		const remoteHome = await this.getUserHomeDirectory();
+		this.logger.info(`pl.reset: Stop Platforma on the server`);
+		await this.stop();
+		this.logger.info(`pl.reset: Deleting Platforma workDir ${require_pl_paths.workDir(remoteHome)} on the server`);
+		await this.sshClient.deleteFolder(require_pl_paths.workDir(remoteHome));
+	}
+	/** Downloads binaries and untar them on the server,
+	* generates all the configs, creates necessary dirs,
+	* and finally starts all the services. */
+	async platformaInit(options) {
+		const state = {
+			localWorkdir: options.localWorkdir,
+			step: "init"
+		};
+		const { onProgress } = options;
+		const ops = {
+			...defaultSshPlConfig,
+			...options
+		};
+		state.plBinaryOps = ops.plBinary;
+		try {
+			await this.doStepDetectArch(state, onProgress);
+			await this.doStepDetectHome(state, onProgress);
+			if (!await this.doStepReadExistedConfig(state, ops, onProgress)) {
+				await onProgress?.("Platforma is already running. Skipping initialization.");
+				return state.existedSettings;
+			}
+			await this.doStepStopExistedPlatforma(state, onProgress);
+			await this.doStepCheckDbLock(state, onProgress);
+			await onProgress?.("Installation platforma...");
+			await this.doStepDownloadBinaries(state, onProgress, ops);
+			await this.doStepFetchPorts(state);
+			await this.doStepGenerateNewConfig(state, onProgress, ops);
+			await this.doStepCreateFoldersAndSaveFiles(state, onProgress);
+			await this.doStepConfigureSupervisord(state, onProgress);
+			await this.doStepSaveNewConnectionInfo(state, onProgress, ops);
+			await this.doStepStartPlatforma(state, onProgress);
+			return state.connectionInfo;
+		} catch (e) {
+			const msg = `SshPl.platformaInit: ${e}, state: ${JSON.stringify(this.removeSensitiveData(state))}`;
+			this.logger.error(msg);
+			throw new Error(msg);
+		}
+	}
+	async doStepStopExistedPlatforma(state, onProgress) {
+		state.step = "stopExistedPlatforma";
+		if (!require_supervisord.isAllAlive(state.alive, state.shouldUseMinio ?? false)) return;
+		await onProgress?.("Stopping services...");
+		await this.stop();
+	}
+	removeSensitiveData(state) {
+		const stateCopy = { ...state };
+		stateCopy.generatedConfig = {
+			...stateCopy.generatedConfig,
+			filesToCreate: { skipped: "sanitized" }
+		};
+		return stateCopy;
+	}
+	async doStepStartPlatforma(state, onProgress) {
+		state.step = "startPlatforma";
+		await onProgress?.("Starting Platforma on the server...");
+		await this.start(state.shouldUseMinio ?? false);
+		state.started = true;
+		this.initState = state;
+		await onProgress?.("Platforma has been started successfully.");
+	}
+	async doStepSaveNewConnectionInfo(state, onProgress, ops) {
+		state.step = "saveNewConnectionInfo";
+		const config = state.generatedConfig;
+		await onProgress?.("Saving connection information...");
+		state.connectionInfo = require_connection_info.newConnectionInfo(config.plUser, config.plPassword, state.ports, (0, _milaboratories_ts_helpers.notEmpty)(ops.useGlobalAccess), ops.plBinary.version, state.shouldUseMinio ?? false);
+		await this.sshClient.writeFileOnTheServer(require_pl_paths.connectionInfo(state.remoteHome), require_connection_info.stringifyConnectionInfo(state.connectionInfo));
+		await onProgress?.("Connection information saved.");
+	}
+	async doStepCheckDbLock(state, onProgress) {
+		const removeLockFile = async (lockFilePath) => {
+			try {
+				await this.sshClient.exec(`rm -f ${lockFilePath}`);
+				this.logger.info(`Removed stale lock file ${lockFilePath}`);
+			} catch (e) {
+				const msg = `Failed to remove stale lock file ${lockFilePath}: ${e}`;
+				this.logger.error(msg);
+				throw new Error(msg);
+			}
+		};
+		state.step = "checkDbLock";
+		await onProgress?.("Checking for DB lock...");
+		const lockFilePath = require_pl_paths.platformaDbLock(state.remoteHome);
+		if (!await this.sshClient.checkFileExists(lockFilePath)) {
+			await onProgress?.("No DB lock found. Proceeding...");
+			return;
+		}
+		this.logger.info(`DB lock file found at ${lockFilePath}. Checking which process holds it...`);
+		const lockProcessInfo = await this.findLockHolder(lockFilePath);
+		if (!lockProcessInfo) {
+			this.logger.warn("Lock file exists but no process is holding it. Removing stale lock file...");
+			await removeLockFile(lockFilePath);
+			return;
+		}
+		this.logger.info(`Found process ${lockProcessInfo.pid} (user: ${lockProcessInfo.user}) holding DB lock`);
+		if (lockProcessInfo.user !== this.username) {
+			const msg = `DB lock is held by process ${lockProcessInfo.pid} owned by user '${lockProcessInfo.user}', but current user is '${this.username}'. Cannot kill process owned by different user.`;
+			this.logger.error(msg);
+			throw new Error(msg);
+		}
+		this.logger.info(`Process ${lockProcessInfo.pid} belongs to current user ${this.username}. Killing it...`);
+		await this.killRemoteProcess(lockProcessInfo.pid);
+		this.logger.info("Process holding DB lock has been terminated.");
+		if (await this.sshClient.checkFileExists(lockFilePath)) await removeLockFile(lockFilePath);
+	}
+	async doStepConfigureSupervisord(state, onProgress) {
+		await onProgress?.("Writing supervisord configuration...");
+		state.step = "configureSupervisord";
+		const config = state.generatedConfig;
+		let supervisorConfig;
+		if (state.shouldUseMinio) supervisorConfig = require_supervisord.generateSupervisordConfigWithMinio(config.minioConfig.storageDir, config.minioConfig.envs, await this.getFreePortForPlatformaOnServer(state.remoteHome, state.arch), config.workingDir, config.plConfig.configPath, state.binPaths.minioRelPath, state.binPaths.downloadedPl);
+		else supervisorConfig = require_supervisord.generateSupervisordConfig(await this.getFreePortForPlatformaOnServer(state.remoteHome, state.arch), config.workingDir, config.plConfig.configPath, state.binPaths.downloadedPl);
+		if (!await this.sshClient.writeFileOnTheServer(require_pl_paths.supervisorConf(state.remoteHome), supervisorConfig)) throw new Error(`Can not write supervisord config on the server ${require_pl_paths.workDir(state.remoteHome)}`);
+		await onProgress?.("Supervisord configuration written.");
+	}
+	async doStepCreateFoldersAndSaveFiles(state, onProgress) {
+		state.step = "createFoldersAndSaveFiles";
+		const config = state.generatedConfig;
+		await onProgress?.("Generating folder structure...");
+		for (const [filePath, content] of Object.entries(config.filesToCreate)) {
+			await this.sshClient.writeFileOnTheServer(filePath, content);
+			this.logger.info(`Created file ${filePath}`);
+		}
+		for (const dir of config.dirsToCreate) {
+			await this.sshClient.ensureRemoteDirCreated(dir);
+			this.logger.info(`Created directory ${dir}`);
+		}
+		await onProgress?.("Folder structure created.");
+	}
+	async doStepGenerateNewConfig(state, onProgress, ops) {
+		state.step = "generateNewConfig";
+		await onProgress?.("Generating new config...");
+		state.generatedConfig = { ...await (0, _milaboratories_pl_config.generateSshPlConfigs)({
+			logger: this.logger,
+			workingDir: require_pl_paths.workDir(state.remoteHome),
+			portsMode: {
+				type: "customWithMinio",
+				ports: {
+					debug: state.ports.debug.remote,
+					grpc: state.ports.grpc.remote,
+					http: state.ports.http.remote,
+					minio: state.ports.minioPort.remote,
+					minioConsole: state.ports.minioConsolePort.remote,
+					monitoring: state.ports.monitoring.remote,
+					httpLocal: state.ports.http.local,
+					grpcLocal: state.ports.grpc.local,
+					minioLocal: state.ports.minioPort.local
+				}
+			},
+			licenseMode: ops.license,
+			useGlobalAccess: (0, _milaboratories_ts_helpers.notEmpty)(ops.useGlobalAccess),
+			plConfigPostprocessing: ops.plConfigPostprocessing,
+			useMinio: state.shouldUseMinio ?? false
+		}) };
+		await onProgress?.("New config generated");
+	}
+	async doStepFetchPorts(state) {
+		state.step = "fetchPorts";
+		state.ports = await this.fetchPorts(state.remoteHome, state.arch);
+		if (!state.ports.debug.remote || !state.ports.grpc.remote || !state.ports.minioPort.remote || !state.ports.minioConsolePort.remote || !state.ports.monitoring.remote || !state.ports.http?.remote) throw new Error(`SshPl.platformaInit: remote ports are not defined`);
+	}
+	async doStepDownloadBinaries(state, onProgress, ops) {
+		state.step = "downloadBinaries";
+		await onProgress?.("Downloading and uploading required binaries...");
+		const glibcVersion = await getGlibcVersion(this.logger, this.sshClient);
+		if (glibcVersion < minRequiredGlibcVersion) throw new Error(`glibc version ${glibcVersion} is too old. Version ${minRequiredGlibcVersion} or higher is required for Platforma.`);
+		const downloadRes = await this.downloadBinariesAndUploadToTheServer(ops.localWorkdir, ops.plBinary, state.remoteHome, state.arch, state.shouldUseMinio ?? false, ops.proxy);
+		await onProgress?.("All required binaries have been downloaded and uploaded.");
+		state.binPaths = {
+			...downloadRes,
+			history: void 0
+		};
+		state.downloadedBinaries = downloadRes.history;
+	}
+	async doStepDetectArch(state, onProgress) {
+		state.step = "detectArch";
+		await onProgress?.("Detecting server architecture...");
+		state.arch = await this.getArch();
+		await onProgress?.("Server architecture detected.");
+	}
+	async doStepDetectHome(state, onProgress) {
+		state.step = "detectHome";
+		await onProgress?.("Fetching user home directory...");
+		state.remoteHome = await this.getUserHomeDirectory();
+		await onProgress?.("User home directory retrieved.");
+	}
+	async doStepReadExistedConfig(state, ops, onProgress) {
+		state.step = "checkAlive";
+		await onProgress?.("Checking platform status...");
+		state.alive = await this.isAlive();
+		if (!state.alive?.platforma) return true;
+		await onProgress?.("All required services are running.");
+		state.existedSettings = await this.readExistedConfig(state.remoteHome);
+		if (!state.existedSettings) throw new Error(`SshPl.platformaInit: platforma is alive but existed settings are not found`);
+		const sameGA = state.existedSettings.useGlobalAccess == ops.useGlobalAccess;
+		const samePlVersion = state.existedSettings.plVersion == ops.plBinary.version;
+		state.needRestart = !(sameGA && samePlVersion);
+		this.logger.info(`SshPl.platformaInit: need restart? ${state.needRestart}`);
+		state.shouldUseMinio = state.existedSettings.minioIsUsed;
+		if (state.shouldUseMinio) this.logger.info(`SshPl.platformaInit: minio is used`);
+		else this.logger.info(`SshPl.platformaInit: minio is not used`);
+		if (!state.needRestart) {
+			await onProgress?.("Server setup completed.");
+			return false;
+		}
+		await onProgress?.("Stopping services...");
+		await this.stop();
+		return true;
+	}
+	async downloadBinariesAndUploadToTheServer(localWorkdir, plBinary, remoteHome, arch, shouldUseMinio, proxy) {
+		const state = [];
+		const dispatcher = (0, _milaboratories_pl_http.defaultHttpDispatcher)(proxy);
+		try {
+			const pl = await this.downloadAndUntar(localWorkdir, remoteHome, arch, "pl", `pl-${plBinary.version}`, dispatcher);
+			state.push(pl);
+			const supervisor = await this.downloadAndUntar(localWorkdir, remoteHome, arch, "supervisord", require_pl_paths.supervisordDirName, dispatcher);
+			state.push(supervisor);
+			const minioPath = require_pl_paths.minioBin(remoteHome, arch.arch);
+			if (shouldUseMinio) {
+				const minio = await this.downloadAndUntar(localWorkdir, remoteHome, arch, "minio", require_pl_paths.minioDirName, dispatcher);
+				state.push(minio);
+				await this.sshClient.chmod(minioPath, 488);
+			}
+			return {
+				history: state,
+				minioRelPath: shouldUseMinio ? minioPath : void 0,
+				downloadedPl: require_pl_paths.platformaBin(remoteHome, arch.arch)
+			};
+		} catch (e) {
+			const msg = `SshPl.downloadBinariesAndUploadToServer: ${e}, state: ${JSON.stringify(state)}`;
+			this.logger.error(msg);
+			throw e;
+		} finally {
+			await dispatcher.close();
+		}
+	}
+	async findLockHolderWithLsof(lockFilePath) {
+		try {
+			const { stdout } = await this.sshClient.exec(`lsof ${lockFilePath} 2>/dev/null || true`);
+			const output = stdout.trim();
+			if (!output) return null;
+			const lines = output.split("\n");
+			if (lines.length <= 1) return null;
+			const parts = lines[1].trim().split(/\s+/);
+			if (parts.length < 3) return null;
+			const pid = Number.parseInt(parts[1], 10);
+			const user = parts[2];
+			return Number.isNaN(pid) || !user ? null : {
+				pid,
+				user
+			};
+		} catch (e) {
+			this.logger.warn(`Failed to use lsof to check lock: ${e}`);
+			return null;
+		}
+	}
+	async findLockHolderWithFuser(lockFilePath) {
+		try {
+			const { stdout } = await this.sshClient.exec(`fuser ${lockFilePath} 2>/dev/null || true`);
+			const output = stdout.trim();
+			if (!output) return null;
+			const match = output.match(/: (\d+)/);
+			if (!match) return null;
+			const pid = Number.parseInt(match[1], 10);
+			if (Number.isNaN(pid)) return null;
+			try {
+				const user = (await this.sshClient.exec(`ps -o user= -p ${pid} 2>/dev/null || true`)).stdout.trim();
+				return user ? {
+					pid,
+					user
+				} : null;
+			} catch (e) {
+				this.logger.warn(`Failed to get user for PID ${pid}: ${e}`);
+				return null;
+			}
+		} catch (e) {
+			this.logger.warn(`Failed to use fuser to check lock: ${e}`);
+			return null;
+		}
+	}
+	async findLockHolder(lockFilePath) {
+		const viaLsof = await this.findLockHolderWithLsof(lockFilePath);
+		if (viaLsof) return viaLsof;
+		return this.findLockHolderWithFuser(lockFilePath);
+	}
+	async killRemoteProcess(pid) {
+		this.logger.info(`Killing process ${pid}...`);
+		try {
+			await this.sshClient.exec(`kill ${pid} 2>/dev/null || true`);
+			await (0, _milaboratories_ts_helpers.sleep)(1e3);
+			try {
+				await this.sshClient.exec(`kill -0 ${pid} 2>/dev/null`);
+				this.logger.warn(`Process ${pid} still alive after SIGTERM, forcing kill...`);
+				await this.sshClient.exec(`kill -9 ${pid} 2>/dev/null || true`);
+				await (0, _milaboratories_ts_helpers.sleep)(500);
+			} catch {}
+		} catch (e) {
+			const msg = `Failed to kill process ${pid}: ${e}`;
+			this.logger.error(msg);
+			throw new Error(msg);
+		}
+	}
+	/** We have to extract pl in the remote server,
+	* because Windows doesn't support symlinks
+	* that are found in Linux pl binaries tgz archive.
+	* For this reason, we extract all to the remote server.
+	* It requires `tar` to be installed on the server
+	* (it's not installed for Rocky Linux for example). */
+	async downloadAndUntar(localWorkdir, remoteHome, arch, softwareName, tgzName, dispatcher) {
+		const state = {};
+		state.binBasePath = require_pl_paths.binariesDir(remoteHome);
+		await this.sshClient.ensureRemoteDirCreated(state.binBasePath);
+		state.binBasePathCreated = true;
+		let downloadBinaryResult = null;
+		const attempts = 5;
+		for (let i = 1; i <= attempts; i++) try {
+			downloadBinaryResult = await require_pl_binary_download.downloadBinaryNoExtract({
+				logger: this.logger,
+				baseDir: localWorkdir,
+				softwareName,
+				tgzName,
+				arch: arch.arch,
+				platform: arch.platform,
+				dispatcher
+			});
+			break;
+		} catch (e) {
+			await (0, _milaboratories_ts_helpers.sleep)(300);
+			if (i == attempts) throw new Error(`downloadAndUntar: ${attempts} attempts, last error: ${e}`);
+		}
+		state.downloadResult = (0, _milaboratories_ts_helpers.notEmpty)(downloadBinaryResult);
+		state.localArchivePath = upath.default.resolve(state.downloadResult.archivePath);
+		state.remoteDir = upath.default.join(state.binBasePath, state.downloadResult.baseName);
+		state.remoteArchivePath = state.remoteDir + ".tgz";
+		await this.sshClient.ensureRemoteDirCreated(state.remoteDir);
+		await this.sshClient.uploadFile(state.localArchivePath, state.remoteArchivePath);
+		state.uploadDone = true;
+		try {
+			await this.sshClient.exec("hash tar");
+		} catch {
+			throw new Error(`tar is not installed on the server. Please install it before running Platforma.`);
+		}
+		const untarResult = await this.sshClient.exec(`tar --warning=no-all -xvf ${state.remoteArchivePath} --directory=${state.remoteDir}`);
+		if (untarResult.stderr) throw new Error(`downloadAndUntar: untar: stderr occurred: ${untarResult.stderr}, stdout: ${untarResult.stdout}`);
+		state.untarDone = true;
+		return state;
+	}
+	async needDownload(remoteHome, arch) {
+		const checkPathSupervisor = require_pl_paths.supervisorBin(remoteHome, arch.arch);
+		const checkPathMinio = require_pl_paths.minioDir(remoteHome, arch.arch);
+		const checkPathPlatforma = require_pl_paths.platformaBin(remoteHome, arch.arch);
+		if (!await this.sshClient.checkFileExists(checkPathPlatforma) || !await this.sshClient.checkFileExists(checkPathMinio) || !await this.sshClient.checkFileExists(checkPathSupervisor)) return true;
+		return false;
+	}
+	async checkIsAliveWithInterval(shouldUseMinio, interval = 1e3, count = 15, shouldStart = true) {
+		const maxMs = count * interval;
+		let total = 0;
+		let alive = await this.isAlive();
+		while (shouldStart ? !require_supervisord.isAllAlive(alive, shouldUseMinio) : require_supervisord.isAllAlive(alive, shouldUseMinio)) {
+			await (0, _milaboratories_ts_helpers.sleep)(interval);
+			total += interval;
+			if (total > maxMs) throw new Error(`isAliveWithInterval: The process did not ${shouldStart ? "started" : "stopped"} after ${maxMs} ms. Live status: ${JSON.stringify(alive)}`);
+			alive = await this.isAlive();
+		}
+	}
+	async readExistedConfig(remoteHome) {
+		return require_connection_info.parseConnectionInfo(await this.sshClient.readFile(require_pl_paths.connectionInfo(remoteHome)));
+	}
+	async fetchPorts(remoteHome, arch) {
+		return {
+			grpc: {
+				local: await (0, _milaboratories_pl_config.getFreePort)(),
+				remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch)
+			},
+			monitoring: {
+				local: await (0, _milaboratories_pl_config.getFreePort)(),
+				remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch)
+			},
+			debug: {
+				local: await (0, _milaboratories_pl_config.getFreePort)(),
+				remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch)
+			},
+			http: {
+				local: await (0, _milaboratories_pl_config.getFreePort)(),
+				remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch)
+			},
+			minioPort: {
+				local: await (0, _milaboratories_pl_config.getFreePort)(),
+				remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch)
+			},
+			minioConsolePort: {
+				local: await (0, _milaboratories_pl_config.getFreePort)(),
+				remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch)
+			}
+		};
+	}
+	async getLocalFreePort() {
+		return new Promise((res) => {
+			const srv = node_net.default.createServer();
+			srv.listen(0, () => {
+				const port = srv.address().port;
+				srv.close((_) => res(port));
+			});
+		});
+	}
+	async getFreePortForPlatformaOnServer(remoteHome, arch) {
+		const freePortBin = require_pl_paths.platformaFreePortBin(remoteHome, arch.arch);
+		const { stdout, stderr } = await this.sshClient.exec(`${freePortBin}`);
+		if (stderr) throw new Error(`getFreePortForPlatformaOnServer: stderr is not empty: ${stderr}, stdout: ${stdout}`);
+		return +stdout;
+	}
+	async getArch() {
+		const { stdout, stderr } = await this.sshClient.exec("uname -s && uname -m");
+		if (stderr) throw new Error(`getArch: stderr is not empty: ${stderr}, stdout: ${stdout}`);
+		const arr = stdout.split("\n");
+		return {
+			platform: arr[0],
+			arch: arr[1]
+		};
+	}
+	async getUserHomeDirectory() {
+		const { stdout, stderr } = await this.sshClient.exec("echo $HOME");
+		if (stderr) {
+			const home = `/home/${this.username}`;
+			console.warn(`getUserHomeDirectory: stderr is not empty: ${stderr}, stdout: ${stdout}, will get a default home: ${home}`);
+			return home;
+		}
+		return stdout.trim();
+	}
+};
 const defaultSshPlConfig = {
-    useGlobalAccess: false,
-    plBinary: {
-        type: "Download",
-        version: pl_version.getDefaultPlVersion(),
-    },
+	useGlobalAccess: false,
+	plBinary: {
+		type: "Download",
+		version: require_pl_version.getDefaultPlVersion()
+	}
 };
 /**
- * Gets the glibc version on the remote system
- * @returns The glibc version as a number
- * @throws Error if version cannot be determined
- */
+* Gets the glibc version on the remote system
+* @returns The glibc version as a number
+* @throws Error if version cannot be determined
+*/
 async function getGlibcVersion(logger, sshClient) {
-    try {
-        const { stdout, stderr } = await sshClient.exec("ldd --version | head -n 1");
-        if (stderr) {
-            throw new Error(`Failed to check glibc version: ${stderr}`);
-        }
-        return parseGlibcVersion(stdout);
-    }
-    catch (e) {
-        logger.error(`glibc version check failed: ${e}`);
-        throw e;
-    }
+	try {
+		const { stdout, stderr } = await sshClient.exec("ldd --version | head -n 1");
+		if (stderr) throw new Error(`Failed to check glibc version: ${stderr}`);
+		return parseGlibcVersion(stdout);
+	} catch (e) {
+		logger.error(`glibc version check failed: ${e}`);
+		throw e;
+	}
 }
 function parseGlibcVersion(output) {
-    const versionMatch = output.match(/\d+\.\d+/);
-    if (!versionMatch) {
-        throw new Error(`Could not parse glibc version from: ${output}`);
-    }
-    return parseFloat(versionMatch[0]);
+	const versionMatch = output.match(/\d+\.\d+/);
+	if (!versionMatch) throw new Error(`Could not parse glibc version from: ${output}`);
+	return parseFloat(versionMatch[0]);
 }
 
+//#endregion
 exports.SshPl = SshPl;
 exports.parseGlibcVersion = parseGlibcVersion;
-//# sourceMappingURL=pl.cjs.map
+//# sourceMappingURL=pl.cjs.map