@milaboratories/pl-deployments 2.3.3 → 2.4.1

package/dist/index.mjs

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