@milaboratories/pl-deployments 1.2.3 → 1.2.4

package/dist/index.mjs

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