@milaboratories/pl-deployments 2.4.6 → 2.4.8

package/dist/index.mjs

@@ -1,1366 +0,0 @@
-var Y = Object.defineProperty;
-var Q = (o, t, e) => t in o ? Y(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
-var p = (o, t, e) => Q(o, typeof t != "symbol" ? t + "" : t, e);
-import { spawn as tt } from "node:child_process";
-import { sleep as x, fileExists as v, assertNever as j, notEmpty as m, RetryablePromise as et } from "@milaboratories/ts-helpers";
-import O from "node:fs";
-import g, { readFile as rt } from "node:fs/promises";
-import h from "upath";
-import { request as it } from "undici";
-import { Readable as nt, Writable as ot } from "node:stream";
-import { text as st } from "node:stream/consumers";
-import * as at from "tar";
-import ct from "decompress";
-import * as lt from "node:os";
-import P from "node:os";
-import dt, { Client as D } from "ssh2";
-import G from "node:net";
-import ht from "node:dns";
-import { randomBytes as F } from "node:crypto";
-import { generateSshPlConfigs as ut, getFreePort as $ } from "@milaboratories/pl-config";
-import { z as f } from "zod";
-function pt(o, t) {
-  return o.info(`Running:
-cmd: ${JSON.stringify([t.cmd, ...t.args])}
-wd: ${t.opts.cwd}`), o.info("  spawning child process"), tt(t.cmd, t.args, t.opts);
-}
-async function k(o) {
-  try {
-    return process.kill(o, 0), !0;
-  } catch {
-    return !1;
-  }
-}
-function J(o) {
-  return process.kill(o, "SIGINT");
-}
-async function L(o, t) {
-  let r = 0;
-  for (; await k(o); )
-    if (await x(100), r += 100, r > t)
-      throw new Error(`The process did not stopped after ${t} ms.`);
-}
-const ft = ["linux", "macos", "windows"];
-function R(o) {
-  switch (o.toLowerCase()) {
-    case "darwin":
-      return "macos";
-    case "linux":
-      return "linux";
-    case "win32":
-      return "windows";
-    default:
-      throw new Error(
-        `operating system '${o}' is not currently supported by Platforma ecosystem. The list of OSes supported: ` + JSON.stringify(ft)
-      );
-  }
-}
-const wt = ["amd64", "arm64"];
-function C(o) {
-  switch (o) {
-    case "aarch64":
-    case "aarch64_be":
-    case "arm64":
-      return "arm64";
-    case "x86_64":
-    case "x64":
-      return "amd64";
-    default:
-      throw new Error(
-        `processor architecture '${o}' is not currently supported by Platforma ecosystem. The list of architectures supported: ` + JSON.stringify(wt)
-      );
-  }
-}
-const mt = "https://cdn.platforma.bio/software", yt = "https://cdn-ga.pl-open.science/software";
-async function gt(o, t, e, r, i, n) {
-  const s = z(e, r, t, C(i), R(n)), { archiveUrl: a, alternativeArchiveGAUrl: c, archivePath: l } = s;
-  try {
-    await A(o, a, l), s.wasDownloadedFrom = a;
-  } catch {
-    await A(o, c, l), s.wasDownloadedFrom = c;
-  }
-  return s;
-}
-async function vt(o, t, e, r, i, n) {
-  const s = z(e, r, t, C(i), R(n)), { archiveUrl: a, alternativeArchiveGAUrl: c, archivePath: l, archiveType: d, targetFolder: u } = s;
-  try {
-    await A(o, a, l), s.wasDownloadedFrom = a;
-  } catch {
-    await A(o, c, l), s.wasDownloadedFrom = c;
-  }
-  return await St(o, l, d, u), s;
-}
-function z(o, t, e, r, i) {
-  const n = `${t}-${r}`, s = Ct[i], a = `${n}.${s}`, c = `${mt}/${o}/${i}/${a}`, l = `${yt}/${o}/${i}/${a}`, d = h.join(e, a), u = h.join(e, n);
-  return {
-    archiveUrl: c,
-    alternativeArchiveGAUrl: l,
-    archivePath: d,
-    archiveType: s,
-    targetFolder: u,
-    baseName: n
-  };
-}
-async function A(o, t, e) {
-  const r = {};
-  r.dstArchive = e;
-  try {
-    if (r.fileExisted = await v(e), r.fileExisted)
-      return o.info(`Platforma Backend archive download skipped: '${e}' already exists`), r;
-    await g.mkdir(h.dirname(e), { recursive: !0 }), r.dirnameCreated = !0, o.info(`Downloading archive:
-  URL: ${t}
- Save to: ${e}`);
-    const { body: i, statusCode: n } = await it(t);
-    if (r.statusCode = n, n != 200) {
-      const s = await st(i);
-      throw r.errorMsg = `failed to download archive: ${n}, response: ${s.slice(0, 1e3)}`, o.error(r.errorMsg), new Error(r.errorMsg);
-    }
-    return r.tmpPath = e + ".tmp", await nt.toWeb(i).pipeTo(ot.toWeb(O.createWriteStream(r.tmpPath))), r.wroteTmp = !0, r.tmpExisted = await v(r.tmpPath), await g.rename(r.tmpPath, e), r.renamed = !0, r.newExisted = await v(e), r;
-  } catch (i) {
-    const n = `downloadArchive: ${JSON.stringify(i)}, state: ${JSON.stringify(r)}`;
-    throw o.error(n), new Error(n);
-  }
-}
-const $t = ".ok";
-async function St(o, t, e, r) {
-  if (o.info("extracting archive..."), o.info(`  archive path: '${t}'`), o.info(`  target dir: '${r}'`), !await v(t)) {
-    const n = `Platforma Backend binary archive not found at '${t}'`;
-    throw o.error(n), new Error(n);
-  }
-  const i = h.join(r, $t);
-  if (await v(i)) {
-    o.info(`Platforma Backend binaries unpack skipped: '${r}' exists`);
-    return;
-  }
-  switch (await v(r) && (o.info(`Removing previous incompletely unpacked folder: '${r}'`), await g.rm(r, { recursive: !0 })), o.info(`  creating target dir '${r}'`), await g.mkdir(r, { recursive: !0 }), o.info(
-    `Unpacking Platforma Backend archive:
-  Archive:   ${t}
-  Target dir: ${r}`
-  ), e) {
-    case "tgz":
-      await at.x({
-        file: t,
-        cwd: r,
-        gzip: !0
-      });
-      break;
-    case "zip":
-      await ct(t, r);
-      break;
-    default:
-      j(e);
-  }
-  await g.writeFile(i, "ok"), o.info("  ... unpack done.");
-}
-const Ct = {
-  linux: "tgz",
-  macos: "tgz",
-  windows: "zip"
-};
-function N() {
-  return "1.35.2";
-}
-function Et() {
-  return { type: "Download", version: N() };
-}
-async function Ft(o, t, e) {
-  switch (e.type) {
-    case "Download":
-      const r = await vt(o, t, "pl", `pl-${e.version}`, P.arch(), P.platform());
-      return h.join(r.baseName, "binaries", At[R(P.platform())]);
-    case "Local":
-      return e.path;
-    default:
-      j(e);
-  }
-}
-const At = {
-  linux: "platforma",
-  macos: "platforma",
-  windows: "platforma.exe"
-};
-function V(o) {
-  return h.join(o, "pl_pid");
-}
-async function bt(o) {
-  if (!await v(o))
-    return;
-  const t = await g.readFile(o);
-  return Number(t.toString());
-}
-async function Pt(o, t) {
-  await g.writeFile(o, JSON.stringify(t));
-}
-function Dt() {
-  return {};
-}
-function xt(o, t, e) {
-  return o[t] = e, e;
-}
-async function _(o, t) {
-  const e = Dt();
-  try {
-    return await t((i, n) => xt(e, i, n), e);
-  } catch (r) {
-    throw o.error(`error ${r} while doing traced operation, state: ${JSON.stringify(e)}`), r;
-  }
-}
-const Ot = "config-local.yaml";
-class kt {
-  constructor(t, e, r, i, n, s, a, c) {
-    p(this, "instance");
-    p(this, "pid");
-    p(this, "nRuns", 0);
-    p(this, "lastRunHistory", {});
-    p(this, "wasStopped", !1);
-    this.logger = t, this.workingDir = e, this.startOptions = r, this.initialStartHistory = i, this.onClose = n, this.onError = s, this.onCloseAndError = a, this.onCloseAndErrorNoStop = c;
-  }
-  async start() {
-    await _(this.logger, async (t, e) => {
-      this.wasStopped = !1;
-      const r = pt(this.logger, this.startOptions);
-      r.on("error", (n) => {
-        this.logger.error(
-          `error '${n}', while running platforma, started opts: ${JSON.stringify(this.debugInfo())}`
-        ), this.onError !== void 0 && this.onError(this), this.onCloseAndError !== void 0 && this.onCloseAndError(this), this.onCloseAndErrorNoStop !== void 0 && !this.wasStopped && this.onCloseAndErrorNoStop(this);
-      }), r.on("close", () => {
-        this.logger.warn(`platforma was closed, started opts: ${JSON.stringify(this.debugInfo())}`), this.onClose !== void 0 && this.onClose(this), this.onCloseAndError !== void 0 && this.onCloseAndError(this), this.onCloseAndErrorNoStop !== void 0 && !this.wasStopped && this.onCloseAndErrorNoStop(this);
-      }), t("started", !0);
-      const i = t("pidFile", V(this.workingDir));
-      t("pid", m(r.pid)), t("pidWritten", await Pt(i, m(r.pid))), this.nRuns++, this.instance = r, this.pid = r.pid, this.lastRunHistory = e;
-    });
-  }
-  stop() {
-    this.wasStopped = !0, J(m(this.pid));
-  }
-  async waitStopped() {
-    await L(m(this.pid), 15e3);
-  }
-  stopped() {
-    return this.wasStopped;
-  }
-  async isAlive() {
-    return await k(m(this.pid));
-  }
-  debugInfo() {
-    return {
-      lastRunHistory: this.lastRunHistory,
-      nRuns: this.nRuns,
-      pid: this.pid,
-      workingDir: this.workingDir,
-      initialStartHistory: this.initialStartHistory,
-      wasStopped: this.wasStopped
-    };
-  }
-}
-async function Ee(o, t) {
-  const e = Math.max(lt.cpus().length - 2, 1), r = Nt(t, e);
-  return await _(o, async (i, n) => {
-    i("startOptions", { ...r, config: "too wordy" });
-    const s = h.resolve(r.workingDir);
-    r.closeOld && i("closeOld", await Rt(o, s));
-    const a = h.join(s, Ot);
-    o.info(`writing configuration '${a}'...`), await g.writeFile(a, r.config);
-    const c = h.join(s, "binaries"), l = await Ft(o, c, r.plBinary), d = i("binaryPath", h.join("binaries", l)), u = _t(d, a, r, s, process.env);
-    i("processOpts", {
-      cmd: u.cmd,
-      args: u.args,
-      cwd: u.opts.cwd
-    });
-    const w = new kt(
-      o,
-      r.workingDir,
-      u,
-      n,
-      r.onClose,
-      r.onError,
-      r.onCloseAndError,
-      r.onCloseAndErrorNoStop
-    );
-    return await w.start(), w;
-  });
-}
-async function Rt(o, t) {
-  return await _(o, async (e, r) => {
-    const i = e("pidFilePath", V(t)), n = e("pid", await bt(i)), s = e("wasAlive", await k(n));
-    return n !== void 0 && s && (e("stopped", J(n)), e("waitStopped", await L(n, 1e4))), r;
-  });
-}
-function Nt(o, t) {
-  var i;
-  const e = {
-    plBinary: Et(),
-    spawnOptions: {
-      env: {
-        GOMAXPROCS: String(t)
-      }
-    },
-    closeOld: !0
-  };
-  if ((i = o.spawnOptions) != null && i.env && (e.spawnOptions.env = { ...e.spawnOptions.env, ...o.spawnOptions.env }), o.spawnOptions) {
-    const n = { ...o.spawnOptions };
-    delete n.env, e.spawnOptions = { ...e.spawnOptions, ...n };
-  }
-  const r = { ...o };
-  return delete r.spawnOptions, { ...e, ...r };
-}
-function _t(o, t, e, r, i) {
-  var a;
-  const n = {
-    cmd: o,
-    args: ["--config", t],
-    opts: {
-      env: { ...i },
-      cwd: r,
-      stdio: ["pipe", "ignore", "inherit"],
-      windowsHide: !0
-      // hide a terminal on Windows
-    }
-  };
-  (a = e.spawnOptions) != null && a.env && (n.opts.env = { ...n.opts.env, ...e.spawnOptions.env });
-  const s = { ...e.spawnOptions };
-  return delete s.env, n.opts = { ...n.opts, ...s }, n;
-}
-const Ut = {
-  keepaliveInterval: 6e4,
-  keepaliveCountMax: 10
-};
-class U {
-  constructor(t, e) {
-    p(this, "config");
-    p(this, "homeDir");
-    p(this, "forwardedServers", []);
-    this.logger = t, this.client = e;
-  }
-  /**
-   * Initializes the SshClient and establishes a connection using the provided configuration.
-   * @param config - The connection configuration object for the SSH client.
-   * @returns A new instance of SshClient with an active connection.
-   */
-  static async init(t, e) {
-    const r = {
-      ...Ut,
-      ...e
-    }, i = new U(t, new D());
-    return await i.connect(r), i;
-  }
-  getForwardedServers() {
-    return this.forwardedServers;
-  }
-  getFullHostName() {
-    var t, e;
-    return `${(t = this.config) == null ? void 0 : t.host}:${(e = this.config) == null ? void 0 : e.port}`;
-  }
-  getUserName() {
-    var t;
-    return (t = this.config) == null ? void 0 : t.username;
-  }
-  /**
-   * Connects to the SSH server using the specified configuration.
-   * @param config - The connection configuration object for the SSH client.
-   * @returns A promise that resolves when the connection is established or rejects on error.
-   */
-  async connect(t) {
-    return this.config = t, await Bt(this.client, t);
-  }
-  /**
-   * Executes a command on the SSH server.
-   * @param command - The command to execute on the remote server.
-   * @returns A promise resolving with the command's stdout and stderr outputs.
-   */
-  async exec(t) {
-    return new Promise((e, r) => {
-      this.client.exec(t, (i, n) => {
-        if (i)
-          return r(new Error(`ssh.exec: ${t}: ${i}`));
-        let s = "", a = "";
-        n.on("close", (c) => {
-          c === 0 ? e({ stdout: s, stderr: a }) : r(new Error(`Command ${t} exited with code ${c}, stdout: ${s}, stderr: ${a}`));
-        }).on("data", (c) => {
-          s += c.toString();
-        }).stderr.on("data", (c) => {
-          a += c.toString();
-        });
-      });
-    });
-  }
-  /**
-   * Retrieves the supported authentication methods for a given host and port.
-   * @param host - The hostname or IP address of the server.
-   * @param port - The port number to connect to on the server.
-   * @returns 'publickey' | 'password'[] A promise resolving with a list of supported authentication methods.
-   */
-  static async getAuthTypes(t, e) {
-    return new Promise((r) => {
-      let i = "";
-      const n = new D();
-      n.on("ready", () => {
-        n.end();
-        const s = this.extractAuthMethods(i);
-        r(s.length === 0 ? ["publickey", "password"] : s);
-      }), n.on("error", () => {
-        n.end(), r(["publickey", "password"]);
-      }), n.connect({
-        host: t,
-        port: e,
-        username: (/* @__PURE__ */ new Date()).getTime().toString(),
-        debug: (s) => {
-          i += `${s}
-`;
-        }
-      });
-    });
-  }
-  /**
-   * Extracts authentication methods from debug logs.
-   * @param log - The debug log output containing authentication information.
-   * @returns An array of extracted authentication methods.
-   */
-  static extractAuthMethods(t) {
-    const e = t.match(/Inbound: Received USERAUTH_FAILURE \((.+)\)/);
-    return e && e[1] ? e[1].split(",").map((r) => r.trim()) : [];
-  }
-  /**
-   * Sets up port forwarding between a remote port on the SSH server and a local port.
-   * A new connection is used for this operation instead of an existing one.
-   * @param ports - An object specifying the remote and local port configuration.
-   * @param config - Optional connection configuration for the SSH client.
-   * @returns { server: net.Server } A promise resolving with the created server instance.
-   */
-  async forwardPort(t, e) {
-    const r = `ssh.forward:${t.localPort}:${t.remotePort}.id_${F(1).toString("hex")}`;
-    e = e ?? this.config;
-    const i = new et((n) => new Promise((s, a) => {
-      const c = new D();
-      c.on("ready", () => {
-        this.logger.info(`${r}.client.ready`), s(c);
-      }), c.on("error", (l) => {
-        this.logger.info(`${r}.client.error: ${l}`), n.reset(), a(l);
-      }), c.on("close", () => {
-        this.logger.info(`${r}.client.closed`), n.reset();
-      }), c.connect(e);
-    }));
-    return await i.ensure(), new Promise((n, s) => {
-      const a = G.createServer({ pauseOnConnect: !0 }, async (c) => {
-        const l = `${r}.sock_${F(1).toString("hex")}`;
-        let d;
-        try {
-          d = await i.ensure();
-        } catch (w) {
-          this.logger.info(`${l}.persistentClient.catch: ${w}`), c.end();
-          return;
-        }
-        d.setNoDelay(!0), c.setNoDelay(!0);
-        let u;
-        try {
-          u = await It(this.logger, d, "127.0.0.1", 0, "127.0.0.1", t.remotePort);
-        } catch (w) {
-          this.logger.error(`${l}.forwardOut.err: ${w}`), c.end();
-          return;
-        }
-        c.pipe(u), u.pipe(c), c.resume(), u.on("error", (w) => {
-          this.logger.error(`${l}.stream.error: ${w}`), c.end(), u.end();
-        }), u.on("close", () => {
-          c.end(), u.end();
-        }), c.on("close", () => {
-          this.logger.info(`${l}.localSocket: closed`), c.end(), u.end();
-        });
-      });
-      a.listen(t.localPort, "127.0.0.1", () => {
-        this.logger.info(`${r}.server: started listening`), this.forwardedServers.push(a), n({ server: a });
-      }), a.on("error", (c) => {
-        a.close(), s(new Error(`${r}.server: error: ${JSON.stringify(c)}`));
-      }), a.on("close", () => {
-        this.logger.info(`${r}.server: closed ${JSON.stringify(t)}`), this.forwardedServers = this.forwardedServers.filter((c) => c !== a);
-      });
-    });
-  }
-  closeForwardedPorts() {
-    this.logger.info("[SSH] Closing all forwarded ports..."), this.forwardedServers.forEach((t) => {
-      const e = t.address();
-      if (e && typeof e != "string") {
-        const r = e;
-        this.logger.info(`[SSH] Closing port forward for server ${r.address}:${r.port}`);
-      }
-      t.close();
-    }), this.forwardedServers = [];
-  }
-  /**
-  * Checks if a specified host is available by performing a DNS lookup.
-  * @param hostname - The hostname or IP address to check.
-  * @returns A promise resolving with `true` if the host is reachable, otherwise `false`.
-  */
-  static async checkHostAvailability(t) {
-    return new Promise((e) => {
-      ht.lookup(t, (r) => {
-        e(!r);
-      });
-    });
-  }
-  /**
-   * Determines whether a private key requires a passphrase for use.
-   * @param privateKey - The private key content to check.
-   * @returns A promise resolving with `true` if a passphrase is required, otherwise `false`.
-   */
-  static async isPassphraseRequiredForKey(t) {
-    return new Promise((e, r) => {
-      try {
-        return dt.utils.parseKey(t) instanceof Error && e(!0), e(!1);
-      } catch (i) {
-        console.log("Error parsing privateKey"), r(new Error(`ssh.isPassphraseRequiredForKey: err ${i}`));
-      }
-    });
-  }
-  /**
-   * Uploads a local file to a remote server via SFTP.
-   * This function creates new SFTP connection
-   * @param localPath - The local file path.
-   * @param remotePath - The remote file path on the server.
-   * @returns A promise resolving with `true` if the file was successfully uploaded.
-   */
-  async uploadFile(t, e) {
-    return await this.withSftp(async (r) => new Promise((i, n) => {
-      r.fastPut(t, e, (s) => {
-        if (s) {
-          const a = new Error(
-            `ssh.uploadFile: err: ${s}, localPath: ${t}, remotePath: ${e}`
-          );
-          return n(a);
-        }
-        i(!0);
-      });
-    }));
-  }
-  async withSftp(t) {
-    return new Promise((e, r) => {
-      this.client.sftp((i, n) => {
-        if (i)
-          return r(new Error(`ssh.withSftp: sftp err: ${i}`));
-        t(n).then(e).catch((s) => {
-          r(new Error(`ssh.withSftp.callback: err ${s}`));
-        }).finally(() => {
-          n == null || n.end();
-        });
-      });
-    });
-  }
-  async writeFileOnTheServer(t, e, r = 432) {
-    return this.withSftp(async (i) => this.writeFile(i, t, e, r));
-  }
-  async getForderStructure(t, e, r = { files: [], directories: [] }) {
-    return new Promise((i, n) => {
-      t.readdir(e, async (s, a) => {
-        if (s)
-          return n(s);
-        for (const c of a) {
-          const l = `${e}/${c.filename}`;
-          if (c.attrs.isDirectory()) {
-            r.directories.push(l);
-            try {
-              await this.getForderStructure(t, l, r);
-            } catch (d) {
-              return n(d instanceof Error ? d : new Error(String(d)));
-            }
-          } else
-            r.files.push(l);
-        }
-        i(r);
-      });
-    });
-  }
-  rmdir(t, e) {
-    return new Promise((r, i) => {
-      t.rmdir(e, (n) => n ? i(n) : r(!0));
-    });
-  }
-  unlink(t, e) {
-    return new Promise((r, i) => {
-      t.unlink(e, (n) => n ? i(n) : r(!0));
-    });
-  }
-  async deleteFolder(t) {
-    return this.withSftp(async (e) => {
-      try {
-        const r = await this.getForderStructure(e, t);
-        this.logger.info("ssh.deleteFolder list of files and directories"), this.logger.info(`ssh.deleteFolder list of files: ${r.files}`), this.logger.info(`ssh.deleteFolder list of directories: ${r.directories}`);
-        for (const i of r.files)
-          this.logger.info(`ssh.deleteFolder unlink file ${i}`), await this.unlink(e, i);
-        r.directories.sort((i, n) => n.length - i.length);
-        for (const i of r.directories)
-          this.logger.info(`ssh.deleteFolder rmdir  ${i}`), await this.rmdir(e, i);
-        return await this.rmdir(e, t), !0;
-      } catch (r) {
-        this.logger.error(r);
-        const i = r instanceof Error ? r.message : "";
-        throw new Error(`ssh.deleteFolder: path: ${t}, message: ${i}`);
-      }
-    });
-  }
-  async readFile(t) {
-    return this.withSftp(async (e) => new Promise((r, i) => {
-      e.readFile(t, (n, s) => {
-        if (n)
-          return i(new Error(`ssh.readFile: ${n}`));
-        r(s.toString());
-      });
-    }));
-  }
-  async chmod(t, e) {
-    return this.withSftp(async (r) => new Promise((i, n) => {
-      r.chmod(t, e, (s) => s ? n(new Error(`ssh.chmod: ${s}, path: ${t}, mode: ${e}`)) : i(void 0));
-    }));
-  }
-  async checkFileExists(t) {
-    return this.withSftp(async (e) => new Promise((r, i) => {
-      e.stat(t, (n, s) => {
-        if (n)
-          return (n == null ? void 0 : n.code) === 2 ? r(!1) : i(new Error(`ssh.checkFileExists: err ${n}`));
-        r(s.isFile());
-      });
-    }));
-  }
-  async checkPathExists(t) {
-    return this.withSftp(async (e) => new Promise((r, i) => {
-      e.stat(t, (n, s) => {
-        if (n)
-          return n.code === 2 ? r({ exists: !1, isFile: !1, isDirectory: !1 }) : i(new Error(`ssh.checkPathExists: ${n}`));
-        r({
-          exists: !0,
-          isFile: s.isFile(),
-          isDirectory: s.isDirectory()
-        });
-      });
-    }));
-  }
-  async writeFile(t, e, r, i = 432) {
-    return new Promise((n, s) => {
-      t.writeFile(e, r, { mode: i }, (a) => {
-        if (a)
-          return s(new Error(`ssh.writeFile: err ${a}, remotePath: ${e}`));
-        n(!0);
-      });
-    });
-  }
-  uploadFileUsingExistingSftp(t, e, r, i = 432) {
-    return new Promise((n, s) => {
-      rt(e).then(async (a) => this.writeFile(t, r, a, i).then(() => {
-        n(void 0);
-      }).catch((c) => {
-        const l = `uploadFileUsingExistingSftp: ${c}`;
-        this.logger.error(l), s(new Error(l));
-      }));
-    });
-  }
-  async __uploadDirectory(t, e, r, i = 432) {
-    return new Promise((n, s) => {
-      O.readdir(e, async (a, c) => {
-        if (a)
-          return s(new Error(`ssh.__uploadDir: err ${a}, localDir: ${e}, remoteDir: ${r}`));
-        try {
-          await this.__createRemoteDirectory(t, r);
-          for (const l of c) {
-            const d = h.join(e, l), u = `${r}/${l}`;
-            O.lstatSync(d).isDirectory() ? await this.__uploadDirectory(t, d, u, i) : await this.uploadFileUsingExistingSftp(t, d, u, i);
-          }
-          n();
-        } catch (l) {
-          const d = `ssh.__uploadDir: catched err ${l}`;
-          this.logger.error(d), s(new Error(d));
-        }
-      });
-    });
-  }
-  /**
-   * Uploads a local directory and its contents (including subdirectories) to the remote server via SFTP.
-   * @param localDir - The path to the local directory to upload.
-   * @param remoteDir - The path to the remote directory on the server.
-   * @returns A promise that resolves when the directory and its contents are uploaded.
-   */
-  async uploadDirectory(t, e, r = 432) {
-    return new Promise((i, n) => {
-      this.withSftp(async (s) => {
-        try {
-          await this.__uploadDirectory(s, t, e, r), i();
-        } catch (a) {
-          n(new Error(`ssh.uploadDirectory: ${a}`));
-        }
-      });
-    });
-  }
-  /**
-   * Ensures that a remote directory and all its parent directories exist.
-   * @param sftp - The SFTP wrapper.
-   * @param remotePath - The path to the remote directory.
-   * @returns A promise that resolves when the directory is created.
-   */
-  __createRemoteDirectory(t, e) {
-    return new Promise((r, i) => {
-      const n = e.split("/");
-      let s = "";
-      const a = (c) => {
-        if (c >= n.length)
-          return r();
-        s += `${n[c]}/`, t.stat(s, (l) => {
-          l ? t.mkdir(s, (d) => {
-            if (d)
-              return i(new Error(`ssh.__createRemDir: err ${d}, remotePath: ${e}`));
-            a(c + 1);
-          }) : a(c + 1);
-        });
-      };
-      a(0);
-    });
-  }
-  /**
-   * Ensures that a remote directory and all its parent directories exist.
-   * @param sftp - The SFTP wrapper.
-   * @param remotePath - The path to the remote directory.
-   * @returns A promise that resolves when the directory is created.
-   */
-  ensureRemoteDirCreated(t, e = 493) {
-    return this.withSftp(async (r) => {
-      const i = t.split("/");
-      let n = "";
-      for (const s of i) {
-        n += `${s}/`;
-        try {
-          await new Promise((a, c) => {
-            r.stat(n, (l) => {
-              if (!l) return a();
-              r.mkdir(n, { mode: e }, (d) => {
-                if (d)
-                  return c(new Error(`ssh.createRemoteDir: err ${d}, remotePath: ${t}`));
-                a();
-              });
-            });
-          });
-        } catch (a) {
-          throw console.error(`Failed to create directory: ${n}`, a), a;
-        }
-      }
-    });
-  }
-  /**
-   * Downloads a file from the remote server to a local path via SFTP.
-   * @param remotePath - The remote file path on the server.
-   * @param localPath - The local file path to save the file.
-   * @returns A promise resolving with `true` if the file was successfully downloaded.
-   */
-  async downloadFile(t, e) {
-    return this.withSftp(async (r) => new Promise((i, n) => {
-      r.fastGet(t, e, (s) => {
-        if (s)
-          return n(new Error(`ssh.downloadFile: err ${s}, remotePath: ${t}, localPath: ${e}`));
-        i(!0);
-      });
-    }));
-  }
-  /**
-   * Closes the SSH client connection and forwarded ports.
-   */
-  close() {
-    this.closeForwardedPorts(), this.client.end();
-  }
-}
-async function Bt(o, t, e, r) {
-  return new Promise((i, n) => {
-    o.on("ready", () => {
-      i(o);
-    }), o.on("error", (s) => {
-      n(new Error(`ssh.connect: ${s}`));
-    }), o.on("close", () => {
-    }), o.connect(t), o.setNoDelay(!0);
-  });
-}
-async function It(o, t, e, r, i, n) {
-  return new Promise((s, a) => {
-    t.forwardOut(e, r, i, n, (c, l) => c ? (o.error(`forwardOut.error: ${c}`), a(c)) : s(l));
-  });
-}
-const Tt = "minio-2024-12-18T13-15-44Z", Mt = "supervisord-0.7.3", Ht = "supervisord_0.7.3_Linux_64-bit";
-function y(o) {
-  return h.join(o, ".platforma_ssh");
-}
-function b(o) {
-  return h.join(y(o), "binaries");
-}
-function jt(o, t) {
-  return h.join(b(o), `pl-${N()}-${C(t)}`);
-}
-function q(o, t) {
-  return h.join(jt(o, t), "binaries");
-}
-function I(o, t) {
-  return h.join(q(o, t), "platforma");
-}
-function Gt(o, t) {
-  return h.join(q(o, t), "free-port");
-}
-function W(o, t) {
-  return h.join(b(o), `minio-2024-12-18T13-15-44Z-${C(t)}`);
-}
-function Jt(o, t) {
-  return h.join(W(o, t), "minio");
-}
-function Lt(o, t) {
-  return h.join(b(o), `supervisord-0.7.3-${C(t)}`, Ht);
-}
-function K(o, t) {
-  return h.join(Lt(o, t), "supervisord");
-}
-function Z(o) {
-  return h.join(y(o), "supervisor.conf");
-}
-function T(o) {
-  return h.join(y(o), "connection.txt");
-}
-function zt(o) {
-  return h.join(y(o), "platforma_cli_logs.log");
-}
-async function Vt(o, t, e) {
-  const r = await B(o, t, e, "--daemon");
-  if (r.stderr)
-    throw new Error(`Can not run ssh Platforma ${r.stderr}`);
-}
-async function qt(o, t, e) {
-  const r = await B(o, t, e, "ctl shutdown");
-  if (r.stderr)
-    throw new Error(`Can not stop ssh Platforma ${r.stderr}`);
-}
-function E(o, t) {
-  return t ? o.platforma && o.minio : o.platforma;
-}
-function Wt(o) {
-  return o.execError === void 0;
-}
-async function Kt(o, t, e, r) {
-  let i;
-  try {
-    i = await B(t, e, r, "ctl status");
-  } catch (c) {
-    return { execError: String(c) };
-  }
-  if (i.stderr)
-    return o.info(`supervisord ctl status: stderr occurred: ${i.stderr}, stdout: ${i.stdout}`), { rawResult: i };
-  const n = M(i.stdout, "platforma"), s = M(i.stdout, "minio"), a = {
-    rawResult: i,
-    platforma: n,
-    minio: s
-  };
-  return a.minio || o.warn("Minio is not running on the server"), a.platforma || o.warn("Platforma is not running on the server"), a;
-}
-function Zt(o, t, e, r) {
-  const i = F(16).toString("hex"), n = o;
-  return `
-[supervisord]
-logfile=${t}/supervisord.log
-loglevel=info
-pidfile=${t}/supervisord.pid
-
-[inet_http_server]
-port=127.0.0.1:${n}
-username=default-user
-password=${i}
-
-[supervisorctl]
-serverurl=http://127.0.0.1:${n}
-username=default-user
-password=${i}
-
-[program:platforma]
-autostart=true
-command=${r} --config ${e}
-directory=${t}
-autorestart=true
-stdout_logfile=${t}/platforma_cli_logs.log
-stdout_logfile_maxbytes=10000
-stdout_logfile_backups=10
-redirect_stderr=true
-`;
-}
-function Xt(o, t, e, r, i, n, s) {
-  const a = Object.entries(t).map(([d, u]) => `${d}="${u}"`).join(","), c = F(16).toString("hex"), l = e;
-  return `
-[supervisord]
-logfile=${r}/supervisord.log
-loglevel=info
-pidfile=${r}/supervisord.pid
-
-[inet_http_server]
-port=127.0.0.1:${l}
-username=default-user
-password=${c}
-
-[supervisorctl]
-serverurl=http://127.0.0.1:${l}
-username=default-user
-password=${c}
-
-[program:platforma]
-autostart=true
-depends_on=minio
-command=${s} --config ${i}
-directory=${r}
-autorestart=true
-
-[program:minio]
-autostart=true
-environment=${a}
-command=${n} server ${o}
-directory=${r}
-autorestart=true
-`;
-}
-async function B(o, t, e, r) {
-  const i = K(t, e), n = Z(t), s = `${i} --configuration ${n} ${r}`;
-  return await o.exec(s);
-}
-function M(o, t) {
-  return ((i) => i.replace(/\x1B\[[0-9;]*m/g, ""))(o).split(`
-`).some((i) => {
-    const [n, s] = i.trim().split(/\s{2,}/);
-    return n === t && s === "Running";
-  });
-}
-const S = f.object({
-  local: f.number(),
-  remote: f.number()
-}), Yt = f.object({
-  grpc: S,
-  http: S.optional(),
-  monitoring: S,
-  debug: S,
-  /** @deprecated */
-  minioPort: S,
-  /** @deprecated */
-  minioConsolePort: S
-}), Qt = f.object({
-  plUser: f.string(),
-  plPassword: f.string(),
-  ports: Yt,
-  // It's false by default because it was added later,
-  // and in some deployments there won't be useGlobalAccess flag in the file.
-  useGlobalAccess: f.boolean().default(!1),
-  // We added the field afterwards, the pl backend was this version.
-  plVersion: f.string().default("1.18.3"),
-  // It's true by default because it was added later and previous installation use minio.
-  minioIsUsed: f.boolean().default(!0)
-});
-function te(o, t, e, r, i, n) {
-  return {
-    plUser: o,
-    plPassword: t,
-    ports: e,
-    useGlobalAccess: r,
-    plVersion: i,
-    minioIsUsed: n
-  };
-}
-function ee(o) {
-  return Qt.parse(JSON.parse(o));
-}
-function re(o) {
-  return JSON.stringify(o, void 0, 2);
-}
-const H = 2.28;
-class X {
-  constructor(t, e, r) {
-    p(this, "initState", { step: "init" });
-    this.logger = t, this.sshClient = e, this.username = r;
-  }
-  info() {
-    return {
-      username: this.username,
-      initState: this.initState
-    };
-  }
-  static async init(t, e) {
-    try {
-      const r = await U.init(t, e);
-      return new X(t, r, m(e.username));
-    } catch (r) {
-      throw t.error(`Connection error in SshClient.init: ${r}`), r;
-    }
-  }
-  cleanUp() {
-    this.sshClient.close();
-  }
-  /** Provides an info if the platforma and minio are running along with the debug info. */
-  async isAlive() {
-    const t = await this.getArch(), e = await this.getUserHomeDirectory();
-    return await Kt(this.logger, this.sshClient, e, t.arch);
-  }
-  /** Starts all the services on the server.
-    * Idempotent semantic: we could call it several times. */
-  async start(t) {
-    const e = await this.getArch(), r = await this.getUserHomeDirectory();
-    try {
-      if (!E(await this.isAlive(), t))
-        return await Vt(this.sshClient, r, e.arch), await this.checkIsAliveWithInterval(t);
-    } catch (i) {
-      let n = `SshPl.start: ${i}`, s = "";
-      try {
-        s = await this.sshClient.readFile(zt(r)), n += `, platforma cli logs: ${s}`;
-      } catch (a) {
-        n += `, Can not read platforma cli logs: ${a}`;
-      }
-      throw this.logger.error(n), new Error(n);
-    }
-  }
-  /** Stops all the services on the server.
-    * Idempotent semantic: we could call it several times. */
-  async stop() {
-    const t = await this.getArch(), e = await this.getUserHomeDirectory();
-    try {
-      const r = await this.isAlive();
-      if (Wt(r)) {
-        await qt(this.sshClient, e, t.arch);
-        const i = r.minio === !0;
-        return await this.checkIsAliveWithInterval(i, 1e3, 15, !1);
-      }
-    } catch (r) {
-      const i = `PlSsh.stop: ${r}`;
-      throw this.logger.error(i), new Error(i);
-    }
-  }
-  /** Stops the services, deletes a directory with the state and closes SSH connection. */
-  async reset() {
-    return await this.stopAndClean(), this.cleanUp(), !0;
-  }
-  /** Stops platforma and deletes its state. */
-  async stopAndClean() {
-    const t = await this.getUserHomeDirectory();
-    this.logger.info("pl.reset: Stop Platforma on the server"), await this.stop(), this.logger.info(`pl.reset: Deleting Platforma workDir ${y(t)} on the server`), await this.sshClient.deleteFolder(y(t));
-  }
-  /** Downloads binaries and untar them on the server,
-   * generates all the configs, creates necessary dirs,
-   * and finally starts all the services. */
-  async platformaInit(t) {
-    const e = { localWorkdir: t.localWorkdir, step: "init" }, { onProgress: r } = t, i = {
-      ...ie,
-      ...t
-    };
-    e.plBinaryOps = i.plBinary;
-    try {
-      return await this.doStepDetectArch(e, r), await this.doStepDetectHome(e, r), await this.doStepReadExistedConfig(e, i, r) ? (await this.doStepStopExistedPlatforma(e, r), await (r == null ? void 0 : r("Installation platforma...")), await this.doStepDownloadBinaries(e, r, i), await this.doStepFetchPorts(e), await this.doStepGenerateNewConfig(e, r, i), await this.doStepCreateFoldersAndSaveFiles(e, r), await this.doStepConfigureSupervisord(e, r), await this.doStepSaveNewConnectionInfo(e, r, i), await this.doStepStartPlatforma(e, r), e.connectionInfo) : (await (r == null ? void 0 : r("Platforma is already running. Skipping initialization.")), e.existedSettings);
-    } catch (n) {
-      const s = `SshPl.platformaInit: ${n}, state: ${JSON.stringify(this.removeSensitiveData(e))}`;
-      throw this.logger.error(s), new Error(s);
-    }
-  }
-  async doStepStopExistedPlatforma(t, e) {
-    t.step = "stopExistedPlatforma", E(t.alive, t.shouldUseMinio ?? !1) && (await (e == null ? void 0 : e("Stopping services...")), await this.stop());
-  }
-  removeSensitiveData(t) {
-    const e = { ...t };
-    return e.generatedConfig = { ...e.generatedConfig, filesToCreate: { skipped: "sanitized" } }, e;
-  }
-  async doStepStartPlatforma(t, e) {
-    t.step = "startPlatforma", await (e == null ? void 0 : e("Starting Platforma on the server...")), await this.start(t.shouldUseMinio ?? !1), t.started = !0, this.initState = t, await (e == null ? void 0 : e("Platforma has been started successfully."));
-  }
-  async doStepSaveNewConnectionInfo(t, e, r) {
-    t.step = "saveNewConnectionInfo";
-    const i = t.generatedConfig;
-    await (e == null ? void 0 : e("Saving connection information...")), t.connectionInfo = te(
-      i.plUser,
-      i.plPassword,
-      t.ports,
-      m(r.useGlobalAccess),
-      r.plBinary.version,
-      t.shouldUseMinio ?? !1
-    ), await this.sshClient.writeFileOnTheServer(
-      T(t.remoteHome),
-      re(t.connectionInfo)
-    ), await (e == null ? void 0 : e("Connection information saved."));
-  }
-  async doStepConfigureSupervisord(t, e) {
-    await (e == null ? void 0 : e("Writing supervisord configuration...")), t.step = "configureSupervisord";
-    const r = t.generatedConfig;
-    let i;
-    if (t.shouldUseMinio ? i = Xt(
-      r.minioConfig.storageDir,
-      r.minioConfig.envs,
-      await this.getFreePortForPlatformaOnServer(t.remoteHome, t.arch),
-      r.workingDir,
-      r.plConfig.configPath,
-      t.binPaths.minioRelPath,
-      t.binPaths.downloadedPl
-    ) : i = Zt(
-      await this.getFreePortForPlatformaOnServer(t.remoteHome, t.arch),
-      r.workingDir,
-      r.plConfig.configPath,
-      t.binPaths.downloadedPl
-    ), !await this.sshClient.writeFileOnTheServer(Z(t.remoteHome), i))
-      throw new Error(`Can not write supervisord config on the server ${y(t.remoteHome)}`);
-    await (e == null ? void 0 : e("Supervisord configuration written."));
-  }
-  async doStepCreateFoldersAndSaveFiles(t, e) {
-    t.step = "createFoldersAndSaveFiles";
-    const r = t.generatedConfig;
-    await (e == null ? void 0 : e("Generating folder structure..."));
-    for (const [i, n] of Object.entries(r.filesToCreate))
-      await this.sshClient.writeFileOnTheServer(i, n), this.logger.info(`Created file ${i}`);
-    for (const i of r.dirsToCreate)
-      await this.sshClient.ensureRemoteDirCreated(i), this.logger.info(`Created directory ${i}`);
-    await (e == null ? void 0 : e("Folder structure created."));
-  }
-  async doStepGenerateNewConfig(t, e, r) {
-    t.step = "generateNewConfig", await (e == null ? void 0 : e("Generating new config..."));
-    const i = await ut({
-      logger: this.logger,
-      workingDir: y(t.remoteHome),
-      portsMode: {
-        type: "customWithMinio",
-        ports: {
-          debug: t.ports.debug.remote,
-          grpc: t.ports.grpc.remote,
-          http: t.ports.http.remote,
-          minio: t.ports.minioPort.remote,
-          minioConsole: t.ports.minioConsolePort.remote,
-          monitoring: t.ports.monitoring.remote,
-          httpLocal: t.ports.http.local,
-          grpcLocal: t.ports.grpc.local,
-          minioLocal: t.ports.minioPort.local
-        }
-      },
-      licenseMode: r.license,
-      useGlobalAccess: m(r.useGlobalAccess),
-      plConfigPostprocessing: r.plConfigPostprocessing,
-      useMinio: t.shouldUseMinio ?? !1
-    });
-    t.generatedConfig = { ...i }, await (e == null ? void 0 : e("New config generated"));
-  }
-  async doStepFetchPorts(t) {
-    var e;
-    if (t.step = "fetchPorts", t.ports = await this.fetchPorts(t.remoteHome, t.arch), !t.ports.debug.remote || !t.ports.grpc.remote || !t.ports.minioPort.remote || !t.ports.minioConsolePort.remote || !t.ports.monitoring.remote || !((e = t.ports.http) != null && e.remote))
-      throw new Error("SshPl.platformaInit: remote ports are not defined");
-  }
-  async doStepDownloadBinaries(t, e, r) {
-    t.step = "downloadBinaries", await (e == null ? void 0 : e("Downloading and uploading required binaries..."));
-    const i = await ne(this.logger, this.sshClient);
-    if (i < H)
-      throw new Error(`glibc version ${i} is too old. Version ${H} or higher is required for Platforma.`);
-    const n = await this.downloadBinariesAndUploadToTheServer(
-      r.localWorkdir,
-      r.plBinary,
-      t.remoteHome,
-      t.arch,
-      t.shouldUseMinio ?? !1
-    );
-    await (e == null ? void 0 : e("All required binaries have been downloaded and uploaded.")), t.binPaths = { ...n, history: void 0 }, t.downloadedBinaries = n.history;
-  }
-  async doStepDetectArch(t, e) {
-    t.step = "detectArch", await (e == null ? void 0 : e("Detecting server architecture...")), t.arch = await this.getArch(), await (e == null ? void 0 : e("Server architecture detected."));
-  }
-  async doStepDetectHome(t, e) {
-    t.step = "detectHome", await (e == null ? void 0 : e("Fetching user home directory...")), t.remoteHome = await this.getUserHomeDirectory(), await (e == null ? void 0 : e("User home directory retrieved."));
-  }
-  async doStepReadExistedConfig(t, e, r) {
-    var s;
-    if (t.step = "checkAlive", await (r == null ? void 0 : r("Checking platform status...")), t.alive = await this.isAlive(), !((s = t.alive) != null && s.platforma))
-      return !0;
-    if (await (r == null ? void 0 : r("All required services are running.")), t.existedSettings = await this.readExistedConfig(t.remoteHome), !t.existedSettings)
-      throw new Error("SshPl.platformaInit: platforma is alive but existed settings are not found");
-    const i = t.existedSettings.useGlobalAccess == e.useGlobalAccess, n = t.existedSettings.plVersion == e.plBinary.version;
-    return t.needRestart = !(i && n), this.logger.info(`SshPl.platformaInit: need restart? ${t.needRestart}`), t.shouldUseMinio = t.existedSettings.minioIsUsed, t.shouldUseMinio ? this.logger.info("SshPl.platformaInit: minio is used") : this.logger.info("SshPl.platformaInit: minio is not used"), t.needRestart ? (await (r == null ? void 0 : r("Stopping services...")), await this.stop(), !0) : (await (r == null ? void 0 : r("Server setup completed.")), !1);
-  }
-  async downloadBinariesAndUploadToTheServer(t, e, r, i, n) {
-    const s = [];
-    try {
-      const a = await this.downloadAndUntar(
-        t,
-        r,
-        i,
-        "pl",
-        `pl-${e.version}`
-      );
-      s.push(a);
-      const c = await this.downloadAndUntar(
-        t,
-        r,
-        i,
-        "supervisord",
-        Mt
-      );
-      s.push(c);
-      const l = Jt(r, i.arch);
-      if (n) {
-        const d = await this.downloadAndUntar(
-          t,
-          r,
-          i,
-          "minio",
-          Tt
-        );
-        s.push(d), await this.sshClient.chmod(l, 488);
-      }
-      return {
-        history: s,
-        minioRelPath: n ? l : void 0,
-        downloadedPl: I(r, i.arch)
-      };
-    } catch (a) {
-      const c = `SshPl.downloadBinariesAndUploadToServer: ${a}, state: ${JSON.stringify(s)}`;
-      throw this.logger.error(c), a;
-    }
-  }
-  /** 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(t, e, r, i, n) {
-    const s = {};
-    s.binBasePath = b(e), await this.sshClient.ensureRemoteDirCreated(s.binBasePath), s.binBasePathCreated = !0;
-    let a = null;
-    const c = 5;
-    for (let d = 1; d <= c; d++)
-      try {
-        a = await gt(
-          this.logger,
-          t,
-          i,
-          n,
-          r.arch,
-          r.platform
-        );
-        break;
-      } catch (u) {
-        if (await x(300), d == c)
-          throw new Error(`downloadAndUntar: ${c} attempts, last error: ${u}`);
-      }
-    s.downloadResult = m(a), s.localArchivePath = h.resolve(s.downloadResult.archivePath), s.remoteDir = h.join(s.binBasePath, s.downloadResult.baseName), s.remoteArchivePath = s.remoteDir + ".tgz", await this.sshClient.ensureRemoteDirCreated(s.remoteDir), await this.sshClient.uploadFile(s.localArchivePath, s.remoteArchivePath), s.uploadDone = !0;
-    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 l = await this.sshClient.exec(
-      `tar --warning=no-all -xvf ${s.remoteArchivePath} --directory=${s.remoteDir}`
-    );
-    if (l.stderr)
-      throw new Error(`downloadAndUntar: untar: stderr occurred: ${l.stderr}, stdout: ${l.stdout}`);
-    return s.untarDone = !0, s;
-  }
-  async needDownload(t, e) {
-    const r = K(t, e.arch), i = W(t, e.arch), n = I(t, e.arch);
-    return !await this.sshClient.checkFileExists(n) || !await this.sshClient.checkFileExists(i) || !await this.sshClient.checkFileExists(r);
-  }
-  async checkIsAliveWithInterval(t, e = 1e3, r = 15, i = !0) {
-    const n = r * e;
-    let s = 0, a = await this.isAlive();
-    for (; i ? !E(a, t) : E(a, t); ) {
-      if (await x(e), s += e, s > n)
-        throw new Error(`isAliveWithInterval: The process did not ${i ? "started" : "stopped"} after ${n} ms. Live status: ${JSON.stringify(a)}`);
-      a = await this.isAlive();
-    }
-  }
-  async readExistedConfig(t) {
-    const e = await this.sshClient.readFile(T(t));
-    return ee(e);
-  }
-  async fetchPorts(t, e) {
-    return {
-      grpc: {
-        local: await $(),
-        remote: await this.getFreePortForPlatformaOnServer(t, e)
-      },
-      monitoring: {
-        local: await $(),
-        remote: await this.getFreePortForPlatformaOnServer(t, e)
-      },
-      debug: {
-        local: await $(),
-        remote: await this.getFreePortForPlatformaOnServer(t, e)
-      },
-      http: {
-        local: await $(),
-        remote: await this.getFreePortForPlatformaOnServer(t, e)
-      },
-      minioPort: {
-        local: await $(),
-        remote: await this.getFreePortForPlatformaOnServer(t, e)
-      },
-      minioConsolePort: {
-        local: await $(),
-        remote: await this.getFreePortForPlatformaOnServer(t, e)
-      }
-    };
-  }
-  async getLocalFreePort() {
-    return new Promise((t) => {
-      const e = G.createServer();
-      e.listen(0, () => {
-        const r = e.address().port;
-        e.close((i) => t(r));
-      });
-    });
-  }
-  async getFreePortForPlatformaOnServer(t, e) {
-    const r = Gt(t, e.arch), { stdout: i, stderr: n } = await this.sshClient.exec(`${r}`);
-    if (n)
-      throw new Error(`getFreePortForPlatformaOnServer: stderr is not empty: ${n}, stdout: ${i}`);
-    return +i;
-  }
-  async getArch() {
-    const { stdout: t, stderr: e } = await this.sshClient.exec("uname -s && uname -m");
-    if (e)
-      throw new Error(`getArch: stderr is not empty: ${e}, stdout: ${t}`);
-    const r = t.split(`
-`);
-    return {
-      platform: r[0],
-      arch: r[1]
-    };
-  }
-  async getUserHomeDirectory() {
-    const { stdout: t, stderr: e } = await this.sshClient.exec("echo $HOME");
-    if (e) {
-      const r = `/home/${this.username}`;
-      return console.warn(`getUserHomeDirectory: stderr is not empty: ${e}, stdout: ${t}, will get a default home: ${r}`), r;
-    }
-    return t.trim();
-  }
-}
-const ie = {
-  useGlobalAccess: !1,
-  plBinary: {
-    type: "Download",
-    version: N()
-  }
-};
-async function ne(o, t) {
-  try {
-    const { stdout: e, stderr: r } = await t.exec("ldd --version | head -n 1");
-    if (r)
-      throw new Error(`Failed to check glibc version: ${r}`);
-    return oe(e);
-  } catch (e) {
-    throw o.error(`glibc version check failed: ${e}`), e;
-  }
-}
-function oe(o) {
-  const t = o.match(/\d+\.\d+/);
-  if (!t)
-    throw new Error(`Could not parse glibc version from: ${o}`);
-  return parseFloat(t[0]);
-}
-export {
-  Qt as ConnectionInfo,
-  Ot as LocalConfigYaml,
-  kt as LocalPl,
-  S as PortPair,
-  U as SshClient,
-  X as SshPl,
-  Yt as SshPlPorts,
-  N as getDefaultPlVersion,
-  Ee as localPlatformaInit,
-  Nt as mergeDefaultOps,
-  te as newConnectionInfo,
-  ee as parseConnectionInfo,
-  oe as parseGlibcVersion,
-  _t as plProcessOps,
-  re as stringifyConnectionInfo
-};
-//# sourceMappingURL=index.mjs.map