@milaboratories/pl-deployments 1.1.4 → 1.1.5

package/dist/index.mjs

@@ -1,45 +1,45 @@
-var K = Object.defineProperty;
-var q = (s, r, t) => r in s ? K(s, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[r] = t;
-var d = (s, r, t) => q(s, typeof r != "symbol" ? r + "" : r, t);
-import { spawn as G } from "node:child_process";
-import { sleep as S, fileExists as f, assertNever as N, notEmpty as p } from "@milaboratories/ts-helpers";
+var G = Object.defineProperty;
+var Z = (s, r, t) => r in s ? G(s, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[r] = t;
+var w = (s, r, t) => Z(s, typeof r != "symbol" ? r + "" : r, t);
+import { spawn as V } from "node:child_process";
+import { sleep as C, fileExists as m, assertNever as T, notEmpty as f, RetryablePromise as Y } from "@milaboratories/ts-helpers";
 import E from "node:fs";
-import w, { readFile as Z } from "node:fs/promises";
+import p, { readFile as Q } from "node:fs/promises";
 import u from "upath";
-import { request as V } from "undici";
-import { Readable as Y, Writable as Q } from "node:stream";
-import { text as X } from "node:stream/consumers";
-import * as tt from "tar";
-import rt from "decompress";
+import { request as X } from "undici";
+import { Readable as tt, Writable as rt } from "node:stream";
+import { text as et } from "node:stream/consumers";
+import * as it from "tar";
+import ot from "decompress";
 import k from "node:os";
-import et, { Client as v } from "ssh2";
-import U from "node:net";
-import it from "node:dns";
-import { generateSshPlConfigs as ot, getFreePort as g } from "@milaboratories/pl-config";
-import { randomBytes as nt } from "node:crypto";
-function st(s, r) {
+import st, { Client as S } from "ssh2";
+import B from "node:net";
+import nt from "node:dns";
+import { randomBytes as F } from "node:crypto";
+import { generateSshPlConfigs as at, getFreePort as y } from "@milaboratories/pl-config";
+function ct(s, r) {
   return s.info(`Running:
 cmd: ${JSON.stringify([r.cmd, ...r.args])}
-wd: ${r.opts.cwd}`), s.info("  spawning child process"), G(r.cmd, r.args, r.opts);
+wd: ${r.opts.cwd}`), s.info("  spawning child process"), V(r.cmd, r.args, r.opts);
 }
-async function C(s) {
+async function D(s) {
   try {
     return process.kill(s, 0), !0;
   } catch {
     return !1;
   }
 }
-function T(s) {
+function _(s) {
   return process.kill(s, "SIGINT");
 }
-async function B(s, r) {
+async function j(s, r) {
   let e = 0;
-  for (; await C(s); )
-    if (await S(100), e += 100, e > r)
+  for (; await D(s); )
+    if (await C(100), e += 100, e > r)
       throw new Error(`The process did not stopped after ${r} ms.`);
 }
-const at = ["linux", "macos", "windows"];
-function H(s) {
+const lt = ["linux", "macos", "windows"];
+function I(s) {
   switch (s.toLowerCase()) {
     case "darwin":
       return "macos";
@@ -49,12 +49,12 @@ function H(s) {
       return "windows";
     default:
       throw new Error(
-        `operating system '${s}' is not currently supported by Platforma ecosystem. The list of OSes supported: ` + JSON.stringify(at)
+        `operating system '${s}' is not currently supported by Platforma ecosystem. The list of OSes supported: ` + JSON.stringify(lt)
       );
   }
 }
-const ct = ["amd64", "arm64"];
-function $(s) {
+const ht = ["amd64", "arm64"];
+function P(s) {
   switch (s) {
     case "aarch64":
     case "aarch64_be":
@@ -65,155 +65,155 @@ function $(s) {
       return "amd64";
     default:
       throw new Error(
-        `processor architecture '${s}' is not currently supported by Platforma ecosystem. The list of architectures supported: ` + JSON.stringify(ct)
+        `processor architecture '${s}' is not currently supported by Platforma ecosystem. The list of architectures supported: ` + JSON.stringify(ht)
       );
   }
 }
-async function lt(s, r, t, e, i, o) {
-  const n = ut(t, e, r, $(i), H(o)), { archiveUrl: a, archivePath: c } = n;
-  return await _(s, a, c), n;
+async function ut(s, r, t, e, i, o) {
+  const n = wt(t, e, r, P(i), I(o)), { archiveUrl: c, archivePath: a } = n;
+  return await H(s, c, a), n;
 }
-async function ht(s, r, t, e, i) {
-  const o = dt(t, r, $(e), H(i)), { archiveUrl: n, archivePath: a, archiveType: c, targetFolder: l, binaryPath: h } = o;
-  return await _(s, n, a), await pt(s, a, c, l), o;
+async function dt(s, r, t, e, i) {
+  const o = pt(t, r, P(e), I(i)), { archiveUrl: n, archivePath: c, archiveType: a, targetFolder: l, binaryPath: h } = o;
+  return await H(s, n, c), await mt(s, c, a, l), o;
 }
-function ut(s, r, t, e, i) {
-  const o = `${r}-${e}`, n = I[i], a = `${o}.${n}`, c = `https://cdn.platforma.bio/software/${s}/${i}/${a}`, l = u.join(t, a), h = u.join(t, o);
+function wt(s, r, t, e, i) {
+  const o = `${r}-${e}`, n = M[i], c = `${o}.${n}`, a = `https://cdn.platforma.bio/software/${s}/${i}/${c}`, l = u.join(t, c), h = u.join(t, o);
   return {
-    archiveUrl: c,
+    archiveUrl: a,
     archivePath: l,
     archiveType: n,
     targetFolder: h,
     baseName: o
   };
 }
-function dt(s, r, t, e) {
-  const i = `pl-${s}-${t}`, o = I[e], n = `${i}.${o}`, a = `https://cdn.platforma.bio/software/pl/${e}/${n}`, c = u.join(r, n), l = u.join(r, i), h = u.join(i, "binaries", ft[e]);
+function pt(s, r, t, e) {
+  const i = `pl-${s}-${t}`, o = M[e], n = `${i}.${o}`, c = `https://cdn.platforma.bio/software/pl/${e}/${n}`, a = u.join(r, n), l = u.join(r, i), h = u.join(i, "binaries", gt[e]);
   return {
-    archiveUrl: a,
-    archivePath: c,
+    archiveUrl: c,
+    archivePath: a,
     archiveType: o,
     targetFolder: l,
     binaryPath: h,
     baseName: i
   };
 }
-async function _(s, r, t) {
+async function H(s, r, t) {
   const e = {};
   e.dstArchive = t;
   try {
-    if (e.fileExisted = await f(t), e.fileExisted)
+    if (e.fileExisted = await m(t), e.fileExisted)
       return s.info(`Platforma Backend archive download skipped: '${t}' already exists`), e;
-    await w.mkdir(u.dirname(t), { recursive: !0 }), e.dirnameCreated = !0, s.info(`Downloading archive:
+    await p.mkdir(u.dirname(t), { recursive: !0 }), e.dirnameCreated = !0, s.info(`Downloading archive:
   URL: ${r}
  Save to: ${t}`);
-    const { body: i, statusCode: o } = await V(r);
+    const { body: i, statusCode: o } = await X(r);
     if (e.statusCode = o, o != 200) {
-      const n = await X(i);
+      const n = await et(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 = t + ".tmp", await Y.toWeb(i).pipeTo(Q.toWeb(E.createWriteStream(e.tmpPath))), e.wroteTmp = !0, e.tmpExisted = await f(e.tmpPath), await w.rename(e.tmpPath, t), e.renamed = !0, e.newExisted = await f(t), e;
+    return e.tmpPath = t + ".tmp", await tt.toWeb(i).pipeTo(rt.toWeb(E.createWriteStream(e.tmpPath))), e.wroteTmp = !0, e.tmpExisted = await m(e.tmpPath), await p.rename(e.tmpPath, t), e.renamed = !0, e.newExisted = await m(t), e;
   } catch (i) {
     const o = `downloadArchive: error ${JSON.stringify(i)} occurred, state: ${JSON.stringify(e)}`;
     throw s.error(o), new Error(o);
   }
 }
-const wt = ".ok";
-async function pt(s, r, t, e) {
-  if (s.info("extracting archive..."), s.info(`  archive path: '${r}'`), s.info(`  target dir: '${e}'`), !await f(r)) {
+const ft = ".ok";
+async function mt(s, r, t, e) {
+  if (s.info("extracting archive..."), s.info(`  archive path: '${r}'`), s.info(`  target dir: '${e}'`), !await m(r)) {
     const o = `Platforma Backend binary archive not found at '${r}'`;
     throw s.error(o), new Error(o);
   }
-  const i = u.join(e, wt);
-  if (await f(i)) {
+  const i = u.join(e, ft);
+  if (await m(i)) {
     s.info(`Platforma Backend binaries unpack skipped: '${e}' exists`);
     return;
   }
-  switch (await f(e) && (s.info(`Removing previous incompletely unpacked folder: '${e}'`), await w.rm(e, { recursive: !0 })), s.info(`  creating target dir '${e}'`), await w.mkdir(e, { recursive: !0 }), s.info(
+  switch (await m(e) && (s.info(`Removing previous incompletely unpacked folder: '${e}'`), await p.rm(e, { recursive: !0 })), s.info(`  creating target dir '${e}'`), await p.mkdir(e, { recursive: !0 }), s.info(
     `Unpacking Platforma Backend archive:
   Archive:   ${r}
   Target dir: ${e}`
   ), t) {
     case "tgz":
-      await tt.x({
+      await it.x({
         file: r,
         cwd: e,
         gzip: !0
       });
       break;
     case "zip":
-      await rt(r, e);
+      await ot(r, e);
       break;
     default:
-      N(t);
+      T(t);
   }
-  await w.writeFile(i, "ok"), s.info("  ... unpack done.");
+  await p.writeFile(i, "ok"), s.info("  ... unpack done.");
 }
-const I = {
+const M = {
   linux: "tgz",
   macos: "tgz",
   windows: "zip"
-}, ft = {
+}, gt = {
   linux: "platforma",
   macos: "platforma",
   windows: "platforma.exe"
 };
-function F() {
+function b() {
   return "1.18.3";
 }
-function mt() {
-  return { type: "Download", version: F() };
+function yt() {
+  return { type: "Download", version: b() };
 }
-async function gt(s, r, t) {
+async function $t(s, r, t) {
   switch (t.type) {
     case "Download":
-      return (await ht(s, r, t.version, k.arch(), k.platform())).binaryPath;
+      return (await dt(s, r, t.version, k.arch(), k.platform())).binaryPath;
     case "Local":
       return t.path;
     default:
-      N(t);
+      T(t);
   }
 }
-function j(s) {
+function J(s) {
   return u.join(s, "pl_pid");
 }
-async function yt(s) {
-  if (!await f(s))
+async function Pt(s) {
+  if (!await m(s))
     return;
-  const r = await w.readFile(s);
+  const r = await p.readFile(s);
   return Number(r.toString());
 }
-async function $t(s, r) {
-  await w.writeFile(s, JSON.stringify(r));
+async function vt(s, r) {
+  await p.writeFile(s, JSON.stringify(r));
 }
-function Pt() {
+function St() {
   return {};
 }
-function vt(s, r, t) {
+function Ct(s, r, t) {
   return s[r] = t, t;
 }
-async function b(s, r) {
-  const t = Pt();
+async function A(s, r) {
+  const t = St();
   try {
-    return await r((i, o) => vt(t, i, o), t);
+    return await r((i, o) => Ct(t, i, o), t);
   } catch (e) {
     throw s.error(`error ${e} while doing traced operation, state: ${JSON.stringify(t)}`), e;
   }
 }
-const St = "config-local.yaml";
-class Et {
-  constructor(r, t, e, i, o, n, a, c) {
-    d(this, "instance");
-    d(this, "pid");
-    d(this, "nRuns", 0);
-    d(this, "lastRunHistory", {});
-    d(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;
+const Et = "config-local.yaml";
+class Ft {
+  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 = 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 b(this.logger, async (r, t) => {
+    await A(this.logger, async (r, t) => {
       this.wasStopped = !1;
-      const e = st(this.logger, this.startOptions);
+      const e = ct(this.logger, this.startOptions);
       e.on("error", (o) => {
         this.logger.error(
           `error '${o}', while running platforma, started opts: ${JSON.stringify(this.debugInfo())}`
@@ -221,21 +221,21 @@ class Et {
       }), 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);
       }), r("started", !0);
-      const i = r("pidFile", j(this.workingDir));
-      r("pid", p(e.pid)), r("pidWritten", await $t(i, p(e.pid))), this.nRuns++, this.instance = e, this.pid = e.pid, this.lastRunHistory = t;
+      const i = r("pidFile", J(this.workingDir));
+      r("pid", f(e.pid)), r("pidWritten", await vt(i, f(e.pid))), this.nRuns++, this.instance = e, this.pid = e.pid, this.lastRunHistory = t;
     });
   }
   stop() {
-    this.wasStopped = !0, T(p(this.pid));
+    this.wasStopped = !0, _(f(this.pid));
   }
   async waitStopped() {
-    await B(p(this.pid), 15e3);
+    await j(f(this.pid), 15e3);
   }
   stopped() {
     return this.wasStopped;
   }
   async isAlive() {
-    return await C(p(this.pid));
+    return await D(f(this.pid));
   }
   debugInfo() {
     return {
@@ -248,21 +248,21 @@ class Et {
     };
   }
 }
-async function Xt(s, r) {
+async function ir(s, r) {
   const t = {
-    plBinary: mt(),
+    plBinary: yt(),
     spawnOptions: {},
     closeOld: !0,
     ...r
   };
-  return await b(s, async (e, i) => {
+  return await A(s, async (e, i) => {
     e("startOptions", { ...t, config: "too wordy" });
     const o = u.resolve(t.workingDir);
-    t.closeOld && e("closeOld", await Ct(s, o));
-    const n = u.join(o, St);
-    s.info(`writing configuration '${n}'...`), await w.writeFile(n, t.config);
-    const a = await gt(s, u.join(o, "binaries"), t.plBinary), l = {
-      cmd: e("binaryPath", u.join("binaries", a)),
+    t.closeOld && e("closeOld", await Dt(s, o));
+    const n = u.join(o, Et);
+    s.info(`writing configuration '${n}'...`), await p.writeFile(n, t.config);
+    const c = await $t(s, u.join(o, "binaries"), t.plBinary), l = {
+      cmd: e("binaryPath", u.join("binaries", c)),
       args: ["-config", n],
       opts: {
         env: { ...process.env },
@@ -278,7 +278,7 @@ async function Xt(s, r) {
       args: l.args,
       cwd: l.opts.cwd
     });
-    const h = new Et(
+    const h = new Ft(
       s,
       t.workingDir,
       l,
@@ -291,20 +291,20 @@ async function Xt(s, r) {
     return await h.start(), h;
   });
 }
-async function Ct(s, r) {
-  return await b(s, async (t, e) => {
-    const i = t("pidFilePath", j(r)), o = t("pid", await yt(i)), n = t("wasAlive", await C(o));
-    return o !== void 0 && n && (t("stopped", T(o)), t("waitStopped", await B(o, 1e4))), e;
+async function Dt(s, r) {
+  return await A(s, async (t, e) => {
+    const i = t("pidFilePath", J(r)), o = t("pid", await Pt(i)), n = t("wasAlive", await D(o));
+    return o !== void 0 && n && (t("stopped", _(o)), t("waitStopped", await j(o, 1e4))), e;
   });
 }
-const Ft = {
+const bt = {
   keepaliveInterval: 6e4,
   keepaliveCountMax: 10
 };
-class D {
+class x {
   constructor(r, t) {
-    d(this, "config");
-    d(this, "homeDir");
+    w(this, "config");
+    w(this, "homeDir");
     this.logger = r, this.client = t;
   }
   /**
@@ -314,9 +314,9 @@ class D {
    */
   static async init(r, t) {
     const e = {
-      ...Ft,
+      ...bt,
       ...t
-    }, i = new D(r, new v());
+    }, i = new x(r, new S());
     return await i.connect(e), i;
   }
   getFullHostName() {
@@ -333,15 +333,7 @@ class D {
    * @returns A promise that resolves when the connection is established or rejects on error.
    */
   async connect(r) {
-    return this.config = r, new Promise((t, e) => {
-      this.client.on("ready", () => {
-        t(void 0);
-      }).on("error", (i) => {
-        e(new Error(`ssh.connect: error occurred: ${i}`));
-      }).on("timeout", () => {
-        e(new Error("timeout was occurred while waiting for SSH connection."));
-      }).connect(r);
-    });
+    return this.config = r, await At(this.client, r);
   }
   /**
    * Executes a command on the SSH server.
@@ -353,13 +345,13 @@ class D {
       this.client.exec(r, (i, o) => {
         if (i)
           return e(`ssh.exec: ${r}, error occurred: ${i}`);
-        let n = "", a = "";
-        o.on("close", (c) => {
-          c === 0 ? t({ stdout: n, stderr: a }) : e(new Error(`Command ${r} exited with code ${c}`));
-        }).on("data", (c) => {
-          n += c.toString();
-        }).stderr.on("data", (c) => {
-          a += c.toString();
+        let n = "", c = "";
+        o.on("close", (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) => {
+          c += a.toString();
         });
       });
     });
@@ -373,7 +365,7 @@ class D {
   static async getAuthTypes(r, t) {
     return new Promise((e) => {
       let i = "";
-      const o = new v();
+      const o = new S();
       o.on("ready", () => {
         o.end();
         const n = this.extractAuthMethods(i);
@@ -408,40 +400,50 @@ class D {
    * @returns { server: net.Server } A promise resolving with the created server instance.
    */
   async forwardPort(r, t) {
-    return t = t ?? this.config, new Promise((e, i) => {
-      if (!t) {
-        i("No config defined");
-        return;
-      }
-      const o = new v();
-      let n;
-      o.on("ready", () => {
-        this.logger.info(`[SSH] Connection to ${t.host}. Remote port ${r.remotePort} will be available locally on the ${r.localPort}`), n = U.createServer({ pauseOnConnect: !0 }, (a) => {
-          o.forwardOut(
-            "127.0.0.1",
-            0,
-            "127.0.0.1",
-            r.remotePort,
-            (c, l) => {
-              if (c) {
-                console.error("Error opening SSH channel:", c.message), a.end();
-                return;
-              }
-              a.pipe(l), l.pipe(a), a.resume();
-            }
-          );
-        }), n.listen(r.localPort, "127.0.0.1", () => {
-          this.logger.info(`[+] Port local ${r.localPort} available locally for remote port → :${r.remotePort}`), e({ server: n });
-        }), n.on("error", (a) => {
-          o.end(), n.close(), i(new Error(`ssh.forwardPort: server error: ${a}`));
-        }), n.on("close", () => {
-          this.logger.info(`Server closed ${JSON.stringify(r)}`), o && (this.logger.info("End SSH connection"), o.end());
+    const e = `ssh.forward:${r.localPort}:${r.remotePort}.id_${F(1).toString("hex")}`;
+    t = t ?? this.config;
+    const i = new Y((o) => new Promise((n, c) => {
+      const a = new S();
+      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(t);
+    }));
+    return await i.ensure(), new Promise((o, n) => {
+      const c = B.createServer({ pauseOnConnect: !0 }, async (a) => {
+        const l = `${e}.sock_${F(1).toString("hex")}`;
+        let h;
+        try {
+          h = await i.ensure();
+        } catch (g) {
+          this.logger.info(`${l}.persistentClient.catch: ${g}`), a.end();
+          return;
+        }
+        let d;
+        try {
+          d = await xt(this.logger, h, "127.0.0.1", 0, "127.0.0.1", r.remotePort);
+        } catch (g) {
+          this.logger.error(`${l}.forwardOut.err: ${g}`), a.end();
+          return;
+        }
+        a.pipe(d), d.pipe(a), a.resume(), d.on("error", (g) => {
+          this.logger.error(`${l}.stream.error: ${g}`), a.end(), d.end();
+        }), d.on("close", () => {
+          a.end(), d.end();
+        }), a.on("close", () => {
+          this.logger.info(`${l}.localSocket: closed`), a.end(), d.end();
         });
-      }), o.on("error", (a) => {
-        this.logger.error(`[SSH] SSH connection error, ports: ${JSON.stringify(r)}, err: ${a.message}`), n == null || n.close(), i(`ssh.forwardPort: conn.err: ${a}`);
-      }), o.on("close", () => {
-        this.logger.info(`[SSH] Connection closed, ports: ${JSON.stringify(r)}`);
-      }), o.connect(t);
+      });
+      c.listen(r.localPort, "127.0.0.1", () => {
+        this.logger.info(`${e}.server: started listening`), 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(r)}`);
+      });
     });
   }
   /**
@@ -451,7 +453,7 @@ class D {
   */
   static async checkHostAvailability(r) {
     return new Promise((t) => {
-      it.lookup(r, (e) => {
+      nt.lookup(r, (e) => {
         t(!e);
       });
     });
@@ -464,7 +466,7 @@ class D {
   static async isPassphraseRequiredForKey(r) {
     return new Promise((t, e) => {
       try {
-        return et.utils.parseKey(r) instanceof Error && t(!0), t(!1);
+        return st.utils.parseKey(r) instanceof Error && t(!0), t(!1);
       } catch (i) {
         console.log("Error parsing privateKey"), e(new Error(`ssh.isPassphraseRequiredForKey: err ${i}`));
       }
@@ -481,10 +483,10 @@ class D {
     return await this.withSftp(async (e) => new Promise((i, o) => {
       e.fastPut(r, t, (n) => {
         if (n) {
-          const a = new Error(
+          const c = new Error(
             `ssh.uploadFile: err: ${n}, localPath: ${r}, remotePath: ${t}`
           );
-          return o(a);
+          return o(c);
         }
         i(!0);
       });
@@ -513,12 +515,12 @@ class D {
   }
   async getForderStructure(r, t, e = { files: [], directories: [] }) {
     return new Promise((i, o) => {
-      r.readdir(t, async (n, a) => {
+      r.readdir(t, async (n, c) => {
         if (n)
           return o(n);
-        for (const c of a) {
-          const l = `${t}/${c.filename}`;
-          if (c.attrs.isDirectory()) {
+        for (const a of c) {
+          const l = `${t}/${a.filename}`;
+          if (a.attrs.isDirectory()) {
             e.directories.push(l);
             try {
               await this.getForderStructure(r, l, e);
@@ -598,20 +600,20 @@ class D {
   }
   async writeFile(r, t, e, i = 432) {
     return new Promise((o, n) => {
-      r.writeFile(t, e, { mode: i }, (a) => {
-        if (a)
-          return n(new Error(`ssh.writeFile: err ${a}, remotePath: ${t}`));
+      r.writeFile(t, e, { mode: i }, (c) => {
+        if (c)
+          return n(new Error(`ssh.writeFile: err ${c}, remotePath: ${t}`));
         o(!0);
       });
     });
   }
   uploadFileUsingExistingSftp(r, t, e, i = 432) {
     return new Promise((o, n) => {
-      Z(t).then(async (a) => {
-        this.writeFile(r, e, a, i).then(() => {
+      Q(t).then(async (c) => {
+        this.writeFile(r, e, c, i).then(() => {
           o(void 0);
-        }).catch((c) => {
-          const l = `uploadFileUsingExistingSftp: error ${c} occurred`;
+        }).catch((a) => {
+          const l = `uploadFileUsingExistingSftp: error ${a} occurred`;
           this.logger.error(l), n(new Error(l));
         });
       });
@@ -619,14 +621,14 @@ class D {
   }
   async __uploadDirectory(r, t, e, i = 432) {
     return new Promise((o, n) => {
-      E.readdir(t, async (a, c) => {
-        if (a)
-          return n(new Error(`ssh.__uploadDir: err ${a}, localDir: ${t}, remoteDir: ${e}`));
+      E.readdir(t, async (c, a) => {
+        if (c)
+          return n(new Error(`ssh.__uploadDir: err ${c}, localDir: ${t}, remoteDir: ${e}`));
         try {
           await this.__createRemoteDirectory(r, e);
-          for (const l of c) {
-            const h = u.join(t, l), m = `${e}/${l}`;
-            E.lstatSync(h).isDirectory() ? await this.__uploadDirectory(r, h, m, i) : await this.uploadFileUsingExistingSftp(r, h, m, i);
+          for (const l of a) {
+            const h = u.join(t, l), d = `${e}/${l}`;
+            E.lstatSync(h).isDirectory() ? await this.__uploadDirectory(r, h, d, i) : await this.uploadFileUsingExistingSftp(r, h, d, i);
           }
           o();
         } catch (l) {
@@ -659,18 +661,18 @@ class D {
     return new Promise((e, i) => {
       const o = t.split("/");
       let n = "";
-      const a = (c) => {
-        if (c >= o.length)
+      const c = (a) => {
+        if (a >= o.length)
           return e();
-        n += `${o[c]}/`, r.stat(n, (l) => {
+        n += `${o[a]}/`, r.stat(n, (l) => {
           l ? r.mkdir(n, (h) => {
             if (h)
               return i(new Error(`ssh.__createRemDir: err ${h}, remotePath: ${t}`));
-            a(c + 1);
-          }) : a(c + 1);
+            c(a + 1);
+          }) : c(a + 1);
         });
       };
-      a(0);
+      c(0);
     });
   }
   /**
@@ -686,18 +688,18 @@ class D {
       for (const n of i) {
         o += `${n}/`;
         try {
-          await new Promise((a, c) => {
+          await new Promise((c, a) => {
             e.stat(o, (l) => {
-              if (!l) return a();
+              if (!l) return c();
               e.mkdir(o, { mode: t }, (h) => {
                 if (h)
-                  return c(new Error(`ssh.createRemoteDir: err ${h}, remotePath: ${r}`));
-                a();
+                  return a(new Error(`ssh.createRemoteDir: err ${h}, remotePath: ${r}`));
+                c();
               });
             });
           });
-        } catch (a) {
-          throw console.error(`Failed to create directory: ${o}`, a), a;
+        } catch (c) {
+          throw console.error(`Failed to create directory: ${o}`, c), c;
         }
       }
     });
@@ -724,65 +726,80 @@ class D {
     this.client.end();
   }
 }
-const bt = "minio-2024-12-18T13-15-44Z", Dt = "supervisord-0.7.3", At = "supervisord_0.7.3_Linux_64-bit";
-function y(s) {
+async function At(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(r);
+  });
+}
+async function xt(s, r, t, e, i, o) {
+  return new Promise((n, c) => {
+    r.forwardOut(t, e, i, o, (a, l) => a ? (s.error(`forwardOut.error: ${a}`), c(a)) : n(l));
+  });
+}
+const Ot = "minio-2024-12-18T13-15-44Z", kt = "supervisord-0.7.3", Rt = "supervisord_0.7.3_Linux_64-bit";
+function $(s) {
   return u.join(s, "platforma_ssh");
 }
-function P(s) {
+function v(s) {
   return u.join(s, "platforma_ssh", "binaries");
 }
-function kt(s, r) {
-  return u.join(P(s), `pl-${F()}-${$(r)}`);
+function Nt(s, r) {
+  return u.join(v(s), `pl-${b()}-${P(r)}`);
 }
-function J(s, r) {
-  return u.join(kt(s, r), "binaries");
+function L(s, r) {
+  return u.join(Nt(s, r), "binaries");
 }
-function x(s, r) {
-  return u.join(J(s, r), "platforma");
+function R(s, r) {
+  return u.join(L(s, r), "platforma");
 }
-function xt(s, r) {
-  return u.join(J(s, r), "free-port");
+function Ut(s, r) {
+  return u.join(L(s, r), "free-port");
 }
-function M(s, r) {
-  return u.join(P(s), `minio-2024-12-18T13-15-44Z-${$(r)}`);
+function z(s, r) {
+  return u.join(v(s), `minio-2024-12-18T13-15-44Z-${P(r)}`);
 }
-function Ot(s, r) {
-  return u.join(M(s, r), "minio");
+function Tt(s, r) {
+  return u.join(z(s, r), "minio");
 }
-function Rt(s, r) {
-  return u.join(P(s), `supervisord-0.7.3-${$(r)}`, At);
+function Bt(s, r) {
+  return u.join(v(s), `supervisord-0.7.3-${P(r)}`, Rt);
 }
-function L(s, r) {
-  return u.join(Rt(s, r), "supervisord");
+function W(s, r) {
+  return u.join(Bt(s, r), "supervisord");
 }
-function z(s) {
-  return u.join(y(s), "supervisor.conf");
+function K(s) {
+  return u.join($(s), "supervisor.conf");
 }
-function O(s) {
-  return u.join(y(s), "connection.txt");
+function N(s) {
+  return u.join($(s), "connection.txt");
 }
-async function Nt(s, r, t) {
-  const e = await A(s, r, t, "--daemon");
+async function _t(s, r, t) {
+  const e = await O(s, r, t, "--daemon");
   if (e.stderr)
     throw new Error(`Can not run ssh Platforma ${e.stderr}`);
 }
-async function Ut(s, r, t) {
-  const e = await A(s, r, t, "ctl shutdown");
+async function jt(s, r, t) {
+  const e = await O(s, r, t, "ctl shutdown");
   if (e.stderr)
     throw new Error(`Can not stop ssh Platforma ${e.stderr}`);
 }
-async function Tt(s, r, t, e) {
-  const i = await A(r, t, e, "ctl status");
+async function It(s, r, t, e) {
+  const i = await O(r, t, e, "ctl status");
   if (i.stderr)
     return s.info(`supervisord ctl status: stderr occurred: ${i.stderr}, stdout: ${i.stdout}`), !1;
   const o = {
-    platforma: R(i.stdout, "platforma"),
-    minio: R(i.stdout, "minio")
+    platforma: U(i.stdout, "platforma"),
+    minio: U(i.stdout, "minio")
   };
   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);
 }
-function Bt(s, r, t, e, i, o, n) {
-  const a = Object.entries(r).map(([h, m]) => `${h}="${m}"`).join(","), c = nt(16).toString("hex"), l = t;
+function Ht(s, r, t, e, i, o, n) {
+  const c = Object.entries(r).map(([h, d]) => `${h}="${d}"`).join(","), a = F(16).toString("hex"), l = t;
   return `
 [supervisord]
 logfile=${e}/supervisord.log
@@ -792,12 +809,12 @@ pidfile=${e}/supervisord.pid
 [inet_http_server]
 port=127.0.0.1:${l}
 username=default-user
-password=${c}
+password=${a}
 
 [supervisorctl]
 serverurl=http://127.0.0.1:${l}
 username=default-user
-password=${c}
+password=${a}
 
 [program:platforma]
 autostart=true
@@ -808,26 +825,26 @@ autorestart=true
 
 [program:minio]
 autostart=true
-environment=${a}
+environment=${c}
 command=${o} server ${s}
 directory=${e}
 autorestart=true
 `;
 }
-async function A(s, r, t, e) {
-  const i = L(r, t), o = z(r), n = `${i} --configuration ${o} ${e}`;
+async function O(s, r, t, e) {
+  const i = W(r, t), o = K(r), n = `${i} --configuration ${o} ${e}`;
   return await s.exec(n);
 }
-function R(s, r) {
+function U(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 === r && n === "Running";
   });
 }
-class W {
+class q {
   constructor(r, t, e) {
-    d(this, "initState", {});
+    w(this, "initState", {});
     this.logger = r, this.sshClient = t, this.username = e;
   }
   info() {
@@ -838,8 +855,8 @@ class W {
   }
   static async init(r, t) {
     try {
-      const e = await D.init(r, t);
-      return new W(r, e, p(t.username));
+      const e = await x.init(r, t);
+      return new q(r, e, f(t.username));
     } catch (e) {
       throw r.error(`Connection error in SshClient.init: ${e}`), e;
     }
@@ -847,7 +864,7 @@ class W {
   async isAlive() {
     const r = await this.getArch(), t = await this.getUserHomeDirectory();
     try {
-      return await Tt(this.logger, this.sshClient, t, r.arch);
+      return await It(this.logger, this.sshClient, t, r.arch);
     } catch {
       return !1;
     }
@@ -855,7 +872,7 @@ class W {
   async start() {
     const r = await this.getArch(), t = await this.getUserHomeDirectory();
     try {
-      return await Nt(this.sshClient, t, r.arch), await this.checkIsAliveWithInterval();
+      return await _t(this.sshClient, t, r.arch), await this.checkIsAliveWithInterval();
     } catch (e) {
       const i = `ssh.start: error occurred ${e}`;
       throw this.logger.error(i), new Error(i);
@@ -864,7 +881,7 @@ class W {
   async stop() {
     const r = await this.getArch(), t = await this.getUserHomeDirectory();
     try {
-      return await Ut(this.sshClient, t, r.arch), await this.checkIsAliveWithInterval(void 0, void 0, !1);
+      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}`;
       throw this.logger.error(i), new Error(i);
@@ -872,7 +889,7 @@ class W {
   }
   async reset() {
     const r = 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 ${r} on the server`), await this.sshClient.deleteFolder(y(r)), !0;
+    return 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)), !0;
   }
   async platformaInit(r) {
     const t = { localWorkdir: r };
@@ -889,9 +906,9 @@ class W {
       );
       if (t.binPaths = { ...e, history: void 0 }, t.downloadedBinaries = e.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 ot({
+      const i = await at({
         logger: this.logger,
-        workingDir: y(t.remoteHome),
+        workingDir: $(t.remoteHome),
         portsMode: {
           type: "customWithMinio",
           ports: {
@@ -909,11 +926,11 @@ class W {
         }
       });
       t.generatedConfig = { ...i, filesToCreate: { skipped: "it is too wordy" } };
-      for (const [a, c] of Object.entries(i.filesToCreate))
-        await this.sshClient.writeFileOnTheServer(a, c), this.logger.info(`Created file ${a}`);
-      for (const a of i.dirsToCreate)
-        await this.sshClient.createRemoteDirectory(a), this.logger.info(`Created directory ${a}`);
-      const o = Bt(
+      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 = Ht(
         i.minioConfig.storageDir,
         i.minioConfig.envs,
         await this.getFreePortForPlatformaOnServer(t.remoteHome, t.arch),
@@ -922,14 +939,14 @@ class W {
         t.binPaths.minioRelPath,
         t.binPaths.downloadedPl
       );
-      if (!await this.sshClient.writeFileOnTheServer(z(t.remoteHome), o))
-        throw new Error(`Can not write supervisord config on the server ${y(t.remoteHome)}`);
+      if (!await this.sshClient.writeFileOnTheServer(K(t.remoteHome), o))
+        throw new Error(`Can not write supervisord config on the server ${$(t.remoteHome)}`);
       return t.connectionInfo = {
         plUser: i.plUser,
         plPassword: i.plPassword,
         ports: t.ports
       }, await this.sshClient.writeFileOnTheServer(
-        O(t.remoteHome),
+        N(t.remoteHome),
         JSON.stringify(t.connectionInfo, void 0, 2)
       ), await this.start(), t.started = !0, this.initState = t, {
         plUser: i.plUser,
@@ -949,7 +966,7 @@ class W {
         t,
         e,
         "pl",
-        `pl-${F()}`
+        `pl-${b()}`
       );
       i.push(o);
       const n = await this.downloadAndUntar(
@@ -957,20 +974,20 @@ class W {
         t,
         e,
         "supervisord",
-        Dt
+        kt
       );
       i.push(n);
-      const a = Ot(t, e.arch), c = await this.downloadAndUntar(
+      const c = Tt(t, e.arch), a = await this.downloadAndUntar(
         r,
         t,
         e,
         "minio",
-        bt
+        Ot
       );
-      return i.push(c), await this.sshClient.chmod(a, 488), {
+      return i.push(a), await this.sshClient.chmod(c, 488), {
         history: i,
-        minioRelPath: a,
-        downloadedPl: x(t, e.arch)
+        minioRelPath: c,
+        downloadedPl: R(t, e.arch)
       };
     } catch (o) {
       const n = `SshPl.downloadBinariesAndUploadToServer: error ${o} occurred, state: ${JSON.stringify(i)}`;
@@ -983,12 +1000,12 @@ class W {
   * For this reason, we extract all to the remote server. */
   async downloadAndUntar(r, t, e, i, o) {
     const n = {};
-    n.binBasePath = P(t), await this.sshClient.createRemoteDirectory(n.binBasePath), n.binBasePathCreated = !0;
-    let a = null;
-    const c = 5;
-    for (let h = 1; h <= c; h++)
+    n.binBasePath = v(t), await this.sshClient.createRemoteDirectory(n.binBasePath), n.binBasePathCreated = !0;
+    let c = null;
+    const a = 5;
+    for (let h = 1; h <= a; h++)
       try {
-        a = await lt(
+        c = await ut(
           this.logger,
           r,
           i,
@@ -997,11 +1014,11 @@ class W {
           e.platform
         );
         break;
-      } catch (m) {
-        if (await S(300), h == c)
-          throw new Error(`downloadAndUntar: ${c} attempts, last error: ${m}`);
+      } catch (d) {
+        if (await C(300), h == a)
+          throw new Error(`downloadAndUntar: ${a} attempts, last error: ${d}`);
       }
-    n.downloadResult = p(a), n.localArchivePath = u.resolve(n.downloadResult.archivePath), n.remoteDir = u.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 = u.resolve(n.downloadResult.archivePath), n.remoteDir = u.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}`
     );
@@ -1010,49 +1027,49 @@ class W {
     return n.plUntarDone = !0, n;
   }
   async needDownload(r, t) {
-    const e = L(r, t.arch), i = M(r, t.arch), o = x(r, t.arch);
+    const e = W(r, t.arch), i = z(r, t.arch), o = R(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 : n; ) {
-      if (await S(r), o += r, o > i)
+      if (await C(r), o += r, o > i)
         throw new Error(`isAliveWithInterval: The process did not ${e ? "started" : "stopped"} after ${i} ms.`);
       n = await this.isAlive();
     }
   }
   async getUserCredentials(r) {
-    const t = await this.sshClient.readFile(O(r));
+    const t = await this.sshClient.readFile(N(r));
     return JSON.parse(t);
   }
   async fetchPorts(r, t) {
     return {
       grpc: {
-        local: await g(),
+        local: await y(),
         remote: await this.getFreePortForPlatformaOnServer(r, t)
       },
       monitoring: {
-        local: await g(),
+        local: await y(),
         remote: await this.getFreePortForPlatformaOnServer(r, t)
       },
       debug: {
-        local: await g(),
+        local: await y(),
         remote: await this.getFreePortForPlatformaOnServer(r, t)
       },
       minioPort: {
-        local: await g(),
+        local: await y(),
         remote: await this.getFreePortForPlatformaOnServer(r, t)
       },
       minioConsolePort: {
-        local: await g(),
+        local: await y(),
         remote: await this.getFreePortForPlatformaOnServer(r, t)
       }
     };
   }
   async getLocalFreePort() {
     return new Promise((r) => {
-      const t = U.createServer();
+      const t = B.createServer();
       t.listen(0, () => {
         const e = t.address().port;
         t.close((i) => r(e));
@@ -1060,7 +1077,7 @@ class W {
     });
   }
   async getFreePortForPlatformaOnServer(r, t) {
-    const e = xt(r, t.arch), { stdout: i, stderr: o } = await this.sshClient.exec(`${e}`);
+    const e = Ut(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;
@@ -1086,11 +1103,11 @@ class W {
   }
 }
 export {
-  St as LocalConfigYaml,
-  Et as LocalPl,
-  D as SshClient,
-  W as SshPl,
-  F as getDefaultPlVersion,
-  Xt as localPlatformaInit
+  Et as LocalConfigYaml,
+  Ft as LocalPl,
+  x as SshClient,
+  q as SshPl,
+  b as getDefaultPlVersion,
+  ir as localPlatformaInit
 };
 //# sourceMappingURL=index.mjs.map