@milaboratories/pl-deployments 1.1.9 → 1.1.11

package/dist/index.mjs

@@ -1,45 +1,46 @@
-var q = Object.defineProperty;
-var Z = (s, t, r) => t in s ? q(s, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : s[t] = r;
-var w = (s, t, r) => Z(s, typeof t != "symbol" ? t + "" : t, r);
-import { spawn as V } from "node:child_process";
-import { sleep as F, fileExists as m, assertNever as _, notEmpty as p, RetryablePromise as Y } from "@milaboratories/ts-helpers";
-import A from "node:fs";
-import f, { readFile as Q } from "node:fs/promises";
+var V = Object.defineProperty;
+var Y = (s, r, t) => r in s ? V(s, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[r] = t;
+var w = (s, r, t) => Y(s, typeof r != "symbol" ? r + "" : r, t);
+import { spawn as Q } from "node:child_process";
+import { sleep as b, fileExists as g, assertNever as j, notEmpty as f, RetryablePromise as X } from "@milaboratories/ts-helpers";
+import D from "node:fs";
+import m, { readFile as tt } from "node:fs/promises";
 import d from "upath";
-import { request as X } from "undici";
-import { Readable as rr, Writable as tr } from "node:stream";
-import { text as er } from "node:stream/consumers";
-import * as ir from "tar";
-import or from "decompress";
-import C from "node:os";
-import sr, { Client as E } from "ssh2";
-import I from "node:net";
-import nr from "node:dns";
-import { randomBytes as D } from "node:crypto";
-import { generateSshPlConfigs as ar, getFreePort as y } from "@milaboratories/pl-config";
-function cr(s, t) {
+import { request as rt } from "undici";
+import { Readable as et, Writable as it } from "node:stream";
+import { text as ot } from "node:stream/consumers";
+import * as st from "tar";
+import nt from "decompress";
+import A from "node:os";
+import at, { Client as F } from "ssh2";
+import H from "node:net";
+import ct from "node:dns";
+import { randomBytes as k } from "node:crypto";
+import { generateSshPlConfigs as lt, getFreePort as P } from "@milaboratories/pl-config";
+import { z as p } from "zod";
+function ht(s, r) {
   return s.info(`Running:
-cmd: ${JSON.stringify([t.cmd, ...t.args])}
-wd: ${t.opts.cwd}`), s.info("  spawning child process"), V(t.cmd, t.args, t.opts);
+cmd: ${JSON.stringify([r.cmd, ...r.args])}
+wd: ${r.opts.cwd}`), s.info("  spawning child process"), Q(r.cmd, r.args, r.opts);
 }
-async function k(s) {
+async function x(s) {
   try {
     return process.kill(s, 0), !0;
   } catch {
     return !1;
   }
 }
-function j(s) {
+function J(s) {
   return process.kill(s, "SIGINT");
 }
-async function H(s, t) {
+async function M(s, r) {
   let e = 0;
-  for (; await k(s); )
-    if (await F(100), e += 100, e > t)
-      throw new Error(`The process did not stopped after ${t} ms.`);
+  for (; await x(s); )
+    if (await b(100), e += 100, e > r)
+      throw new Error(`The process did not stopped after ${r} ms.`);
 }
-const lr = ["linux", "macos", "windows"];
-function b(s) {
+const dt = ["linux", "macos", "windows"];
+function O(s) {
   switch (s.toLowerCase()) {
     case "darwin":
       return "macos";
@@ -49,12 +50,12 @@ function b(s) {
       return "windows";
     default:
       throw new Error(
-        `operating system '${s}' is not currently supported by Platforma ecosystem. The list of OSes supported: ` + JSON.stringify(lr)
+        `operating system '${s}' is not currently supported by Platforma ecosystem. The list of OSes supported: ` + JSON.stringify(dt)
       );
   }
 }
-const hr = ["amd64", "arm64"];
-function P(s) {
+const ut = ["amd64", "arm64"];
+function S(s) {
   switch (s) {
     case "aarch64":
     case "aarch64_be":
@@ -65,31 +66,31 @@ function P(s) {
       return "amd64";
     default:
       throw new Error(
-        `processor architecture '${s}' is not currently supported by Platforma ecosystem. The list of architectures supported: ` + JSON.stringify(hr)
+        `processor architecture '${s}' is not currently supported by Platforma ecosystem. The list of architectures supported: ` + JSON.stringify(ut)
       );
   }
 }
-const dr = "https://cdn.platforma.bio/software", ur = "https://cdn-ga.pl-open.science/software";
-async function wr(s, t, r, e, i, o) {
-  const n = M(r, e, t, P(i), b(o)), { archiveUrl: c, alternativeArchiveGAUrl: a, archivePath: l } = n;
+const wt = "https://cdn.platforma.bio/software", ft = "https://cdn-ga.pl-open.science/software";
+async function pt(s, r, t, e, i, o) {
+  const n = L(t, e, r, S(i), O(o)), { archiveUrl: c, alternativeArchiveGAUrl: a, archivePath: l } = n;
   try {
-    await v(s, c, l), n.wasDownloadedFrom = c;
+    await C(s, c, l), n.wasDownloadedFrom = c;
   } catch {
-    await v(s, a, l), n.wasDownloadedFrom = a;
+    await C(s, a, l), n.wasDownloadedFrom = a;
   }
   return n;
 }
-async function fr(s, t, r, e, i, o) {
-  const n = M(r, e, t, P(i), b(o)), { archiveUrl: c, alternativeArchiveGAUrl: a, archivePath: l, archiveType: h, targetFolder: u, baseName: g } = n;
+async function mt(s, r, t, e, i, o) {
+  const n = L(t, e, r, S(i), O(o)), { archiveUrl: c, alternativeArchiveGAUrl: a, archivePath: l, archiveType: h, targetFolder: u, baseName: y } = n;
   try {
-    await v(s, c, l), n.wasDownloadedFrom = c;
+    await C(s, c, l), n.wasDownloadedFrom = c;
   } catch {
-    await v(s, a, l), n.wasDownloadedFrom = a;
+    await C(s, a, l), n.wasDownloadedFrom = a;
   }
-  return await mr(s, l, h, u), n;
+  return await yt(s, l, h, u), n;
 }
-function M(s, t, r, e, i) {
-  const o = `${t}-${e}`, n = gr[i], c = `${o}.${n}`, a = `${dr}/${s}/${i}/${c}`, l = `${ur}/${s}/${i}/${c}`, h = d.join(r, c), u = d.join(r, o);
+function L(s, r, t, e, i) {
+  const o = `${r}-${e}`, n = $t[i], c = `${o}.${n}`, a = `${wt}/${s}/${i}/${c}`, l = `${ft}/${s}/${i}/${c}`, h = d.join(t, c), u = d.join(t, o);
   return {
     archiveUrl: a,
     alternativeArchiveGAUrl: l,
@@ -99,146 +100,146 @@ function M(s, t, r, e, i) {
     baseName: o
   };
 }
-async function v(s, t, r) {
+async function C(s, r, t) {
   const e = {};
-  e.dstArchive = r;
+  e.dstArchive = t;
   try {
-    if (e.fileExisted = await m(r), e.fileExisted)
-      return s.info(`Platforma Backend archive download skipped: '${r}' already exists`), e;
-    await f.mkdir(d.dirname(r), { recursive: !0 }), e.dirnameCreated = !0, s.info(`Downloading archive:
-  URL: ${t}
- Save to: ${r}`);
-    const { body: i, statusCode: o } = await X(t);
+    if (e.fileExisted = await g(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 rt(r);
     if (e.statusCode = o, o != 200) {
-      const n = await er(i);
+      const n = await ot(i);
       throw e.errorMsg = `failed to download archive: ${o}, response: ${n.slice(0, 1e3)}`, s.error(e.errorMsg), new Error(e.errorMsg);
     }
-    return e.tmpPath = r + ".tmp", await rr.toWeb(i).pipeTo(tr.toWeb(A.createWriteStream(e.tmpPath))), e.wroteTmp = !0, e.tmpExisted = await m(e.tmpPath), await f.rename(e.tmpPath, r), e.renamed = !0, e.newExisted = await m(r), e;
+    return e.tmpPath = t + ".tmp", await et.toWeb(i).pipeTo(it.toWeb(D.createWriteStream(e.tmpPath))), e.wroteTmp = !0, e.tmpExisted = await g(e.tmpPath), await m.rename(e.tmpPath, t), e.renamed = !0, e.newExisted = await g(t), e;
   } catch (i) {
     const o = `downloadArchive: error ${JSON.stringify(i)} occurred, state: ${JSON.stringify(e)}`;
     throw s.error(o), new Error(o);
   }
 }
-const pr = ".ok";
-async function mr(s, t, r, e) {
-  if (s.info("extracting archive..."), s.info(`  archive path: '${t}'`), s.info(`  target dir: '${e}'`), !await m(t)) {
-    const o = `Platforma Backend binary archive not found at '${t}'`;
+const gt = ".ok";
+async function yt(s, r, t, e) {
+  if (s.info("extracting archive..."), s.info(`  archive path: '${r}'`), s.info(`  target dir: '${e}'`), !await g(r)) {
+    const o = `Platforma Backend binary archive not found at '${r}'`;
     throw s.error(o), new Error(o);
   }
-  const i = d.join(e, pr);
-  if (await m(i)) {
+  const i = d.join(e, gt);
+  if (await g(i)) {
     s.info(`Platforma Backend binaries unpack skipped: '${e}' exists`);
     return;
   }
-  switch (await m(e) && (s.info(`Removing previous incompletely unpacked folder: '${e}'`), await f.rm(e, { recursive: !0 })), s.info(`  creating target dir '${e}'`), await f.mkdir(e, { recursive: !0 }), s.info(
+  switch (await g(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(
     `Unpacking Platforma Backend archive:
-  Archive:   ${t}
+  Archive:   ${r}
   Target dir: ${e}`
-  ), r) {
+  ), t) {
     case "tgz":
-      await ir.x({
-        file: t,
+      await st.x({
+        file: r,
         cwd: e,
         gzip: !0
       });
       break;
     case "zip":
-      await or(t, e);
+      await nt(r, e);
       break;
     default:
-      _(r);
+      j(t);
   }
-  await f.writeFile(i, "ok"), s.info("  ... unpack done.");
+  await m.writeFile(i, "ok"), s.info("  ... unpack done.");
 }
-const gr = {
+const $t = {
   linux: "tgz",
   macos: "tgz",
   windows: "zip"
 };
-function x() {
+function R() {
   return "1.18.3";
 }
-function yr() {
-  return { type: "Download", version: x() };
+function Pt() {
+  return { type: "Download", version: R() };
 }
-async function $r(s, t, r) {
-  switch (r.type) {
+async function vt(s, r, t) {
+  switch (t.type) {
     case "Download":
-      const e = await fr(s, t, "pl", `pl-${r.version}`, C.arch(), C.platform());
-      return d.join(e.baseName, "binaries", Pr[b(C.platform())]);
+      const e = await mt(s, r, "pl", `pl-${t.version}`, A.arch(), A.platform());
+      return d.join(e.baseName, "binaries", St[O(A.platform())]);
     case "Local":
-      return r.path;
+      return t.path;
     default:
-      _(r);
+      j(t);
   }
 }
-const Pr = {
+const St = {
   linux: "platforma",
   macos: "platforma",
   windows: "platforma.exe"
 };
-function J(s) {
+function G(s) {
   return d.join(s, "pl_pid");
 }
-async function vr(s) {
-  if (!await m(s))
+async function Ct(s) {
+  if (!await g(s))
     return;
-  const t = await f.readFile(s);
-  return Number(t.toString());
+  const r = await m.readFile(s);
+  return Number(r.toString());
 }
-async function Sr(s, t) {
-  await f.writeFile(s, JSON.stringify(t));
+async function Et(s, r) {
+  await m.writeFile(s, JSON.stringify(r));
 }
-function Cr() {
+function At() {
   return {};
 }
-function Er(s, t, r) {
-  return s[t] = r, r;
+function Ft(s, r, t) {
+  return s[r] = t, t;
 }
-async function O(s, t) {
-  const r = Cr();
+async function N(s, r) {
+  const t = At();
   try {
-    return await t((i, o) => Er(r, i, o), r);
+    return await r((i, o) => Ft(t, i, o), t);
   } catch (e) {
-    throw s.error(`error ${e} while doing traced operation, state: ${JSON.stringify(r)}`), e;
+    throw s.error(`error ${e} while doing traced operation, state: ${JSON.stringify(t)}`), e;
   }
 }
-const Fr = "config-local.yaml";
-class Ar {
-  constructor(t, r, e, i, o, n, c, a) {
+const bt = "config-local.yaml";
+class Dt {
+  constructor(r, t, e, i, o, n, c, a) {
     w(this, "instance");
     w(this, "pid");
     w(this, "nRuns", 0);
     w(this, "lastRunHistory", {});
     w(this, "wasStopped", !1);
-    this.logger = t, this.workingDir = r, this.startOptions = e, this.initialStartHistory = i, this.onClose = o, this.onError = n, this.onCloseAndError = c, this.onCloseAndErrorNoStop = a;
+    this.logger = r, this.workingDir = t, this.startOptions = e, this.initialStartHistory = i, this.onClose = o, this.onError = n, this.onCloseAndError = c, this.onCloseAndErrorNoStop = a;
   }
   async start() {
-    await O(this.logger, async (t, r) => {
+    await N(this.logger, async (r, t) => {
       this.wasStopped = !1;
-      const e = cr(this.logger, this.startOptions);
+      const e = ht(this.logger, this.startOptions);
       e.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", () => {
         this.logger.warn(`platforma was closed, started opts: ${JSON.stringify(this.debugInfo())}`), this.onClose !== void 0 && this.onClose(this), this.onCloseAndError !== void 0 && this.onCloseAndError(this), this.onCloseAndErrorNoStop !== void 0 && !this.wasStopped && this.onCloseAndErrorNoStop(this);
-      }), t("started", !0);
-      const i = t("pidFile", J(this.workingDir));
-      t("pid", p(e.pid)), t("pidWritten", await Sr(i, p(e.pid))), this.nRuns++, this.instance = e, this.pid = e.pid, this.lastRunHistory = r;
+      }), r("started", !0);
+      const i = r("pidFile", G(this.workingDir));
+      r("pid", f(e.pid)), r("pidWritten", await Et(i, f(e.pid))), this.nRuns++, this.instance = e, this.pid = e.pid, this.lastRunHistory = t;
     });
   }
   stop() {
-    this.wasStopped = !0, j(p(this.pid));
+    this.wasStopped = !0, J(f(this.pid));
   }
   async waitStopped() {
-    await H(p(this.pid), 15e3);
+    await M(f(this.pid), 15e3);
   }
   stopped() {
     return this.wasStopped;
   }
   async isAlive() {
-    return await k(p(this.pid));
+    return await x(f(this.pid));
   }
   debugInfo() {
     return {
@@ -251,20 +252,20 @@ class Ar {
     };
   }
 }
-async function st(s, t) {
-  const r = {
-    plBinary: yr(),
+async function fr(s, r) {
+  const t = {
+    plBinary: Pt(),
     spawnOptions: {},
     closeOld: !0,
-    ...t
+    ...r
   };
-  return await O(s, async (e, i) => {
-    e("startOptions", { ...r, config: "too wordy" });
-    const o = d.resolve(r.workingDir);
-    r.closeOld && e("closeOld", await Dr(s, o));
-    const n = d.join(o, Fr);
-    s.info(`writing configuration '${n}'...`), await f.writeFile(n, r.config);
-    const c = d.join(o, "binaries"), a = await $r(s, c, r.plBinary), h = {
+  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, bt);
+    s.info(`writing configuration '${n}'...`), await m.writeFile(n, t.config);
+    const c = d.join(o, "binaries"), a = await vt(s, c, t.plBinary), h = {
       cmd: e("binaryPath", d.join("binaries", a)),
       args: ["-config", n],
       opts: {
@@ -273,7 +274,7 @@ async function st(s, t) {
         stdio: ["pipe", "ignore", "inherit"],
         windowsHide: !0,
         // hide a terminal on Windows
-        ...r.spawnOptions
+        ...t.spawnOptions
       }
     };
     e("processOpts", {
@@ -281,80 +282,80 @@ async function st(s, t) {
       args: h.args,
       cwd: h.opts.cwd
     });
-    const u = new Ar(
+    const u = new Dt(
       s,
-      r.workingDir,
+      t.workingDir,
       h,
       i,
-      r.onClose,
-      r.onError,
-      r.onCloseAndError,
-      r.onCloseAndErrorNoStop
+      t.onClose,
+      t.onError,
+      t.onCloseAndError,
+      t.onCloseAndErrorNoStop
     );
     return await u.start(), u;
   });
 }
-async function Dr(s, t) {
-  return await O(s, async (r, e) => {
-    const i = r("pidFilePath", J(t)), o = r("pid", await vr(i)), n = r("wasAlive", await k(o));
-    return o !== void 0 && n && (r("stopped", j(o)), r("waitStopped", await H(o, 1e4))), e;
+async function kt(s, r) {
+  return await N(s, async (t, e) => {
+    const i = t("pidFilePath", G(r)), o = t("pid", await Ct(i)), n = t("wasAlive", await x(o));
+    return o !== void 0 && n && (t("stopped", J(o)), t("waitStopped", await M(o, 1e4))), e;
   });
 }
-const kr = {
+const xt = {
   keepaliveInterval: 6e4,
   keepaliveCountMax: 10
 };
-class R {
-  constructor(t, r) {
+class U {
+  constructor(r, t) {
     w(this, "config");
     w(this, "homeDir");
     w(this, "forwardedServers", []);
-    this.logger = t, this.client = r;
+    this.logger = r, this.client = t;
   }
   /**
    * Initializes the SshClient and establishes a connection using the provided configuration.
    * @param config - The connection configuration object for the SSH client.
    * @returns A new instance of SshClient with an active connection.
    */
-  static async init(t, r) {
+  static async init(r, t) {
     const e = {
-      ...kr,
-      ...r
-    }, i = new R(t, new E());
+      ...xt,
+      ...t
+    }, i = new U(r, new F());
     return await i.connect(e), i;
   }
   getForwardedServers() {
     return this.forwardedServers;
   }
   getFullHostName() {
-    var t, r;
-    return `${(t = this.config) == null ? void 0 : t.host}:${(r = this.config) == null ? void 0 : r.port}`;
+    var r, t;
+    return `${(r = this.config) == null ? void 0 : r.host}:${(t = this.config) == null ? void 0 : t.port}`;
   }
   getUserName() {
-    var t;
-    return (t = this.config) == null ? void 0 : t.username;
+    var r;
+    return (r = this.config) == null ? void 0 : r.username;
   }
   /**
    * Connects to the SSH server using the specified configuration.
    * @param config - The connection configuration object for the SSH client.
    * @returns A promise that resolves when the connection is established or rejects on error.
    */
-  async connect(t) {
-    return this.config = t, await br(this.client, t);
+  async connect(r) {
+    return this.config = r, await Ot(this.client, r);
   }
   /**
    * Executes a command on the SSH server.
    * @param command - The command to execute on the remote server.
    * @returns A promise resolving with the command's stdout and stderr outputs.
    */
-  async exec(t) {
-    return new Promise((r, e) => {
-      this.client.exec(t, (i, o) => {
+  async exec(r) {
+    return new Promise((t, e) => {
+      this.client.exec(r, (i, o) => {
         if (i)
-          return e(`ssh.exec: ${t}, error occurred: ${i}`);
+          return e(`ssh.exec: ${r}, error occurred: ${i}`);
         let n = "", c = "";
         o.on("close", (a) => {
-          a === 0 ? r({ stdout: n, stderr: c }) : e(new Error(`Command ${t} exited with code ${a}`));
+          a === 0 ? t({ stdout: n, stderr: c }) : e(new Error(`Command ${r} exited with code ${a}`));
         }).on("data", (a) => {
           n += a.toString();
         }).stderr.on("data", (a) => {
@@ -369,10 +370,10 @@ class R {
    * @param port - The port number to connect to on the server.
    * @returns 'publickey' | 'password'[] A promise resolving with a list of supported authentication methods.
    */
-  static async getAuthTypes(t, r) {
+  static async getAuthTypes(r, t) {
     return new Promise((e) => {
       let i = "";
-      const o = new E();
+      const o = new F();
       o.on("ready", () => {
         o.end();
         const n = this.extractAuthMethods(i);
@@ -380,8 +381,8 @@ class R {
       }), o.on("error", () => {
         o.end(), e(["publickey", "password"]);
       }), o.connect({
-        host: t,
-        port: r,
+        host: r,
+        port: t,
         username: (/* @__PURE__ */ new Date()).getTime().toString(),
         debug: (n) => {
           i += `${n}
@@ -395,9 +396,9 @@ class R {
    * @param log - The debug log output containing authentication information.
    * @returns An array of extracted authentication methods.
    */
-  static extractAuthMethods(t) {
-    const r = t.match(/Inbound: Received USERAUTH_FAILURE \((.+)\)/);
-    return r && r[1] ? r[1].split(",").map((e) => e.trim()) : [];
+  static extractAuthMethods(r) {
+    const t = r.match(/Inbound: Received USERAUTH_FAILURE \((.+)\)/);
+    return t && t[1] ? t[1].split(",").map((e) => e.trim()) : [];
   }
   /**
    * Sets up port forwarding between a remote port on the SSH server and a local port.
@@ -406,61 +407,61 @@ class R {
    * @param config - Optional connection configuration for the SSH client.
    * @returns { server: net.Server } A promise resolving with the created server instance.
    */
-  async forwardPort(t, r) {
-    const e = `ssh.forward:${t.localPort}:${t.remotePort}.id_${D(1).toString("hex")}`;
-    r = r ?? this.config;
-    const i = new Y((o) => new Promise((n, c) => {
-      const a = new E();
+  async forwardPort(r, t) {
+    const e = `ssh.forward:${r.localPort}:${r.remotePort}.id_${k(1).toString("hex")}`;
+    t = t ?? this.config;
+    const i = new X((o) => new Promise((n, c) => {
+      const a = new F();
       a.on("ready", () => {
         this.logger.info(`${e}.client.ready`), n(a);
       }), a.on("error", (l) => {
         this.logger.info(`${e}.client.error: ${l}`), o.reset(), c(l);
       }), a.on("close", () => {
         this.logger.info(`${e}.client.closed`), o.reset();
-      }), a.connect(r);
+      }), a.connect(t);
     }));
     return await i.ensure(), new Promise((o, n) => {
-      const c = I.createServer({ pauseOnConnect: !0 }, async (a) => {
-        const l = `${e}.sock_${D(1).toString("hex")}`;
+      const c = H.createServer({ pauseOnConnect: !0 }, async (a) => {
+        const l = `${e}.sock_${k(1).toString("hex")}`;
         let h;
         try {
           h = await i.ensure();
-        } catch (g) {
-          this.logger.info(`${l}.persistentClient.catch: ${g}`), a.end();
+        } catch (y) {
+          this.logger.info(`${l}.persistentClient.catch: ${y}`), a.end();
           return;
         }
         let u;
         try {
-          u = await xr(this.logger, h, "127.0.0.1", 0, "127.0.0.1", t.remotePort);
-        } catch (g) {
-          this.logger.error(`${l}.forwardOut.err: ${g}`), a.end();
+          u = await Rt(this.logger, h, "127.0.0.1", 0, "127.0.0.1", r.remotePort);
+        } catch (y) {
+          this.logger.error(`${l}.forwardOut.err: ${y}`), a.end();
           return;
         }
-        a.pipe(u), u.pipe(a), a.resume(), u.on("error", (g) => {
-          this.logger.error(`${l}.stream.error: ${g}`), a.end(), u.end();
+        a.pipe(u), u.pipe(a), a.resume(), u.on("error", (y) => {
+          this.logger.error(`${l}.stream.error: ${y}`), a.end(), u.end();
         }), u.on("close", () => {
           a.end(), u.end();
         }), a.on("close", () => {
           this.logger.info(`${l}.localSocket: closed`), a.end(), u.end();
         });
       });
-      c.listen(t.localPort, "127.0.0.1", () => {
+      c.listen(r.localPort, "127.0.0.1", () => {
         this.logger.info(`${e}.server: started listening`), this.forwardedServers.push(c), o({ server: c });
       }), c.on("error", (a) => {
         c.close(), n(new Error(`${e}.server: error: ${JSON.stringify(a)}`));
       }), c.on("close", () => {
-        this.logger.info(`${e}.server: closed ${JSON.stringify(t)}`), this.forwardedServers = this.forwardedServers.filter((a) => a !== c);
+        this.logger.info(`${e}.server: closed ${JSON.stringify(r)}`), this.forwardedServers = this.forwardedServers.filter((a) => a !== c);
       });
     });
   }
   closeForwardedPorts() {
-    this.logger.info("[SSH] Closing all forwarded ports..."), this.forwardedServers.forEach((t) => {
-      const r = t.address();
-      if (r && typeof r != "string") {
-        const e = r;
+    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}`);
       }
-      t.close();
+      r.close();
     }), this.forwardedServers = [];
   }
   /**
@@ -468,10 +469,10 @@ class R {
   * @param hostname - The hostname or IP address to check.
   * @returns A promise resolving with `true` if the host is reachable, otherwise `false`.
   */
-  static async checkHostAvailability(t) {
-    return new Promise((r) => {
-      nr.lookup(t, (e) => {
-        r(!e);
+  static async checkHostAvailability(r) {
+    return new Promise((t) => {
+      ct.lookup(r, (e) => {
+        t(!e);
       });
     });
   }
@@ -480,10 +481,10 @@ class R {
    * @param privateKey - The private key content to check.
    * @returns A promise resolving with `true` if a passphrase is required, otherwise `false`.
    */
-  static async isPassphraseRequiredForKey(t) {
-    return new Promise((r, e) => {
+  static async isPassphraseRequiredForKey(r) {
+    return new Promise((t, e) => {
       try {
-        return sr.utils.parseKey(t) instanceof Error && r(!0), r(!1);
+        return at.utils.parseKey(r) instanceof Error && t(!0), t(!1);
       } catch (i) {
         console.log("Error parsing privateKey"), e(new Error(`ssh.isPassphraseRequiredForKey: err ${i}`));
       }
@@ -496,12 +497,12 @@ class R {
    * @param remotePath - The remote file path on the server.
    * @returns A promise resolving with `true` if the file was successfully uploaded.
    */
-  async uploadFile(t, r) {
+  async uploadFile(r, t) {
     return await this.withSftp(async (e) => new Promise((i, o) => {
-      e.fastPut(t, r, (n) => {
+      e.fastPut(r, t, (n) => {
         if (n) {
           const c = new Error(
-            `ssh.uploadFile: err: ${n}, localPath: ${t}, remotePath: ${r}`
+            `ssh.uploadFile: err: ${n}, localPath: ${r}, remotePath: ${t}`
           );
           return o(c);
         }
@@ -509,17 +510,12 @@ class R {
       });
     }));
   }
-  delay(t) {
-    return new Promise((r, e) => {
-      setTimeout(() => r(), t);
-    });
-  }
-  async withSftp(t) {
-    return new Promise((r, e) => {
+  async withSftp(r) {
+    return new Promise((t, e) => {
       this.client.sftp((i, o) => {
         if (i)
           return e(new Error(`ssh.withSftp: sftp err: ${i}`));
-        t(o).then(r).catch((n) => {
+        r(o).then(t).catch((n) => {
           e(new Error(`ssh.withSftp.callback: err ${n}`));
         }).finally(() => {
           o == null || o.end();
@@ -527,20 +523,20 @@ class R {
       });
     });
   }
-  async writeFileOnTheServer(t, r, e = 432) {
-    return this.withSftp(async (i) => this.writeFile(i, t, r, e));
+  async writeFileOnTheServer(r, t, e = 432) {
+    return this.withSftp(async (i) => this.writeFile(i, r, t, e));
   }
-  async getForderStructure(t, r, e = { files: [], directories: [] }) {
+  async getForderStructure(r, t, e = { files: [], directories: [] }) {
     return new Promise((i, o) => {
-      t.readdir(r, async (n, c) => {
+      r.readdir(t, async (n, c) => {
         if (n)
           return o(n);
         for (const a of c) {
-          const l = `${r}/${a.filename}`;
+          const l = `${t}/${a.filename}`;
           if (a.attrs.isDirectory()) {
             e.directories.push(l);
             try {
-              await this.getForderStructure(t, l, e);
+              await this.getForderStructure(r, l, e);
             } catch (h) {
               return o(h);
             }
@@ -551,60 +547,60 @@ class R {
       });
     });
   }
-  rmdir(t, r) {
+  rmdir(r, t) {
     return new Promise((e, i) => {
-      t.rmdir(r, (o) => o ? i(o) : e(!0));
+      r.rmdir(t, (o) => o ? i(o) : e(!0));
     });
   }
-  unlink(t, r) {
+  unlink(r, t) {
     return new Promise((e, i) => {
-      t.unlink(r, (o) => o ? i(o) : e(!0));
+      r.unlink(t, (o) => o ? i(o) : e(!0));
     });
   }
-  async deleteFolder(t) {
-    return this.withSftp(async (r) => {
+  async deleteFolder(r) {
+    return this.withSftp(async (t) => {
       try {
-        const e = await this.getForderStructure(r, t);
+        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(r, i);
+          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(r, i);
-        return await this.rmdir(r, t), !0;
+          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: ${t}, message: ${i}`);
+        throw new Error(`ssh.deleteFolder: path: ${r}, message: ${i}`);
       }
     });
   }
-  async readFile(t) {
-    return this.withSftp(async (r) => new Promise((e, i) => {
-      r.readFile(t, (o, n) => {
+  async readFile(r) {
+    return this.withSftp(async (t) => new Promise((e, i) => {
+      t.readFile(r, (o, n) => {
         if (o)
           return i(new Error(`ssh.readFile: err occurred ${o}`));
         e(n.toString());
       });
     }));
   }
-  async chmod(t, r) {
+  async chmod(r, t) {
     return this.withSftp(async (e) => new Promise((i, o) => {
-      e.chmod(t, r, (n) => n ? o(new Error(`ssh.chmod: ${n}, path: ${t}, mode: ${r}`)) : i(void 0));
+      e.chmod(r, t, (n) => n ? o(new Error(`ssh.chmod: ${n}, path: ${r}, mode: ${t}`)) : i(void 0));
     }));
   }
-  async checkFileExists(t) {
-    return this.withSftp(async (r) => new Promise((e, i) => {
-      r.stat(t, (o, n) => {
+  async checkFileExists(r) {
+    return this.withSftp(async (t) => new Promise((e, i) => {
+      t.stat(r, (o, n) => {
         if (o)
-          return o.code === 2 ? e(!1) : i(new Error(`ssh.checkFileExists: err ${o}`));
+          return (o == null ? void 0 : o.code) === 2 ? e(!1) : i(new Error(`ssh.checkFileExists: err ${o}`));
         e(n.isFile());
       });
     }));
   }
-  async checkPathExists(t) {
-    return this.withSftp(async (r) => new Promise((e, i) => {
-      r.stat(t, (o, n) => {
+  async checkPathExists(r) {
+    return this.withSftp(async (t) => new Promise((e, i) => {
+      t.stat(r, (o, n) => {
         if (o)
           return o.code === 2 ? e({ exists: !1, isFile: !1, isDirectory: !1 }) : i(new Error(`ssh.checkPathExists: ${o}`));
         e({
@@ -615,19 +611,19 @@ class R {
       });
     }));
   }
-  async writeFile(t, r, e, i = 432) {
+  async writeFile(r, t, e, i = 432) {
     return new Promise((o, n) => {
-      t.writeFile(r, e, { mode: i }, (c) => {
+      r.writeFile(t, e, { mode: i }, (c) => {
         if (c)
-          return n(new Error(`ssh.writeFile: err ${c}, remotePath: ${r}`));
+          return n(new Error(`ssh.writeFile: err ${c}, remotePath: ${t}`));
         o(!0);
       });
     });
   }
-  uploadFileUsingExistingSftp(t, r, e, i = 432) {
+  uploadFileUsingExistingSftp(r, t, e, i = 432) {
     return new Promise((o, n) => {
-      Q(r).then(async (c) => {
-        this.writeFile(t, e, c, i).then(() => {
+      tt(t).then(async (c) => {
+        this.writeFile(r, e, c, i).then(() => {
           o(void 0);
         }).catch((a) => {
           const l = `uploadFileUsingExistingSftp: error ${a} occurred`;
@@ -636,16 +632,16 @@ class R {
       });
     });
   }
-  async __uploadDirectory(t, r, e, i = 432) {
+  async __uploadDirectory(r, t, e, i = 432) {
     return new Promise((o, n) => {
-      A.readdir(r, async (c, a) => {
+      D.readdir(t, async (c, a) => {
         if (c)
-          return n(new Error(`ssh.__uploadDir: err ${c}, localDir: ${r}, remoteDir: ${e}`));
+          return n(new Error(`ssh.__uploadDir: err ${c}, localDir: ${t}, remoteDir: ${e}`));
         try {
-          await this.__createRemoteDirectory(t, e);
+          await this.__createRemoteDirectory(r, e);
           for (const l of a) {
-            const h = d.join(r, l), u = `${e}/${l}`;
-            A.lstatSync(h).isDirectory() ? await this.__uploadDirectory(t, h, u, i) : await this.uploadFileUsingExistingSftp(t, h, u, i);
+            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);
           }
           o();
         } catch (l) {
@@ -661,10 +657,14 @@ class R {
    * @param remoteDir - The path to the remote directory on the server.
    * @returns A promise that resolves when the directory and its contents are uploaded.
    */
-  async uploadDirectory(t, r, e = 432) {
+  async uploadDirectory(r, t, e = 432) {
     return new Promise((i, o) => {
       this.withSftp(async (n) => {
-        await this.__uploadDirectory(n, t, r, e), i();
+        try {
+          await this.__uploadDirectory(n, r, t, e), i();
+        } catch (c) {
+          o(new Error(`ssh.uploadDirectory: ${c}`));
+        }
       });
     });
   }
@@ -674,17 +674,17 @@ class R {
    * @param remotePath - The path to the remote directory.
    * @returns A promise that resolves when the directory is created.
    */
-  __createRemoteDirectory(t, r) {
+  __createRemoteDirectory(r, t) {
     return new Promise((e, i) => {
-      const o = r.split("/");
+      const o = t.split("/");
       let n = "";
       const c = (a) => {
         if (a >= o.length)
           return e();
-        n += `${o[a]}/`, t.stat(n, (l) => {
-          l ? t.mkdir(n, (h) => {
+        n += `${o[a]}/`, r.stat(n, (l) => {
+          l ? r.mkdir(n, (h) => {
             if (h)
-              return i(new Error(`ssh.__createRemDir: err ${h}, remotePath: ${r}`));
+              return i(new Error(`ssh.__createRemDir: err ${h}, remotePath: ${t}`));
             c(a + 1);
           }) : c(a + 1);
         });
@@ -698,9 +698,9 @@ class R {
    * @param remotePath - The path to the remote directory.
    * @returns A promise that resolves when the directory is created.
    */
-  createRemoteDirectory(t, r = 493) {
+  createRemoteDirectory(r, t = 493) {
     return this.withSftp(async (e) => {
-      const i = t.split("/");
+      const i = r.split("/");
       let o = "";
       for (const n of i) {
         o += `${n}/`;
@@ -708,9 +708,9 @@ class R {
           await new Promise((c, a) => {
             e.stat(o, (l) => {
               if (!l) return c();
-              e.mkdir(o, { mode: r }, (h) => {
+              e.mkdir(o, { mode: t }, (h) => {
                 if (h)
-                  return a(new Error(`ssh.createRemoteDir: err ${h}, remotePath: ${t}`));
+                  return a(new Error(`ssh.createRemoteDir: err ${h}, remotePath: ${r}`));
                 c();
               });
             });
@@ -727,11 +727,11 @@ class R {
    * @param localPath - The local file path to save the file.
    * @returns A promise resolving with `true` if the file was successfully downloaded.
    */
-  async downloadFile(t, r) {
+  async downloadFile(r, t) {
     return this.withSftp(async (e) => new Promise((i, o) => {
-      e.fastGet(t, r, (n) => {
+      e.fastGet(r, t, (n) => {
         if (n)
-          return o(new Error(`ssh.downloadFile: err ${n}, remotePath: ${t}, localPath: ${r}`));
+          return o(new Error(`ssh.downloadFile: err ${n}, remotePath: ${r}, localPath: ${t}`));
         i(!0);
       });
     }));
@@ -743,80 +743,87 @@ class R {
     this.closeForwardedPorts(), this.client.end();
   }
 }
-async function br(s, t, r, e) {
+async function Ot(s, r, t, e) {
   return new Promise((i, o) => {
     s.on("ready", () => {
       i(s);
     }), s.on("error", (n) => {
       o(new Error(`ssh.connect: error occurred: ${n}`));
     }), s.on("close", () => {
-    }), s.connect(t);
+    }), s.connect(r);
   });
 }
-async function xr(s, t, r, e, i, o) {
+async function Rt(s, r, t, e, i, o) {
   return new Promise((n, c) => {
-    t.forwardOut(r, e, i, o, (a, l) => a ? (s.error(`forwardOut.error: ${a}`), c(a)) : n(l));
+    r.forwardOut(t, e, i, o, (a, l) => a ? (s.error(`forwardOut.error: ${a}`), c(a)) : n(l));
   });
 }
-const Or = "minio-2024-12-18T13-15-44Z", Rr = "supervisord-0.7.3", Ur = "supervisord_0.7.3_Linux_64-bit";
+const Nt = "minio-2024-12-18T13-15-44Z", Ut = "supervisord-0.7.3", Bt = "supervisord_0.7.3_Linux_64-bit";
 function $(s) {
-  return d.join(s, "platforma_ssh");
+  return d.join(s, ".platforma_ssh");
 }
-function S(s) {
-  return d.join(s, "platforma_ssh", "binaries");
+function E(s) {
+  return d.join($(s), "binaries");
 }
-function Nr(s, t) {
-  return d.join(S(s), `pl-${x()}-${P(t)}`);
+function Tt(s, r) {
+  return d.join(E(s), `pl-${R()}-${S(r)}`);
 }
-function L(s, t) {
-  return d.join(Nr(s, t), "binaries");
+function W(s, r) {
+  return d.join(Tt(s, r), "binaries");
 }
-function N(s, t) {
-  return d.join(L(s, t), "platforma");
+function T(s, r) {
+  return d.join(W(s, r), "platforma");
 }
-function Br(s, t) {
-  return d.join(L(s, t), "free-port");
+function It(s, r) {
+  return d.join(W(s, r), "free-port");
 }
-function W(s, t) {
-  return d.join(S(s), `minio-2024-12-18T13-15-44Z-${P(t)}`);
+function z(s, r) {
+  return d.join(E(s), `minio-2024-12-18T13-15-44Z-${S(r)}`);
 }
-function Tr(s, t) {
-  return d.join(W(s, t), "minio");
+function _t(s, r) {
+  return d.join(z(s, r), "minio");
 }
-function _r(s, t) {
-  return d.join(S(s), `supervisord-0.7.3-${P(t)}`, Ur);
+function jt(s, r) {
+  return d.join(E(s), `supervisord-0.7.3-${S(r)}`, Bt);
 }
-function z(s, t) {
-  return d.join(_r(s, t), "supervisord");
+function K(s, r) {
+  return d.join(jt(s, r), "supervisord");
 }
-function G(s) {
+function q(s) {
   return d.join($(s), "supervisor.conf");
 }
-function B(s) {
+function I(s) {
   return d.join($(s), "connection.txt");
 }
-async function Ir(s, t, r) {
-  const e = await U(s, t, r, "--daemon");
+async function Ht(s, r, t) {
+  const e = await B(s, r, t, "--daemon");
   if (e.stderr)
     throw new Error(`Can not run ssh Platforma ${e.stderr}`);
 }
-async function jr(s, t, r) {
-  const e = await U(s, t, r, "ctl shutdown");
+async function Jt(s, r, t) {
+  const e = await B(s, r, t, "ctl shutdown");
   if (e.stderr)
     throw new Error(`Can not stop ssh Platforma ${e.stderr}`);
 }
-async function Hr(s, t, r, e) {
-  const i = await U(t, r, e, "ctl status");
+async function Mt(s, r, t, e) {
+  let i;
+  try {
+    i = await B(r, t, e, "ctl status");
+  } catch (a) {
+    return { execError: String(a), allAlive: !1 };
+  }
   if (i.stderr)
-    return s.info(`supervisord ctl status: stderr occurred: ${i.stderr}, stdout: ${i.stdout}`), !1;
-  const o = {
-    platforma: T(i.stdout, "platforma"),
-    minio: T(i.stdout, "minio")
+    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"), c = {
+    rawResult: i,
+    platforma: o,
+    minio: n,
+    allAlive: o && n
   };
-  return o.platforma && o.minio ? !0 : (o.minio || s.warn("Minio is not running on the server"), o.platforma || s.warn("Platforma is not running on the server"), !1);
+  return c.allAlive || (c.minio || s.warn("Minio is not running on the server"), c.platforma || s.warn("Platforma is not running on the server")), c;
 }
-function Mr(s, t, r, e, i, o, n) {
-  const c = Object.entries(t).map(([h, u]) => `${h}="${u}"`).join(","), a = D(16).toString("hex"), l = r;
+function Lt(s, r, t, e, i, o, n) {
+  const c = Object.entries(r).map(([h, u]) => `${h}="${u}"`).join(","), a = k(16).toString("hex"), l = t;
   return `
 [supervisord]
 logfile=${e}/supervisord.log
@@ -848,21 +855,52 @@ directory=${e}
 autorestart=true
 `;
 }
-async function U(s, t, r, e) {
-  const i = z(t, r), o = G(t), n = `${i} --configuration ${o} ${e}`;
+async function B(s, r, t, e) {
+  const i = K(r, t), o = q(r), n = `${i} --configuration ${o} ${e}`;
   return await s.exec(n);
 }
-function T(s, t) {
+function _(s, r) {
   return ((i) => i.replace(/\x1B\[[0-9;]*m/g, ""))(s).split(`
 `).some((i) => {
     const [o, n] = i.trim().split(/\s{2,}/);
-    return o === t && n === "Running";
+    return o === r && n === "Running";
   });
 }
-class K {
-  constructor(t, r, e) {
+const v = p.object({
+  local: p.number(),
+  remote: p.number()
+}), Gt = p.object({
+  grpc: v,
+  monitoring: v,
+  debug: v,
+  minioPort: v,
+  minioConsolePort: v
+}), Wt = p.object({
+  plUser: p.string(),
+  plPassword: p.string(),
+  ports: Gt,
+  // 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)
+});
+function zt(s, r, t, e) {
+  return {
+    plUser: s,
+    plPassword: r,
+    ports: t,
+    useGlobalAccess: e
+  };
+}
+function Kt(s) {
+  return Wt.parse(JSON.parse(s));
+}
+function qt(s) {
+  return JSON.stringify(s, void 0, 2);
+}
+class Z {
+  constructor(r, t, e) {
     w(this, "initState", {});
-    this.logger = t, this.sshClient = r, this.username = e;
+    this.logger = r, this.sshClient = t, this.username = e;
   }
   info() {
     return {
@@ -870,142 +908,157 @@ class K {
       initState: this.initState
     };
   }
-  static async init(t, r) {
+  static async init(r, t) {
     try {
-      const e = await R.init(t, r);
-      return new K(t, e, p(r.username));
+      const e = await U.init(r, t);
+      return new Z(r, e, f(t.username));
     } catch (e) {
-      throw t.error(`Connection error in SshClient.init: ${e}`), e;
+      throw r.error(`Connection error in SshClient.init: ${e}`), e;
     }
   }
   cleanUp() {
     this.sshClient.close();
   }
+  /** Provides an info if the platforma and minio are running along with the debug info. */
   async isAlive() {
-    const t = await this.getArch(), r = await this.getUserHomeDirectory();
-    try {
-      return await Hr(this.logger, this.sshClient, r, t.arch);
-    } catch {
-      return !1;
-    }
+    const r = await this.getArch(), t = await this.getUserHomeDirectory();
+    return await Mt(this.logger, this.sshClient, t, r.arch);
   }
+  /** Starts all the services on the server.
+    * Idempotent semantic: we could call it several times. */
   async start() {
-    const t = await this.getArch(), r = await this.getUserHomeDirectory();
+    const r = await this.getArch(), t = await this.getUserHomeDirectory();
     try {
-      return await Ir(this.sshClient, r, t.arch), await this.checkIsAliveWithInterval();
+      if (!(await this.isAlive()).allAlive)
+        return await Ht(this.sshClient, t, r.arch), await this.checkIsAliveWithInterval();
     } catch (e) {
-      const i = `ssh.start: error occurred ${e}`;
+      const i = `SshPl.start: error occurred ${e}`;
       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 t = await this.getArch(), r = await this.getUserHomeDirectory();
+    const r = await this.getArch(), t = await this.getUserHomeDirectory();
     try {
-      return await jr(this.sshClient, r, t.arch), await this.checkIsAliveWithInterval(void 0, void 0, !1);
+      if ((await this.isAlive()).allAlive)
+        return await Jt(this.sshClient, t, r.arch), await this.checkIsAliveWithInterval(void 0, void 0, !1);
     } catch (e) {
-      const i = `ssh.stop: error occurred ${e}`;
+      const i = `PlSsh.stop: error occurred ${e}`;
       throw this.logger.error(i), new Error(i);
     }
   }
+  /** Stops the services, deletes a directory with the state and closes SSH connection. */
   async reset() {
-    const t = await this.getUserHomeDirectory();
-    return this.logger.info("pl.reset: Stop Platforma on the server"), await this.stop(), this.logger.info(`pl.reset: Deleting Platforma workDir ${t} on the server`), await this.sshClient.deleteFolder($(t)), this.cleanUp(), !0;
-  }
-  async platformaInit(t) {
-    const r = { localWorkdir: t.localWorkdir };
+    return await this.stopAndClean(), this.cleanUp(), !0;
+  }
+  /** 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 ${r} on the server`), await this.sshClient.deleteFolder($(r));
+  }
+  /** 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 };
     try {
-      if (r.arch = await this.getArch(), r.remoteHome = await this.getUserHomeDirectory(), r.isAlive = await this.isAlive(), r.isAlive) {
-        if (r.userCredentials = await this.getUserCredentials(r.remoteHome), !r.userCredentials)
+      const e = {
+        ...Zt,
+        ...r
+      };
+      if (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)
           throw new Error("SshPl.platformaInit: platforma is alive but userCredentials are not found");
-        return r.userCredentials;
+        if (!(t.userCredentials.useGlobalAccess != e.useGlobalAccess))
+          return t.userCredentials;
+        await this.stopAndClean();
       }
-      const e = await this.downloadBinariesAndUploadToTheServer(
-        t.localWorkdir,
-        r.remoteHome,
-        r.arch
+      const i = await this.downloadBinariesAndUploadToTheServer(
+        e.localWorkdir,
+        t.remoteHome,
+        t.arch
       );
-      if (r.binPaths = { ...e, history: void 0 }, r.downloadedBinaries = e.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)
+      if (t.binPaths = { ...i, history: void 0 }, t.downloadedBinaries = i.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)
         throw new Error("SshPl.platformaInit: remote ports are not defined");
-      const i = await ar({
+      const o = await lt({
         logger: this.logger,
-        workingDir: $(r.remoteHome),
+        workingDir: $(t.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
+            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
           }
         },
-        licenseMode: t.license
+        licenseMode: e.license,
+        useGlobalAccess: f(e.useGlobalAccess)
       });
-      r.generatedConfig = { ...i, filesToCreate: { skipped: "it is too wordy" } };
-      for (const [c, a] of Object.entries(i.filesToCreate))
-        await this.sshClient.writeFileOnTheServer(c, a), this.logger.info(`Created file ${c}`);
-      for (const c of i.dirsToCreate)
-        await this.sshClient.createRemoteDirectory(c), this.logger.info(`Created directory ${c}`);
-      const o = Mr(
-        i.minioConfig.storageDir,
-        i.minioConfig.envs,
-        await this.getFreePortForPlatformaOnServer(r.remoteHome, r.arch),
-        i.workingDir,
-        i.plConfig.configPath,
-        r.binPaths.minioRelPath,
-        r.binPaths.downloadedPl
+      t.generatedConfig = { ...o, filesToCreate: { skipped: "it is too wordy" } };
+      for (const [a, l] of Object.entries(o.filesToCreate))
+        await this.sshClient.writeFileOnTheServer(a, l), this.logger.info(`Created file ${a}`);
+      for (const a of o.dirsToCreate)
+        await this.sshClient.createRemoteDirectory(a), this.logger.info(`Created directory ${a}`);
+      const n = Lt(
+        o.minioConfig.storageDir,
+        o.minioConfig.envs,
+        await this.getFreePortForPlatformaOnServer(t.remoteHome, t.arch),
+        o.workingDir,
+        o.plConfig.configPath,
+        t.binPaths.minioRelPath,
+        t.binPaths.downloadedPl
       );
-      if (!await this.sshClient.writeFileOnTheServer(G(r.remoteHome), o))
-        throw new Error(`Can not write supervisord config on the server ${$(r.remoteHome)}`);
-      return r.connectionInfo = {
-        plUser: i.plUser,
-        plPassword: i.plPassword,
-        ports: r.ports
-      }, await this.sshClient.writeFileOnTheServer(
-        B(r.remoteHome),
-        JSON.stringify(r.connectionInfo, void 0, 2)
-      ), await this.start(), r.started = !0, this.initState = r, {
-        plUser: i.plUser,
-        plPassword: i.plPassword,
-        ports: r.ports
-      };
+      if (!await this.sshClient.writeFileOnTheServer(q(t.remoteHome), n))
+        throw new Error(`Can not write supervisord config on the server ${$(t.remoteHome)}`);
+      return t.connectionInfo = zt(
+        o.plUser,
+        o.plPassword,
+        t.ports,
+        f(e.useGlobalAccess)
+      ), await this.sshClient.writeFileOnTheServer(
+        I(t.remoteHome),
+        qt(t.connectionInfo)
+      ), await this.start(), t.started = !0, this.initState = t, t.connectionInfo;
     } catch (e) {
-      const i = `SshPl.platformaInit: error occurred: ${e}, state: ${JSON.stringify(r)}`;
+      const i = `SshPl.platformaInit: error occurred: ${e}, state: ${JSON.stringify(t)}`;
       throw this.logger.error(i), new Error(i);
     }
   }
-  async downloadBinariesAndUploadToTheServer(t, r, e) {
+  async downloadBinariesAndUploadToTheServer(r, t, e) {
     const i = [];
     try {
       const o = await this.downloadAndUntar(
-        t,
         r,
+        t,
         e,
         "pl",
-        `pl-${x()}`
+        `pl-${R()}`
       );
       i.push(o);
       const n = await this.downloadAndUntar(
-        t,
         r,
+        t,
         e,
         "supervisord",
-        Rr
+        Ut
       );
       i.push(n);
-      const c = Tr(r, e.arch), a = await this.downloadAndUntar(
-        t,
+      const c = _t(t, e.arch), a = await this.downloadAndUntar(
         r,
+        t,
         e,
         "minio",
-        Or
+        Nt
       );
       return i.push(a), await this.sshClient.chmod(c, 488), {
         history: i,
         minioRelPath: c,
-        downloadedPl: N(r, e.arch)
+        downloadedPl: T(t, e.arch)
       };
     } catch (o) {
       const n = `SshPl.downloadBinariesAndUploadToServer: error ${o} occurred, state: ${JSON.stringify(i)}`;
@@ -1014,18 +1067,20 @@ class K {
   }
   /** We have to extract pl in the remote server,
   * because Windows doesn't support symlinks
-  * that are found in linux pl binaries tgz archive.
-  * For this reason, we extract all to the remote server. */
-  async downloadAndUntar(t, r, e, i, o) {
+  * that are found in Linux pl binaries tgz archive.
+  * For this reason, we extract all to the remote server.
+  * It requires `tar` to be installed on the server
+  * (it's not installed for Rocky Linux for example). */
+  async downloadAndUntar(r, t, e, i, o) {
     const n = {};
-    n.binBasePath = S(r), await this.sshClient.createRemoteDirectory(n.binBasePath), n.binBasePathCreated = !0;
+    n.binBasePath = E(t), await this.sshClient.createRemoteDirectory(n.binBasePath), n.binBasePathCreated = !0;
     let c = null;
     const a = 5;
     for (let h = 1; h <= a; h++)
       try {
-        c = await wr(
+        c = await pt(
           this.logger,
-          t,
+          r,
           i,
           o,
           e.arch,
@@ -1033,78 +1088,78 @@ class K {
         );
         break;
       } catch (u) {
-        if (await F(300), h == a)
+        if (await b(300), h == a)
           throw new Error(`downloadAndUntar: ${a} attempts, last error: ${u}`);
       }
-    n.downloadResult = p(c), n.localArchivePath = d.resolve(n.downloadResult.archivePath), n.remoteDir = d.join(n.binBasePath, n.downloadResult.baseName), n.remoteArchivePath = n.remoteDir + ".tgz", await this.sshClient.createRemoteDirectory(n.remoteDir), await this.sshClient.uploadFile(n.localArchivePath, n.remoteArchivePath);
+    n.downloadResult = f(c), n.localArchivePath = d.resolve(n.downloadResult.archivePath), n.remoteDir = d.join(n.binBasePath, n.downloadResult.baseName), n.remoteArchivePath = n.remoteDir + ".tgz", await this.sshClient.createRemoteDirectory(n.remoteDir), await this.sshClient.uploadFile(n.localArchivePath, n.remoteArchivePath);
     const l = await this.sshClient.exec(
-      `tar xvf ${n.remoteArchivePath} --directory=${n.remoteDir}`
+      `tar --warning=no-all -xvf ${n.remoteArchivePath} --directory=${n.remoteDir}`
     );
     if (l.stderr)
-      throw new Error(`downloadAndUntar: untar: stderr occurred: ${l.stderr}, stdout: ${l.stdout}`);
+      throw Error(`downloadAndUntar: untar: stderr occurred: ${l.stderr}, stdout: ${l.stdout}`);
     return n.plUntarDone = !0, n;
   }
-  async needDownload(t, r) {
-    const e = z(t, r.arch), i = W(t, r.arch), o = N(t, r.arch);
+  async needDownload(r, t) {
+    const e = K(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(t = 1e3, r = 15, e = !0) {
-    const i = r * t;
+  async checkIsAliveWithInterval(r = 1e3, t = 15, e = !0) {
+    const i = t * r;
     let o = 0, n = await this.isAlive();
-    for (; e ? !n : n; ) {
-      if (await F(t), o += t, o > i)
-        throw new Error(`isAliveWithInterval: The process did not ${e ? "started" : "stopped"} after ${i} ms.`);
+    for (; e ? !n.allAlive : n.allAlive; ) {
+      if (await b(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();
     }
   }
-  async getUserCredentials(t) {
-    const r = await this.sshClient.readFile(B(t));
-    return JSON.parse(r);
+  async getUserCredentials(r) {
+    const t = await this.sshClient.readFile(I(r));
+    return Kt(t);
   }
-  async fetchPorts(t, r) {
+  async fetchPorts(r, t) {
     return {
       grpc: {
-        local: await y(),
-        remote: await this.getFreePortForPlatformaOnServer(t, r)
+        local: await P(),
+        remote: await this.getFreePortForPlatformaOnServer(r, t)
       },
       monitoring: {
-        local: await y(),
-        remote: await this.getFreePortForPlatformaOnServer(t, r)
+        local: await P(),
+        remote: await this.getFreePortForPlatformaOnServer(r, t)
       },
       debug: {
-        local: await y(),
-        remote: await this.getFreePortForPlatformaOnServer(t, r)
+        local: await P(),
+        remote: await this.getFreePortForPlatformaOnServer(r, t)
       },
       minioPort: {
-        local: await y(),
-        remote: await this.getFreePortForPlatformaOnServer(t, r)
+        local: await P(),
+        remote: await this.getFreePortForPlatformaOnServer(r, t)
       },
       minioConsolePort: {
-        local: await y(),
-        remote: await this.getFreePortForPlatformaOnServer(t, r)
+        local: await P(),
+        remote: await this.getFreePortForPlatformaOnServer(r, t)
       }
     };
   }
   async getLocalFreePort() {
-    return new Promise((t) => {
-      const r = I.createServer();
-      r.listen(0, () => {
-        const e = r.address().port;
-        r.close((i) => t(e));
+    return new Promise((r) => {
+      const t = H.createServer();
+      t.listen(0, () => {
+        const e = t.address().port;
+        t.close((i) => r(e));
       });
     });
   }
-  async getFreePortForPlatformaOnServer(t, r) {
-    const e = Br(t, r.arch), { stdout: i, stderr: o } = await this.sshClient.exec(`${e}`);
+  async getFreePortForPlatformaOnServer(r, t) {
+    const e = It(r, t.arch), { stdout: i, stderr: o } = await this.sshClient.exec(`${e}`);
     if (o)
       throw new Error(`getFreePortForPlatformaOnServer: stderr is not empty: ${o}, stdout: ${i}`);
     return +i;
   }
   async getArch() {
-    const { stdout: t, stderr: r } = await this.sshClient.exec("uname -s && uname -m");
-    if (r)
-      throw new Error(`getArch: stderr is not empty: ${r}, stdout: ${t}`);
-    const e = t.split(`
+    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(`
 `);
     return {
       platform: e[0],
@@ -1112,20 +1167,23 @@ class K {
     };
   }
   async getUserHomeDirectory() {
-    const { stdout: t, stderr: r } = await this.sshClient.exec("echo $HOME");
-    if (r) {
+    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: ${r}, stdout: ${t}, will get a default home: ${e}`), e;
+      return console.warn(`getUserHomeDirectory: stderr is not empty: ${t}, stdout: ${r}, will get a default home: ${e}`), e;
     }
-    return t.trim();
+    return r.trim();
   }
 }
+const Zt = {
+  useGlobalAccess: !1
+};
 export {
-  Fr as LocalConfigYaml,
-  Ar as LocalPl,
-  R as SshClient,
-  K as SshPl,
-  x as getDefaultPlVersion,
-  st as localPlatformaInit
+  bt as LocalConfigYaml,
+  Dt as LocalPl,
+  U as SshClient,
+  Z as SshPl,
+  R as getDefaultPlVersion,
+  fr as localPlatformaInit
 };
 //# sourceMappingURL=index.mjs.map